Sam Abbott-Kennedy

Sounds like a game mechanic waiting to happen 😜

A snippet of my programming language showing optionals and early returns on optionals: ``` fn maybe(b: bool): ?u32 { if (b) return 10 return none } fn opt_return(b: bool): ?u32 { let x = maybe(b) println(x?) //if x is none, return here, else print the value of x (10) println("x was some!") return x } fn main(): u32 { let x = opt_return(true) if (x) |value| { println(value + 10) } else println("x was none") let y = opt_return(false) if (y) |value| { println(value + 10) } else println("y was none") return 0 } ```

The output of the program: ``` 10 x was some! 20 y was none ```

It's all coming together. Now I have unions I can implement the optional type ?T which is just a tagged union. In addition I could implement rust style try-unwrap of optionals basically for free with all the parts I have!
Here opt_return only prints x if it's some, else it returns early!
#compiler

Now with the fancy struct syntax, implementing tagged unions was relatively easy. Also got rid of all those pesky semicolons messing up the place
#compiler

Blew apart my struct and function parsing to allow default values and named arguments. Pretty swanky imo
#compiler

Output of the program:

Not sure it's the greatest use of it but the new `with` statement works nicely with raylib 😅
#raylib #compiler

A snippet of my programming language showing the defer statement: ``` fn main() { let f = os::open_file("test.txt"); defer os::close(f); for _ in 0..15 { os::write(f, "Hello once again from osmium!\n"); } } ```

A snippet from my programming language showing the same code but using a `with` statement: ``` fn main() { with let f = os::open_file("test.txt"); { println("closing file!"); os::close(f); } { for _ in 0..15 { os::write(f, "Hello once again from osmium!\n"); } println("done writing!"); } println("end of main!"); } ```

The output of the with statement variant showing the order in which things are run: ``` done writing! closing file! end of main! ```

Added a defer statement to my language, but I didn't like how the resource acquisition and disposal had to be separated. So I added a with statement that just desugars to defer, and I kinda like it!
#compiler

A program in my programming language showing pointer allocation and illegal freeing: ``` fn bad(ptr: &u32) { free ptr; } fn main() { let x = new u32; free x; let i = 10; let p = &i; free p; } ```

The error messages from compiling the program: ``` Error: Cannot free a pointer with lifetime `Param` at src\main\resources\examples\memory.os:2:5 2 | free ptr; | ^^^^^^^^^ Error: Cannot free a pointer with lifetime `Stack` at src\main\resources\examples\memory.os:11:5 11 | free p; | ^^^^^^^ ```

Starting on the memory management for my language. Nothing fancy but just a few more guard rails than C. Every pointer has an "origin": Stack, Param, Heap, or Global. Only Heap can be freed, and Stack can't be returned from functions.
Maybe this will cause problems but we'll see!
#compiler #llvm

Osmium Raylib ffi speedrun

#compiler #llvm #raylib

Using FFI and modules to make an os.os file that's imported to write to a file: `os.os`: ``` extern fn exit(status: u32); extern struct FILE(); extern fn fopen(filename: &const char, mode: &const char): &FILE; extern fn fputs(s: &const char, file: &FILE): u32; extern fn fclose(file: &FILE); struct File(handle: &FILE) { fn write(self: File, s: string): u32 { return fputs(s.data, self.handle); } fn close(self: File) { fclose(self.handle); } } fn open_file(filename: string): File { return File(fopen(filename.data, "w".data)); } ``` files.os: ``` import "core/os.os"; fn main() { let f = os::open_file("test.txt"); for _ in 0..10 { os::write(f, "Hello again from osmium!\n"); } os::close(f); } ``` test.txt: ``` Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! Hello again from osmium! ```

Yeah like that

A program in my programming language showing FFI: ``` extern fn exit(status: u32); extern struct FILE(); extern fn fopen(filename: &const char, mode: &const char): &FILE; extern fn fputs(s: &const char, file: &FILE): u32; extern fn fclose(file: &FILE); fn main() { let file = fopen("test.txt".data, "w".data); if file == null { println("Could not open file!"); exit(1); } for _ in 0..10 { fputs("Hello from osmium!\n".data, file); } fclose(file); } ```

The output in a new file `test.txt` ``` Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! Hello from osmium! ```

Decided the next logical step from modules was ffi, surprisingly straightforward to implement! Now I can tuck all that nasty ffi code in a libc.os or something
#compiler

The way it works is horribly inefficient, it takes the main file and parses it and gathers every type and function declared. Then it takes every import statement, finds the file it points to and then repeats the process recursively to build a graph. Then the graph is DFS'd to emit one llvm file!

A picture of 3 separate files in my programming language that form a dependency chain. main.os imports io.os and math.os, math.os imports io.os. main.os: ``` import "math.os"; import "io.os"; fn main() { io::print_msg("Hello from main.os!"); var v = math::Vec(1.0, 2.0); println(math::dot(v, v)); var x = math::pow(2.0, 3); println(x); math::greet(); } ``` math.os: ``` import "io.os"; struct Vec(x: f32, y: f32) { fn dot(v1: Vec, v2: Vec): f32 { return v1.x * v2.x + v1.y * v2.y; } } fn pow(x: f32, p: u32): f32 { for _ in 1..p x = x * x; return x; } fn greet() { io::print_msg("Hello from math.os!"); } ``` io.os: ``` fn print_msg(msg: string) { println(msg); } ```

The output of the program: ``` Hello from main.os! 5.000000 16.000000 Hello from math.os! ```

I managed to implement a somewhat halfway decent module system. I'm not thrilled that the import needs the relative path but it'll do for now. Plus it handles the same file being imported multiple times across the compilation graph 😌

#compiler #llvm

A program in my programming language showing string slicing: ``` fn main() { var s: string = "Hello from osmium!"; println(s); println(s[6..=10]); var sl = s[8..17]; println(sl); for c in s[0..5] { print(c); print(' '); } } ```

The output of the program: ``` Hello from osmium! from om osmium H e l l o ```

Added strings to my language, since they're just backed by a slice of u8's all the regular slice operations just worked out of the box

Again nothing real languages don't do but it's so satisfying seeing it work!
#compiler #llvm

Something about the automatic printing of structs is very pleasing to me. It's incredibly simple and the print function is just one enormous hack at the moment but for debugging the compiler it's so good

A program in my programming language showing array slicing: ``` fn print_slice(sl: []u32) { for i in sl print(i); } fn main() { var a = [*]u32 { 4, 5, 6, 7 }; print_slice(&a); var sl: []u32 = a[2..=3]; print_slice(sl); print(sl); //prints the raw underlying struct { ptr, len } sl[0] = 1; //mutate the original array through the slice, makes sense since []T == &[N]T for x in a print(x); } ```

The output of running the program: ``` 4 5 6 7 6 7 { &[0x61dff2e8], 2 } 4 5 1 7 ```

One huge rewrite later and a brand new backend (LLVM) and I'm extremely happy with my programming language's slices. Nothing fancy that any other real language doesn't do but it's fun seeing my scrappy little compiler go.
#compiler

Taking structs to weird new places (java records) #compiler #development

I had it pointed out to me that fn means function declarations are easier to grep, and thus having a keyword like var or let does the same for variables. So I think we stick with the trendy syntax for now

A snippet of my programming language of a recursive descent parser with rust style syntax.

A snippet of my programming language of a recursive descent parser with C style syntax.

Trying to decide if I want the easier to parse, trendy variable: Type syntax, or the (imo) nicer but harder to parse Type variable syntax. Mainly I'm just trying to bikeshed so I don't have to think about implementing a module system 😔 #compiler

A screenshot of code in my language showing a recursive descent parser

Writing a compiler, so far the language looks pretty cozy but every new feature I add pulls it closer to either zig or rust 😩

I love how Wizwag looks, I'm looking forward to getting to play it!

Brewing again, this time a sort of west coast IPA to use up some Pacific Sunrise hops I got for cheap. A bit lower OG than I wanted but still a respectable 1.054. The Kveik has already munched that down to 1.020 so today is dry hop day apparently 🍻

Now I have the urge to make a ship like that in starfield so I can walk around in it 😩

2kg of mixed berries added, the beer is now a nice dry 1.006 and tastes like summer. I'm hoping it clears a bit more but with all that wheat and pectin I'm doubtful 🍻
#homebrewing

And here it is. It's spicy and bitter but also slightly sweet and thick. Tastes very much like strawberry but thankfully solidly a saison rather than a wine

Definitely going to sink this whole batch 🍻

Berry sour is underway, 62/30/8 pils/wheat/oats. About 8 IBU of saaz with a late addition of mosaic and some frozen blackberries I had in my freezer

OG was bang on target at 1.042, and pitched 1pk Philly Sour at 23C

Once it slows down I'll be adding more frozen berries 🍻
#homebrewing #beer

The sun finally came out after days of rain so I had to take some screenshots of my new oblivion remastered character

Just in time for the end of the long weekend 🍻

Strawberry wheat saison bottled, I think I overdid it slightly with the puree. It tastes a bit wine-y but has some beer bitterness. Cold crashing didn't help much with the clarity but I don't think it ever would have. Let's see what it's like carbed and conditioned 🍻

Well now you can, Mr Ur