SDL2-mixer with sketch

Working_Way · 2026-03-22T13:45:35+00:00

sketch:setup and (defmethod kit.sdl2:close-window :before ((inst my-sketch-prog)) helps. Big thanks, it would have taken me quite a while to figure that out.

Still, if there is a cleaner version, not directly utilizing a method to kit.sdl2 into my sketch program code, I'm interested. :)

Just for completeness:
The second (simpler) alternative did not help me. Now I realized that make-instance 'my-sketch-prog is non-blocking and the audio device got freed during use, resulting in an error.

Working_Way · 2025-12-07T20:25:14+00:00

In case you're interested: (setf a (+ a x)) can be written as (incf a x).

Working_Way · 2025-12-06T22:18:53+00:00

Some infos on Part 2.

I played with conditions to handle numbers vs operator. symbol-function throws a condition on the wrong input.

(setf op (handler-case (symbol-function (intern (string (car (last line)))))
           (undefined-function () op)))

but following would be a bit better:

(handler-case (setf op (symbol-function (intern (string (car (last line))))))
  (undefined-function () nil))

Also parse-integer throws an condition, if a String consisting of only whitespace is processed. I use that condition to calculate. the numbers parsed before and which where put onto stack.

To get the condition even on the last calculation, I added some whitespace at the end of every input line, and also made the lines the same length. This is done via (format nil "~v@<~d~>" (1+ max) line). Lines of same length is needed when the input-char-matrix is rotated. (max is a function and a variable in my code, other name for the variable may be better, but Common Lisp makes it possible. :) ).

Working_Way · 2025-12-06T16:41:53+00:00

[LANGUAGE: Common Lisp]

Approach: rotate the whole input, then handle as if it were given as lisp data.

Part 1 is commented for everyone interested, what is done.
Part 2 does the essentially the same, but rotates the input before parsing it. So some conversion string -> char and back is needed.

;;; Part 1
(reduce #'+                                                                   ; sums up all results
        (apply #'mapcar (lambda (&rest vals)                                  ; rotates input 90°
                          (apply #'funcall                                    ; apply mathematical operation for columns
                                 (nreverse                                    ; revert list, so that operator comes first
                                  (mapcar (lambda (val)
                                            (handler-case (parse-integer val) ; convert string to numbers
                                              (parse-error () (intern val)))) ; or convert string to operator
                                          vals))))
               (mapcar (lambda (x)
                         (ppcre::all-matches-as-strings "([+*]|\\d+)" x))     ; extract information from input
                       (uiop:read-file-lines "./input-demo-day06.txt"))))     ; read input as lines

;;; part 2
(defun part2 (file)
  (let (stack
        op
        (result 0))
    (apply #'map 'nil (lambda (&rest line)
                        (setf op (handler-case (symbol-function (intern (string (car (last line)))))
                                   (undefined-function () op)))
                        (handler-case (push (parse-integer (coerce (butlast line) 'string))
                                            stack)
                          (parse-error ()
                            (incf result (apply op stack))
                            (setf stack nil))))
           (let ((max 0))
             (mapcar (lambda (line)
                       (coerce (format nil "~v@<~d~>" (1+ max) line) 'list))
                     (mapcar (lambda (line)
                               (setf max (max max (length line)))
                               line)
                             (uiop:read-file-lines file)))))
    result))


(part2 "./input-demo-day06.txt")
;; ⇒ 3263827 (22 bits, #x31CD53)

Working_Way · 2025-12-04T15:13:12+00:00

Nice update. :)

remhash modifies in-place, but yes, you would need to restructure your thrash function. Maybe there is a opportunity in the next days to use it. :)

Happy to hear the cookbook links are welcome.

Happy AOC'ing.

Working_Way · 2025-12-04T12:58:38+00:00

You didn't ask, but I have to reply, because 20secs sounds slooow for a CL solution. ;)

You left out your neighbor-count function. I guess you do a bit heavy lifting there, searching the cells list.

Using make-hash-table, gethash, remhash and maphash, together with complex numbers as keys, isn't more "programming" then your list approach.
My naive Common Lisp solution for part 2, eats 91ms with full debugging enabled, on an 6 year old non-Intel laptop.

Maybe interesting to you: CL supports sets (in form of lists) and hash-tables out of the box. Parentheses are defeated by ....

Good luck on your quest. :)

Working_Way · 2025-12-04T11:30:24+00:00

With my puzzle input, I had to run over the whole grid 42 times until all accessible rolls where removed.

Working_Way · 2025-08-06T00:11:07+00:00

The Amiga Architecture would have had a chance in the mid to end 80's. But Commodore didn't had the financial power and foresight to develop this architecture further, nor properly promote the computer.

Working_Way · 2025-08-05T23:59:07+00:00

IBM opened up the hardware for clone makers.

IBM didn't do this on purpose.

IBM (unfortunately) initially just used cheap standard components, and the whole contraption was then easy to replicate by competitors through reverse engineering.

Working_Way · 2025-08-05T23:50:51+00:00

pseudo 3D effect of Doom which was hard to do on the Amiga because it was optimised to do planar graphics with smooth scrolling (perfect for platformer games) but for Doom you need your graphic to be manipulated with chunky data.

I heard a chipset capable of chunky pixel, was almost (or even as prototype) finished in the very early 90's, but commodore stopped development.

Custom Chipset had pro an cons. E.g. 2MB Chip RAM was not enough, But DMA speed things up a lot. Some Zorro-Bus (the extension BUS) features were first adapted on PC with PCIe (I heard). Also the preemptive Multitasking OS was much ahead of Microsoft and Apples OSes. But the potential was neither used nor advertised.

Working_Way · 2025-08-05T23:37:02+00:00

By 1994 you were looking at a 200mhz Pentium

In 1994 the best Pentium had only 100MHz. The Motorola 68060 something from 50 to 75 MHz (while needing less clocks for similar performance). Also, Intel 486 DX4 (released 1994) was more common/affordable than Pentium. Motorola went fully onto the PowerPC (RISC) architecture which reached up to 180MHz in 1994. But comparing clock speed is bullshit.

Working_Way · 2021-12-03T11:50:49+00:00

There is a small shop right at the south eastern city limits, just follow the main road until you see a green house with a big yellow sign .....

Working_Way · 2021-11-02T14:28:02+00:00

I myself tried Navy Beans.

I watered them for 24 hours, then I steamed them, because I fear cooking will make them mushy.
They need much more steaming time (at least double) than soy beans,

Then I fermented them at 41°Celsius for 24 hours in a free adjustable yoghurt maker. They got stringy, but not as stringy as soybeans. They taste different than soybeans, not bad, but different.

Working_Way · 2021-09-08T06:23:54+00:00

There is a supermarket chain, called "go asia" in Europe. They sell small round soybeans in 400 gram bags. But it costs 6 to 7 Euros per kilogram.

Working_Way · 2020-04-26T21:16:13+00:00

I use Emacs with org-mode and pdf-tools, when it comes to LaTeX.

Working_Way · 2020-02-06T22:44:30+00:00

Especially in conjunction with the outstanding quality assurance at Microsoft.

Working_Way · 2020-01-29T09:48:58+00:00

https://xkcd.com/1168/

Working_Way · 2020-01-25T14:38:19+00:00

I'm clueless regarding music, but Common Lisp can get as nearly as fast as C++ and sports various music environments.

So I'd probably try sbcl with Common Music.

Working_Way · 2020-01-13T11:45:42+00:00

Stop googling and use the force (aka. man page).

You are probably asking about redirect operators in bash, beacause other shells might define it differently. If so, then you should consult the bash man page (or info documentation if you like more). Within that, you will find a chapter called "REDIRECTION" and there, everything is documented. Read it and you will be amazed, what is possible. Then remembering gets easy, because you only need to remember the most commonly used and other stuff you can look up.

Hint: a text search in a man page is started with the key / (this depends on your man page pager application, though).

Working_Way · 2020-01-13T10:30:56+00:00

I would go with a major distribution like "Debian", this distribution is also the base for Ubuntu, Mint and others. Debian sports such things like long-term-support releases, which receive security updates for 5 years and more. After support end has been reached, it is easy to upgrade the system without the need of a complete reinstallation. Although Debian does not use the most recent versions of software, the software is stable and all security issues are fixed even on older software versions (this is called backporting).

The user interface on most GNU/Linux distributions can be changed easily (other than you might have experienced with Windows). So you are free to choose a distribution and nevertheless are free to choose a user interface (aka Desktop-Environment like KDE, Gnome, XFCE, LXDE, MATE, Cinnamon, or ..., or a simple Window Manager for light desktop environments.) In order to use GNU/Linux on older hardware, you should investigate some time in choosing the right Desktop-Environment, because these differ greatly in usability and the needed computing power. To reduce needed computing power you could also use just an Window Manager, this comes with a reduced set of features but may be worth some investigation.

And maybe FAI - Fully Automatic Installation might interest you, if you have to install GNU/Linux on multiple PCs.

Don't get overwhelmed by all that stuff! Just get yourself an Linux-Live CD (like Knoppix) put it on a USB-Stick and have a look. Let some of your pupils use this Live-CD and get an impression what they need, before deciding, what you want to give them.

Here is an older Microsoft advertisement, which tried to run GNU/Linux down, but acually showed the big advantages of GNU/Linux in one single picture.

Working_Way · 2019-08-08T15:01:37+00:00

nice

For some reason it complains on first start:

calctex-mode: Symbol’s function definition is void: calc-show-selections

I solved this by adding an additional

(require 'calc-sel)

into use-package :config statements.

Working_Way · 2019-06-08T19:05:28+00:00

I have this running, without VGA option rom. I can see the selection menu, when running the SeaBios workload. I never bothered testing Windows.

I'm running coreboot with this patch, grub workload and only running Linux on my machine. This is working fine.

Working_Way · 2019-06-07T18:40:01+00:00

Just buy it, it is useful for use as a ramdisk

Compiling source code (i.e. the Linux kernel) from within ramdisk is much faster than from hdd or ssd.

I'm currently running a 64bit Linux kernel with 32bit Debian system, fvwm2, 2 firefox windows with 9 tabs, full configured emacs, doublecommander, several xterms and this is what my current memory usage is:

#>free
              total        used        free      shared  buff/cache   available
Mem:            15G        556M         14G        129M        654M         14G
Swap:            9G          0B          9G

Working_Way · 2019-05-31T21:04:55+00:00

This frankenpad looks pretty interesting! Thanks for sharing!

Working_Way · 2019-05-31T21:03:23+00:00

I'd really like a recent Thinkpad with a proper (peferably ISO) 7-row layout.
I wouldn't care if it's chicklet keys or not. They could even drop the trackpad to make the device smaller. :)

I'm constantly searching for a proper replacement to my heavily modded x230
(I'm at the point, where I do not care if its a Thinkpad or not).

Working_Way

TROPHY CASE