diff options
Diffstat (limited to 'comp/lucas-standen-NEA/writeup/t support the usage of higher order functions, this will mean the')
| -rw-r--r-- | comp/lucas-standen-NEA/writeup/t support the usage of higher order functions, this will mean the | 1208 |
1 files changed, 1208 insertions, 0 deletions
diff --git a/comp/lucas-standen-NEA/writeup/t support the usage of higher order functions, this will mean the b/comp/lucas-standen-NEA/writeup/t support the usage of higher order functions, this will mean the new file mode 100644 index 0000000..e18f9c0 --- /dev/null +++ b/comp/lucas-standen-NEA/writeup/t support the usage of higher order functions, this will mean the @@ -0,0 +1,1208 @@ +.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 |