path: root/comp/lucas-standen-NEA/writeup/coverpage.ms

.TL
The solution To bad code
.AU
Lucas Standen
.AI
7949
.AB

.NH 1
Reading this document
.LP
This document is writen in roff and can be found online at:

https://github.com/standenboy/school/tree/master/comp/lucas-standen-NEA/writeup

It is using the ms macro of troff. It can be compiled using the Makefile,
or make.sh. A table of
contents has been generated using pdftocgen, it is embedded into the pdf,
most pdf readers have
a button to open it (firefox has it in the top left, in zathura press tab
to view it).

A note on formating of the roff, the text is limited to 80 characters per
line and is writen in
plain ascii, no utf8 emojis and the like. Code snippets are left in plain
text, while full files
are converted to a ps file via https://carbon.now.sh/ they should be 150mm ^
2 (as ps is a vector
format this wont lower quality, you might need to zoom in though) and then
have there source linked
above them; assuming they are from a file and not a small example.

.NH 1
Analysis
.NH 2
The current problem
.LP
For general small and simple projects, I write in C. However this leads to
hours of debugging due to
segfaults, and memory leaks. Due to the languages manual memory management
the programmer is
required to know so much information about the hardware they write for,
and the second anything goes
wrong, it is vague on how to fix things.

.B "I need a language that stops me from shooting myself in the foot"

C has been standard for many decades now and its age is showing, it lacks
many modern features like
OOP, or higher level functional abstractions, that have become common in
modern years due to there
helpfulness. This is not to fault C's achievements either, the language is
my personal choice for
most projects for a reason, it's fast and powerful; any solution I make
should not cut that away.

.NH 2
A solution
.LP
.BI "Zippy LANG"

A next generation language, for general use. Designed for keeping code simple,
neat and readable.
It will be similar to functional languages, known for there strict ability
to keep code safe and
practical. The language should be interpreted like python, perl and lisp,
to allow for easy
debugging tools.

The goal of Zippy is to make codding easier, while remaining fast, with a
interpreter writen in C.

.NH 2
What is a programming language
.NH 3
A very simple explanation
.LP
At its lowest definition a PL is a set of specific words, that when given
to a computer in the
right order have a reproducible behaviour. A more human way of saying that,
would be its how we
control computers.
.NH 3
Why are there so many
.LP
When someone is looking at code it can often be seen as just that, however
there are hundreds of
languages that all take the idea of "code" in very different ways. Some are
designed for specific
hardware, some are designed for making general use programs while others
are highly specialized.
It is important to see "code", as more than just one overarching term and
instead see where the code
is being used, and evaluate it from that.


.NH 2
Researching, and getting a scope of the project
.LP
Before I start to design a language i should first find examples of others
and find what i want my
language to be like.

I'd like my language to feel modern so i should take inspiration from what
other modern languages
do, however on the backed i want my language to be stable and fast, for that
i should look at
older projects.

.NH 3
Examples of older similar projects, that are a good base for my language
.NH 4
Python
.LP
Python is a high level OOP language that was designed in 1991. It was made
to make programming easy
while still being able to use some of C's functions. Although it has become
standard for many use
cases, it is slow and inefficient, and very bloated.

https://www.python.org/

Zippy should take pythons high level abstractions, as they make programming
very easy and it should
try and take notes from its libraries as they are mostly well written,
and well documented.
.NH 4
Lisp
.LP
Lisp is the second ever programming language, developed at MiT, it is the
first functional language,
creating many common features like higher order functions, recursion, and
garbage collection. It is
generally not used any more as it feels old compared to other functional
languages, like Ocaml or
Haskell.

https://lisp-lang.org/

Zippy should try to take alot from the syntax of lisp, () make it easy to
see what parts of code
will effect what, and make things easy to parse.
.NH 4
Perl
.LP
Perl is scripting language designed for use in linux, when bash is too slow,
or not suited for the
job. Perl is often described as the glue of the universe (see xkcd
https://3d.xkcd.com/224/).
Its syntax is quite strange however and it is slow. Making it poorly suited
towards general use.

https://www.perl.org/

Zippy should take from perls minimalism, it is a small language that is of
a similar size to bash
or zsh, while feeling closer to python. If Zippy can achieve a similar small
size, while remaining
powerful I will be happy.

.NH 3
Examples of new similar projects that are also a good base
.NH 4
Gleam
.LP
Gleam is a modern language releasing in the past 5 years. It is highly
functional, with no mutable
data, no traditional loops. Instead recursion can be used to replace alot
of these features.
Gleam compiles to erlang/Beam bytecode, much like java to the jvm, and doing
this has made Gleam
a highly scalable language with good library support out the box.

https://gleam.run/

Zippy should take from the functional elements of Gleam, as they keep programs
safer, however Zippy
should not remove all procedural elements, as for loops are very helpful
.NH 4
Haskell
.LP
Haskell is another modern functional language known for being very complicated,
however incredibly
powerful. Its syntax feels very mathematical, and incredibly terse.

https://www.haskell.org/

Perhaps Zippy could learn from Haskell, as it provides functional and
procedural elements, making it
a well rounded language
.NH 4
Hare
.LP
Hare was designed to be a 100 year language, and thus stability is its main
goal, it is not set to
have a syntax change any time soon, and it has strong emphasis on memory
safety. It fits into the
same part of the tech stack as C, and thus it can be used for some very low
level work.

https://harelang.org/

I think Zippy should have a strong emphasis on stability, much like Hare,
to many times have I segfaulted due to a
tiny mistake. Zippy should also look to Hare's small size, you can buy a
copy of Hare on a

.B "SINGLE 3 1/2'' FLOLPY"

.LP
This is something I too should try to achieve.

.NH 3
What should be taken away from these languages?
.LP
I was already leaning towards functional programming when I started this
project however now I
believe it's the only option for producing safe applications. Zippy will be
a functional language
with a strong emphasis on recursion.

I also believe that I should take size of the interpreter into account,
as this is important for
keeping the project manageable and consistent.

And finally I think that syntax should be inspired by Lisp, although Lisp
itself can be a messy
language, with the right changes I am confident that I can make a attractive
language for the 21st
century.

.NH 2
Clients
.LP
In a project of this nature, the Client is every programmer alive; which is
a pretty large scope.
To narrow this down as much as possible, I will interview a small handful
of people throughout the
project, of different skill levels.

.NH 3
Client 1, Amy C
.LP
My first client is a friend of mine, Amy C, she is a confident programmer
who has completed many
complicated projects. I am choosing her as a client as she can give me
technical feed back on my
project and its function/utility.
.NH 3
Client 2, Rayn M
.LP
Another friend of mine, Rayn M, is a technical computer user, however he
does not know how to
program at a high level. He will be a good client as he can show me how my
language looks to
some one who doesn't understand the inside workings, helping me design the
structure of the code.
.NH 3
Client 3, a normie
.LP
some stuff about how the normie finds the completed project.
.NH 3
Client 4, myself
.LP
I've wanted to take out a project like this for a long long time, and this
is the perfect
opportunity to do so, I will be assessing myself along the way of this,
building the project to my
personal specification.

.NH 2
Questionnaires
.LP
It is important to get feedback from end users, so I will take multiple
questionnaires throughout
the project. I will then use them to slightly edit the requirements of my
project this should make
the final outcome more helpful and what people want.

In the section bellow you will find questionnaires from the analyses stage
of my project.
.NH 3
Questionnaire 1 for Amy C

.BI "[30th April 2024]"
.BI "answered by Amy, see pull request she left"
.NH 4
What do you find the most important in a language? (eg: speed, readability)
.LP
Speed, readability, debugging ease and disk space efficiency.
.NH 4
What tools are important for a language to have? (eg: pkg-manager, IDE
integration)
.LP
IDE integration (things like tab complete and debugging tools), a package
manager, and the ability
to interact with the user through the command line easily.
.NH 4
What features do you like from other languages (eg: C's advanced memory
management, haskell's terse
syntax)
.LP
The ability to pass the memory reference of an object or function and a
collection of built-in or
standard functions like "print", "split", or "sort".
.NH 4
What do you want to program in this language (eg: websites, low level systems)
.LP
Lightweight command line tools and web back ends.
.NH 4
Do you intend to use graphics in the programs you write?
.LP
No.
.NH 4
Would you prefer a language that focuses on ease of use, or power of the code?
.LP
I like a good balance between the two.
.NH 4
What were your last 3 projects? (could they have been written in Zippy?)
.LP
A website, a small command-line tool and a midi keyboard (program runs on
a Raspberry Pi Pico).
.NH 4
How many languages would you use on a single project? (could Zippy be used
in your codebase?)
.LP
I try to use as little languages in a project as possible, so likely not in
an existing project.
.NH 4
Do you care for low level control, or would you prefer high level abstractions?
.LP
I think low-level control is very important, but high-level abstractions
are convenient, so a good
balance between the two is best.
.NH 4
Would you be happy to develop libraries for things that aren't already
implemented
(eg: an SQL library)
.LP
Potentially if it is simple enough to implement new things.

.NH 3
Notes from questionnaire 1
.LP
Some of the key things that I'm taking away from this first questionnaire,
are my client/users
initial needs and use cases. I think it's clear my language can be of
assistance to my client, Zippy
will be a good language for web back ends and small command line tools,
which my client expressed
interested in.

I find the fact my client is worried by executable size interesting, however
I doubt it will be an
issue; a ballooning code-base is unlikely as only one person is writing
the project.

I am also taking on the fact that my client wants good command line tools,
so a pkg-manager and
bundler should be a priority, perhaps they could be written in Zippy after
the interpreter is done.

.NH 2
The first elements of the project
.LP
At this stage I can say that I'm confident in my project and its scope. I
have a goal in mind for
it.

.B "The key things to take away from this section are:"

.B ----
Make a high level language with a useable set of features, to replace C in
many situations.

.B ----
Keep the language readable and easy, with powerful tools available.

.B ----
Ensure the language is well supported with tools like a pkg-manager.

.NH 2
Moddeling
.LP
In larger projects, when a programmer needs a data structure that the language
they are writing in
doesn't provide, they will need to make their own.

Bellow are a few examples of these data structures that C doesn't already
provide.
.NH 3
Linked lists
.LP
this is an alternative implementation of a list, where you store some data,
and the memory address
to the next node. Then you can move through the list by reading the data
then reading the data of
the next node, and then repeating until the 'next' part of the node is empty.

A diagram showing this can be seen here:

.PSPIC linkedlist.ps

.LP
In C this is easy to implement as you can find a memory address very easily
with '&' to find where
a bit of data is stored. I will need to use a 'struct', which is a bit like
a class in C (however
you can't attach a function to it). A simple implementation looks like this:

typedef struct ll {
        void *data; // the data of the node
        ll *next; // the next node

} ll;

.LP
The pro's of a linked list are the fact that they can have data appended to
the start or end easily
by changing the root node, or the next node.

Linked lists have a few downsides, for example you can't move through them
backwards, and unless you
store it on its own, you cant find the length of it in a fast way.

In my project I would like to use linked list in the AST (see later sections
for info), and to store
lists in the language.
.NH 3
Dictionaries
.LP
A dictionary is a simple data structure that just stores, a bit of data,
and a number or string to
identify it.
A dictionary like a linked list can be implemented with a struct in c like so:

typedef struct dict {
        void *data;
        int id;

} dict;

.LP
In my project I think I could use a linked list represent a Zippy variable
and an ID that i can use
to identify it, this could make execution faster as i can compare ID's
rather than string values

.NH 2
Prototyping hard features
.NH 3
Abstract Syntax Trees (AST) theory
.LP
In a programming language many abstract data types will be used to allow
the code to execute,
however I think the hardest part of this is an abstract syntax tree. This
is a data structure that
holds the code in an ordered form that can be analysed and executed in a
simple way. It is a tree
structure, with the top node being a root and all lower nodes being things
needed to calculate the
root. It can be used not only for code but also for mathematical expressions. I
think the easiest
way to show it is via a mathematical example

Take the follow expression for example:

.BX "(1 + (10 * (3 - (2 * 4))))"

We know that this is equal to -49

However for a computer this is far harder to understand. This is because it
has no understanding of
order of operation

To solve this we use an AST (abstract syntax tree)

When you solve that expression you know to start with (2 * 4), then 3 -
the answer to that and so on

We can represent the steps as a tree like so:

.PSPIC ast.ps

.I "[Evalutates to 2 * (2 + 2)]"

As you can see, you need to evaluate the expression in the most brackets
first, then the next, and
so on, working you way up

You can evaluate code in a similar way, treating each operation (such as +-*/)
as functions, doing
the most deeply nested function first, then working up. Each expression can
be represented in this
tree, then to show a whole program you can create a list of trees

.NH 3
Implementing AST's
.LP
As a prototype i will make a program that can take mathematical expressions
and evaluate them, and
allowing for functions (in the form f(x)).
It will do this via AST's

This prototype takes 173 lines of code, it takes a string as a cmd line
argument then converts it
into an abstract syntax tree, and finally it executes it. This is just a
simple prototype and thus
it is small in scope. It can only do simple operators (+-*/) and requires
literal values to be
surrounded by [] so it knows its not another expression to evaluate.

https://github.com/standenboy/school/tree/master/comp/lucas-standen-NEA/code/proto/ast

.PSPIC astg.ps

.LP
Above is the code for the AST, it stores an operation (which is just an
integer), and it stores
a real left and real right value, along side two other nodes. The real values
are integers, this
would be the 2 numbers in reference in the expression. The 2 nodes are a
recursive data structure,
much like putting an object of a class inside the definition of that class
itself. They are used to
store values that may still be expressions, for example (+ [1] (+ [1] [1]))
the second part of this
expression would be in the "right" variable. When code is executed I can
check if "left", or "right"
are null and if they are i know that i am at the lowest expression that is
only literal values.
Then I can execute that node and work my way up the tree.


The exec function will execute the operation, unless there is a deeper node,
if there is a deeper
node, then it executes it, and places the result in the right or left spot
respectively.

Expressions are taken as input with the following code, and converted into
the AST:

https://github.com/standenboy/school/tree/master/comp/lucas-standen-NEA/code/proto/ast

.PSPIC ast.c.ps

Here is an example input and output:

 ./ast "(+ (- [3] [1]) (- [3] [1]))"

.BX 4

Note the [] used to tell the program where the literal values are.

Overall this was a relatively successful prototype, however it isn't fully
functional as a language
it has fit the design.

The rest of the code is the process of converting the string input to literal
values and inserting
them into the AST

.NH 3
Feedback
.LP
From my first Client (Amy C), she said that putting the numbers inside square
brackets was
inconvenient and annoying and it would be better if the numbers were separated
by spaces instead of
separate square bracket surrounded literals.

As this is a prototype I won't fix this issue, however in the actual language
this is a needed
feature that I will be implementing.

.NH 3
Mixing linked lists and AST's
.LP
Mixing these 2 data structures together you can repressent an entire program. A
linked list of
AST's is how Zippy will repressent all code the user writes

Here is an example of this:

.PSPIC AST+LL.ps

.LP
In this example the linked list is represented by the numbers seen at the top,
and the AST's are the
tree's moving down.

As you can see when a value is referenced that is from a different AST the
tree will link to another
one. This will work the same for function calls, however instead of linking
to value definitions it
will link to function definitions.

.NH 2
Objectives
.NH 3
An interpreter for the Zippy language
.NH 4
Linked list of AST's
.LP
All of a loaded program should be represented as a linked list of individual
AST's, The developer
should be able to access the AST for easy hacking. Functions can be represented
as a pointer to
another part of the list.
.NH 4
A lisp like syntax
.LP
This is to ensure the language can be parsed quickly, and is easy to write.
.NH 4
Functional language
.LP
This language should lean into the functional programming paradigm, taking
inspiration from other
functional languages such as lisp, and gleam.
.NH 5
Recursion
.LP
Zippy must support recursive algorithms being implemented into it, this will
make the AST, have
nodes linking back to parent nodes in a linked list.
.NH 5
Higher order functions
.LP
Zippy must support the usage of higher order functions, this will mean the
AST needs to have an
unlimited depth as otherwise the limit would be quickly reached, it can't
be hard-coded, it must be
dynamic.
.NH 4
Performance
.LP
The interpreter must be fast and memory efficient, the language is designed
to work as an
alternative to C, one of the fastest languages of all time, the interpreter
must be fast, however
memory footprint is not as much of a requirement.
.NH 4
Safe
.LP
Code that the user writes must be safe, and not prone to errors. This can
be handeled via the strong
syntax checker and type safety.

.NH 3
Standard library for Zippy
.NH 4
io
.LP
The language must have a simple to use I/O library to make outputs easy.
.NH 4
string
.LP
The language should have a sting library that provides a string type, and
many complex algorithms
that can be applied to them (concatenation, insertion, appending, splitting,
stripping).
.NH 4
sorts
.LP
The language should have a sorting library that provides algorithms used
for sorting (like merge
sort).
.NH 4
graphs
.LP
the language must have a graph library, that allows for easy creation and
working with graphs, it
should provide many algorithms to help traverse these graphs

.NH 3
Tooling for the Zippy language
.NH 4
zpypkg
.LP
Zippy must provide a package manager, that allows code to be shared between
multiple users, easily.
It should sync projects via git and allow them to be stored on any git host
the user likes.
.NH 4
Syntax checker
.LP
Zippy shouldn't have a built in syntax checker, instead it should be something
that can be run
independently of the interpreter, this means that a lot of the checking that
interpreted languages
do, can be done once by the developer, before shipping the app, as opposed
to every time the program
is run, which brings down performance.
.NH 3
Integration with C, via a C API
.NH 4
C API
.LP
You should be able to execute a string of Zippy code in C using a library
that is linked with
interpreter. This could allow Zippy to be used as a configuration language
like Lua.

.NH 2
Desirable features
.LP
If time allows I'd like to add some of the following features to flesh out
the language:
.NH 3
Raylib support
.LP
Raylib is a powerful game engine for C, however it has been ported to most
languages under the
sun due to how simple it is. If I have time, porting Raylib to Zippy would
make the language
far more useable, as it can be use for graphics programming.

https://www.Raylib.com/

.NH 3
Vim integration.
.LP
Zippy should have integration with the Vim editor for syntax highlighting,
this can be done via
generating a linked list of AST's then colouring function calls a specific
colour, and variables
another, etc, etc.
.NH 3
LSP
.LP
A LSP (language server protocol), is used in code IDE's to auto complete
code for you, I'd
like one for Zippy. Although I am unsure as to how to tackle this. I believe
a program called
treesitter can be helpful for this.
.NH 3
Networking sockets
.LP
If possible I'd also like to provide bindings for unix network sockets,
however this would be
very difficult, as I would need to allow Zippy stucts to be directly converted
to C stucts,
when executing ELF symbols (Parts of an execuable file).

.NH 1
Design
.NH 2
Language specification
.LP
Like any other programming language Zippy needs to have a defined syntax,
as mentioned in the
objectives section of Analysis, I want the language to follow a lisp like
syntax.

I also believe higher order functions should be taken as standard and many
core functions will use
them.

.NH 3
Data types
.NH 4
Basic types
.LP
i32 - signed integer of size 32 bits

u32 - unsigned integer of size 32 bits

i64 - signed integer of size 64 bits

u64 - unsigned integer of size 64 bits

char - single ascii code

float - standard C float

.NH 4
Advanced types
.LP
function - a function that can be used

generic - should be avoided, removes checks for data types when inputting
values to functions
will cause many runtime errors, however when absolutely needed it is useful.

.NH 4
Arrays
.LP
Arrays can be show like so:

x:type[]

With x being the variable name, type being the type of variable, and []
showing its an array

All arrays are dynamic, represented by a linked list on the back end.
.NH 5
Strings
.LP
Strings, like in C are arrays of chars

.NH 3
Built in functions
.NH 4
defun
.LP
(defun a:type b:type returntype
        ...
        ...

)

Returns a function that take A and B as an argument (fixed types), and
returns a value of
returntype.

.NH 4
let
.LP
(let x:type value)

Creates constant x of type type to value.

.NH 4
set
.LP
(set x:type value)

Creates/recreates the variable value of x to value.

.NH 4
if/elif/else
.LP
(if condition function)

(elif condition function)

(else function)


Executes the function provided if the condition is true.

Elif works the same, except only if the previous if statement is false.

Else executes only if all previous statements were false.

.NH 4
for
.LP
(for i (condition) function)

Runs the function while the condition is true, and increments i every time
the function
is called.

.NH 4
while
.LP
(while condition function)

Runs the function if the condition is true, keeps running until it is false.

.NH 4
symbol
.LP
(symbol a:type b:type c:type returntype name:char[] elf:char[])

Returns a function that takes arguments A, B, C (of fixed types), the name
of the function,
and the file path of the elf.
.NH 5

.NH 4
Arithmetic operations
.LP
Simple operations

(+ a b) returns a + b

(- a b) returns a - b

(* a b) returns a * b

(/ a b) returns a / b

.NH 4
Comparison
.LP
All return true or false

(= a b) returns if a = b

(!= a b) returns if a != b

(> a b) returns if a > b

(< a b) returns if a < b

(=> a b) returns if a => b

(=< a b) returns if a =< b

.NH 4
cast
.LP
(cast a:generic type:char[])

returns a but cast to data type type, which is a string.

.NH 4
typeof
.LP
(typeof a:generic)

returns in a string the type that variable A is.

.NH 4
terminate
.LP
(terminate error:error)

Kills the program at the current point, frees all related memory, prints
error info stored in error.

.NH 4
return
.LP
(return a:type)

Must be used in defun, returns "a" from the function, "a" must be of the
functions return type.

.NH 3
List of keywords
.LP
defun

for

while

if

elif

else

exit

return

symbol

set

let

.NH 2
Memory management
.LP
Memory will be allocated when a variable is initialized, and freed when the
program stops.
Although this isn't the fastest method, it is simple and has less runtime
overhead.

.NH 2
Questionnaire 2 for Rayn M
.NH 3
How do you find this layout of the language?
.LP
.I "(5-6 points)"
- I like the immutable nature of the language
- I like the simplicity
- I like the low level performance this will have
- I dislike the word terminate
- I like the procedural approach, with the function robustness
- I dislike the brackets!
.NH 3
Response
.LP
Although he does dislike some of my features I believe them to be core parts
of the language so
I will keep them. I will also keep his points in mind though, I don't want
to discourage learning
the language due to its abstract syntax.

However as per his request I will change the terminate keyword to the more
normal exit.

An updated keyword list is as flows:

defun

for

while

if

elif

else

exit

return

symbol

set

let

.NH 2
What language do you use to make a programming language
.LP
As mentioned before Zippy will be written in C, with some parts being written
in Zippy itself.
I will try and keep most dependencies/libraries to a minimal to make the
project easier to manage.

.NH 3
What is C?
.LP
C was made by Dennis Ritchie, in 1972 at AT&T's bell labs. It was designed
to make programming low
level systems far easier than it had been before. It was used to create the
unix operating system
which would go on to inspire most modern operating systems in some way. (macos
still has code from
the original release of C+unix).

The language quickly caught on outside of bell labs after more available
releases of unix arrived
such as bsd 4.4, sun os and GNU. It was found to be able to do all the things
that you could do in
ASM however with far less a headache.

.NH 3
Why is C?
.LP
As mentioned C can do anything that ASM can do, meaning it is lightning fast
and can take advantage
of direct memory access. This allows you to make very fast lightweight
executables that can rival
the performance of handwritten ASM (often beating it if you enable compiler
optimisations). It is
this that makes C the perfect language for any and all programming languages,
where speed is key,
and allfeatures need to be available are present.

.NH 3
How is C?
.LP
C is compiled to ASM, the main compilers available are clang, gcc and MSVC,
I will be using gcc
as it is generally standard in linux environments.

Many build systems are available for C, the main ones being cmake and gnu
make. Both of them have
the goal of putting the compiling process in one command. Cmake is cross
platform (sorta windows
doesn't work well but it does work).

.NH 3
Libraries
.LP
The libraries I will use are the following:

C stdlib

C unistd

C errno

Unix device files

Zippy strings

Zippy graphs

Zippy sorts

Addition libraries (may not be implemented):

Raylib

C sockets + Zippy sockets

.NH 3
Modularization
.LP
To make the project more manageable I will split it into many C files,
this is to keep it from
becoming impossible to edit code.

The file layout looks as follows:

PLACE HERE

As you can see this is split up over around 40 files and 16 folders, each
file should not go over
~500 lines of code. This is to keep everything as easy to manage as possible.

This level of modularization in needed for the development of Zippy as
without it, files will become
a mess that can't be worked with.

All .c files will be compiled into .o files, then the .o files can be linked
with the final zpy.c
to generate the final executable.


.NH 4
Build system
.LP
The entire project is being build with GNU make files, each folder that
builds something will have
its own makefile. This will mean the entire project can be compiled with a
single make in the root
folder of the project.

Example of make:

make -j2

This will build all files specified by 'Makefile' with 2 threads.

The project should be build with gcc, and ld. It should be build with the
-O3 build flag to ensure
the program runs as fast as possible. -O3 forces the compiler to build with
optimizations.

When the project is finished, I will try compiling with clang and tcc,
to compare performance.

.NH 2
Time table
.LP
The first step is to tackle the interpreter, so the zpy.c file needs to be
finished. The tokenizer,
execution, and libs folders need to be finished, after this point you should
be able to execute
Zippy code however not syntax check it or get error handling.

The next step is zpycheck, the syntax and error handler, this should be ran
before code is shipped
to the user. It can reuse a lot of code from the tokenizer and execution steps.

Finally I need to make zpypkg, this should be easy as most of it can be
written in Zippy, and a few
bits can be written in bash. It should be a good test to how Zippy can
be written.

If time allows it is at this point that I will write a Raylib library and
a unix/C sockets library.

.NH 2
Flow through the system
.LP
The alogrithum to run code is quite complex however it can be boiled down
to a few simple steps:

.B "read the text file (strip line breaks and tabs)"
.LP
.B "create an empty linked list"
.LP
.B "get the first expression from the text file (with be encapsulated with
"()""
.B "get the function call and its args into a token"
.LP
.B "if the arguments of the function are there own function call, then
convert them into a token"
.LP
.B "set that token as the argument in the first token"
.LP
.B "append the root token to the linked list"
.LP
.B "repeat until the text file string is empty"
.LP
.B "allocate memory for the program and prepare the exection step"
.LP
.B "at the start of the linked list traverse to the bottem of the tree
(made of tokens)"
.LP
.B "execute the lowest token"
.LP
.B "repeat until all tokens including the root have been executed"
.LP
.B "move to the next node of the linked list"
.LP
.B "repeat until the linked list is empty"

.LP
Within each of these steps is many smaller steps. The hardest part will be
making the tokens, as
this requires alot of string manipultation. The execution will be a recursive
alogrithum. All trees
will be represented via structs (see section on AST's).

PUT SOME FLOW CHARTS HERE

.NH 1
Technical Solution
.NH 1
Testing
.NH 1
Evaluation
.AE