UCSD Pascal In Depth
https://markbessey.blog/2025/04/29/ucsd-pascal-in-depth/ [markbessey.blog]
2025-05-28 05:09
tags:
pascal
programming
retro
series
systems
text
The p-System comes with an editor. It’s a full-screen editor, with some fairly advanced features for the time, like auto-indent, bookmarks, and cut and paste. It’s modal, which is hardly surprising, considering that modal editors were the latest usability improvement of the age, compared to the line-oriented editors of the previous decade.
Also: https://markbessey.blog/2025/04/30/ucsd-pascal-in-depth-2/
Some features of the p-System were really ahead of their time. And then, there is the filesystem. Whenever you set out to create any software, but especially an operating system, which you intend to be aggressively cross-platform, you inevitably run into conflicts between being sophisticated, and hitting the lowest common denominator.
Also: https://markbessey.blog/2025/05/08/ucsd-pascal-in-depth-3-n/
But the 1970s were a very different time. So let’s talk about the text file format for the USCD p-System. This is not just something that applies to the text editor, incidentally. If you declare a file as “text” type in Pascal, it gets the same formatting applied. The formatting is transparently stripped from the file if you send it to the PRINTER: or CONSOLE: device.
Overview: https://markbessey.blog/ucsd-p-system-info/
Also: https://github.com/mbessey/p-system-tools
source: trivium
Making the rav1d Video Decoder 1% Faster
https://ohadravid.github.io/posts/2025-05-rav1d-faster/ [ohadravid.github.io]
2025-05-25 00:24
tags:
c
compiler
perf
programming
rust
rav1d is a port of dav1d, created by (1) running c2rust on dav1d, (2) incorporating dav1d’s asm-optimized functions, and (3) changing the code to be more Rust-y and safer.
Video decoders are notoriously complex pieces of software, but because we are comparing the performance of two similar deterministic binaries we might be able to avoid a lot of that complexity - with the right tooling.
source: HN
Go Scheduler
https://nghiant3223.github.io/2025/04/15/go-scheduler.html [nghiant3223.github.io]
2025-05-21 22:40
tags:
article
concurrency
go
programming
systems
Understanding the Go scheduler is crucial for Go programmer to write efficient concurrent programs. It also helps us become better at troubleshooting performance issues or tuning the performance of our Go programs. In this post, we will explore how Go scheduler evolved over time, and how the Go code we write happens under the hood.
source: HN
Build your own ResponseWriter: safer HTTP in Go
https://anto.pt/articles/go-http-responsewriter [anto.pt]
2025-05-09 19:14
tags:
go
programming
web
Go’s http.ResponseWriter writes directly to the socket, which can lead to subtle bugs like forgetting to set a status code or accidentally modifying headers too late.
source: L
Beating the Fastest Lexer Generator in Rust
https://alic.dev/blog/fast-lexing [alic.dev]
2025-05-09 19:07
tags:
compiler
perf
programming
rust
text
I was aware of the efficiency of state machine driven lexers, but most generators have one problem: they can’t be arbitrarily generic and consistently optimal at the same time. There will always be some assumptions about your data that are either impossible to express, or outside the scope of the generator’s optimizations. Either way, I was curious to find out how my hand-rolled implementation would fare.
source: L
Write the most clever code you possibly can
https://buttondown.com/hillelwayne/archive/write-the-most-clever-code-you-possibly-can/ [buttondown.com]
2025-05-09 18:55
tags:
development
essay
ideas
programming
How do we make something utterly mundane? By using it and working at the boundaries of our skills. Almost everything I’m “good at” comes from banging my head against it more than is healthy. That suggests a really good reason to write clever code: it’s an excellent form of purposeful practice. Writing clever code forces us to code outside of our comfort zone, developing our skills as software engineers.
source: L
Cheating the Reaper in Go
https://mcyoung.xyz/2025/04/21/go-arenas/ [mcyoung.xyz]
2025-04-21 23:49
tags:
garbage-collection
go
malloc
programming
These things mean that despite Go having a GC, it’s possible to do manual memory management in pure Go and in cooperation with the GC (although without any help from the runtime package). To demonstrate this, we will be building an untyped, garbage-collected arena abstraction in Go which relies on several GC implementation details.
source: HN
Marching Events: What does iCalendar have to do with ray marching?
https://pwy.io/posts/marching-events/ [pwy.io]
2025-04-18 05:31
tags:
format
programming
rust
I’ve found a way of describing occurrences through distance functions. This means that instead of implementing logic for all combinations of frequencies and parameters - as that spooky table from before suggests one might do - we can simply compose a couple of distance functions together.
source: HN
I want a good parallel computer
https://raphlinus.github.io/gpu/2025/03/21/good-parallel-computer.html [raphlinus.github.io]
2025-03-22 17:56
tags:
concurrency
cpu
graphics
hardware
programming
I believe a simpler, more powerful parallel computer is possible, and that there are signs in the historical record. In a slightly alternate universe, we would have those computers now, and be doing the work of designing algorithms and writing programs to run well on them, for a very broad range of tasks.
source: L
The Defer Technical Specification: It Is Time
https://thephd.dev/c2y-the-defer-technical-specification-its-time-go-go-go [thephd.dev]
2025-03-19 22:48
tags:
c
compiler
programming
standard
Time for me to write this blog post and prepare everyone for the implementation blitz that needs to happen to make defer a success for the C programming language.
source: HN
Robust Wavefront OBJ model parsing in C
https://nullprogram.com/blog/2025/03/02/ [nullprogram.com]
2025-03-15 19:25
tags:
c
graphics
programming
Wavefront OBJ is a line-oriented, text format for 3D geometry. It’s widely supported by modeling software, easy to parse, and trivial to emit, much like Netpbm for 2D image data. Poke around hobby 3D graphics projects and you’re likely to find a bespoke OBJ parser. While typically only loading their own model data, so robustness doesn’t much matter, they usually have hard limitations and don’t stand up to fuzz testing. This article presents a robust, partial OBJ parser in C with no hard-coded limitations, written from scratch. Like similar articles, it’s not really about OBJ but demonstrating some techniques you’ve probably never seen before.
Quicksort with Jenkins for Fun and No Profit
https://susam.net/jenkins-quicksort.html [susam.net]
2025-03-14 22:48
tags:
programming
sorting
swtools
turtles
Jenkins supports pipeline scripts written in Groovy as a first-class entity. A pipeline script effectively defines the build job. It can define build properties, build stages, build steps, etc. It can even invoke other build jobs, including itself.
Wait a minute! If a pipeline can invoke itself, can we, perhaps, solve a recursive problem with it? Absolutely! This is precisely what we are going to do in this post. We are going to implement quicksort as a Jenkins pipeline for fun and not a whit of profit!
source: trivium
Constant-Time Code: The Pessimist Case
https://eprint.iacr.org/2025/435 [eprint.iacr.org]
2025-03-08 06:09
tags:
compiler
cpu
crypto
paper
pdf
perf
programming
turtles
This note discusses the problem of writing cryptographic implementations in software, free of timing-based side-channels, and many ways in which that endeavour can fail in practice. It is a pessimist view: it highlights why such failures are expected to become more common, and how constant-time coding is, or will soon become, infeasible in all generality.
From compiler optimizations to CPU pipelines and register renaming.
Zen and the Art of Microcode Hacking
https://bughunters.google.com/blog/5424842357473280/zen-and-the-art-of-microcode-hacking [bughunters.google.com]
2025-03-08 06:03
tags:
bios
cpu
exploit
hash
programming
security
systems
In this post, we first discuss the background of what microcode is, why microcode patches exist, why the integrity of microcode is important for security, and how AMD attempts to prevent tampering with microcode. Next, we focus on the microcode patch signature validation process and explain in detail the vulnerability present (using CMAC as a hash function). Finally, we discuss how to use some of the tools we’ve released today which can help researchers reproduce and expand on our work (skip to the Zentool section of this blogpost for a “how to” on writing your own microcode).
source: HN
0+0 > 0: C++ thread-local storage performance
https://yosefk.com/blog/cxx-thread-local-storage-performance.html [yosefk.com]
2025-02-17 21:29
tags:
compiler
concurrency
cxx
library
perf
programming
We’ll discuss how to make sure that your access to TLS (thread-local storage) is fast. If you’re interested strictly in TLS performance guidelines and don’t care about the details, skip right to the end — but be aware that you’ll be missing out on assembly listings of profound emotional depth, which can shake even a cynical, battle-hardened programmer. If you don’t want to miss out on that — and who would?! — read on, and you shall learn the computer-scientific insight behind the intriguing inequality 0+0 > 0.
source: HN
Can atproto scale down?
https://bsky.bad-example.com/can-atproto-scale-down/ [bsky.bad-example.com]
2025-02-17 21:10
tags:
networking
perf
programming
social
storage
And skipping right to the end, my answer to “can it scale down” is just: “yes!”. Here’s my Raspberry Pi 4b, at home, consuming a few watts and pulling around 20GB of simplified firehose events per day. It’s an AppView indexing all cross-repo references (backlinks) in the AT-mosphere, often up to 1,500 created per second. It’s closing in on one billion backlinks, eating up an old SATA SSD connected over a salvaged USB adapter.
source: L
"A calculator app? Anyone could make that."
https://chadnauseam.com/coding/random/calculator-app [chadnauseam.com]
2025-02-17 21:02
tags:
android
compsci
math
programming
ux
A calculator should show you the result of the mathematical expression you entered. That’s much, much harder than it sounds.
source: HN
How do modern compilers choose which variables to put in registers?
https://langdev.stackexchange.com/questions/4325/how-do-modern-compilers-choose-which-variables-to-put-in-registers [langdev.stackexchange.com]
2025-02-17 20:59
tags:
compiler
cpu
programming
This is a very broad subject. The problem of deciding how to map a program with arbitrarily many variables onto a fixed set of registers is known as register allocation, and it has been the subject of much research, study, and engineering effort since the very earliest compilers. One of the canonical approaches, graph coloring, was first proposed in 1981. Countless other approaches and variants have been explored since then, and I cannot hope to cover the full breadth of the topic in a single answer.
source: HN
Get in loser. We're rewinding the stack.
https://andrews.substack.com/p/get-in-loser-were-rewinding-the-stack [andrews.substack.com]
2025-02-17 20:57
tags:
perl
programming
series
wasm
In my last post, I expressed frustration at how the lack of exnref support in most WebAssembly runtimes made zeroperl effectively unusable. However, complaining alone doesn’t solve problems—if something is broken, fix it. Don’t accept the status quo or let it derail your goals.
Using libsetjmp from the WASI SDK for setjmp/longjmp breaks compatibility across WebAssembly runtimes, so I decided to implement it myself. Binaryen has an Asyncify feature, which provides more than enough functionality to build a setjmp implementation from scratch.
Part of a series on getting perl running in wasm.
https://andrews.substack.com/p/zeroperl-sandboxed-perl-with-webassembly
source: HN
The Art of Dithering and Retro Shading for the Web
https://blog.maximeheckel.com/posts/the-art-of-dithering-and-retro-shading-web/ [blog.maximeheckel.com]
2025-02-03 19:47
tags:
gl
graphics
interactive
programming
visualization
web
I spent the past few months building my personal website from the ground up, finally taking the time to incorporate some 3D work to showcase my shader and WebGL skills. Throughout this work, I got to truly understand the crucial role that post-processing plays in making a scene actually look good, which brought some resolutions to long-term frustrations I had with my past React Three Fiber and shader projects where my vision wouldn’t materialize regardless of the amount of work and care I was putting into them.
Taking the time to build, combine, and experiment with custom post-processing effects gave me an additional creative outlet, and among the many types I got to iterate on, I always had a particular affection for the several “retro” effects I came up with. With subtle details such as dithering, color quantization, or pixelization/CRT RGB cells, they bring a pleasant contrast between the modern web landscape and a long-gone era of technology we 90s/early 2000s kids are sometime longing for.
source: HN