Category Archives: Navel Gazing

DARPA and the Makers

So there has been a spat going on, where Mitch Altman is parting ways* with other important folks in the Maker movement over concerns about their accepting DARPA money for STEM education. The organization accepting the grant is largely being represented in the arguments by Tim O’Reilly.

Altman and O’Reilly are some of the more substantial organizers of hacker/maker types, and I generally have a great deal of respect for their opinions and activities… but I don’t get what the DARPA fearmongering is about. As far as I can tell, the only problem is that from 1972-1993, and again from 1996 on, the U.S. Government’s technology investment agnecy has had “Defense” prepended to its name out of political necessity. I suppose part of my befuddlement is that the ethics of such things have long been carefully thought through in academia, so seeing the non-academic maker types fret about it is novel.

First off, let’s talk about DARPA. Go read the mission statement. They are tied to the DoD, but their job is to develop technology. Basically, it’s in the United States’ strategic interests to make sure domestic technological advancement keeps pace with or exceeds that of the rest of the world. Strategic does not mean military, I would like to think most of learned this, if not in school, at least from playing empire-building games. The MENTOR program this grant in in particular comes from is to fund education that will nurture future engineers and scientists, to support the goal of advancing science and technology. This is fundamentally the same organization that funded most of the major advances in computing (See Project MAC, MULTICS, and the Internet), even though they grew a “D” in their name, and were founded out of fear of the Soviet’s technological capacity. As it turns out fear of annihilation is a great way to get reluctant politicians to think about the future. DARPA isn’t the armed forces, they’re the US government’s way of investing in technology.

Next, let’s take a little dip into the philosophy of technology. Once some useful bit of technological progress has been made, it won’t be long until EVERYONE has access to it, such is the nature of history and technology. More cynically, the U.S. Military-Industrial complex will do whatever they want with any technology they dredge up, whether or not they paid for its development. Arguments about the intention of technology are kind of ridiculous, and yes, I’m aware that that makes my Utilitarian ethical precepts show. To use one of my favorite examples instead of going into a nebulous argument, the same cheap sensor and storage technology that makes mass surveillance possible also allows us all carry a recording device with which we can watch the watchers and disseminate our findings (so long as our rights to record police stay intact). The difference between menacing and empowering technology is entirely in its application, and the creators, much less the creators’ financial backers, generally don’t get a whole lot of say in the matter.

Finally, let’s talk about practical matters about politics and money in the United States. First, if you’re involved in the technology industry, you are already complicit. Like so many things in the modern world, the technology industry is, to a distressing degree, driven by the military industrial complex. We talk about the need for funding NASA as a matter of driving the leading edge of science and engineering so that technologies trickle down into our every day lives. The same applies to defense; World War 2 and the Cold War were arguably the primary technological drivers of the 20th century. I tend to think of DARPA, like the DoD operated national labs, as “The conservatives won’t let us fund science, so we call it defense and do it anyway.” Yes, it is reprehensible that “Education” and “Science” will get cut, but “Defense” won’t. Yes, some immediate military technology comes out of DARPA programs, but whether or not we are in a decade with the “D” prepended, it has always been about advancing technology. The principle here is that the U.S. Government is offering up money to advance STEM education from a fund that looks enough like defense to remain funded, and it is even better that its use is being directed by people who’s ideas about STEM education are agreeable, to O’Reilly, to Altman, and to people like me.

I’ll even admit there is a little bit of self-justification in here, but we’re all being a little ridiculous: Mitch made his announcement, most likely from some kind of Linux box (Which is a developed clone of a cut-down version of an old ARPA project), on the Internet (which is based entirely on the fruit of another ARPA project).

So, my opinion? Let’s celebrate that a little piece of the DoD budget is going to paying makers to teach future makers instead of fighting wars of aggression on flimsy pretenses in random oil-rich nations on the other side of the world. It surely isn’t perfect, but it is a step in the right direction.

* A bit of my own ideological weirdness: most of the argument took place on Facebook, which I think is sort of an embarrassment to our society, so the link to the original source is indirected through Slashdot.

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

Bookish Dreaming

I only remember a dream every year or so, but I realized on the way back from getting breakfast with friends this morning that a book I thought I’d been reading was entirely in a dream. It was a long dream with various dream-space fucked-up-ness to the setting building (No University space is that large, that nice… or has three large highly styled cafe/lounge spaces in the same complex) and interaction with various old acquaintances, but there was one section I didn’t realize was a dream because it was so normal:
< dream content >
I picked up a book (roughly A4 sized, and inch or so thick, nicely black cloth-bound with gold embossing) about code generation for a particular class of exotic hybrid-SIMD machines (I remember details, which are realistic, but not specific enough to pick out which machine) by David Padua (respected figure in parallel computing, who I’ve met at conferences) and a coauthor I couldn’t remember when I woke up. I got the book from a well stocked engineering library, and discussed it with various engineering types I know, including my current adviser.
< /dream content >
Until we were headed back from breakfast and I realized the setting was “improbable,” I was sure it had happened. When I got home I had to see if it was something I may have seen referenced – the content and authors were probably based on “Optimizing data permutations for SIMD devices.” which I read a year or two ago, but it isn’t an exact match. The description I remember also matches a section in Encyclopedia of Parallel Computing (four volume, $1500) book that I’ve never seen before (and now want access to). I also want the dream book, because it would be all kinds of useful for my MS project.
Aren’t brains interesting…

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

Poached Eggs and Scones

Poached Eggs and Scones
Failed to work up requisite give-a-fuck this morning, had no pressing obligations until the early afternoon. Result: breakfast of poached eggs with fresh scones and a latte. In a related note, I need a better scone recipe.

Posted in FoodBlogging, Navel Gazing | Leave a comment

Too Much Toolchain Time

Having my “work project” be finishing the code generator and simulator fronted for LARK, and my “play project” be coaxing uClibc and TCC to build for Android (demonstrably possible, it’s just a question of if I’m clever and/or tenacious enough…) is giving me a little too much time working with compiler toolchains to be healthy. It does make me understand how compilers people get their — characteristic — personality traits, though.

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

24!

Another year older, and again much the same, although not exactly as expected; I got a repulsive mixture of “no”s and bullshit offers on the round of PhD applications I sent out last year, and will be in Lexington for another year. That said, my plans for next year still suit me: I’m employed for the next semester working with the revamped EE101 course which covers the “Creative” requirement of the new general studies system at UK, in which we will (among other things) have the engineer younglings doing fun hobby electronics type things.

I also have a bit of the MS project to finish off. In my original plans I would have been defending on right about now. The delay in the MS as roughly as much to do with me being unfocused from the break in momentum as any of the various predictable setbacks in the project.

The combination actually works quite well: because it is a two section class with several people working on it, I should also have plenty of time to work on research, initially finishing off the last of the MS, and then seeing to various other projects which have been previously deferred.

The situation fits my personality: I’m directed, not driven. As long as I’m pointed in a direction I like and making progress, I’m pretty content.

Posted in General, Navel Gazing | Leave a comment

I thought I was going for a nice long skate in the beautiful weather. My heart, lungs, and left (lift) knee had other plans, and cut me off at a little under 30 minutes. I didn’t realize I was that out of shape…

Posted on by pappp | Leave a comment

Research Updates / LLVM Is a PITA

I’ve spent the last several months discovering ways in which LLVM is excessive, ill-behaved, oversold, broken or simply lying in it’s documentation while working on my master’s project. In fact, that is almost ALL of what I accomplished in the past several months, and it was griding on me psychologically. Last weekend, I finally admitted to myself that, for a mixture of psychological and technological reasons, I wasn’t going to be able to finish the project using LLVM. I’ve always had a bail-out path set up to do a simpler full-custom compiler if something proved intractable, and Monday I talked to the advisor about putting that plan into action.

I’m now building a simple C-like language with PCCTS (old school 1.33MR33 emits-pure-C ANTLR and SOURCERER PCCTS, not modern ANTLR), hand-coding C for the remainder, and concentrating on the technically interesting matters. To that end, I’ve accomplished more conceptual work in the last week than the two preceding months, started laying out my new tools, and feel much better. The best “aha” moment I’ve had in months came when I sat down and worked out how the stack and calling conventions were going to work in my new system; LARs are beautiful and well-suited to real world problems in a whole host of ways I didn’t understand before.

Note that I don’t think LLVM is entirely bad; in conception, having a nice cleanly-interfaced compiler infrastructure with a library of frontends, backends, optimizer passes and other common components which snap together via clean interfaces, high level specifications, and a standardized intermediate representation is exactly how compiler tools should be structured. The problem is that LLVM has been drastically oversold, and overcomplicated. Every neat-looking interface has a mess of poorly-documented C++ that needs to be written to support it. Everything is set up with an emphasis on LLVM’s JIT/VM features, making it unnecessarily clumsy to use to produce pure compilers, or interface with external tools. Worst of all, the documentation is deceiving — much worse than incomplete, it appears complete, but is frequently deceptive or wrong. To pick one of the more egregious examples, much of the document points to the MIPS fronted as an example. This should be a good thing – MIPS is a simple design familiar to almost anyone in computing, but the MIPS backend is broken, in apparently fairly fundamental ways. The register descriptions are buggy in ways which cause it to generate incorrect code for any input containing floats, and it appears to be a high-level design problem descended from naively trusting that the register description and allocation mechanisms work as described. It is probably already a good tool for writing production compilers for established designs, but it really isn’t suited to writing research compilers.

Posted in Announcements, Computers, Navel Gazing, School | 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
Install:
Magic2 (150K)
Depends:
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

Blog Move

This blog is in the process of moving in from it’s previous location at http://www.engr.uky.edu/~pseber0/ to it’s new home at pappp.net on bluehost. This current page will no doubt be repeatedly created and destroyed in the process, as I try to explain to the terrible migration tool about internal linking, resources, categories, and a variety of other things it is doing it’s best to lose or mangle. Things should be up and running in a couple of days, when the links will be updated, and the relocation notice will go up at the old location. This post also has a full set of categories, to force updates.

Posted in Announcements, Computers, DIY, Entertainment, FoodBlogging, General, Meta, Music, Navel Gazing, Objects, OldBlog, School | Leave a comment

Huh…

Some time ago, a friend sent me this article about one of our high school class mates (first person, the one at the National Journal Group), mixed with some ruminations on the fucked up standards of the people I grew up with. Earlier today, I saw this on BoingBoing. It took me a minute to put the two together, but I’m pretty sure the business plan that made the Atlantic solvent again is the same one being discussed in the first article.

I don’t know if this is a classic “Credit travels up, blame travels down” situation, or merely a case of self-promoters doing their thing, but it’s interesting how our acquaintance is ever so involved in the first article, and completely absent from the second.

Posted in General, Navel Gazing, OldBlog | Leave a comment