shakedown.social is one of the many independent Mastodon servers you can use to participate in the fediverse.
A community for live music fans with roots in the jam scene. Shakedown Social is run by a team of volunteers (led by @clifff and @sethadam1) and funded by donations.

Administered by:

Server stats:

291
active users

#lowlevel

0 posts0 participants0 posts today

#programming #lowLevel #lisp #commonLisp #article #medium
I wrote a short description of how lisp is coded by writing lisp sequences (lists), and the low level dotted cons view of the lists.

I wrote a funny piece of lisp that outputs a lower triangular emacs orgmode matrix depiction of a lisp form.

medium.com/@screwlisp/lisp-cod

Which leaves me wondering, does anyone "use" or otherwise think about (a . (b . NIL)) the dotted cons way of writing lists while programming?

I got back to working on #HighlightOS , a x86_64 OS (kernel) made from scratch using #assembly & #Rust.

If you're interested in the project, you can go check it out on GitHub:
github.com/adamperkowski/highl

I'm currently working on implementing everything into Rust: github.com/adamperkowski/highl

Everyone is more than welcome to contribute!

GitHubGitHub - adamperkowski/highlightos: 🌄 x86_64 OS (kernel) made from scratch using Assembly & Rust🌄 x86_64 OS (kernel) made from scratch using Assembly & Rust - adamperkowski/highlightos

Fantasy console update: Just added & polished some more of these examples from last year and you can play with them here:

demo.thi.ng/umbrella/fantasy-c

Instructions:

- Press `1` - `6` to select/launch/reset any of the examples
- Press `Space` to download screenshot
- Apart from the raster bars and lissajous curve all other demos can be interacted with via mouse
- Open the browser console to see the (already transpiled) source code of all examples

Example #1: Scribble & color cycling
Hold down left mouse button to cycle the colors (the current palette is also always shown in bottom-left corner). Nice, powerful oldskool effect, which is actually easier to do with these indexed, non-RGB pixel buffers[1]

Example #2: Lissajous bobs
The spheres are actually 2x2 tiles of 8x8 pixel sprites with one color slot chosen as transparency. Drawing 100 spheres here, but could be a lot more...

Example #3: Raster bars
This oldskool effect is achieved via HSYNC interrupts only, i.e. no lines are being drawn — for every single pixel row we simply change the color value of the first palette entry. The text is also only being drawn once, at startup...

Example #4: Particle system
Simple particle system (2k particles) with the emitter position linked to the mouse. 6% probability for larger particles.

Example #5: Random pattern
Classic oldskool generative art, here by defining 4 custom bitmap font characters and then drawing a single randomly chosen char per frame

Example #6: Bitmap font editor
Select a character on the RHS to edit in the left box. Left click to set a pixel, right click to clear it. Press `Delete` to clear the char entirely. The system supports proportional width fonts and the little red triangle can be moved horizontally to adjust the width of each char... Clicking on the `Save` button will download a JSON file of the font's binary data (9 bytes per char: width + 8 data bytes)

In preparation for teaching a 3-day "Computing within limits" workshop @ University of Applied Sciences in Augsburg, almost exactly a year ago (next week) I created a little fantasy console (heavily inspirered by TIC80) to introduce students to:

- the idea of virtual machines / computing environments
- the freedom to design & control any aspect of that environment (and how this relates to the overall idea of personal computing these days)
- designing & building a small (virtual) env from the bottom up (incl. defining opcodes, memory limits, maps/regions, device control registers, interrupts (hsync/vsync), device I/O, comms & multi-tasking possibilities, various retro-computing inspired graphics techniques)
- defining a small low-level API/language for creative coding
- learning about binary/hex and how that knowledge translates visually

The short video gives an overview of five small examples & tools (incl. a bitmap font editor) I had prepared for the workshop — the entire system was built within a couple of days with thi.ng/umbrella and incl. examples is only 12KB (gzipped). In the workshop we later ended up mostly using the TIC80 instead, since we covered quite a few other wider perma- & retro-computing related topics too... The 3 days were barely enough to provide an overview and have some exploration time...

If anyone is interested in a similar workshop, please do let me know, I'm keen to repeat it/extend it...

(Ps. I will post a link to the interactive version later too)

[1] mastodon.thi.ng/@toxi/11029857

#ThingUmbrella #Workshop #VM #FantasyConsole #TIC80 #LowLevel #CreativeCoding #RetroComputing #Augsburg

cc @danielrothaug :)

USB has a plug-n-play implementation that makes a ton of sense if you're a chip vendor - you can register a VID and PID and have kernels automatically load the right drivers for your product.

But when individuals build things that return data via serial, there's no plug-n-play mechanism beyond just loading the serial driver. Is there a standard of some kind of detecting what *kind* of serial device has been plugged in? Like a userspace daemon that reads some kind of preamble from the serial device and can then load a program to handle it?

[ #electronics #embedded #software #lowlevel #usb #serial #arduino ]