Read again, i correct

[Sky89]

Hello,

Read again, i correct


I think C++ and C have many problems because they are "too" weakly
typed, here is another problem of C++ and C, look at this C++ example:


===

#include <conio.h>
#include <iostream>
using namespace std;
#include <stdint.h>



double y;


void a1(unsigned int a)
{
cout << a ;

}

int main()
{

unsigned int b;
int a;



y=3.4;


a1(y);


}

==


This will be accepted by C++ because the parameter a of a1() will equal
3, but this is "not" correct for "reliability" and it is not accepted by
Delphi and FreePascal and ADA because they are more strongly typed than
C++ and C and they will give an error that the type of the parameter a
of a1() is not the same as the type of y.


Also Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.

But C++ and C don't have range checking and don't have many Run-time
checks etc. so that's not good in C++ and C because it is not good for
reliability and it is not good for safety-critical systems.

You can carefully read the following, it is very important:

https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/


And about Escher C++ Verifier, read carefully:

"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."

Read here:

http://www.eschertech.com/products/index.php


So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again that C++ and C don't have range checking and many
Run-time checks, so that's not good in C++ and C because it is not good
for reliability and it is not good for safety-critical systems.



Thank you,
Amine Moulay Ramdane.

[Sky89]

Hello....

Read again, i correct

Delphi is much more rapid/RAD development solution than C++ and the
horror that was MFC. Delphi VCL was also more complete than what Visual
Basic,on the other hand with the new Delphi LLVM compilers there is a
promise for more platforms and better low-level performance,

Here is the new LLVM-based Delphi compilers:

http://docwiki.embarcadero.com/RADStudio/Tokyo/en/LLVM-based_Delphi_Compilers


I think i will also continu to work more with Delphi and FreePascal and
Lazarus, all of them use a "modern" Object Pascal that is much more
powerful than pascal, you have to look at the new Delphi language that
is powerful, i am also using the Delphi mode with FreePascal to be
compatible with Delphi.

Delphi for example works on the following platforms:

Windows
Linux
macOS
iOS
Android

You have to look at the new Delphi here, it is very powerful:

https://www.embarcadero.com/products/delphi


Lazarus and FreePascal are very interesting to use, you have to look
at Lazarus here to notice it:

https://www.lazarus-ide.org/


What i love in Delphi and FreePascal is that
Delphi and FreePascal like ADA are more strongly typed than C++ or C and
they come with range checking and Run-time checks that catch conversion

from negative signed to unsigned , and catch out-of-bounds indices of
dynamic and static arrays and catch arithmetic overflow etc. and you can

also dynamically catch this exception of ERangeError etc. and that's
good for reliability.

But C++ and C don't have range checking and many Run-time checks etc. so
that's not good in C++ and C and that's not good for reliability and it

is not good for safety-critical systems.

This is why i will also to continu to work more with Delphi and
FreePascal and Lazarus, and my Delphi projects can be used with C++Builder.

Look for example at my last invention , here is my last invention for
Delphi and FreePascal:

Scalable reference counting with efficient support for weak references

https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references

You can find my other "inventions"(that are my scalable algorithms etc.)
and my other projects here:

https://sites.google.com/site/aminer68/

Also you can improve strict-type safety(and thus reliability) in Delphi
and FreePascal with variants like this:

--

program test;

uses VARIANTS,SYSUTILS;

var f:double;
a:integer;



FUNCTION ASSIGN(a,B:VARIANT):VARIANT;

begin

IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');


end;

begin

a:=2;

f:=a;

A:=ASSIGN(F,A);


end.
--


Here is the Vartype function:

http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html

[Sky89]

Hello..


I explain my work..

I am an inventor of scalable algorithms and other softwares..

Now you have to understand me more, why do you think i am posting on CPUs
and computers ?

Because parallel programming will "like" extend rapidly Moors law,
because look for example at this:

Intel: 1,000-core Processor Possible

An experimental Intel chip shows the feasibility of building processors
with 1,000 cores, an Intel researcher has asserted.

The architecture for the Intel 48-core Single Chip Cloud Computer (SCC)
processor is "arbitrarily scalable," said Intel researcher Timothy
Mattson, during a talk at the Supercomputer 2010 conference being held
this week in New Orleans.

Read more here:

https://www.pcworld.com/article/211238/intel_1000core_processor_possible.html


And look at this:

3D stacked computer chips could make computers 1,000 times faster

Read more here:

https://www.zmescience.com/research/technology/3d-stacked-computer-chips-43243/


This is why parallel computing and 3D stacking of memory and CPUs
beyond 1000 cores of Intel above, will make CPUs and computers rapidly
very powerful and this will permit to revolutionize rapidly
artificial intelligence and genetics etc., Look for example at the
following video to understand more:

Michio Kaku: Genetics: The Key to Immortality?

https://www.youtube.com/watch?v=QsHuGQieyjY