Hello,

More of my philosophy about my kind of personality 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..

I think i am smart, and 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 53 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 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: