diff options
Diffstat (limited to 'comp/lucas-standen-NEA/writeup2/coverpage.ms')
| -rw-r--r-- | comp/lucas-standen-NEA/writeup2/coverpage.ms | 1208 |
1 files changed, 0 insertions, 1208 deletions
diff --git a/comp/lucas-standen-NEA/writeup2/coverpage.ms b/comp/lucas-standen-NEA/writeup2/coverpage.ms deleted file mode 100644 index e18f9c0..0000000 --- a/comp/lucas-standen-NEA/writeup2/coverpage.ms +++ /dev/null @@ -1,1208 +0,0 @@ -.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 |