TempleOSTS_130707.ISO

TempleOS/Doc/Welcome.TXT

@@ -1,19 +1,20 @@
 $WW,1$$FG,5$$TX+CX,"Welcome to TempleOS"$$FG$
 
 $LK,"Trivial Solutions","FI:::/TempleOS/Doc/TrivialSolutions.TXT"$'s TempleOS is a x86_64, multi-cored, multi-tasking, ring-0-only, single-address_mapped (identity), operating system for recreational programming:
-$ID,2$* Professional hobby projects
-* Teenager projects
-* Non-professional, older-person projects
-$ID,-2$
-Simplicity is a goal to $LK,"keep the line count down","FI:::/TempleOS/Doc/Strategy.TXT"$, so it's easy to tinker with.  As it turns-out, simplicity makes it faster in some ways, too.  It never switches privilege levels, never changes address maps, tends to load whole contiguous files and other, similar things which boost speed.  It's only $TX+D,"139,633","DD_TEMPLEOS_LOC"$ lines of code including the kernel, the 64-bit compiler, the graphics library and all the tools.  More importantly, it's designed to keep the user's line count down -- you can do a "hello world" application in one line of code and can put graphics on the screen with a three line program!
 
-It's a kayak, not a Titanic -- it will crash if you do something wrong.  You quickly reboot, however.  DOS and the 8-bit home computers of the 80's worked fine without memory protection and most computers in the world -- the embedded ones -- operate without protection.  The resulting simplicity of no protections is why TempleOS has value.  In facts, that's the point of TempleOS.  See the $LK,"TempleOS Constitition","FI:::/TempleOS/Doc/Charter.TXT"$.
+$ID,2$* Professionals doing hobby projects
+* Teenagers doing projects
+* Non-professional, older-persons projects
+$ID,-2$
+Simplicity is a goal to $LK,"keep the line count down","FI:::/TempleOS/Doc/Strategy.TXT"$, so it's easy to tinker with.  As it turns-out, simplicity makes it faster in some ways, too.  It never switches privilege levels, never changes address maps, tends to load whole contiguous files and other, similar things which boost speed.  It's only $TX+D,"129,156","DD_TEMPLEOS_LOC"$ lines of code including the kernel, the 64-bit compiler, the graphics library and all the tools.  More importantly, it's designed to keep the user's line count down -- you can do a "hello world" application in one line of code and can put graphics on the screen with a three line program!
+
+It's a kayak, not a Titanic -- it will crash if you do something wrong.  You quickly reboot, however.  DOS and the 8-bit home computers of the 80's worked fine without memory protection and most computers in the world -- the embedded ones -- operate without protection.  The resulting simplicity of no protections is why TempleOS has value.  In facts, that's the point of TempleOS.  See the $LK,"TempleOS Charter","FI:::/TempleOS/Doc/Charter.TXT"$.
 
 Two things to know about TempleOS are that $UL,1$tasks$UL,0$ have $LK,"MAlloc","MN:MAlloc"$/$LK,"Free","MN:Free"$ heap memory, not applications, and tasks have compiler symbol tables that persist at a scope like environment variables in other operating systems, and the symbols can include functions.
 
-In other operating systems, I hated learning one language for command line scripts and another for programming.  With $FG,2$TempleOS$FG$, the command line feeds right into the $FG,2$C+$FG$ (more than $FG,2$C$FG$, less than $FG,2$C++$FG$) compiler, line by line, and it places code into memory it $LK,"MAlloc","MN:MAlloc"$()s.  The compiler is paused at the command line, waiting for input.  Naturally, you $FG,2$#include$FG$ a program to load it into memory and, usually, start it.  During the boot process, many files get compiled before you have access to the command line.  (Don't worry, booting takes only a couple seconds.)  All the header declarations for the operating system are compiled and are available for use in your programs without needing to $FG,2$#include $FG$them.  Everything is truly compiled to native $FG,4$$TX+HTML,"x86_64","http://en.wikipedia.org/wiki/Amd64#AMD64"$$FG$ and nothing is "interpreted".
+In other operating systems, I hated learning one language for command line scripts and another for programming.  With $FG,2$TempleOS$FG$, the command line feeds right into the $LK,"Holy C","FI:::/TempleOS/Doc/HolyC.TXT"$ (more than $FG,2$C$FG$, less than $FG,2$C++$FG$) compiler, line by line, and it places code into memory it $LK,"MAlloc","MN:MAlloc"$()s.  The compiler is paused at the command line, waiting for input.  Naturally, you $FG,2$#include$FG$ a program to load it into memory and, usually, start it.  During the boot process, many files get compiled before you have access to the command line.  (Don't worry, booting takes only a couple of seconds.)  All the header declarations for the operating system are compiled and are available for use in your programs without needing to $FG,2$#include $FG$them.  Everything is truly compiled to native $FG,4$$TX+HTML,"x86_64","http://en.wikipedia.org/wiki/Amd64#AMD64"$$FG$ and nothing is "interpreted".
 
-Statements at the global scope (outside the scope of $FG,2$C+$FG$ functions) execute immediately.  There is no $FG,2$main()$FG$ function.  Instead, you give meaningful names to what would be $FG,2$main()$FG$ functions and you invoke them by calling them with a statement in the global scope, usually at the bottom of your file.
+Statements at the global scope (outside the scope of $LK,"Holy C","FI:::/TempleOS/Doc/HolyC.TXT"$ functions) execute immediately.  There is no $FG,2$main()$FG$ function.  Instead, you give meaningful names to what would be $FG,2$main()$FG$ functions and you invoke them by calling them with a statement in the global scope, usually at the bottom of your file.
 
 I started with $FG,2$C$FG$ syntax, but didn't like the command line for a directory listing looking like this:
 
@@ -29,13 +30,13 @@ $FG$I didn't like that, so I made parentheses optional on calls with no args and
 
 The syntax change created an ambiguity when specifying function addresses.  To resolve it, I  made a '$FG,2$&$FG$' required in front of function names when specifying an address of a function, which is better anyway.
 
-Once I was no longer using standard syntax, I decided to change everything I didn't like.  Here are the new $LK,"operator precedence","FA:::/TempleOS/Doc/Differences.TXT,OP_precedence"$ rules.  See $LK,"Departures from C/C++","FI:::/TempleOS/Doc/Differences.TXT"$.  It's Biblical!  See $LK,"Luke,5:37","BF:Luke,5:37"$.
+Once I was no longer using standard C/C++ syntax, I decided to change everything I didn't like and call it $LK,"Holy C","FI:::/TempleOS/Doc/HolyC.TXT"$.  Here are the new $LK,"operator precedence","FA:::/TempleOS/Doc/HolyC.TXT,OP_precedence"$ rules.  It's Biblical!  See $LK,"Luke,5:37","BF:Luke,5:37"$.
 
 There are no object files in TempleOS and, normally, you don't make executable files either, but you can.  That's known as "$FG,2$Ahead-Of-Time$FG$" compilation.  Instead, you "$FG,2$Just-In-Time$FG$" compile.
 
 Tasks have no priority scheme and are never removed from the queue.  Instead, they often poll whatever they are waiting on and swap-out.  (Swapping tasks takes half a microsecond and does not involve disk activity or memory maps.)  See $LK,"Scheduler","FL:::/TempleOS/Kernel/Scheduler.CPP,1"$.  Polling keeps it simple.  It's might be a problem if you had lots of tasks busy, which rarely happens on a home computer.  The order of the tasks in the queue determines front-to-back window order.  See $LK,"TempleOS MultiTasking","FI:::/TempleOS/Doc/MultiTasking.TXT"$.
 
-The TempleOS native file system is simple, so I don't get sued.  There is an allocation bitmap for clusters and all files are stored contiguously.  You can't grow files.
+The TempleOS $FG,2$RedSea$FG$ file system is simple, so I don't get sued.  There is an allocation bitmap for clusters and all files are stored contiguously.  You can't grow files.
 
 TempleOS is geared toward reading and writing whole files.  Since whole files are processed, checksums and compression are possible.  Filenames ending in "$FG,2$.Z$FG$" are automatically compressed or uncompressed when stored or fetched.  TempleOS supports direct block random access into files, however -- $LK,"FRBlks","MN:FRBlks"$() and $LK,"FWBlks","MN:FWBlks"$().