Hello,
More of my philosophy about Delphi and Freepascal and more of my thoughts..
I am a white arab, and i think i am smart since i have also
invented many scalable algorithms and algorithms..
As you have just noticed, i have just talked about my PERT++ and
my JNI wrapper that i have written in Modern Object Pascal
of Delphi and Freepascal compilers, but why do you think i am also programming in Delphi and Freepascal ?
Of course that Delphi and Freepascal compilers support modern Object Pascal, it is not only Pascal, but it is modern Object Pascal, i mean
that modern Object Pascal of for example Delphi and Freepascal support object oriented programming and support Anonymous methods or typed Lambdas , so i think that it is a decent programming language, even if i know that the new C++ 20 supports generic
Lambdas and templated Lambdas, but i think that Delphi will soon also support generic Lambdas, and in Delphi and Freepascal compilers there is no big runtime like in C# and such compilers, so you get small native executables in Delphi
and Freepascal, and inline assembler is supported by both Delphi
and Freepascal, and Lazarus the IDE of Freepascal and Delphi come
both with one of the best GUI tools, and of course you can make .SO, .DLL, executables, etc. in both Delphi and Freepascal, and both Delphi
and Freepascal compilers are Cross platform to Windows, Linux and Mac
and Android etc. , and i think that modern Object Pascal of Delphi
or Freepascal is more strongly typed than C++ , but less strongly typed than ADA programming language, but i think that modern Object Pascal of Delphi and Freepascal are not Strict as the programming language ADA and are not strict as the programming
language Rust or the pure functional programming languages, so it can also be flexible and advantageous to not be this kind of strictness, and the compilation times of Delphi is extremely fast , and of course Freepascal supports the Delphi mode so that
to be compatible with Delphi and i can go on and on, and it is why i am also programming in Delphi and Freepascal.
And you can read about the last version 11.2 of Delphi from here:
https://www.embarcadero.com/products/delphi
And you can read about Freepascal and Lazarus from here:
https://www.freepascal.org/
https://www.lazarus-ide.org/
More of my philosophy about Asynchronous programming and about the futures and about the ActiveObject and about technology and more of my thoughts..
I think i am highly smart since I have passed two certified IQ tests and i have scored "above" 115 IQ, i think from my new implementation of
future below, you can notice that Asynchronous programming is not a simple task, since it can get too much complicated , since you can
notice in my implementation below that if i make the starting of the thread of the future out of the constructor and if i make the passing of the parameter as a pointer to the future out of the constructor , it
will get more complex to get the automaton of how to use
and call the methods right and safe, so i think that there is
still a problem with Asynchronous programming and it is that
when you have many Asynchronous tasks or threads it can get
really complex, and i think that it is the weakness of Asynchronous programming, and of course i am also speaking of the implementation
of a sophisticated ActiveObject or a future or complex Asynchronous programming.
More of my philosophy about my new updated implementation of a future and about the ActiveObject and about technology and more of my thoughts..
I think i am highly smart since I have passed two certified IQ tests and i have scored "above" 115 IQ, so i have just updated my implementation
of a future, and now both the starting the thread of the future and the passing the parameter as a pointer to the future is made from the constructor so that to make safe the system of the automaton of the how to use and call the methods, and I have just
added support for exceptions, so you have to know that programming with futures is asynchronous programming, but so that to be robust the future implementation has to deal correctly with "exceptions", so in my implementation of a future when an exception
is raised inside the future you will receive the exception, so i have implemented two things: The HasException() method so that to detect the exception from inside the future, and the the exception and its address is returned as a string in the
ExceptionStr property, and my implementation of a future does of course support passing parameters as a pointer to the future, also my implementation of a future works in Windows and Linux, and of course you can also use my following more sophisticated
Threadpool engine with priorities as a sophisticated ActiveObject or such and pass the methods or functions and there parameters to it, here it is:
Threadpool engine with priorities
https://sites.google.com/site/scalable68/threadpool-engine-with-priorities
And stay tuned since i will enhance more my above Threadpool engine with priorities.
So you can download my new updated portable and efficient implementation of a future in Delphi and FreePascal version 1.32 from my website here:
https://sites.google.com/site/scalable68/a-portable-and-efficient-implementation-of-a-future-in-delphi-and-freepascal
And here is a new example program of how to use my implementation of a future in Delphi and Freepascal and notice that the interface has changed a little bit:
--
program TestFuture;
uses system.SysUtils, system.Classes, Futures;
type
TTestFuture1 = class(TFuture)
public
function Compute(ptr:pointer): Variant; override;
end;
TTestFuture2 = class(TFuture)
public
function Compute(ptr:pointer): Variant; override;
end;
var obj1:TTestFuture1;
obj2:TTestFuture2;
a:variant;
function TTestFuture1.Compute(ptr:pointer): Variant;
begin
raise Exception.Create('I raised an exception');
end;
function TTestFuture2.Compute(ptr:pointer): Variant;
begin
writeln(nativeint(ptr));
result:='Hello world !';
end;
begin
writeln;
obj1:=TTestFuture1.create(pointer(12));
if obj1.GetValue(a) then writeln(a)
else if obj1.HasException then writeln(obj1.ExceptionStr);
obj1.free;
writeln;
obj2:=TTestFuture2.create(pointer(12));
if obj2.GetValue(a) then writeln(a);
obj2.free;
end.
---
More of my philosophy about the 12 memory channels of
the new AMD Epyc Genoa CPU and more of my thoughts..
I am a white arab, and i think i am smart since i have also
invented many scalable algorithms and algorithms..
So as i am saying below, i think that so that to use 12 memory
channels in parallel that supports it the new AMD Genoa CPU, the GMI-Wide mode must enlarge more and connects each CCD with more GMI links, so i think that it is what is doing AMD in its new 4 CCDs configuration, even with the costs optimized Epyc Genoa
9124 16 cores with 64 MB of L3 cache with 4 Core Complex Dies (CCDs), that costs around $1000 (Look at it here:
https://www.tomshardware.com/reviews/amd-4th-gen-epyc-genoa-9654-9554-and-9374f-review-96-cores-zen-4-and-5nm-disrupt-the-data-center ), and
as i am explaining more below that the Core Complex Dies (CCDs) connect to memory, I/O, and each other through the I/O Die (IOD) and each CCD connects to the IOD via a dedicated high-speed, or Global Memory I