diff options
Diffstat (limited to 'comp/lucas-standen-NEA')
25 files changed, 792 insertions, 0 deletions
diff --git a/comp/lucas-standen-NEA/code/Makefile b/comp/lucas-standen-NEA/code/Makefile new file mode 100644 index 0000000..a30526c --- /dev/null +++ b/comp/lucas-standen-NEA/code/Makefile @@ -0,0 +1,6 @@ +all: + cd ads; make + cd parser; make + +tests: all + cd ads; make tests diff --git a/comp/lucas-standen-NEA/code/ads/Makefile b/comp/lucas-standen-NEA/code/ads/Makefile new file mode 100644 index 0000000..d6332cb --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/Makefile @@ -0,0 +1,6 @@ +all: + cd dict; make + cd ll; make +tests: all + cd dict; make test + cd ll; make test diff --git a/comp/lucas-standen-NEA/code/ads/dict/Makefile b/comp/lucas-standen-NEA/code/ads/dict/Makefile new file mode 100644 index 0000000..f224267 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/dict/Makefile @@ -0,0 +1,4 @@ +all: dict.c + cc dict.c -c -o dict.o +test: all + cc dict.o dicttest.c -o dicttest diff --git a/comp/lucas-standen-NEA/code/ads/dict/dict.c b/comp/lucas-standen-NEA/code/ads/dict/dict.c new file mode 100644 index 0000000..551afca --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/dict/dict.c @@ -0,0 +1,29 @@ +#include <stdlib.h> +#include <string.h> + +typedef struct dict_t { + int id; + void *data; +}dict_t; + +dict_t *dictalloc(){ + dict_t *output = malloc(sizeof(dict_t)); + return output; +} + +int dictset(dict_t *dict, int id, void *data){ + dict->id = id; + + dict->data = malloc(sizeof(data)); + if (dict->data == NULL) + return 1; + memcpy(dict->data, data, sizeof(data)); + + return 0; +} + +void dictfree(dict_t *dict){ + free(dict->data); + free(dict); +} + diff --git a/comp/lucas-standen-NEA/code/ads/dict/dict.h b/comp/lucas-standen-NEA/code/ads/dict/dict.h new file mode 100644 index 0000000..e6ab69d --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/dict/dict.h @@ -0,0 +1,9 @@ +typedef struct dict_t { + int id; + void *data; +}dict_t; + +dict_t *dictalloc(); +int dictset(dict_t *dict, int id, void *data); +void dictfree(dict_t *dict); + diff --git a/comp/lucas-standen-NEA/code/ads/dict/dicttest b/comp/lucas-standen-NEA/code/ads/dict/dicttest Binary files differnew file mode 100755 index 0000000..dddf2a0 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/dict/dicttest diff --git a/comp/lucas-standen-NEA/code/ads/dict/dicttest.c b/comp/lucas-standen-NEA/code/ads/dict/dicttest.c new file mode 100644 index 0000000..4a20870 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/dict/dicttest.c @@ -0,0 +1,10 @@ +#include <stdio.h> + +#include "dict.h" + +int main(){ + dict_t *dict = dictalloc(); + dictset(dict, 1, "hello"); + printf("%d:%s\n", dict->id, (char *)dict->data); + dictfree(dict); +} diff --git a/comp/lucas-standen-NEA/code/ads/ll/Makefile b/comp/lucas-standen-NEA/code/ads/ll/Makefile new file mode 100644 index 0000000..aaf0241 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/ll/Makefile @@ -0,0 +1,5 @@ +all: ll.c + cc ll.c -c -o ll.o + +test: all + cc ll.o lltest.c -o lltest diff --git a/comp/lucas-standen-NEA/code/ads/ll/ll.c b/comp/lucas-standen-NEA/code/ads/ll/ll.c new file mode 100644 index 0000000..ba0a0df --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/ll/ll.c @@ -0,0 +1,57 @@ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +typedef struct ll_t ll_t; + +typedef struct ll_t { + void *data; + ll_t *next; +} ll_t; + +ll_t *llalloc(){ + ll_t *output = malloc(sizeof(ll_t)); + if (output == NULL) + return NULL; + output->next = NULL; + return output; +} + +void llsetdata(ll_t *node, void *data){ + node->data = malloc(sizeof(data)); + memcpy(node->data, data, sizeof(data)); +} + +void llsetnext(ll_t *node, ll_t *next){ + if (node->next == NULL) + node->next = next; + else + llsetnext(node->next, next); +} + +void *llgetat(ll_t *head, int index){ + if (index == 0) + return head->data; + else { + if (head->next != NULL) { + return llgetat(head->next, index - 1); + }else { + return NULL; + } + } +} + +ll_t *llgetendnode(ll_t *head){ + if (head->next == NULL) + return head; + else + return llgetendnode(head->next); +} + +void llfreeall(ll_t *head){ + if (head->next != NULL) + llfreeall(head->next); + free(head->data); + free(head); +} + diff --git a/comp/lucas-standen-NEA/code/ads/ll/ll.h b/comp/lucas-standen-NEA/code/ads/ll/ll.h new file mode 100644 index 0000000..33b4d57 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/ll/ll.h @@ -0,0 +1,16 @@ +#include <stdlib.h> +#include <string.h> + +typedef struct ll_t ll_t; + +typedef struct ll_t { + void *data; + ll_t *next; +} ll_t; + +ll_t *llalloc(); +void llsetdata(ll_t *node, void *data); +void llsetnext(ll_t *node, ll_t *next); +void *llgetat(ll_t *head, int index); +ll_t *llgetendnode(ll_t *head); +void llfreeall(ll_t *head); diff --git a/comp/lucas-standen-NEA/code/ads/ll/lltest b/comp/lucas-standen-NEA/code/ads/ll/lltest Binary files differnew file mode 100755 index 0000000..14653f6 --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/ll/lltest diff --git a/comp/lucas-standen-NEA/code/ads/ll/lltest.c b/comp/lucas-standen-NEA/code/ads/ll/lltest.c new file mode 100644 index 0000000..454acdf --- /dev/null +++ b/comp/lucas-standen-NEA/code/ads/ll/lltest.c @@ -0,0 +1,19 @@ +#include <stdio.h> + +#include "ll.h" + +int main(){ + ll_t *head = llalloc(); + llsetdata(head, "hello"); + + for (int i = 0; i < 3; i++){ + ll_t *node = llalloc(); + llsetdata(node, "hi"); + llsetnext(head, node); + } + for (int i = 0; i < 4; i++) + printf("%s\n", (char *)llgetat(head, i)); + printf("%s\n", llgetendnode(head)->data); + + llfreeall(head); +} diff --git a/comp/lucas-standen-NEA/code/parser/Makefile b/comp/lucas-standen-NEA/code/parser/Makefile new file mode 100644 index 0000000..9325d95 --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/Makefile @@ -0,0 +1,12 @@ +all: readfile preprocesor parser + cc readfile.o preprocessor.o parser.o -o parser + +readfile: + cc -c readfile.c -o readfile.o +preprocesor: + cc -c preprocessor.c -o preprocessor.o +parser: parser.c + cc -c parser.c -o parser.o + +clean: + rm -rf *.o parser diff --git a/comp/lucas-standen-NEA/code/parser/parser b/comp/lucas-standen-NEA/code/parser/parser Binary files differnew file mode 100755 index 0000000..9d996a8 --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/parser diff --git a/comp/lucas-standen-NEA/code/parser/parser.c b/comp/lucas-standen-NEA/code/parser/parser.c new file mode 100644 index 0000000..3162841 --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/parser.c @@ -0,0 +1,32 @@ +#include <string.h> +#include <stdio.h> +#include <stdbool.h> + +#include "preprocessor.h" + +int main(int argc, char **argv){ + if (argc <= 1){ + printf("no args given!\n"); + return 1; + } + char *code = preprocessor(argc, argv); + if (code == NULL){ + printf("falled to open file\n"); + return 1; + } + for (int i = 0; i < strlen(code); i++){ + if (code[i] == '{'){ + printf("\nopen-scope\n"); + } else if (code[i] == '}'){ + printf("\nclose-scope\n"); + }else { + if (code[i] == '(') + printf("\n"); + else if (code[i] != ')') + printf("%c", code[i]); + } + } + printf("\n"); + free(code); + return 0; +} diff --git a/comp/lucas-standen-NEA/code/parser/preprocessor.c b/comp/lucas-standen-NEA/code/parser/preprocessor.c new file mode 100644 index 0000000..92c6127 --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/preprocessor.c @@ -0,0 +1,24 @@ +#include <stdbool.h> +#include <string.h> + +#include "readfile.h" + +char *preprocessor(int argc, char **argv){ + char *buf = readfile(argv[1]); + if (buf == NULL) + return NULL; + + int i = 0; + + while (buf[i] != '\0'){ + if (buf[i] == '\n'){ + buf[i] = ' '; + } + if (buf[i] == '\t'){ + buf[i] = ' '; + } + i++; + } + + return buf; +} diff --git a/comp/lucas-standen-NEA/code/parser/preprocessor.h b/comp/lucas-standen-NEA/code/parser/preprocessor.h new file mode 100644 index 0000000..855240f --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/preprocessor.h @@ -0,0 +1,5 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +char *preprocessor(int argc, char **argv); diff --git a/comp/lucas-standen-NEA/code/parser/readfile.c b/comp/lucas-standen-NEA/code/parser/readfile.c new file mode 100644 index 0000000..391d5a5 --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/readfile.c @@ -0,0 +1,61 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <stdbool.h> + +bool instring = false; + +char *readfile(char *filepath){ + FILE *fptr; + fptr = fopen(filepath, "r"); + + if (fptr == NULL) + return NULL; + int size = 10; + char *buf = malloc(size); + char c; + + int i = 0; + + buf = buf+i; + buf[0] = '{'; + buf = buf-i; + + i++; + + while ((c = getc(fptr)) != EOF){ + if (i > size + 1){ + size = size + 10; + buf = realloc(buf, size); + } + if (c == '"'){ + if (instring == false) + instring = true; + else + instring = false; + } + + if (c == '!' && instring == false){ + while ((c = getc(fptr)) != EOF && c != '\n'){} + } + buf = buf+i; + buf[0] = c; + buf = buf-i; + i++; + + } + + buf = buf+i; + buf[0] = '}'; + buf = buf-i; + + i++; + + buf = buf+i; + buf[0] = '\0'; + buf = buf-i; + + fclose(fptr); + + return buf; +} diff --git a/comp/lucas-standen-NEA/code/parser/readfile.h b/comp/lucas-standen-NEA/code/parser/readfile.h new file mode 100644 index 0000000..12d98ec --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/readfile.h @@ -0,0 +1 @@ +char *readfile(char *filepath); diff --git a/comp/lucas-standen-NEA/code/parser/sample.zpy b/comp/lucas-standen-NEA/code/parser/sample.zpy new file mode 100644 index 0000000..e289d9d --- /dev/null +++ b/comp/lucas-standen-NEA/code/parser/sample.zpy @@ -0,0 +1,15 @@ +{ +(let fib:function +(defun num:i32 i32 + (if (< num 2) + (return num) + ) + (else + (return (+ (fib (- num 1)) (fib (- num 2)) )) + ) +)) +} +(let a:i32 (fib 5)) +(const str[]:char "hello!") +! returns the 5th fib number +(const str[]:char "hello!") diff --git a/comp/lucas-standen-NEA/overview b/comp/lucas-standen-NEA/overview new file mode 100644 index 0000000..5f7904e --- /dev/null +++ b/comp/lucas-standen-NEA/overview @@ -0,0 +1,302 @@ +CS course work project + +zippy - a high level functional programing language + +zippy will be an interpreted language designed to replace C in higher level use +C is used largely to write most of the unix desktop, however c can be difficult +when writing larger programs, and is missing moddern features like oop or +functional patterns (higher order functions) + +requirents: + - must be human readable, even a non programmer should be able to figure + out what a program is doing + - faster than competion, other languages that have tried to slot into + this position like python are far to slow, and thus it must be faster + - low runtime overhead, the interpreter should be small, it shouldn't + force the developer to think about how the interpreter works to use it + efficently + - have moddern tools, a pkg manager and enviroment manager, making it + easy to develop for + - needs to support c libarys + +language info + +zippy will use function programming as a primary solution, however also support +simple oop, with classes (no inheritence) +its syntax will be comparable to lisp, with prolific use of "()" +it will need a stdlib, which can be taken from C's stdlib + +types: + + char - just like a c char + i32 - 32 bit signed int + f32 - 32 bit signed float + u32 - unsigned 32 bit int + i16- 16 bit signed int + u16 - 16 bit unsigned int + bool - TRUE/FALSE + + + arrays: + + arrays can be created like so + (let arr[]:char "hello there") + (let arr[]:i32 1 2 3) + + all arrays are linked lists of there data type + their size is not fixed + + you can get, or set the value of an array at a specific index using + arr[index] + + strings: + + strings are arrays of chars + a string can be defined by a litteral like so + "hello world" - this is the same as 'h' 'e' 'l'.... + because this is represented as a linked list there is no need to have a + NULL terminator like in c, the end of the string is jus the point where the + linked list has no more nodes + +comments: + + comments can be writen like so + ! this is a comment + +indentation and spacing: + + indentation and new lines arent at all necesary + any new lines will be converted to spaces, and tabs will be removed + the only place that needs spaces is when calling a function and giving its args + +scopes: + + () can be placed anywhere, and anything that is in them is in there own scope + as soon as the bracket is closed, any variables defined in the scope + will be deleted + any scope inherets all variables and functions from the scope that contains it + code writen in the main body of the file can be imagined like so + ( + ... + ... + ... + your code + ... + ... + ... + ) + however that level of indentation is not needed + + this can be helpful if you want to have two scopes with different imports + ( + (import z) + ( + (import x) + ! anything writen here has access to libary x and z + ) + ( + (import y) + ! anything writen here has access to libary y and z + ) + ! anything writen here has access to libary z + ) + +libarys: + + libarys are similar to header files in c + when imported the user can use any function contained within the file + + it would be good practice to put your libary in a struct to avoid functions with the + same names coming from 2 libarys, however its not needed + +errors: + + errors would be + +keywords: + + (defun arg1:type arg2:type returnType + ... + ... + ... + ) + defines a function, can be done anywhere in the program, all functions + must return a value, return type and arguments must be known at runtime + + returns the function that can be asigned with let + + (return VALUE) + returns VALUE from a function, VALUE must be of the same tupe as returnType + in defun + + (for x a b function) + + runs the function inside the loop, x will be increment by 1 each iteration and + it will have a starting value of a running until it reaches b (inclusive) + x cant be changed in any way other than the for loop + x, a, b are all of type i32 + + (while condtion function) + + runs all code inside the loop until the condion is not TRUE + condition must be a bool (TRUE/FALSE) + + (let name:type value) + + assign value to variable name, this will create the variable if it doesn't already + exist, and overwrite it if it does + names type must be defined by type + + (const name:type value) + + same as let but creates an imutable variable + + (import libary) + + searches the libary dir and imports the libary to the current project + libary can also be a specific path if it starts with / or ./ or ../ + + (struct name + ... + ... + ... + (defun init arg1:type type + ... + ... + ... + ) + (defun deinit arg1:type type + ... + ... + ... + ) + ) + + structs can be used as a custom data type + creates a struct/class called name, functions called init will be ran when an + object is created + when deinit is called the code init will be ran, then the object will be deleted + if deinit is not defined it can still be called to delete the instace of the class + + you can create a struct like so: + (let mystruct:name (name.init arg1 arg2)) + + you can call a method attached to an instace of a struct like this: + (mystruct.method arg1 arg2) + + and to destroy it you can just use this: + (mystruct.deinit arg1 arg2) + + structs can be recursive + eg: + (struct node + (defun init next:node + (let next:node next) + ) + ) + + a struct can have default values + eg: + (struct person + (let age:i32 50) + (let name[]:char "john doe") + ... + ... + ... + ) + + this will make the struct have default values + + overall in simple terms structs are just like c structs but they can contain + functions + + (symbol arg1:type arg2:type returntype location) + + returns a function that can be called. the function is retrieved from a .o file + which can be writen in C, the args, should be the args that the function takes in + and there types + the interpreter will try to convert data to the equal type in C, however this may need + to be done manually + the location should be a string which is is the file path to the .o file + + (if condition + ... + ... + ... + )(elif condition + ... + ... + ... + )(else + ... + ... + ... + ) + + simple if statment, if condition is TRUE run the code inside, elif runs if the condition in it + is TRUE and if the previous has not been TRUE + else will run if nothing else is TRUE + + (cast TYPE variable) + + returns a variable casted to type TYPE, if type is function, will return a function with no args + that returns the variable value in its starting type + + conditions: + (= a b) returns TRUE if a is equal to be (works with arrays) + (!= a b) returns TRUE if a is not equal to be (works with arrays) + (> a b) returns TRUE if a > b (does not work with arrays) + (< a b) returns TRUE if a < b (does not work with arrays) + (>= a b) returns TRUE if a >= b (does not work with arrays) + (<= a b) returns TRUE if a <= b (does not work with arrays) + (! a) returns TRUE if a is FALSE (only works on bools) + (| a b) returns TRUE if a or b are TRUE (only works on bools) + (& a b) returns TRUE if a and b are TRUE (only works on bools) + (^ a b) returns TRUE if a xor b is true (only works on bools) + + all these are just functions that can be used to assign values + eg: + (let mybool:bool (= a b)) + ! mybool will be TRUE if a = b + + mathmatical operations: + zippy uses reverse polish notation + (+ a b) returns a + b + (- a b) returns a - b + (* a b) returns a * b + (/ a b) returns a / b, whole number eg: (/ 7 3) = 2 + (/. a b) returns a / b, floating point number eg: (/. 7 3) = 2.5 + (% a b) returns the remander of (/ a b) + (** a b) returns a ^ b + + +sample code + (let fib:function (defun num:i32 i32 + (if (< num 2) + (return num) + ) + (else + (return (+ (fib (- num 1)) (fib (- num 2)) )) + ) + ) + ) + (let a:i32 (fib 5)) + ! returns the 5th fib number + +stdlib: + (import io) + io contains a few types + they are: + (io.file) + io contains many io related functions + they are: + + (io.write "hello %s\n" name) ! this is very similar to printf in C + (let input:char[] (io.read)) + + (let file:io.file (io.open path[]:char "method")) + + (io.fwrite file:io.file "hello %s" name) + (let file[]:char (io.fread file:io.file)) + (let line[]:char (io.freadline file:io.file lineno:i32)) + diff --git a/comp/lucas-standen-NEA/writeup/coverpage.html b/comp/lucas-standen-NEA/writeup/coverpage.html new file mode 100644 index 0000000..a8338b4 --- /dev/null +++ b/comp/lucas-standen-NEA/writeup/coverpage.html @@ -0,0 +1,131 @@ +<!-- Creator : groff version 1.23.0 --> +<!-- CreationDate: Tue Apr 30 14:21:39 2024 --> +<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" +"http://www.w3.org/TR/html4/loose.dtd"> +<html> +<head> +<meta name="generator" content="groff -Thtml, see www.gnu.org"> +<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> +<meta name="Content-Style" content="text/css"> +<style type="text/css"> + p { margin-top: 0; margin-bottom: 0; vertical-align: top } + pre { margin-top: 0; margin-bottom: 0; vertical-align: top } + table { margin-top: 0; margin-bottom: 0; vertical-align: top } + h1 { text-align: center } +</style> +<title>NEA coverpage</title> + +</head> +<body> + +<h1 align="center">NEA coverpage</h1> + +<a href="#1. Analysis">1. Analysis</a><br> +<a href="#1.1. Overview">1.1. Overview</a><br> +<a href="#1.2. Examples of similar projects">1.2. Examples of similar projects</a><br> +<a href="#1.2.1. Python">1.2.1. Python</a><br> +<a href="#1.2.2. Lisp">1.2.2. Lisp</a><br> +<a href="#1.2.3. Perl">1.2.3. Perl</a><br> +<a href="#2. Design">2. Design</a><br> +<a href="#3. Technical Solution">3. Technical Solution</a><br> +<a href="#4. Testing">4. Testing</a><br> +<a href="#5. Evaluation">5. Evaluation</a><br> + +<hr> + + +<p align="center"><i>Lucas standen</i> <br> +7949</p> + + +<p align="center" style="margin-top: 1em"><i>ABSTRACT</i></p> + +<h2>1. Analysis +<a name="1. Analysis"></a> +</h2> + + +<h3>1.1. Overview +<a name="1.1. Overview"></a> +</h3> + + +<p style="margin-top: 1em"><i><b>Zippy LANG</b></i></p> + +<p style="margin-top: 1em">A next generation language, for +general use. Designed for keeping code simple, neet and +readable. <br> +Zippy will be a modern functional language. It will be +interpreted like python/perl and lisp. Its syntax should be +similar to lisp.</p> + +<p style="margin-top: 1em">Some interesting features that +Zippy will have is treating everthing in functions, scopes +that allow for manual but safe memory management, and +interoperablity with C <br> +libarys</p> + +<h3>1.2. Examples of similar projects +<a name="1.2. Examples of similar projects"></a> +</h3> + + +<h4>1.2.1. Python +<a name="1.2.1. Python"></a> +</h4> + + +<p style="margin-top: 1em">Python is a high level OOP +language that was designed in 1991. It was made to make +programming easy whie still being able to use some of +C’s functions. <br> +Although it has become standard for many usecases, it is +slow and inefficent, and very bloated.</p> + +<h4>1.2.2. Lisp +<a name="1.2.2. Lisp"></a> +</h4> + + +<p style="margin-top: 1em">Lisp is the second ever +programming language, developed at MiT, it is the first +functional language, creating many common features like +higher order functions, <br> +recursion, and garbage collection. It is generally not used +anymore as it feels old compared to other functional +languages, like ocaml or haskell.</p> + +<h4>1.2.3. Perl +<a name="1.2.3. Perl"></a> +</h4> + + +<p style="margin-top: 1em">Perl is scripting lang designed +for use in linux, when bash is too slow, or not suited for +the job. <br> +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 for general +use.</p> + +<h2>2. Design +<a name="2. Design"></a> +</h2> + + +<h2>3. Technical Solution +<a name="3. Technical Solution"></a> +</h2> + + +<h2>4. Testing +<a name="4. Testing"></a> +</h2> + + +<h2>5. Evaluation +<a name="5. Evaluation"></a> +</h2> +<hr> +</body> +</html> diff --git a/comp/lucas-standen-NEA/writeup/coverpage.ms b/comp/lucas-standen-NEA/writeup/coverpage.ms new file mode 100644 index 0000000..d6ab182 --- /dev/null +++ b/comp/lucas-standen-NEA/writeup/coverpage.ms @@ -0,0 +1,46 @@ +.TL +NEA coverpage +.AU +Lucas standen +.AI +7949 +.AB +.NH 1 +Analysis +.NH 2 +Overview +.PP +.B Zippy +.B LANG +.PP +A next generation language, for general use. Designed for keeping code simple, neet and readable. + Zippy will be a modern functional language. It will be interpreted like python/perl and lisp. Its syntax should be similar to lisp. +.PP +Some interesting features that Zippy will have is treating everthing in functions, scopes that allow for manual but safe memory management, and interoperablity with C + libarys +.NH 2 +Examples of similar projects +.NH 3 +Python +.PP +Python is a high level OOP language that was designed in 1991. It was made to make programming easy whie still being able to use some of C's functions. + Although it has become standard for many usecases, it is slow and inefficent, and very bloated. +.NH 3 +Lisp +.PP +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 anymore as it feels old compared to other functional languages, like ocaml or haskell. +.NH 3 +Perl +.PP +Perl is scripting lang 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 for general use. +.NH 1 +Design +.NH 1 +Technical Solution +.NH 1 +Testing +.NH 1 +Evaluation +.AE diff --git a/comp/lucas-standen-NEA/writeup/coverpage.pdf b/comp/lucas-standen-NEA/writeup/coverpage.pdf Binary files differnew file mode 100644 index 0000000..92abc11 --- /dev/null +++ b/comp/lucas-standen-NEA/writeup/coverpage.pdf diff --git a/comp/lucas-standen-NEA/writeup/make.sh b/comp/lucas-standen-NEA/writeup/make.sh new file mode 100755 index 0000000..6f7c53e --- /dev/null +++ b/comp/lucas-standen-NEA/writeup/make.sh @@ -0,0 +1,2 @@ +#!/bin/bash +for i in $(ls | grep .ms); do groff -ms $i -T html > $(echo $i | cut -f1 -d".").html; done |