Hello...

Read again, i correct about more philosophy about artificial intelligence and about the objective function that guides..

I am a white arab and i think i am smart since i have also invented many scalable algorithms and algorithms..

I think i am smart, and i have quickly thought about the objective
function of artificial intelligence that guides, so the important philosophical question in artificial intelligence is:

Is general artificial intelligence possible and what is the the objective function that guides general artificial intelligence ?

I think that the objective function of general artificial intelligence
is not the same as a gradient descent with wich we optimize, since i think that the objective function in artificial intelligence is
that we have to build like a model that approximate the result
of the reality, i mean that the objective function of general artificial intelligence has to be that we measure the meaning with the previous meanings from the data, and this way we approximate the meaning, so we have to build much more meanings and meaning from the data and we have to measure the unknown meaning with the previous meanings and if it doesn't approximate well, so it is like a baby that doesn't know about the meaning and it can become a dangerous environment for the baby like for general artificial intelligence, and my way is also valid in a distributed environment with many artifical intelligence robots, so i think that the more localized artificial intelligence will become incrementally and rapidly a more and more generalized artificial intelligence that can approximate a general artificial intelligence, so i think that general artificial intelligence is possible.

More philosophy about Swarm intelligence and about the too much abstraction and more..

I invite you to read about Swarm intelligence here:

How Swarm Intelligence Is Making Simple Tech Much Smarter

https://singularityhub.com/2018/02/08/how-swarm-intelligence-is-making-simple-tech-much-smarter/

I think that humanity is using "specialization" and the "division" of labour that reduces complexity so that to be efficient, so our evolution looks like Swarm intelligence algorithms, since Swarm intelligence algorithms also have to both explore with a bigger size of the population of the Swarm intelligence algorithms and have to do exploitation so that to reduce complexity and be efficient, and this bigger size of of the population in Swarm intelligence algorithms that explore is the division of labour that we use and it is also a specialization and it looks like a divide and conquer algorithms, since notice in the mergesort algorithm that we are reducing the time complexity from for example a time complexity of an n^2 sorting algorithm to n*log(n), and you are noticing it clearly since the mergesort algorithm reduces much more the time complexity by recursively "dividing" the array of elements so that to obtain a small arrays that are already sorted(or we can sort the small arrays of 10 elements by using an algorithm of sorting of n^2 and it will be more efficient), and notice that when we obtain those small arrays that are already sorted, it is what reduces the complexity and brings much more efficiency, since we are recursively using the merge algorithm after that, and notice that the mergesort is also like Swarm intelligence since when we recursively divide and obtain the already sorted arrays, notice that this recursively dividing leads to many already sorted arrays, and it is like the bigger size of the population in Swarm intelligence that explore and that leads to high efficiency, so i think that artificial
intelligence must be like a divide and conquer algorithm, so you divide like in a Divide and conquer algorithm so that to obtain a high quality
or high efficiency since you reduce complexity, so it looks
like PathNet in artificial intelligence, read my following thoughts about it:

https://groups.google.com/g/alt.culture.morocco/c/BKGvkTI5FY4

More philosophy about black box models and too much abstraction..

I think that black box models in AI in deep learning etc. are also too much abstraction, and speaking about the too much abstraction, i invite you to read my following thoughts of my philosophy about Liberalism of the philosopher and economist Adam Smith:

https://groups.google.com/g/comp.programming.threads/c/-UEOsak12mM

So as you are noticing from my thoughts in the above web link that the economic Liberalism of Adam Smith is a too reductionist system that is too much abstraction that doesn't work correctly and i am explaining it in my thoughts above of my philosophy, other than that notice that economic Liberalism of Adam Smith is not even taking into account an important factor that i am speaking about in my below thoughts and it is the too much abstraction that can happen in economy and that can lead to inefficiency, so as you are noticing that this too much abstraction can not be based on monopolistic practices, but it can lead to inefficiency, i mean for example when you abstract too much, the others can not be able of understanding sufficiently and correctly the inside or the behind of your abstraction, so they can "lack" understanding and be inefficient, so we have to be careful about cloud computing of Amazon and such that can become a too much abstraction that leads to this kind of inefficiency, so i think it is too much abstraction if you program the software in a too high level way lacking programming and understanding of the lower level ways of programming.

More philosophy about abstraction and the Divide and Conquer methodology..

I think that humanity is abstracting much more with cloud computing and
with functional programming and such, but since i think i am a philosopher, there is a question in philosophy and it is the following:

Is abstraction always good ?

I think that abstraction comes with disadvantages and advantages,
so the best way is to know how to balance, it is like balancing between Evolutionary design with an agile discipline and Planned design since they both come with disadvantages and advantages, so abstraction can come with disadvantages like the disadvantage that i am speaking about
below, since functional programming has the tendency to much more
move the data between a memory region and another memory region, and it is inefficient, so i think that we have to take it into account and know
how to balance between abstraction and performance or speed, also abstraction comes with another important disadvantage , and it is
that it can become a monopolistic practice, i mean that when you abstract, the others can become too dependent on your abstraction and they can not understand the inside of the abstraction,
so they can become inefficient, so we have to be careful about abstraction since too much abstraction is not good, so i think that functional programming is too much abstraction and i think Chapel
is too much abstraction, read here more about Chapel:

WILL CHAPEL MARK NEXT GREAT AWAKENING FOR PARALLEL PROGRAMMERS?

https://www.nextplatform.com/2018/04/10/will-chapel-mark-next-great-awakening-for-parallel-programmers/

Read my previous thoughts so that to understand more:

More philosophy about one of the most important disadvantage of functional programming..

I have just posted previously my thoughts about continuation—passing style (CPS) and Monads, here they are:

https://groups.google.com/g/alt.comp.lang.borland-delphi/c/kdP6YSTcjj4

I think i am smart and i have just "quickly" noticed that when you are
using patterns of functional programming such as Map and Monads ,
it will come with a very important disadvantage, and it is that you will move much more the data from a memory region to another memory region,
so it is not efficient, since it is really slower, and i think that
it is one of the most important disadvantage of functional programming, since functional programming abstracts more, but it is really slower, so i have just given you previously an example of a "Maybe" Monad in Delphi, and here is an example of the "List" Monad in Delphi and notice how it is really slower by moving the data to the the returned result of the "Bind" function of the Monad as TmList object:

program List_monad;

{$APPTYPE CONSOLE}

uses
System.SysUtils;

type
TmList = record
Value: TArray<Integer>;
function ToString: string;
function Bind(f: TFunc<TArray<Integer>, TmList>): TmList;
end;

function Create(aValue: TArray<Integer>): TmList;
begin
Result.Value := copy(aValue, 0, length(aValue));
end;

{ TmList }

function TmList.Bind(f: TFunc<TArray<Integer>, TmList>): TmList;
begin
Result := f(self.Value);
end;

function TmList.ToString: string;
var
i: Integer;
begin
Result := '[ ';
for i := 0 to length(value) - 1 do
begin
if i > 0 then
Result := Result + ', ';
Result := Result + value[i].toString;
end;
Result := Result + ']';
end;

function Increment(aValue: TArray<Integer>): TmList;
var
i: integer;
begin
SetLength(Result.Value, length(aValue));
for i := 0 to High(aValue) do
Result.Value[i] := aValue[i] + 1;
end;

function Double(aValue: TArray<Integer>): TmList;
var
i: integer;
begin
SetLength(Result.Value, length(aValue));
for i := 0 to High(aValue) do
Result.Value[i] := aValue[i] * 2;
end;