Sam Abbott-Kennedy

@samothyk.bsky.social

79 Followers 267 Following

[onlookers booing]

A screenshot of my ternary based emulator showing "HELLO WORLD" in the top center along with the base-27 rom code in the background

A spell from my WIP TTRPG. The text reads:

Knick-Knack
Class: Arcanist, Knave, Occultist
Duration: 3 turns
Range: Self/Melee
Conjure a simple mundane item worth
20GP or less. Once the spell wears off
the item vanishes.

$A snippet of my programming language showing anonymous structs, multiple return values, and tuples ``` fn multiple_returns(): struct { u32, u32 } { return { 6, 7 } } //accept as anonymous struct fn foo(struct { a: u32, b: u32}) { println(a) println(b) } //accept as tuple fn bar(tup: struct { u32, u32 }) { println(tup.0) println(tup.1) } fn main(): u32 { let x = multiple_returns() foo(x) bar(x) return 0 } ```$

A snippet of code in my programming language showing coercion between a named struct and an unnamed struct, as well as promotion of an anonymous struct's fields to the containing struct:
```
struct Foo {
{ a: u32, b: u32 }
}

struct Pair { a: u32, b: u32 }

fn foo({a: u32, b: u32}, c: u32) {
println(a, b, c)
}

fn main(): u32 {
let pair = Pair { 1, 2 }
foo(pair, 3) //named struct coerced to anonymous struct

let f = Foo { pair }

println(f.a)
println(f.b)

return 0
}
```

$A snippet in my language showing method receivers on a struct `CPU`: ``` struct CPU { clock: u64 = 0, //registers AF: u16 = 0x01b0, BC: u16 = 0x0013, DE: u16 = 0x00D8, HL: u16 = 0x014D, SP: u16 = 0xfffe, //Stack pointer PC: u16 = 0x0100, //Program counter } fn CPU.execute(&self, opcode: u8) { switch (opcode) { 0x00 => println("NOP"), 0x01 => println("Load N16"), // etc for the other 0xFD opcodes... _ => println("unknown"), } } ```$

Two files in my language showing a barebones gameboy CPU and raylib draw loop with the gameboy window running, showing a blank screen

A program in my language showing function overloads:
```
struct Vec2 { x: u32, y: u32 }
struct Vec3 { x: u32, y: u32, z: u32 }

fn add(a: Vec2, b: Vec2): Vec2 {
return Vec2 { a.x + b.x, a.y + b.y }
}

fn add(a: Vec3, b: Vec3): Vec3 {
return Vec3 { a.x + b.x, a.y + b.y, a.z + b.z }
}

fn main(): u32 {
let v2a = Vec2 { 3, 2 }
let v2b = Vec2 { 4, 3 }
let v2c = add(v2a, v2b)
println(v2c)

let v3a = Vec3 { 3, 2, 1 }
let v3b = Vec3 { 2, 1, 1 }
let v3c: Vec3 = add(v3a, v3b)
println(v3c)

return 0
}
```

$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 } ```$

$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 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;
}
```

$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! ```$

$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); } ```$

$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); } ```$

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(' ');
}
}
```

$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); } ```$