Tag Archives: programming

Arduino Promotion Behavior

I was pulling up an old project (A little Simon game which has apparently fallen off the ‘net when I moved my site- will have to repost) to use as a classroom demonstration, and discovered that sometime in the last couple years, the int->unsigned long promotion in Ardino/Processing broke/changed without comment.

The code uses using primitive nested counters and delays to generate sounds and control difficulty, which means rather large numbers (100-microsecond scale delays running for seconds) are being thrown about. To isolate the change, I wrote the following test:
Continue reading

Posted in Computers, DIY, Electronics, General, Objects | Tagged , | Leave a comment

Why Application Programming Sucks

You, the programmer, have a problem you would like to solve. This is what progammers do, but since it seems like a common problem, so you leap to t3h googles for a solution:
“Oh great google god, this lazy progammer beseeches you, find me someone who has already solved my problem”
and sure enough, within the first page of results, there is a promising function, DoWhatIWant(), in the magic library. This magic library must be common enough, since it solves your problem, so you hit the package manager (please tell me you are running a system with a package manager. If you have to spend hours tracking down nullsoft installers of patched second class citizen versions, you have only yourself to blame.) to find and install it.
$ sudo newpackagewrangler updatecommand
$ newpackagewrangler searchcommand magic

…10 hits, one of which is PROBABLY the one you intended…
$ sudo newpackagewrangler new-better-install-command magic2
Magic2 (150K)
behemoth (75.3M), UglyTK (5.6M), libCuteName (200K), libalkjosaoifdnjg (547k)
Install (Y/N)?

Let’s take a moment to figure out what the hell just happened:

  • behemoth: It’s 75Mb of crap – included for a single function that could have been reeimplimented in less than 100 lines of code.
  • UglyTK: It’s the newest, greatest graphical toolkit, for an included example frontend. There are only 4 programs written with it, you don’t use any of them, and it won’t take the theme from GTK or QT.
  • libCuteName: Probably named for an animal or a color; at one point there was a clever reason for this, but it has since been depricated.
  • libalkjosaoifdnjg : It isn’t clear what the hell this does, and it appears the name was selected by placing a keyboard in a box of kittens. Thats fine because all editors support autocompletion, right?

Since Magic.DoWhatIWant() appears to do exactly what you want, the package manager can take care of it, and your system supports shared libraries, how bad could it be?
While the dependency pile downloads and installs, you take a look at the documentation, and find that Magic.DoWhatIWant() has 93 arguments.. and only 70 of them are explained. You think “Surely, such a useful function is used all over the place.” and return to the interwebs to find an example.
The example you find actually has 97 arguments, since the documentation is perpetually out of date, and they don’t appear to be a superset of the 93 from the documentation – But Magic.DoWhatIWant() calls to you, and you begin hacking away to make it work.
After some hours, you come upon a heated argument in the magic maling list archive, where one of the developers has declared one of the 97 arguments “bloated crap,” in the last release cycle and removed it, in the process making DoWhatIWant() sligtly less suited to your problem than it seemed – but now you’ve invested some effort, and it should still do basically what you need once you figure it out…
Typically, two days later, you throw up your hands, and, in about two hours, write a function in pure C that solves the problem – or notice that by preprocessing the input with a 10-line AWK script the problem can be avoided alltogether. Occasionally, again about two days later, you DO get it to work, but end up having to do about half the task DoWhatIWant() was supposed to accomplish yourself – and now have 80Mb of dependencies for your 75k program, meaning you will have to update it every time any of them changes.

I realize several of the issues I’m mocking here are contradictory – that’s why it is such a shitty situation. Also, I do mean to be singling out the “layers on top of layers on top of package managers that were shifty when they were written in the early 90s” package managers so many distributions cling to.
This post brought to you by the bitterness of another weekend spent spelunking around inside of LLVM.

Posted in Computers, DIY, General, Navel Gazing | Tagged , | Leave a comment

ML and Music

I’ve been working on figuring out ML for an Advanced Programming Languages assignment. ML is a peculiar language, so it’s been taking some time, and when I’m spending hours staring at blocks of text I tend to get more into music as a complimentary activity. Both are turning up things worth sharing.
Functional programming has always confused me; as a computer engineer it strikes me as a deeply unnatural thing for the computer to do (what the hell does it look like in memory? — I mostly know and it isn’t pretty), and it isn’t a terribly natural paradigm for humans (although I will grant that is would likely be no more of a contortion for someone not accustomed to programming than any other paradigm). I guess there is a reason the deeply functional stuff tends to be mostly limited to “interesting” languages that are mostly outside the mainstream. I can “feel the power” on a lot of fronts; the ability to completely describe functions as input/output pairs is cool, recursion is natural and easy, and the type system is nifty, but it all still feels a little uncomfortable to me.
I’ve spent the last couple weeks on a Hyper Crush kick . Pandora brought me Hyper Crush off an A Kiss Could be Deadly derived station a while ago, and it took me a while to make up my mind about them. They make INCREDIBLY catchy, ostentatiously course, and somehow still incredibly geeky techno-influenced hiphop, which is either absolutely brilliant or unforgivably obnoxious. Aside from endless energy and spectacular synthesizer work, their songs are laced with a vast and remorseless collection of samples from and references to bits of pop-culture ephemera from the 1960s onward. Just to name a few, one track begins with a sample from The Shangri-Las “Leader of the Pack”, and another borrows its background from “Crazy Frog”. Both mixtape releases (Both available legitimately free online, but buried behind some flash obstructions) are shot through with samples from West Side Story, The Wizard, Back to the Future, and a wide swath of 80s and 90s video games. It is the pure sound of geeks letting their hair down, and it feels damn good.

To compliment the loud, I started listening to The xx yesterday, which I actually learned about from the music section in the back of last week’s The Week, which is usually too pretentious to pay attention to. Their debut album xx is unbelievably complex and nuanced for a first effort from a group of 20somethings. The lyrics are often male/female harmonies (I like the female vocalist’s voice much better, but thats par for the course with me), which are not necessarily the same words or timing for both voices but remain in harmony none the less. The lyrics are also quite subtle, one could reasonably make it through the entire album without realizing it’s mostly about sex. The coolest thing to me is how much they play with negative space; the crisp gaps are as much a part of the music as the instrumentation itself. There really isn’t any standout track, good or bad, on the album, so just go listen to any random track.

Posted in Computers, General, Music, OldBlog, School | Tagged , | Leave a comment