Programming

I read about this hobby project yesterday and thought it was very inspiring. This guy wrote a scraper that compares the prices of groceries and it made a big political splash too. https://mastodon.gamedev.place/@badlogic/111071396799790275

Personally, I also wanted to try some new tech, and created my first android app for my daughter to practice her basic math operations many years ago.

Another option for you would be to find a FOSS project you like and contribute there (fediverse? Hint, hint).

FOSS accounting app. There's like 2 out there that I can find, and I hate them both.

My next project is going to be a terminal tool that takes lat-lon coordinates and a date, and converts both ways between angle of the sun relative to the horizon and time. I wrote a python script a while ago to get times for golden hour, twilight, etc., but I don't like how slow it is, and I want to make more composable terminal tools that people can pipe together.

Currently, I am writing a Fluid Sim in C++ . I am mostly following the repo by Doyub Kim and the book by him called Fluid Engine Development.

Something I've been wanting to work on is a TUI wizard for configuring software.

The thought is most Linux server program use various config files, and in order to configure them correctly it generally takes a few minutes to a few hours to read through their documentation. But a lot of the configuration boils down to passwords/keys, file paths, network locations, a few different booleans, etc.

So the general idea is, for a program, the developer or the community can provide a config file telling the TUI wizard what arguments the config file needs, and this one program can walk the end user through setup and generates the config files. This would reduce the amount of time hunting through documentation and reduce bugs due to typos or invalid choices.

It could go a step further and auto generate keys or passwords if needed, validate entries (ie if the config needs an IP it could make sure it's valid, etc)

I'm working on a project that generates ideas for new coding projects.

I have my own music player written with Python, Gtk, and Gstreamer. I use it almost every day to listen to music during work

I'm creating an RPG in GoDot using asprite for resources. I'm about 6 months in and I find it so relaxing making assets and plunking them in. Whatever you do it should be for you is the golden rule. To often people want to inject themselves in or offer input thats sneakily what they want. It should be what your vision is,, your pace and you shouldn't answer to anyone.

A lot of the actual coding/scripting work that I've done recently has been server stuff. I recently containerized all of my game servers with Docker and bash, and I'm now looking at switching from my current janky Minecraft Docker setup to a fancier setup with autoupdates for Paper and its plugins. I'm far from a professional programmer, so it's been fun to actually hack together useful things for myself.

• make a boilerplate/starter project for something. For instance a java project that has a api so implement Swagger, json, some example endpoints, etc. That way, if I start a new project I don't have to first configure it all and think about what dependencies I need to implement.

Or one for css or Angular. Just implement the basic style for buttons, text, menu's etc and adjust where needed. A bit like Bootstrap but then more basic

• make a private website where combine all your (future) tools/projects. Like some calculate (km to miles, whatever), some links to other projects, a page to your servers/services (kodi, plex, sabnzbd, etc)

For the past year, I've been working on an online scavenger hunt. It features many tech related challenges on various topics (web, protocols, crypto, stegano, ...).

This is the project as a whole, but I had to work on many sub-project to bring it to life, out of which:

• a Pokemon game (assembly)
• an online scoreboard (go)
• an encryption tool (go)
• a crypto hashing tool (go)
• a cli interface (C)
• many deployment shell scripts
• ... much more

What I love about this project is that it touches many different topics. I had to setup reverse proxies, complex firewall rules, VPNs, abuse the TCP/IP stack, ... I could also work on very useless but fun topics, like creating a tool that answers to ICMPv6 traceroute packets to insert fake hops between the requester and the destination. I'm now close to releasing it, and I wonder what I'll do when this is over...

I have dozens of projects in varying levels of completion and maybe like 2 finished projects. Here's my list, steal to your liking because I come up with ideas I want to see in the world, and clearly I'm not a great medium for that:

• Philotic - p2p network of Python servers based on a generalization of process forking. Every server runs the same file (global scope is initialization) but some id-based guard like an annotation lets them do different things. I designed this to act as a lower layer for eventually splitting an LLM across multiple computers, something very obnoxious to do manually but relatively easy to code.
• Servitor - Actually probably will continue working on this, it's a library which makes it easy to use LLMs as "semantic functions", effectively letting you describe a natural language task and execute it as if it were a normal function.
• TAO - Type Annotated Objects, more or less CBOR with some personal improvements. 0-0x7f are tiny ints, the first nibble is a type, and the second nibble is usually an embedded length prefix (or signal for a longer length prefix). Being nibble-based and having a dedicated DEBUG type makes it a lot easier to read in hexdumps, and gives twice as many type prefixes to work with. I rearranged the types a bit to be more sane than CBOR (which eg has separate types for negative and positive integers), and also added streaming and varint support.
• STM/Snow - Structured Text Markup (in-progress name, "Snow" is a bit too informal?), a text serialization format where all data is (un)quoted text, "tags" which are { followed by data or text: data pairs, then }, or "markup" which is [ followed by plaintext interspersed with tags and ending with ]. The mixed positional/named attribute model of tags makes its object model a generalization of XML using JSON-like syntax and I've found it to be very easy to implement parsing.
  • My "pie in the sky" dream is to completely overhaul HTML/CSS/JS for STM/simplified CSS/WASM, but that's never going to happen 😞
• Munchy - IDL-like language for representing file formats as an executable schema. Eventual goal was for it to be powerful enough to parse textual formats like JSON, which tend to be more contextual. At some point I found a similar project using YAML to define the schemas, but not being a DSL made it more confusing IMO.
• RetroArch file - A common file format for RetroArch to combine ROMs, patches, cheats, saves, etc into one cohesive format. Never got far with this one.
• Binary MIME aka contype. I even wrote an RFC apparently? Adorable.
• LLM modification - A paper I wrote about a potential LLM modification replacing the FF layers with a shared vector database to decouple memorization objectives from semantic and syntactic objectives, resulting in smaller foundation models. Predictably no one cared and probably no one should care, but it might be an interesting experiment to implement.
  • Probably a more useful modification I haven't seen yet would be to implement kv caching using a prefix tree rather than a per-request cache. That would make semantic functions a lot faster, since it could cache the prompt between requests and it would only have to process the data.
• Preference vectors - Simple stochastic updating of "preference" and "feature" vectors to transparently associate preferences with content. This would allow people to essentially build their own "The Algorithms", since the update operation can be designed to create a linear space so you can eg request content close to "my preferences + my mood + heavy metal + randomness", and share feature vectors on social media. I think when I tested it I made a weird modular space where d(0, 255) = 1, and it still worked. Stochastic updates work, even in a distributed context, because it's a kind of "simulated annealing".
• Wika - Simplified and standardized WikiText parsing (which is surprisingly not actually standardized and MediaWiki essentially defines it as "whatever our PHP parser can read"). Follow-up is naturally a wiki written in anything other than PHP.
• i2cec - ATtiny11 firmware for bridging the i2c and CEC lines of an HDMI cable so you can send remote control commands via your SMBus to an attached monitor (I accidentally got a TV instead of a normal computer monitor). Never got it to work quite right, timing was very tight.
• U413 - A unix terminal themed BBS forum with a looong history of makes and remakes and a community getting whittled down to a handful of people.

And finally then there's my magnum opus, Espresso, my favorite project I keep coming back to time and time again and ~~bikeshedding~~ refining over many years. If anyone else takes it up I'd be ecstatic.

• Influences: TypeScript, Python, Lua, Rust, C/++, Julia
• Self-hosted prototype-based scripting language with its JIT written in itself (eventually)
• Emphasis on simple rules which build up arbitrary complexity, a pathological avoidance of repetition, conciseness, and near Lispian customizability. SMOL.
• ASCII lexing with unicode support deferred to other stages (compare to Lua, which treats > 0x7e as an identifier - I also treat <= 0x20 as whitespace).
• PDA tokenization (used to be FSA/regex but nested format-strings required more power).
• LR(1) parsing with concurrent bytecode emission (ala Lua), AST is built up until it can be converted to bytecode. The most extreme case is extensive destructuring assignment (Rust, Python, [P2392]) which shares a syntax with object literals, but can be treated as LR(1) by keeping track of a distinction between "lvalue" and "rvalue" compatible syntax.
• All types defined with proto[...T] Super Sub(...args) { ... }, eg proto class Animal { ... } and proto Animal Monkey { ... }
  • The higher-order types include class, enum, union, interface, struct, etc. Compare to [P0707]
  • Note that these kinds are objects, not keywords. They define how to convert the body to a type constructor and prototype chain(s).
  • It took a few months to figure out this is possible by maintaining separate prototype chains for classes and instances.
• Statements implicitly end, ; is an optional operator to explicitly disambiguate their ending.
  • after operator, x() after y() == (var t = x(); y(); t) - surprisingly useful for conciseness.
  • "Everything is an expression" - loops are generators, eg list comprehension works like [...for(var x in 10) x] == list(range(10))
• Operator overloads use the operator itself as the method name, eg proto class { +(rhs) { console.log("\{this} + \{rhs}"); } }
• Type annotations define compiler semantics: Type objects have a delegate() method which define how to represent the variable on the stack. Untyped variables use an inferred type or an implicit any, which wraps a dynamic object. This lets you create objects like int32 while still using the prototype semantics.
• Recently I thought the syntax itself can be partially dynamic by using static scoping and macros which hook into the compiler when they're encountered, but I've tried similar things a few times and it tends to lead to failure. This would need something like C#'s unsafe compilation distinction to avoid catastrophic vulnerabilities.
• "Initialization is compilation" - When you run a file, executing the global scope ("initialization") is treated as a stage of compilation, and the resulting module object is what is saved, not just its bytecode. Compare this to Python, which saves just the bytecode of the module.
• Lifetime semantics (ala Rust and friends) are still a WIP.
• Based on [P0709] and Rust's try! semantics, exceptions are actually wrapped in a returned Result[T, E] type: try is an operator which unwraps the result and returns if it's an error. Thus you get var value = try can_fail();. Using type object operator overloading, the Result type doesn't need to be explicitly annotated because Result[T, E] == T | Result[T, E] == T | fail E.
  • fail keyword instead of throw/raise.
• Really want proper coroutines using PyPy's continulet/stacklet abstraction. Also maybe delimited continuations as the implementation for panics.
• Structured process forking.
• GC based on ideas from this LuaJIT 2.0 GC document.

I could go on for hours with all of the stuff I've thought of for this language. If you want to know more, the README.md and ideas.md are usually the most authoritative, and specification.md is a very formal description of a subset of the stuff that is absolutely 100% decided (mostly syntax). I've written turing complete subsets of it before. First usable implementation to arrive by sometime in 2200 lmao. 🫠 I can also unpack the other projects if you want to know more.

I work on the Jellyfin Roku client, a React Native Lemmy client, and a Next.js Electron Mastodon client.

there was a fedi shitstorm recently RE: centralized blocklists so I tried my hand at a web service that would facilitate aggregating and sharing these lists in a decentralized and dynamic fashion and so far I like how it's coming along

https://crates.io/crates/felicia

I'm hoping to build a frontend for it soon-ish

Started a couple years ago with a simple home network website using Flask to simply save/organize my notes.

It has slowly grown into an entire eco-system that manages/records my entire life, from work to play and everything in between.

• Music player that organizes huge collection of mp3's, scraps the album cover artwork and lyrics, integrated converter (youtube,spotify etc.), playlist to stream/copy to any device, statistics on everything and dozens of other percs/tools/toys custom built.
• Custom news, weather, sunset/sunrise, daylight savings reminders
• Easy on the fly statistical analysis of anything with advanced and simple graphing
• Easy on the fly AI, ML playground
• Reminders, text messages for all upcoming rocket launches (scraped and rss feeds of course)
• Manage my entire home automation setup/status/cams etc.
• Dozens of music related applications for learning/practicing/recording/tracking etc.
• Many, many more applications, just scratching the surface here but everything is automated, I don't want to work it, just enjoy it.

Sometimes I feel a little selfish for keeping all this to myself (my entire household uses it too) but I've been programming and building websites for decades and it's nice to work on something that has no schedules or expectations and the cherry on top for me is zero worry about security or compatibility.

A short list:

• The current one is a Linux system backup tool written in Python that I use for my systems.

• Recently worked through Mozillas PWA materials to learn how to make Progessive Web Apps. I need decide on what to do with that next. This HTML, CSS, JavaScript, pretty much. Put up a Python web server for some of it.

• I have a security system that is tied together via various Python services. I need to work on that more.

• A few years ago I write a big Monte Carlo financial simulation for retirement planning including taxes. Again Python.

• A while ago I wrote a bunch of test code too benchmark all of the ways to make Python fast. Also looked a C extension, parallel computing, vectorization, GPUs. Some results not that intuitive.

I have a ton more.

Building automation to play SpaceTraders as well as tools to aid in board game design

I write a lot of spreadsheets for games I play, so adapting them into more sophisticated software is always something I chip away at. Good opportunity to learn how to implement concepts in new languages too. Right now I'm writing a Warframe simulator in Racket.

Chat client and server for a system that is similar to IRC, but with certificates both for encryption and signing. The idea is that this will provide secure end-to-end communications as well as trusting that the person in the other end isn't just someone with the same nickname.

I make stuff for the Playdate (in Lua), it’s a tiny cheese-slice-shaped gameboy with a reflective 1-bit screen and a crank!

So far I’ve Only done smaller projects like an example project and I worked with a friend to make a little face app for pictures, but I’ve got a few games that I’m going to finish up since I got my preorder last week

Actually there’s an idea sparking up on me.

When I was a junior programmer there were some business guys coming up with the requirement to implement their own validation language (similar to regex). I always thought it is totally stupid to invent your own instead of using something that already exists. But it turned out to be great fun implementing it. I had no prior knowledge in implementing parsers and interpreters. But man I was so proud after I came up with my own solution for the problem. It was such fun, that I even was doing over hours. At the end I create my own tokenizer, a parser and an interpreter. Even something similar to what I now know most people would call an AST (abstract syntax tree).

However, I know I have bought the Crafting Interpreters book without having read it. I really should start digging into it.

Im working on a multiplatform gtk graphing calculator app that's pleasant to use and powerful at the same time. Mainly oriented towards mathematics and chemistry because thats what i do but more stuff may be added eventually.

I am, very slowly, building a Wireguard management UI. None of the ones I looked at do what I want, so I am doing my own. The think I just finished is a magnet: and .torrent handler that sends any link to my central torrent client.

last.fm Tube a combination of last.fm and YouTube

I am interested in all things random or mathematical. I have written programs to simulate the decay of radioactive 'stuff', a program that simulates the CA Lottery by flipping a coin (someone said that your chances are about the same as flipping a coin 25 times in a row in a run of either heads or tails).

On the mathematical side, I have written a program to run the 3n+1 (Colatz) series and record process features, like counting evens and odds, the number of steps, and the maximum value found in the series. Perhaps the average of the values in the series would be interesting to calculate...

Combining mathematics with randomness - I have worked on the 100 prisoners idea, How many loops are created in this run, and how long is the longest one? If any loop contains more than 50 members then the prisoners lose and don't get to go home.

I have ideas for a traditional basic interpreter only lines are labeled not numbered.

I have a traditional Star Trek program that I have written many times improving slightly each time.

Writing a CHIP-8 Emulator was really fun. There's a lot of resources out there and it's really fun, small low level project you can "finish" in a week of casual coding. As someone who was mostly coding highlevel in my job, I really learned a lot.

I used a tutorial book to help me create a python text game, then I rewrote it and have been casually adding things. I sort of want to re-write it again in Java to see how it compares, I'm more comfortable with java so I'm hoping I could focus more on system design. I'm noticing that the more I add to the base game the more spread out my solutions become, so addressing that is the main interest I have with it.

A new project I'm working on is a simple web scraper. I liked building a lexer/parser in the text game and I think having my own web scraper would be useful.

I'm still learning so I aim for projects I can 'finish' in 2-4 weeks.

Oh and a windows notepad that looks like the windows notepad except more customizable. I like the idea of building utilities.

Current main side project is a web music player, using WASM for the UI, because everything else is no fun.

I also have an own, tiny OS automation framework that I've been meaning to continue dicking around with.

Then I've got a minimalistic note-taking helper program. (My note system is just a bunch of loose text files, and that program helps create those files according to a scheme and allows me to search them.)

Planned projects, requiring larger and larger levels of megalomania:

• A musical keyboard application, where I can type on my normal keyboard and it'll play like a piano. Potentially integrating LV2/VST plugins in future.
• A physics-based game, integrating concepts from general relativity and quantum physics and such. Kind of to help (me) visualize these concepts better.
• An own Git forge, with ForgeFed integration, WASM UI etc..

I recently wrote a tool to make my D&D games a little easier. It's a web app that lets you load up an encounter's worth of enemies and keep track of their health (plus extra stuff, like legendary actions). And it does the math for you, which is a huge weight off my mental load.

It would be neat to expand it with an API that lets you load in monsters from a database and calculate the encounter difficulty, but I'm in no hurry. I don't usually have a lot of energy to code on weekends now that it's my full time job.