Inspired by this Lobsters thread, and some of the great comments within it, I would like to ask if anybody is doing some hobby programming this weekend?
I’m spending part of it on one of those changes that sounds tiny but touches half the desktop app: keeping a WebKit-backed terminal alive while SwiftUI rebuilds navigation. SSH can remain connected while the UI loses scrollback and visual state, so I’m separating the long-lived session from the transient view tree and letting SwiftUI rebuild only the native shell. Then feedback triage, and deliberately no new feature this weekend.
upgrading unloved django blog to 5.2, rebuilding vps, moving everything to uv and working out how that’s going to play with piku.
if get that done, fix up some of the css on my blog and start a blog post to use as back country and camping check list (bc i forgot some stuff i really should have taken on last tour).
half arsed look for new job.
help bro cut down a tree.
clean the car.
I got interested in constraint programming, and I had NO idea how it worked. It seemed like magic.
I have started on following the slides and code of MiniCP, and have started implementing the first steps in Rust. I find it very challenging but it is a great learning experience. I got such a thrill from solving the N-Queens problem in milliseconds from a program that I had written myself.
I am continuing to develop the implementation for a few hours this weekend. Because writing a constraint system is hard, I am also learning some new parts of Rust that I have not touched before.
I’m working on a classifier to keep the chaos of my inbox under control. It uses the gemini LLM API (gemini-flash-lite) to add labels to each email depending on things like:
- does it require an action from me?
- does it require a reply from me?
- is there a deadline?
- is it an invoice?
- is the information just an event about changes to information that exists in another system (i.e. a notification that can be deleted)
Currently upgrading from the 2.x to the 3.x model and tuning some of the prompts.
Finally working to finish Eloquent JavaScript - whether this is me procrastinating on revamping and migrating my personal website or trying to fill in my knowledge gaps is a mystery to me.
I’m lucky enough to sometimes take public transit that publicly posts its data on arrival times and the like. Have been working on a script to tell me when there’s a track change (which changes where I need to wait for the train) because I’m a lazy person who wants to just have a notification fly across my phone screen instead of actually checking on the website. Currently working on testing some functionality before dumping it on my Raspberry Pi. I usually work on this while on the transit, but hopefully I’ll do some of it this weekend.
Also would like to get working on the bog-standard baby coder personal project habit tracker, to make sure I remember how to do front end, back end, etc. I’ve learned I am more likely to use a system I built for myself. We will see if I get to it!
Working on my latest videogame, very early stages but it’s coming along nicely.
I also sot up a git server at home and a ssh access key on my el-cheapo laptop and I feel very good every time I push a branch from it to home.
I do have performance issues with Rider though (JetBrains C# IDE), I have disabled basically everything except syntax coloring and still it’s just lagging insanely all the time. 20 seconds i7 quad core peak because I (shudder) select text, or erase some letters in a comment. Aaaaaa! If anyone knows a C# ide that works well with Godot on linux I’m all ears. Syntax coloring, debugging & autocomplete if possible, FOSS would be fantastic (microsoft code thingy sucks ass btw IMO).
Godot is fantastic BTW!
Check out DotRush. It’s made for VSCode/Codium but can be used with pretty much anything else with its LSP. https://github.com/JaneySprings/DotRush
Thanks, but vscode already do c# (and is quite shitty IMO)?
Sure, but DotRush can work well with other editors with LSP support, like NeoVim, Zed, and Sublime as noted here. I’m pretty sure it can work with other editors, too, like emacs, but haven’t tried (yet?). It also explicitly supports Godot.
Trying to get a release of Summit (!summit@lemmy.world) ready. I’ve been trying to catch back up after taking a month hiatus about 2 months ago and still playing catch up.
Been ignoring the community for too long so after this release will need to go tend to requests and bug reports. It’s a lot of work :/
I’m messing with making a kernel softmac driver that can handle Nintendo specific 802.11 frames so that MelonDS can connect to a real DS or to another device using the native Nintendo wirelesss protocol.
Lot’s of interesting reading and packet capture fun with Wireshark has given me an idea of where to start, but the tricky part is that the DS needs less than 20us of round trip latency for it to work, which is insanely low. Otherwise the connection is considered interrupted and gets dropped.
afaik, the only part that “verifies” the latency are ACK frames which the DS expects a return for every frame transmitted, so it should in theory be possible to just make a small driver that generates ACK frames at kernel priority, and forwards the rest of the frame to MelonDS for actual game handling.
I’m hoping it turns out that easy but the MelonDS forums have a long ass thread about how much of a PITA the DS wireless multiplayer timing synchronization requirements are.
Ooh, It does sound interesting. My wild conspiracy is that Nintendo has made hardware offloaded functions that run with sub-microsecond latencies so this 20 us looks more like blocking non-DS hardware from communicating with the DS.
Wow, this would be quite cool. When DS emulators were new, I wanted this to be a thing so bad.
Unrelated (and not what I’m doing this weekend), but I’ve always been interested in reversed-engineering the DS / DSi firmware drivers that connects to WiFi to attempt to backport the 802.11b driver to WEP-only DS games.
Just finished “version 0” for a very simple programming language yesterday, and I’m looking to work on “version 1” this weekend. Rust is truly fun to program in… although writing all the tests was not a very fun experience. But doing the work for that meant I was guaranteed to have a reasonably good grasp of the semantics by the time I finished.
Since it’s Rust, there’s no garbage collector – heck, for this particular language, there’s not even any memory allocation after startup. Instead you get a giant global array of “memory” to work with. The only data type is the 32-bit integer (and thus, using UTF-32 for strings is actually the """correct""" choice for this language). I’m using a vaguely Lisp-like syntax that revolves around
{[a tree] formed from (brackets and whitespace)}… which was probably slightly easier to parse than more traditional syntax, but Rust’s current lack of pattern matching “through”Vec(for example, letting you extractefrom{a b [c (d e)] f}in one step) didn’t always make it feel that way.Nest up: adding while loops, exponentiation and bitwise operators, and most interestingly, string and character literals. (The char literals would just evaluate to their character codes, and string literals would only be usable in a specific write-to-memory construct.) And also expanding the standard library. I’d say “version 1” would really be the more properly “complete” version of the language. I also want to do a functional programming variation (ditching the global memory in favour of reference counted cons cells), and also the whole language is kind of just a stripped down version of another much bigger language half-formed in my head, but that’s all probably for… not this weekend, at any rate.
Looking for a job :(
Yeah, Same here honestly
Writing code inside Mindustry’s logic processor that test belt speeds, benchmark different schematics, etc.
I’ve been tinkering with integrated programming and physical circuits. Working with my hands to “code” a physical piece of hardware that does a specific purpose has been a breath of fresh air in the age of Al.
I have a couple of ideas bouncing around, but they might be too ambitious (plus harder that I use a less common language, often via bindings).
The first is a lot of ideas for a mesh editor, but not sure where to start. Technically, I already started a while ago with a text-based* polygon format/loader for Raylib so if I had some (high-level) way to export that polygon to a 3D file (single/double-sided faces or extruded) that’d be the first step. However I never really used/continued what I made (2D) because of how windings (fan vs strip) are, not good** as you’d need to keep track of it during usage. Perhaps something else might be better, like p5js?
The other is a frameless+floating X11 WM, and I’m similarly unsure of what I should use for drawing a title/titlebar and window buttons (and inset controls if possible).
.xpmfor bar/buttons is a maybe.* sparse (a rectangle is 4 numbers on an otherwise empty grid), not like traditional (filled) ASCII art
** maybe expecting winding from an unordered list of points is too much, but not sure there’s an easy way to cover windings for most situations. Color index (8-way) used as face hints, or similar (4-way?) for inside direction? Multiple origins for raycasts?
fan vs strip
Why not just work with a collection of triangles directly? It uses more memory, yes, but it’s simpler to reason about and can also have parallelism benefits (since each triangle is independent).
It can still be useful to track shared vertices (and reference them by index) though.
That’s how it could work when it gets to 3D anyway (with face-corner vertex color which I might not always need) but that’d be a pain to define by hand and the format I have I don’t actually have a way to define the same point more than once as it’s on a text grid.
for example, an oval
Note: it appears round here, but it isn’t
#values: matrix_xres matrix_yres target_size vert_num #vert pattern is cntrclckwse (related: replace 0 with @ for closed shape) or |/|/ 31 15 160.0 9 1 2 8 3 @ 7 4 6 5Easier to edit in a text editor with syntax highlighting that marks spaces for a visible grid.
My face hinting idea also doesn’t work with this shape due to orientation (would work as a more traditional octagon), it also seems to be more obvious/viable with a larger grid (looks right for a 32x32 star shape).
I’m not sure I quite get it, but if I’m following correctly, you’re using the numbers to indicate a sequence of vertices for a triangle fan here (with
indicating the central vertex), right? If so, the vertices are used in more than one triangle;(0, 1, 2)and(0, 2, 3)are triangles that reuse vertex 0 () and vertex2.If that’s what’s going on then it should be fairly straightforward to turn shapes defined like this into extrusions; for the simplest case you duplicate and offset the triangle fan for the other end and then generate quads/pairs of triangles for the extruded faces of the prism – and for more complicated cases you can repeat that (with planar alignment if needed) following a curve in small increments.
I might not be following though since I don’t know what you mean by color index face hints.
You are right about a few things, though the key is that Raylib is what’s creating the polygon (after I parse the text file into a sequence) and ideally I don’t handle face/mesh creation myself (at low-level). Maybe eventually.
what you mean by color index face hints
For additional context on where faces are.
I’ve mentioned vertex color (ideal as face colors), but I probably do want to handle a 3-digit-hex color palette with object-library-wide management.
here's what I was thinking with verts no longer numbered (instead E for external, C for corner. even-odd might work better in some cases), index numbers as hints and for color
Each arm would be its own color
#values: matrix_xres matrix_yres target_size vert_num #IDEA, fails with heart as there is only 1 corner vertex 32 32 160.0 11 E 1 E2 C C 3E 1 2@3 4 5 C C C 4 5 E E
The reason I’m thinking about this is that it would be better to have one way to define verts. triangle_strip can generally do more (shapes with no central point) than triangle_fan, though I think the star here is the sort-of-thing that a single triangle_strip cannot do. That, and with numbering it only allows 62 verts (0…9, a…z, A…Z), and is a bit clunky to iterate on. Numbering, especially with a strip, is also a lot more complex as you get more verts. If I got to the point of making my own editor*, I might abstract this away so the user only works with points.
Use-in-code-wise I may have already solved fan-vs-strip with a function that just compares the values of the first few points to choose draw type, though I wasn’t confident in that as it’d require a lot more testing. Might be better to store that in an enum as well.
* I wasn’t quite sure of using what I already made for anything more than a simple arcade-like game, so that sort of kills motivation, needing to do even more technical work just to get visible results.
Kotlin Multiplatform because I’m unemployed, and Kotlin is a nice language and it’s been decades since I haven’t done a mobile application (the last ones were in Java for Android and Objective-C for the iPhone).
I haven’t used Kotlin for years but I did do a $WORK project in it once. I prefer co-routines in Kotlin to using
asyncin Rust (which makes sense because it is a higher level language with a garbage collector). I also like how easy it is to write Domain Specific Languages (DSLs) in Kotlin.Good luck with the job search. Its hard out there at the moment.
Thanks!
