zippy supports arrays!

1 files changed, 456 insertions, 237 deletions

diff --git a/comp/lucas-standen-NEA/writeup/coverpage.ms b/comp/lucas-standen-NEA/writeup/coverpage.ms
index f99dd7f..e18f9c0 100644
--- a/comp/lucas-standen-NEA/writeup/coverpage.ms
+++ b/comp/lucas-standen-NEA/writeup/coverpage.ms
@@ -1,12 +1,9 @@
 .TL
-The solution
-
-To bad code
+The solution To bad code
 .AU
 Lucas Standen
 .AI
 7949
-
 .AB
 
 .NH 1
@@ -16,71 +13,98 @@ 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 100 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. 
+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 
+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.
+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 
+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.
+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
+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
+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
+.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 
+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
@@ -88,37 +112,50 @@ 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 
+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.
+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 
+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 
+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.
+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 
+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
@@ -126,36 +163,47 @@ 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
+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
+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
+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
+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.
+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 
+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"
 
@@ -165,36 +213,48 @@ 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
+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 
+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
+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 
+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 
+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.
+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
@@ -202,37 +262,46 @@ 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 
+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 
+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.
+In the section bellow you will find questionnaires from the analyses stage
+of my project.
 .NH 3
-Questionnaire 1 for Amy C  
+Questionnaire 1 for Amy C
 
 .BI "[30th April 2024]"
 .BI "answered by Amy, see pull request she left"
-.NH 4 
+.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)
+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 
+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 
+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 
+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)
@@ -249,18 +318,23 @@ 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).
+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?)
+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.
+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 
+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 
+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.
@@ -268,46 +342,59 @@ 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
+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 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.
+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 
+.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 
+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 ----
+Make a high level language with a useable set of features, to replace C in
+many situations.
 
-.B ---- 
+.B ----
 Keep the language readable and easy, with powerful tools available.
 
-.B ---- 
+.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 
+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.
+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 
+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:
@@ -315,8 +402,10 @@ 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 
+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 {
@@ -326,29 +415,34 @@ typedef struct ll {
 } ll;
 
 .LP
-The pro's of a linked list are the fact that they can have data appended to the start or end easily 
+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 
+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 
+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 
+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;    
+        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 
+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
 
@@ -357,49 +451,63 @@ 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 
+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 
+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 
+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
+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 
+.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 
+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 
+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 
+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 
+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
@@ -407,20 +515,30 @@ https://github.com/standenboy/school/tree/master/comp/lucas-standen-NEA/code/pro
 .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.
+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.
+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:
+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
 
@@ -434,26 +552,32 @@ Here is an example input and output:
 
 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 
+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
+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
+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 
+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
+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:
@@ -461,57 +585,69 @@ 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 
+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
+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 
+.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 
+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 
+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
+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
+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 
+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
+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
+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 
+Standard library for Zippy
 .NH 4
 io
 .LP
@@ -519,17 +655,21 @@ 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).
+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 
+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
+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
@@ -537,32 +677,42 @@ 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.
+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 
+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.
+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:
+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
+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/
@@ -570,20 +720,26 @@ 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 
+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
+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,
+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
@@ -591,10 +747,13 @@ 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.
+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
+I also believe higher order functions should be taken as standard and many
+core functions will use
 them.
 
 .NH 3
@@ -619,7 +778,8 @@ Advanced types
 .LP
 function - a function that can be used
 
-generic - should be avoided, removes checks for data types when inputting values to functions
+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
@@ -629,7 +789,8 @@ 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
+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
@@ -648,7 +809,8 @@ defun
 
 )
 
-Returns a function that take A and B as an argument (fixed types), and returns a value of
+Returns a function that take A and B as an argument (fixed types), and
+returns a value of
 returntype.
 
 .NH 4
@@ -686,7 +848,8 @@ for
 .LP
 (for i (condition) function)
 
-Runs the function while the condition is true, and increments i every time the function
+Runs the function while the condition is true, and increments i every time
+the function
 is called.
 
 .NH 4
@@ -701,14 +864,15 @@ 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,
+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 
+Simple operations
 
 (+ a b) returns a + b
 
@@ -737,7 +901,7 @@ All return true or false
 
 .NH 4
 cast
-.LP 
+.LP
 (cast a:generic type:char[])
 
 returns a but cast to data type type, which is a string.
@@ -754,14 +918,16 @@ terminate
 .LP
 (terminate error:error)
 
-Kills the program at the current point, frees all related memory, prints error info stored in 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.
+Must be used in defun, returns "a" from the function, "a" must be of the
+functions return type.
 
 .NH 3
 List of keywords
@@ -791,13 +957,15 @@ 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.
+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 
+.NH 2
 Questionnaire 2 for Rayn M
 .NH 3
-How do you find this layout of the language? 
+How do you find this layout of the language?
 .LP
 .I "(5-6 points)"
 - I like the immutable nature of the language
@@ -809,11 +977,14 @@ How do you find this layout of the language?
 .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
+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.
+However as per his request I will change the terminate keyword to the more
+normal exit.
 
 An updated keyword list is as flows:
 
@@ -842,38 +1013,52 @@ 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.
+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
+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 
+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, 
+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
+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 
+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
@@ -904,29 +1089,35 @@ 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 
+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
+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
+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
+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 
+.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. 
+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:
 
@@ -934,48 +1125,76 @@ 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.
+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.
+When the project is finished, I will try compiling with clang and tcc,
+to compare performance.
 
-.NH 2 
+.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 
+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 
+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.
+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.
+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:
+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"
-.B "get the first expression from the text file (with be encapsulated with "()""
+.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"
-.B "if the arguments of the function are there own function call, then convert them 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"
-.B "at the start of the linked list traverse to the bottem of the tree (made of tokens)"
+.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"
 
-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
+.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