Plasma Globe Reveals Your Next Clue

If you like solving puzzles out in the real world, you’ve probably been to an escape room before, or are at least familiar with its concept of getting (voluntarily) locked inside a place and searching for clues that will eventually lead to a key or door lock combination that gets you out again. And while there are plenty of analog options available to implement this, the chances are you will come across more and more electronics-infused puzzles nowadays, especially if it fits the escape room’s theme itself. [Alastair Aitchison] likes to create such puzzles and recently discovered how he can utilize a USB powered plasma globe as a momentary switch in one of his installations.

The concept is pretty straightforward, [Alastair] noticed the plasma globe will draw significantly more current when it’s being touched compared to its idle state, which he measures using an INA219 current shunt connected to an Arduino. As a demo setup in his video, he uses two globes that will trigger a linear actuator when touched at the same time, making it an ideal multiplayer installation. Whether the amount of fingers, their position on the globe, or movement make enough of a reliable difference in the current consumption to implement a more-dimensional switch is unfortunately not clear, but definitely something worth experimenting with.

In case you’re planning to build your own escape room and are going for the Mad Scientist Laboratory theme, you’ll obviously need at least one of those plasma globes sparking in a corner anyway, so this will definitely come in handy — maybe even accompanied by something slightly larger? And for all other themes, you can always resort to an RFID-based solution instead.

Continue reading “Plasma Globe Reveals Your Next Clue”

Life After IRC – Your Move, Mozilla!

Last year marked the 30th anniversary of the Internet Relay Chat protocol (IRC) and it is hard to imagine that [Jarkko Oikarinen] could have foreseen the impact his invention would one day have on the world as we know it. How it would turn from a simple, decentralized real-time communication system for university-internal use into a global phenomenon, connecting millions of users all over the world, forming its own subculture, eventually reaching mainstream status in some parts of the world — including a Eurodance song about a bot topping European music charts.

Those days of glory, however, have long been gone, and with it the version of an internet where IRC was the ideal choice. What was once a refuge to escape the real world has since become the fundamental centerpiece of that same real world, and our ways of communicating with each other has moved on with it. Nevertheless, despite a shift in mainstream and everyday communication behavior, IRC is still relevant enough today, and going especially strong in the open source community, with freenode, as one of the oldest networks, being the most frequently used one, along some smaller ones like OFTC and Mozilla’s own dedicated network. But that is about to change.

Last month, Mozilla’s envoy [Mike Hoye] announced the decommissioning of irc.mozilla.org within “the next small number of months, and moving all communication to a new, or at least different system. And while this only affects Mozilla’s own, standalone IRC network and projects, and not the entire open source community, it is a rather substantial move, considering Mozilla’s overall reach and impact on the internet itself — past, present, and now even more the future. Let’s face it, IRC has been dying for years, but there is also no genuine alternative available yet that could truly replace it. With Mozilla as driving force, there is an actual chance that they will come up with a worthy replacement that transforms IRC’s spirit into the modern era.

Continue reading “Life After IRC – Your Move, Mozilla!”

Thumbs Up For This CRT Handheld Gaming Console

Despite all the progress video game graphics have made, it is safe to say that we won’t see any decline in oldschool 8-bit games any time soon. For some it’s about nostalgia, for others it’s just a great and simple-enough first step into game development itself. For [gocivici] it was a bit of both when he built this camcorder style, one-button gaming console.

With a Raspberry Pi Zero running PICO-8 at its core, [gocivici] salvaged the viewfinder of an old camcorder for the display, and that way turned it into a whole other kind of handheld console. For full ergonomic handling, one single, thumb-operated push button serves as only control option. This of course makes it a bit challenging to re-use existing games that would require more input options, so he and some friends decided to just write a suitable game on their own with the hopes that others might follow.

Unfortunately we don’t see a lot of projects using these old camcorder viewfinders, and considering modern LCD and OLED options it’s not really that surprising, but there’s just something intriguing about these tiny CRTs. So in case you want to see more of them, have a look at this tiny Atari display, and the DIY night vision monocle from a few years back. And to keep your eyes safe and sound, [gocivici] got you covered as well.

Continue reading “Thumbs Up For This CRT Handheld Gaming Console”

Telephone Plays The Songs Of Its People

Music, food, and coding style have one thing in common: we all have our own preferences. On the other hand, there are arguably more people on this planet than there are varieties in any one of those categories, so we rarely fail to find like-minded folks sharing at least some of our taste. Well, in case your idea of a good time is calling a service hotline for some exquisite tunes, [Fuzzy Wobble] and his hold music jukebox, appropriately built into a telephone, is just your guy.

Built around an Arduino with an Adafruit Music Maker shield, [Fuzzy Wobble] uses the telephone’s keypad as input for selecting one of the predefined songs to play, and replaced the phone’s bell with a little speaker to turn it into a jukebox. For a more genuine experience, the audio is of course also routed to the handset, although the true hold music connoisseur might feel disappointed about the wide frequency range and lack of distortion the MP3s used in his example provide. Jokes aside, projects like these are a great reminder that often times, the journey really is the reward, and the end result doesn’t necessarily have to make sense for anyone to enjoy what you’re doing.

As these old-fashioned phones gradually disappear from our lives, and even the whole concept of landline telephony is virtually extinct in some parts of the world already, we can expect to see more and more new purposes for them. Case in point, this scavenger hunt puzzle solving device, or the rotary phone turned virtual assistant.

Continue reading “Telephone Plays The Songs Of Its People”

“Good Code Documents Itself” And Other Hilarious Jokes You Shouldn’t Tell Yourself

Code documentation — is there anything more exciting than spending your time writing extensive comments? If I had to guess, your answer is probably somewhere along the lines of “uhm, yes, everything is more exciting than that”. Plus, requesting to document your code is almost like an insult to your well thought out design, this beautiful creation you implemented so carefully that it just has to be obvious what is happening. Writing about it is just redundant, the code is all you need.

As a result, no matter if it’s some open source side project or professional software development, code documentation usually comes in two flavors: absent and useless. The dislike for documenting ones code seems universal among programmers of any field or language, no matter where in the world they are. And it’s understandable, after all, you’re in it for the coding, implementing all the fun stuff. If you wanted to tell stories, you would have chosen a different path in life.

This reluctance has even formed whole new paradigms and philosophies claiming how comments are actually harmful, and anyone trying to weasel their way out of it can now happily rehash all those claims. But, to exaggerate a bit, we’re essentially villainizing information this way. While it is true that comments can be counterproductive, it’s more the fundamental attitude towards them that causes the harm here.

In the end, code documentation is a lot like error handling, we are told early on how it’s important and necessary, but we fail to understand why and instead grow to resent doing it again for that same old teacher, supervisor, or annoying teammate. But just like error handling, we are the ones who can actually benefit the most from it — if done right. But in order to do it right, we need to face some harsh truths and start admitting that there is no such thing as self-documenting code, and maybe we simply don’t understand what we’re actually doing if we can’t manage to write a few words about it.

So let’s burst some bubbles!

Continue reading ““Good Code Documents Itself” And Other Hilarious Jokes You Shouldn’t Tell Yourself”

Never Mind The Sheet Music, Here’s Spreadsheet Music

Nothing says Rockstar Musician Lifestyle like spreadsheet software. Okay, we might have mixed up the word order a bit in that sentence, but there’s always Python to add some truth to it. After all, if we look at the basic concept of MIDI sequencers, we essentially have a row of time-interval steps, and depending on the user interface, either virtual or actual columns of pitches or individual instruments. From a purely technical point of view, spreadsheets and the like would do just fine here.

Amused by that idea, [Maxime] wrote a Python sequencer that processes CSV files that works with both hardware and software MIDI synthesizers. Being Python, most of the details are implemented in external modules, which makes the code rather compact and easy to follow, considering it supports both drums and melody tracks in the most common scales. If you want to give it a try, all you need is the python-rtmidi and mido module, and you should be good to go.

However, if spreadsheets aren’t your thing, [Maxime] has also a browser-based sequencer project with integrated synthesizer ongoing, with a previous version of it also available on GitHub. And in case software simply doesn’t work out for you here, and you prefer a more hands-on experience, don’t worry, MIDI sequencers seem like an unfailing resource for inspiration — whether they’re built into an ancient cash register, are made entirely out of wood, or are built from just everything.

Continue reading “Never Mind The Sheet Music, Here’s Spreadsheet Music”

Crash Your Code – Lessons Learned From Debugging Things That Should Never Happen™

Let’s be honest, no one likes to see their program crash. It’s a clear sign that something is wrong with our code, and that’s a truth we don’t like to see. We try our best to avoid such a situation, and we’ve seen how compiler warnings and other static code analysis tools can help us to detect and prevent possible flaws in our code, which could otherwise lead to its demise. But what if I told you that crashing your program is actually a great way to improve its overall quality? Now, this obviously sounds a bit counterintuitive, after all we are talking about preventing our code from misbehaving, so why would we want to purposely break it?

Wandering around in an environment of ones and zeroes makes it easy to forget that reality is usually a lot less black and white. Yes, a program crash is bad — it hurts the ego, makes us look bad, and most of all, it is simply annoying. But is it really the worst that could happen? What if, say, some bad pointer handling doesn’t cause an instant segmentation fault, but instead happily introduces some garbage data to the system, widely opening the gates to virtually any outcome imaginable, from minor glitches to severe security vulnerabilities. Is this really a better option? And it doesn’t have to be pointers, or anything of C’s shortcomings in particular, we can end up with invalid data and unforeseen scenarios in virtually any language.

It doesn’t matter how often we hear that every piece of software is too complex to ever fully understand it, or how everything that can go wrong will go wrong. We are fully aware of all the wisdom and cliches, and completely ignore them or weasel our way out of it every time we put a /* this should never happen */ comment in our code.

So today, we are going to look into our options to deal with such unanticipated situations, how we can utilize a deliberate crash to improve our code in the future, and why the average error message is mostly useless.

Continue reading “Crash Your Code – Lessons Learned From Debugging Things That Should Never Happen™”