Hello,

More of my philosophy about my education and more..

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

My Diploma is a university level Diploma, my school in Morocco where i have studied and gotten my university level Diploma in Microelectronics and informatics was under the control of Paris Academie in France (we call it Académie de Paris), and here it is:

https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Ffr.wikipedia.org%2Fwiki%2FAcad%25C3%25A9mie_de_Paris

I have started my studies in Microelectronics and informatics in 1986,
and in my studies of informatics in my university level school i have programmed and worked with the following computer that was called Altos 586, it was a Unix system, here it is:

https://en.wikipedia.org/wiki/Altos_586

And i have gotten my university level Diploma in Microelectronics and informatics in 1989.

So as you notice that i know how to program in Unix and in Linux and in Windows too.

Here is my extended thoughts about my education and my personallity:

I have come to Canada when i was 20 years old, and i am living
in Canada Quebec for 32 years and now i am 52 years old , but i am genetically an athletic guy and i feel that i am still young because
i am more athletic and i am 6 Feet tall, and i am beautiful
from the inside since i am a gentleman type of person and it is also
genetical in me, and i have worked as a software consultant with
some hospitals in USA, and i have worked with some computer hardware companies and software companies in British Colombia and in New Brunswick in Canada, and here is more about my education and my Diploma and more:

My name is Amine Moulay Ramdane, i am a white arab from Morocco, and
i think i am smart since i have also invented many scalable algorithms
and algorithms, and i am a gentleman type of person, and i live in
Quebec Canada since year 1989, i am also a Canadian from Morocco, and
you have seen me writing my thoughts of my political philosophy here,
and now i will talk about my education and my Diploma: my Diploma is a
university level Diploma, my school in Morocco where i have studied and
gotten my university level Diploma in Microelectronics and informatics
was under the control of Paris Academie in France (we call it Académie
de Paris), and here it is:

https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Ffr.wikipedia.org%2Fwiki%2FAcad%25C3%25A9mie_de_Paris

And i have continued to study one more year of applied mathematics in
university of Montreal in Quebec Canada, and i have succeeded this one
year in applied mathematics in university of Montreal, so with my
Diploma and this one year of applied mathematics i have studied and
succeeded 3 years at the university level, after that i have studied
Network administration and i have also worked as a network administrator
and as software developer consultant, the name of my company was and is
Cyber-NT Communications in Quebec Canada, and around years 2001 and
2002 i have started to implement some of my softwares like PerlZip that
looked like PkZip of PKware software company, but i have implemented it
for Perl , and i have implemented the Dynamic Link Libraries of my
PerlZip that permits to compress and decompress etc. with the
"Delphi"compiler, so my PerlZip software product was very fast
and very efficient, in year 2002 i have posted the Beta version on
internet, and as a proof , please read about it here:

http://computer-programming-forum.com/52-perl-modules/ea157f4a229fc720.htm

And after that i have sold the release version of my PerlZip
product to many many companies and to many individuals around the world,
and i have even sold it to many Banks in Europe, and with that i have
made more money.

And after that i have continued to work like a software developer
consultant and network administrator, the name of my company was and is
Cyber-NT Communications,

Here is my company in Quebec(Canada) called Cyber-NT Communications,
i have worked as a software developer and as a network administrator,
read the proof here:

https://opencorporates.com/companies/ca_qc/2246777231

Also read the following part of a somewhat old book of O'Reilly called
Perl for System Administration by David N. Blank-Edelman, and you will
notice that it contains my name and it speaks about some of my Perl modules:

https://www.oreilly.com/library/view/perl-for-system/1565926099/ch04s04.html

And you can find my Open source software projects here in my website:

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

And here is my photo that i have just put in my website, you can take a look at it since i am a white arab:

https://sites.google.com/site/scalable68/jackson-network-problem

And here is my poems of Love that i have invented quickly:

And read my following poems of Love that i think are flexible from the start, here they are and read them carefully:

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

And read my following proverbs that i think are flexible from the start and that i have just invented quickly, here they are and read them carefully:

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

And here my other two just new proverbs that i have invented quickly:

Here is the first one of my proverbs:

"Resourcefulness is one of the most important things, and it is a skill,
and the good news is: this skill can be learned and mastered, and
resourcefulness is attained only when we combine the resourceful mindset
and skills, so we have to filter out some of the most useful resources
that help us, and resourcefulness is also to know who/what to look for
and what to ask, and when ressourcefulness is attained this becomes an
engine that permits you to have hope and to be energetic and to be
positive in doing what you are doing, since resourcefulness also permits
to easy the jobs for you."

And here is the second one of my proverbs:

"When you walk towards a goal in life it's like you walk down a forest
path towards a goal, but when you walk this forest path you can look at
flowers and pretty trees and be happier or you can also learn more and
have more experience which is useful while walking in the forest, then
life is like this, you can go through it towards goals, but going
through it you can also have pleasures that make you happier and you can
learn more and have more experience and that is useful to you, and i
think this conception of life makes you more positive."

And here is the translation in french of my new proverb:

"Quand tu marches vers un objectif dans la vie, c'est comme tu marches
dans un chemin de forêt vers un objectif, mais quand tu marches dans ce
chemin de forêt tu peux regarder des fleurs et de jolis arbres et être
plus joyeux ou tu peux aussi en apprendre plus et avoir plus
d'expérience qui est utile en marchant dans la forêt, alors la vie
ressemble à cela, tu peux la traverser vers des objectifs, mais en la
traversant tu peux avoir aussi des plaisirs qui te rendent plus heureux
et tu peux apprendre plus et avoir plus d'experience et cela t'est
utile, et je pense que cette conception de la vie te rend plus positif."

So you have to understand that my proverb above is like
trying to well balance between, in one side, our strong human desire for
success and the fear or the disliking of failure to attain the goal,
and, in the other side, i am showing in my new proverb the good sides or
advantages or the pros of walking our lives towards the goal or goals
even if failure or failures happen(s), and i think this conception of
life of my proverb permits to be more positive, also you have to align
the usefulness of the utility with the global mission of the country or
global world.

More of my philosophy about stack memory allocations and about preemptive and non-preemptive timesharing..

I think i am smart, and as you are noticing in my below thoughts that
i am abstracting smartly so that to make you understand preemptive and non-preemptive timesharing , other than that i will also give you
an interesting Stack memory allocation algorithm in Delphi and Freepascal so that to use it smartly with my below sophisticated Stackful coroutines Library, so i will extend my sophisticated Stackful coroutines Library so that to support it smartly, and here it is:

--

var pool: array [1..limit] of integer;
memory: array [min..max] of integer;
top: integer;

procedure initialize;

var index: integer;

begin
for index := 1 to limit do
pool[index] := empty;
top := min − 1
end;

procedure allocate( index, length: integer; var address: integer);

begin

address := pool[index];
if address <> empty then
pool[index] := memory[address]
else
begin
address := top + 1;
top := top + length;
if not (top <= max)
then raise Exception.Create('Stack overflow..')

end
end;

procedure release( index, address: integer);
begin
memory[address] := pool[index];
pool[index] := address
end;

--

More of my philosophy about about the paper and about preemptive and non-preemptive timesharing and more..

I have just forgotten to post about who has written the following
paper about cooperative and preemptive tasking:

https://users.ece.cmu.edu/~koopman/pubs/koopman90_HeavyweightTasking.pdf

Here is the Professor Phil Koopman of Carnegie Mellon University from Department of Electrical and Computer Engineering who has written
this paper:

https://users.ece.cmu.edu/~koopman/personal.html

And note that i am calling, in my thoughts below, cooperative and preemptive tasking: "preemptive and non-preemptive timesharing"

More of my philosophy about Intel 8051 controller and about preemptive and non-preemptive timesharing and more..

I have just quickly read the following interesting paper and it says
that judicious use of cooperative tasking techniques can also often meet an embedded system's multitasking requirements, while giving better
performance and a simpler software environment than a preemptive multitasker, so read it carefully here:

https://users.ece.cmu.edu/~koopman/pubs/koopman90_HeavyweightTasking.pdf

And notice that it also says in the above paper that so that to meet
the requirements with cooperative multitasking you have to move the time-critical code to interrupt-service routines. And let us look
for example at the Intel 8051 controller here:

https://www.electronicwings.com/8051/introduction-to-8051-controller

So as you notice that it has many hardware interrupts that you can
use so that to make the cooperative tasking efficient, and i think it also comes with two clock timers interrupts that you can use to implement preemptive multitasking if you want, and you have also to know about interrupt latency when programming embedded systems with hardware controllers, and you have to know that the hardware interrupts have to get serviced fast enough and often enough, so you shouldn't disable
interrupts for too long a period of time, and just to give you an idea
, look for example at the nonbuffered communication UART (Universal
Asynchronous Receiver Transmitter) operating at 38,400 bits per second will interrupt every 208 microseconds. This is 1/38,400*8 because they
will interrupt for every byte (8 bits), and a processor or controller running at 25MHz executes most of its instructions in
2 or 3 system-clock periods. That would be an average of 120 nanoseconds
(1/25,000,000*3). In theory, this means you could execute as
many as 1,730 instructions in the interrupt interval. So that was only
in theory, now you have to do the reality check. You must take into
consideration that there are more interrupts than just that communication channel. The timer interrupt will be firing off every so often. And the communication interrupt itself will have interrupts
disabled for good period of time, and not only that, but there is also the tasks switch that can be expensive, so you have to think about
it efficiently.

So i invite you to read my below thoughts about preemptive and non-preemptive timesharing and more so that to understand much more efficiently:

More of my philosophy about preemptive and non-preemptive timesharing and more..

I have just took a smart look at Modula-2 language(Modula-2 is a structured, procedural programming language developed between 1977 and 1985 by Niklaus Wirth at ETH Zurich, and he has also developed Pascal
language, read about Niklaus Wirth here: https://en.wikipedia.org/wiki/Niklaus_Wirth), and i think Modula-2 language was among the first languages that has provided preemptive and non-preemptive timesharing with coroutines, but the preemptive timesharing in Modula-2 uses Interrupt handling using IOTRANSFER, but it is best reserved for programs that will run without operating system support. Installing an interrupt handler on a multiuser system is not feasi­ble because doing so would affect other users. (For this reason, IOTRANSFER is not a mandatory feature of Modula-2.) Even on single-user systems, IOTRANSFER can be difficult to use because installing an interrupt handler causes the old interrupt handler (which most likely belongs to the operating system) to be lost. So this is why i think that the best way in modern operating systems is to use non-preemptive timesharing with coroutines, so this is why i am providing you with my sophisticated implementation of stackful coroutines, read about it in my thoughts below:

More of my philosophy about timesharing that is a Solution to Computer Bottlenecks..

I invite you to look at the following very interesting video about timesharing that is a Solution to Computer Bottlenecks:

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

I think i am smart, and you have to understand one important thing
and it is: What is the difference between a software architect and
a software engineer?, i think there is an important difference and it
is also like abstracted in the following question:

"How it is made?"

So i think that software engineering works at a higher level than
a software architect, this is why you will notice that i am
quickly implementing a sophisticated stackful coroutines
Library and i am quickly implementing setjmp() and longjmp() with
x64 assembler or code machine, read my below thoughts about them, but you have to know that my sophisticated stackful coroutines Library
does a kind of timesharing as in the above video, but i think that there is two kinds of timesharing: the preemptive one, and the non-preemptive one, but the difference is that the preemptive one does interrupt with a timer the coroutines from an external scheduler in
a form of function, but notice below that i am implementing the non-preemptive timesharing in my sophisticated coroutines Library, but you have to be smart and notice that my way of doing is like the software architect way, since i am implementing it from the lowest level with x64 assembler routines that are part of the non-preemptive scheduler, but not only that, but you have also to look at how i am also implementing a
sophisticated and much more rich interface in my stackful coroutines Library, so it is like both software achitecting and software engineering, so here is all my below thoughts that shows how i am implementing it quickly, so read it carefully since you have also to know what's the problem with the stack frames when architecturing and using the setjmp() and longjmp() so that to implement coroutines:

More of my philosophy and precision about the link of the article and more...

And notice that the link below of the article that shows the problem
of implementing coroutines with just setjmp() and longjmp()
is from the last semester of the second year of the course
called "CS4411 Operating Systems" from Michigan Technological University, but i think i am smart and those courses are easy
for me, so i invite you to read about this course that requires
both the course of "CS3331 Concurrent Computing" and "CS3421 Computer Organization", and here it is:

http://www.csl.mtu.edu/cs4411.ck/www/Home.html

More of my philosophy about coroutines and about setjmp() and longjmp()..

I think i am smart, and i will say that with setjmp() and longjmp()
you can implement a generator or the like, but you can not implement coroutines with just setjmp() and longjmp(), and so that to understand it, i invite you to read the following article that shows how when you yield from a first function with a longjmp() to the main body of a program and when you call another functions with longjmp(), it can make the stack frames not work correctly, and when you understand it you will not use setjmp() and longjmp() alone so that to implement coroutines, so read the following article so that to understand the problem with
the stack frames, and i am understanding it easily:

https://www.csl.mtu.edu/cs4411.ck/www/NOTES/non-local-goto/coroutine.html

So this is why i have also implemented my sophisticated stackful coroutines library so that to solve this problem, and here is my sophisticated coroutines library and read about it and download it from here:

https://sites.google.com/site/scalable68/object-oriented-stackful-coroutines-library-for-delphi-and-freepascal

More of my philosophy about setjmp() and longjmp() and generators and coroutines..

I have just quickly implemented setjmp() and longjmp() in x64 assembler,
and after that i have just implemented quickly a good example of a generator with my setjmp() and longjmp(), look at it below, and in computer science, a generator is a routine that can be used to control the iteration behaviour of a loop. All generators are also iterators. A generator is very similar to a function that returns an array, in that a generator has parameters, can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator yields the values one at a time, which requires less memory and allows the caller to get started processing the first few values immediately.. In short, a generator looks like a function but behaves like an iterator. So here is my implementations in freepascal and delphi and they are working perfectly:

Here is my first unit that implements longjmp() and setjmp() and notice
how i am saving the non-volatile registers and how i am coding it in
x64 assembler:

=====

{ Volatile registers: The calling program assumes registers
RAX, RCX, RDX, and R8 through R11 are volatile.
The contents of registers RBX, RSI, RDI, RBP, RSP, and
R12 through R15 are considered non-volatile. Functions return
values in RAX. }

unit JmpLib64;

{$IFDEF FPC}
{$ASMMODE intel}
{$ENDIF}
interface

type
jmp_buf = record
RBX,
RSI,
RDI,
RSP,
RBP,
RIP,
R12,
R13,
R14,
R15: UInt64;
end;

{ setjmp captures the complete task state which can later be used to perform a non-local goto using longjmp. setjmp returns 0 when it is initially called, and a non-zero value when it is returning from a call to longjmp. setjmp must be called before longjmp. }

function setjmp(out jmpb: jmp_buf): UInt64;

{ longjmp restores the task state captured by setjmp (and passed in jmpb). It then returns in such a way that setjmp appears to have returned with the value retval. setjmp must be called before longjmp. }

procedure longjmp(const jmpb: jmp_buf; retval: UInt64);
implementation

function setjmp(out jmpb: jmp_buf): UInt64; assembler;{$IFDEF FPC} nostackframe; {$ENDIF}register;
asm
{ -> RCX jmpb }
{ <- RAX Result }
MOV RDX, [RSP] // Fetch return address (RIP)
// Save task state
MOV [RCX+jmp_buf.&RBX], RBX
MOV [RCX+jmp_buf.&RSI], RSI
MOV [RCX+jmp_buf.&RDI], RDI
MOV [RCX+jmp_buf.&RSP], RSP
MOV [RCX+jmp_buf.&RBP], RBP
MOV [RCX+jmp_buf.&RIP], RDX
MOV [RCX+jmp_buf.&R12], R12
MOV [RCX+jmp_buf.&R13], R13
MOV [RCX+jmp_buf.&R14], R14
MOV [RCX+jmp_buf.&R15], R15

SUB RAX, RAX
@@1:
end;

procedure longjmp(const jmpb: jmp_buf; retval: UInt64);assembler;{$IFDEF FPC} nostackframe; {$ENDIF}register;
asm
{ -> RCX jmpb }
{ RDX retval }
{ <- RAX Result }
XCHG RDX, RCX
MOV RAX,RCX
MOV RCX, [RDX+jmp_buf.&RIP]
// Restore task state
MOV RBX, [RDX+jmp_buf.&RBX]
MOV RSI, [RDX+jmp_buf.&RSI]
MOV RDI, [RDX+jmp_buf.&RDI]
MOV RSP, [RDX+jmp_buf.&RSP]
MOV RBP, [RDX+jmp_buf.&RBP]
MOV R12, [RDX+jmp_buf.&R12]
MOV R13, [RDX+jmp_buf.&R13]
MOV R14, [RDX+jmp_buf.&R14]
MOV R15, [RDX+jmp_buf.&R15]
MOV [RSP], RCX // Restore return address (RIP)

TEST RAX, RAX // Ensure retval is <> 0
JNZ @@1
MOV RAX, 1
@@1:
end;

end.

===============
And here is my example of a generator with my longjmp() and setjmp():

{ In computer science, a generator is a routine that can be used to control the iteration behaviour of a loop. All generators are also iterators. A generator is very similar to a function that returns an array, in that a generator has parameters, can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator yields the values one at a time, which requires less memory and allows the caller to get started processing the first few values immediately. In short, a generator looks like a function but behaves like an iterator. }

program test_generator;

{$APPTYPE CONSOLE}

uses
JmpLib64;

type PtrInt = ^Integer;

var
childtask,maintask: jmp_buf;
myarr1: array of integer;
i,a:integer;
Ptr1:PtrInt;

function generator(var myarr:array of integer):integer;

var i1:integer;
val:integer;
ptr:PtrInt;
begin

i1:=0;

val:= setjmp(childtask);

i1:=val-1;

if val=0 then
begin
new(ptr);
ptr^:=myarr1[i1];
longjmp(maintask,uint64(ptr));
end;

if val=10
then
begin
writeln('Exiting child..');
exit;
end;

inc(i1);
new(ptr);
ptr^:=myarr1[i1];
longjmp(maintask,uint64(ptr));
end;

begin

setlength(myarr1,10);

for i:=0 to 9
do myarr1[i]:=i;

uint64(ptr1):=setjmp(maintask);

if ptr1=nil then generator(myarr1);

a:=ptr1^;
dispose(ptr1);

if (a<=length(myarr1))
then
begin
if a=length(myarr1)
then longjmp(childtask,a+1)
else
begin
writeln('Value returned by generator is: ',a);
longjmp(childtask,a+1);
end;
end;

setlength(myarr1,0);

end.

===

Thank you,
Amine Moulay Ramdane.