Read again, i correct...

[Ramine]

Hello....

I am coming from a long road of software development,
i have specialized more on parallel computing and it
has allowed me to bring you also my Parallel archiver,
now i am implementing a GUI interface to a system that uses my Parallel
Archiver, this system doesn't look as zip or 7Zip , because
they use an innefficient way so when you delete a file from
a big archive it will take too much time, so the
delete function doesn't scale on 7Zip or Zip, so
i am actually implementing a new system as a command line
and GUI that is more efficient than 7Zip or Zip in many ways
and that works on windows.. the GUI interface will support Drag and Drop
and passing file from the Clipboard and it will support 3 compression
algorithm: Zstd and LZ4 and LZMA, so stay tuned i am
actually implementing it.


Thank you,
Amine Moulay Ramdane.

[Ramine]

Hello.......

Fist solution:

I think that C++ and ADA and Object Pascal must make the data types
objects, and make datastructures objects and make IO objects etc. and
wrap those objects with a scalable reader-writer lock or transactional
memory, and the compiler designers and implementors must test those
objects correctly to ensure that they work correctly, this will ensure a
level of security that avoids race conditions that is tolerable,
so no need for pure functions and Mvars of Haskel and Lisp.

Or you can use this solution:

About C++ and my following enhancement to it...

C++ must add properties that you can access only from the constructor
and can not be accessed from the methods of the object.

This way you will be able to implement more cleanly my following
implementation:

First you have to call a constructor that will put the global variables
as pointers for example in there respective queues..

And after that each method that wants to access a global variable will
take the global variable from the queue and copy it in a local
variable and work with it locally, and after that it will put
it back in its global queue , and other threads will block waiting
for the variables on there respective queues, it's like message passing
and it's like pure functions with Mvars in Haskel and this mechanism is
good and will avoid race conditions in Object oriented programming.

If you say to me that pure functions of Lisp and Haskel are pure
functions , but with my previous implementation you still can
by error forget to put your global variables that is
shared by threads in the properties that can not be accessed
by the object or in there respective global queues, i will say that
my implementation easy the job for us, because defining what is shared
and putting it in the properties that can not be accessed from the
object is easy and is as easy as making an error on sequential
programming, so in my opinion this level of security can be tolerated in
Object oriented programming without using Functional programming, other
than that we also have Transactional memory that is composable and easy
to use to solve our parallel programming problems in Object oriented
programming.


For Deadlocks use this:

Use Lock Hierarchies to Avoid Deadlock

http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163