I was once rushed into hospital, severely ill and should have already been dead. I was initially treated by a black nurse, on a table in a small storage room off a corridor, surrounded by junk, because there were no beds available. The light bulb was gone, and so the door had to be wide open, whilst she stuck drips into my arms, people just walking passed.
After a few hours, I was moved to a bed, where the two main people who saved my life and looked after me, was a Japanese man, and an Indian man.
When I came out of the danger zone, those two men had a little celebration with me, stood at the end of my bed, genuinely happy and relieved.
I remember noting at the time, that if they had an attitude of only people of their own "race" being worthy of medical attention, or that diversity was not allowed, then I would be dead.
This was emthasised by the fact that the white doctor took three days to get around to seeing me, looked through some paperwork, and told me that I should have died and was lucky to be alive, before moving on and was never seen again.
At one point, I could hear the black nurse receiving the most disgusting racist abuse by a patient she was trying to help. Then the nurse came to me, and actually apologised to me, for me having to hear it, bringing me headphones to block sound.
I refused them though, and said it wasn't right for me to block out something that she couldn't. I briefly touched her hand, looked up at her with a smile, and thanked her for helping to save my life.

#diversity #inclusion #racism #lifeexperiences #randomhospitalstory

A thought that popped into my head when I woke up at 4 am and couldn’t get back to sleep…

Imagine that AI/LLM tools were being marketed to workers as a way to do the same work more quickly and work fewer hours without telling their employers.

“Use ChatGPT to write your TPS reports, go home at lunchtime. Spend more time with your kids!” “Use Claude to write your code, turn 60-hour weeks into four-day weekends!” “Collect two paychecks by using AI! You can hold two jobs without the boss knowing the difference!”

Imagine if AI/LLM tools were not shareholder catnip, but a grassroots movement of tooling that workers were sharing with each other to work less. Same quality of output, but instead of being pushed top-down, being adopted to empower people to work less and “cheat” employers.

Imagine if unions were arguing for the right of workers to use LLMs as labor saving devices, instead of trying to protect members from their damage.

CEOs would be screaming bloody murder. There’d be an overnight industry in AI-detection tools and immediate bans on AI in the workplace. Instead of Microsoft CoPilot 365, Satya would be out promoting Microsoft SlopGuard - add ons that detect LLM tools running on Windows and prevent AI scrapers from harvesting your company’s valuable content for training.

The media would be running horror stories about the terrible trend of workers getting the same pay for working less, and the awful quality of LLM output. Maybe they’d still call them “hallucinations,” but it’d be in the terrified tone of 80s anti-drug PSAs.

What I’m trying to say in my sleep-deprived state is that you shouldn’t ignore the intent and ill effects of these tools. If they were good for you, shareholders would hate them.

You should understand that they’re anti-worker and anti-human. TPTB would be fighting them tooth and nail if their benefits were reversed. It doesn’t matter how good they get, or how interesting they are: the ultimate purpose of the industry behind them is to create less demand for labor and aggregate more wealth in fewer hands.

Unless you happen to be in a very very small club of ultra-wealthy tech bros, they’re not for you, they’re against you. #AI #LLMs #claude #chatgpt

Anche noi di #snowfan.it abbiamo il nostro motore di ricerca! 🔍❄️

Potete usare #SearXNG ospitato sul mio server:
➡️ searxng.noho.st/x/

È un meta-motore di ricerca libero e rispettoso della privacy. Nessun tracciamento, niente profili pubblicitari, solo risultati presi da tante fonti diverse. È a disposizione di tuttə nel #Fediverso, usatelo pure e condividetelo!

Come impostarlo come motore predefinito su #Firefox

Apri searxng.noho.st/x/ in una scheda di Firefox.

Clicca dentro la casella di ricerca di SearXNG.

Fai clic destro sulla casella di ricerca e scegli
“Aggiungi motore di ricerca ‘SearXNG…’” (o nome simile).

Conferma. Ora Firefox conosce il nuovo motore.

Vai su Impostazioni → Ricerca.

Sotto “Motore di ricerca predefinito” apri il menu a tendina.

Seleziona SearXNG – searxng.noho.st come motore predefinito.

Da questo momento tutto ciò che digiti nella barra degli indirizzi o nella barra di ricerca passerà dal nostro SearXNG.

Avete anche la possibilità di impostarlo come volete.🙏

P.s. Vi suggerisco di togliere GOOGLE dalle impostazioni dei motori di ricerca, tanto ci ha bloccato ... segno che funziona bene.😎

@privacypride

searxng.noho.st/x/preferences

Hackaday Podcast Episode 353: Fantastic Peripherals, Fake or Not Fake Picos, and Everything on the Steam Deck

Join Hackaday Editors Elliot Williams and Tom Nardi as they swap their favorite hacks and stories from the week. In this episode, they’ll start off by marveling over the evolution of the “smart knob” and other open hardware input devices, then discuss a futuristic propulsion technology you can demo in your own kitchen sink, and a cheap handheld game system that get’s a new lease on life thanks to the latest version of the ESP32 microcontroller.

From there they’ll cover spinning CRTs, creating custom GUIs on Android, and yet another thing you can build of out that old Ender 3 collecting dust in the basement. The episode wraps up with a discussion about putting Valve’s Steam Deck to work and a look at the history-making medical evacuation of the International Space Station.

Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

html5-player.libsyn.com/embed/…

As always, this episode is available in DRM-free MP3.

Where to Follow Hackaday Podcast

Places to follow Hackaday podcasts:

• iTunes
• Spotify
• Stitcher
• RSS
• YouTube
• Check out our Libsyn landing page

Episode 353 Show Notes:

What’s that Sound?

• Think you know that sound? Fill out this form for a chance to win a Hackaday Podcast T-Shirt.

Interesting Hacks of the Week:

• Simplifying The SmartKnob
  
  • Haptic Smart Knob Does Several Jobs

  
  

• Yamato-1: The World’s First Ship With Magnetohydrodynamic Propulsion
  
  • A Magnetohydrodynamic Drive In The Kitchen Sink
  • Bulked Up MHD Drive Makes Waves While Standing Still

  
  

• When Electricity Doesn’t Take The Shortest Path
• Looking At A Real Fake Raspberry Pi RP2040 Board
• An Open Source Electromagnetic Resonance Tablet
  
  • Glitching USB Firmware For Fun

  
  

• ESP32-P4 Powers Retro Handheld After A Transplant
  
  • Teardown: 168-in-1 Retro Handheld Game
  • GitHub – ducalex/retro-go: Retro emulation for the ODROID-GO and other ESP32 devices

  
  

Quick Hacks:

• Elliot’s Picks:
  
  • Hacking The Krups Cook4Me Smart Cooking Pot For Doom
  • Great Trains, Not So Great AI Chatbot Security
  • An SD Card Of Your Own For Microcontroller Projects
  • Making A CRT Spin Right Round, Round, Round

  
  

• Tom’s Picks:
  
  • Smart Home? Make It Smart Quarters With This LCARS Dashboard
  • Windows? Linux? Browser? Same Executable
  • EnderSpark: Convert Your Broken Creality FDM Printer Into An EDM Machine!

  
  

Can’t-Miss Articles:

• A Linux Power User Puts SteamOS To Work
  
  • Welcome to the CachyOS Wiki
  • Bazzite – The operating system for the next generation of gamers

  
  

• ISS Medical Emergency: An Orbital Ambulance Ride

hackaday.com/2026/01/16/hackad…

Trying Out the Allwinner-Based Walnut Pi SBC

When it comes to the term ‘Raspberry Pi clones’, the most that they really clone is the form factor, as nobody is creating clones of Broadcom VideoCore-based SoCs. At least not if they want to stay safe from Broadcom’s vicious legal team. That said, the Walnut Pi 1B single-board computer (SBC) that [Silly Workshop] recently took a gander at seems to be taking a fairly typical approach to a Raspberry Pi 4 form factor compatible board.

Part of Walnut Pi’s line-up, the Allwinner H616/H168-equipped 1B feels like it takes hints from both the RPi 4B and the Asus Tinkerboard, especially with its nicely colored GPIO pins. There’s also a beefier Walnut Pi 2B with an Allwinner T527 SoC that’s not being reviewed here. Translating the Chinese-language documentation for the board suggests that either the H616 or H618 may be installed, with both featuring a quad-core Cortex-A53, so in the ballpark of the Raspberry Pi 3.

There are also multiple RAM configurations, ranging from 1 GB of DDR3 to 4 GB of LPDDR4, with the 1 GB version being fun to try and run benchmarks like GeekBench on. Ultimately the impression was that it’s just another Allwinner SoC-based board, with a half-hearted ‘custom’ Linux image, no hardware acceleration due to missing (proprietary) Allwinner IP block drivers, etc.

While cheaper than a Raspberry Pi SBC, if you need anything more than the basic Allwinner H61* support and Ethernet/WiFi, there clearly are better options, some of which may even involve repurposing an e-waste Android TV box.

youtube.com/embed/XbNntV_yU50?…

hackaday.com/2026/01/16/trying…

Optimizing Software with Zero-Copy and Other Techniques

An important aspect in software engineering is the ability to distinguish between premature, unnecessary, and necessary optimizations. A strong case can be made that the initial design benefits massively from optimizations that prevent well-known issues later on, while unnecessary optimizations are those simply do not make any significant difference either way. Meanwhile ‘premature’ optimizations are harder to define, with Knuth’s often quoted-out-of-context statement about these being ‘the root of all evil’ causing significant confusion.

We can find Donald Knuth’s full quote deep in the 1974 article Structured Programming with go to Statements, which at the time was a contentious optimization topic. On page 268, along with the cited quote, we see that it’s a reference to making presumed optimizations without understanding their effect, and without a clear picture of which parts of the program really take up most processing time. Definitely sound advice.

And unlike back in the 1970s we have today many easy ways to analyze application performance and to quantize bottlenecks. This makes it rather inexcusable to spend more time today vilifying the goto statement than to optimize one’s code with simple techniques like zero-copy and binary message formats.

Got To Go Fast

The cache hierarchy of the 2008 Intel Nehalem x86 microarchitecture. (Source: Intel)
There’s a big difference between having a conceptual picture of how one’s code interacts with the hardware and having an in-depth understanding. While the basic concept of more lines of code (LoC) translating into more RAM, CPU, and disk resources used is technically true much of the time, the real challenge lies in understanding how individual CPU cores are scheduled by the OS, how core cache synchronization works, and the impact that the L2 and L3 cache have.

Another major challenge is that of simply moving data around between system RAM, caches and registers, which seems obvious at face value, but the impact of certain decisions can have big implications. For example, passing a pointer to a memory address instead of the entire string, and performing aligned memory accesses instead of unaligned can take more or less time. This latter topic is especially relevant on x86, as this ISA allows unaligned memory access with a major performance penalty, while ARM will hard fault the application at the merest misaligned twitch.

I came across a range of these issues while implementing my remote procedure call library NymphRPC. Initially I used a simple and easy to parse binary message format, but saddled it with a naïve parser implementation that involved massive copying of strings, as this was the zero-planning-needed, smooth-brained, ‘safe’ choice. In hindsight this was a design failure with a major necessary optimization omitted that would require major refactoring later.

In this article I’d like to highlight both the benefits of simple binary formats as well as how simple it is to implement a zero-copy parser that omits copying of message data during parsing, while also avoiding memory alignment issues when message data is requested and copied to a return value.

KISS

Perhaps the biggest advantage of binary message formats is that they’re very simple, very small, and extremely low in calories. In the case of NymphRPC its message format features a standard header, a message-specific body, and a terminator. For a simple NymphRPC message call for example we would see something like:
uint32 Signature: DRGN (0x4452474e)
uint32 Total message bytes following this field.
uint8 Protocol version (0x00).
uint32 Method ID: identifier of the remote function.
uint32 Flags (see _Flags_ section).
uint64 Message ID. Simple incrementing global counter.
<..> Serialised values.
uint8 Message end. None type (0x01).
The very first value is a 32-bit unsigned integer that when interpreted as characters identifies this as a valid NymphRPC message. (‘DRGN’, because dragonfly nymph.) This is followed by another uint32 that contains the number of bytes that follow in the message. We’re now eight bytes in and we already have done basic validation and know what size buffer to allocate.

Serializing the values is done similarly, with an 8-bit type code followed by the byte(s) that contain the value. This is both easy to parse without complex validation like XML or JSON, and about as light-weight as one can make a format without adding something like compression.

Only If Needed

When we receive the message bytes on the network socket, we read it into a buffer. Because the second 32-bit value which we read earlier contained the message size, we can make sure to allocate a buffer that’s large enough to fit the rest of the message’s bytes. The big change with zero-copy parsing commences after this, where the naïve approach is to copy the entire byte buffer into e.g. a std::string for subsequent substring parsing.

Instead of such a blunt method, the byte buffer is parsed in-place with the use of a moving index pointer into the buffer. The two key methods involved with the parsing can be found in [url=https://github.com/MayaPosch/NymphRPC/blob/master/src/nymph_message.cpp]nymph_message.cpp[/url] and [url=https://github.com/MayaPosch/NymphRPC/blob/master/src/nymph_types.cpp]nymph_types.cpp[/url], with the former providing the NymphMessage constructor and the basic message parser. After parsing the header, the NymphType class provides a parseValue() function that takes a value type code, a reference to the byte buffer and the current index. This function is called until the terminating NYMPH_TYPE_NONE is found, or some error occurs.

Looking at parseValue() in more detail, we can see two things of note: the first is that we are absolutely copying certain data despite the ‘zero-copy’ claim, and the liberal use of memcpy() instead of basic assignment statements. The first item is easy to explain: the difference between either copying the memory address or the value of a simple integer/floating point type is so minimal that we trip head-first into the same ‘premature optimization’ thing that Mr. Knuth complained about back in 1974.

Ergo we just copy the value and don’t break our pretty little heads about whether doing the same thing in a more convoluted way would net us a few percent performance improvement or loss. This is different with non-trivial types, such as strings. These are simply a char* pointer into the byte buffer, leaving the string’s bytes in peace and quiet until the application demands either that same character pointer via the API or calls the convenience function that assembles a readily-packaged std::string.

Memcpy Is Love

Although demonizing ‘doing things the C way’ appears to be a popular pastime, if you want to write code that works with the hardware instead of against it, you really want to be able to write some highly performative C code and fully understand it. When I had written the first zero-copy implementation of NymphRPC and had also written up what I thought was a solid article on how well optimized the project now was, I had no idea that I had a “fun” surprise waiting for me.

As I happily tried running the new code on a Raspberry Pi SBC after doing the benchmarking for the article on an x86 system, the first thing it did was give me a hard fault message in the shell along with a strongly disapproving glare from the ARM CPU. As it turns out, doing a direct assignment like this is bound to get you into trouble:
methodId = *((uint32_t*) (binmsg + index));
This line casts the current index into the byte buffer as a uint32_t type before dereferencing it and assigning the value to the variable. When you’re using e.g. std::string the alignment issues sort themselves out somewhere within the depths of the STL, but with direct memory access like this you’re at the mercy of the underlying platform. Which is a shame, because platforms like ARM do not know the word ‘mercy’.

Fortunately this is easy to fix:
memcpy(&methodId, (binmsg + index), 4);
Instead of juggling pointers ourselves, we simply tell memcpy what the target address is, where it should copy from and how many bytes are to be copied. Among all the other complex scenarios that this function has to cope with, doing aligned memory address access for reading and writing is probably among its least complex requirements.

Hindsight

Looking back on the NymphRPC project so far, it’s clear that some necessary optimizations that ought to have been there from the very beginning weren’t there. At least as far as unnecessary and premature optimizations go, I do feel that I have successfully dodged these, but since these days we’re still having annual flamewars about the merits of using goto I very much doubt that we will reach consensus here.

What is clear from the benchmarking that I have done on NymphRPC before and after this major refactoring is that zero-copy makes a massive difference, with especially operations involving larger data (string) chunks becoming multiple times faster, with many milliseconds shaved off and the Callgrind tool of Valgrind no longer listing __memcpy_avx_unaligned_erms as the biggest headache due to std::string abuse.

Perhaps the most important lesson from optimizing a library like NymphRPC is that aside from it being both frustrating and fun, it’s also a humbling experience that makes it clear that even as a purported senior developer there’s always more to learn. Even if putting yourself out there with a new experience like porting a lock-free ring buffer to a language like Ada and getting corrected by others stings a little.

After all, we are here to write performant software that’s easy to maintain and have fun while doing it, with sharing optimization tips and other tricks just being part of the experience.

hackaday.com/2026/01/16/optimi…