Category Archives: DIY

Virtualbox

I’ve liked fiddling with OSes for as long as I can remember, and have been through a couple VM solutions to ease the overhead of that habit. Until recently, I had been settled on qemu with the kqemu module for acceleration for some time, and thought it was pretty good. Then, one of the group mates got me to give VirtualBox, which was too much of a hassle last time I looked at options, another try. The result:
Virtualbox on Arch, running HaikuA1 and a Snow Leopard installer
That is my ArchLinux-running T510 hosting Virtualbox VMs with a Haiku R1 instance and a Snow Leopard installer (with a bootdisc for CPU recognition issues, apparently once updated it will boot straight from VirtualBox’s EFI). The partially-visible terminal with htop in the bottom left shows that it isn’t even eating my machine to do that.
Basically, it’s faster, it’s lighter on host resources, it’s more compatible, and NATed networking for the guests just works. Also, there is no hassle because the Arch package maintainers wrote some excellent support scripts. Converting my images and moving over. Do like.

Posted in Computers, DIY, General | 1 Comment

Otomata

Cellular automation-based generative synthesizer in flash. Very cool. Incredibly easy to make pleasing patterns. Would love a scaled up version.

Posted in Computers, DIY, Entertainment, General, Music | Leave a comment

WordPress Header Glitch

For some reason, the 3.1 to 3.1.1 WordPress update (or something coincident with it) removed the rel=me link back to my Google profile from my headers. Those links are important – they’re how this page is integrated into my online identity via XFN (The “Xhtml Friends Network”), one of the open standards which will obsolete proprietary social networks like the normal standards-driven internet obsoleted AOL, Compuserve, and the other early walled-garden services (oh please oh please oh please oh….). More immediately, they are what lets google know it should pull blog posts into my Buzz feed and such. Fixed now.

Posted in Computers, DIY, Meta | Tagged , , | Leave a comment

I ran into a description of harmonic drives earlier. I hadn’t seen anything quite like them before, and they are just so cool – flexible driven gear for high torque, high fraction engagement, and inherently loaded for zero-backlash. Even though … Continue reading

Posted on by pappp | Leave a comment

Cluster GPU Thermal Monitoring

The research group has been writing some simple monitoring scripts for handling the clusters. The focus is mostly on montitoring NAK (page in serious need of update), which has always had thermal irregularities with it’s GPUs. Some of the (poorly designed) GPU coolers have recently finished cooking their fans, and the “repair” has been to remove the cowling and mount an 80mm fan in the case to blow across the heatsink — this produces comparable temperatures to the vendor solution, whch is pathetic. This thermal instability requires that the system temperatures be periodically checked, and we have written variety of colorful scripts both for users and for the displays in the front of the machine room. The one I wrote for my own use is a simple combination of bash and AWK, which produces nice colorized one-line summaires for each machine when run with something like “mpirun –hostfile ~/nakhosts ./pstatc.sh | sort” where nakhosts is a standard MPI-friedly list of hosts, and ~/bin/ has nvidia-smi (a little tool for handling nivida GPUs from the command line) exported to the nodes. Script attached here for perusal (and so I can find it later). Possibly the best part is that it made me referesh my memory on using ANSI Color Escapes, which has been on my list of skills to touch up for a while – That foray also lead to souping up the script Hank was working on to use background colored spaces for ghetto bargraphs to keep the displays in the windows of the machine room interesting until we are set up to drive them with something else. One of these days I really should learn to use ncurses, or at least get better with one of the GUI libraries…

Posted in Computers, DIY, General, School | Tagged , , | Leave a comment

Package Manager Security

(The following is long, rather technical, and somewhat esoteric. Sorry, it’s what I do.)
I try to keep reasonably abreast of developments in Arch Linux, since it has been my favorite distribution for about seven years now, and the OS on my primary-use computer for five of them. Someone (almost entirely a single very loud someone as it turns out) has been making noise about package signing in pacman, the package manger used by and written for Arch, and said noise propagated up to an article on LWN, so I took some time out tonight to read up on the matter.

The short version is that the description of events on pacman developer Dan McGee’s blog seems to be essentially correct, and the “Arrogant and dismissive” accusations were the result of someone new showing up and making long-winded demands on the mailing list in regard to a topic which has been under (occasionally contentious) discussion for years. The Arch community can certainly be a little blunt, but it has never struck me as unfriendly or inappropriately autocratic (there is quite a bit of the “Those people actually doing things get to decide how they are done” mentality: as far as I am concerned this is exactly right for community projects).

The two primary things I learned in reading are that package manager security is indeed a hard problem, and that most of the possible attacks would be extremely difficult to carry out, regardless of package signing. The typical least concern matter of security: if production machines anywhere that matters are having their DNS (& etc.) spoofed on the required scale, there is a much bigger problem than trying to slip compromised packages into systems during updates. I’ve also discovered that generally, people don’t seem to care: for example, as best I can make out, gentoo has had discussions on package/repository signing since 2002, support since 2004… and it isn’t generally used today. The Arch Wiki has a nifty article about how various distributions handle package security in the context of designing a system for Arch – it is somewhat incomplete, but the only comparison of existing systems I found. Note that the page was started and largely populated in July of 2009.

One thing I don’t quite understand is why there isn’t a movement toward, at least optionally, performing updates over secured connections: simply using ssl (which has it’s own problems) for mirror-to-mirror and user-to-mirror communication would (aside from making the CPU load involved in running a mirror much higher and considerably slowing update downloads…) convey many of the befits of signed packages/repositories with less hassle. More importantly, it would close many of the holes in package management systems which do support signing for those individuals and organizations with sufficiently critical systems and/or paranoid administrators to be willing to swallow the overhead.

With all that in mind, I find myself agreeing with the pacman developer’s ambivalence on the issue – a security scheme for pacman is not so much a “critical feature” as a”nice to have”, largely for future proofing. Likewise, a broken scheme, or one so obtrusive it goes unused is probably worse than none at all. The obtrusive issue is honestly probably the most important to me – one of my favorite things about pacman is that the makepkg process is incredibly easy. I can often go from a source tarball or CMS checkout to a easily handled package as fast as I can (safely) build and install by hand. Contrast this with, say, Debian, where packaging and installing even simple software is often a painful multi-hour affair even with things like debhelper, and simple packages tend to (in my experience) do unhelpful things like fail to uninstall cleanly. I want making my own packages, and building or modifying packages with scripts written by others to remain easy and transparent much more than I want to be protected from improbable attacks.

Forcing the issue (it looks like security features will appear in the next few pacman release cycles as a result of the noise, mostly handled by existing developers) was probably not the right thing – the security scheme should have been done slowly, carefully, and correctly by someone who is actually interested in the matter – the last point both so that it really is done right, and because Arch and Pacman are community maintained projects, where everything should be done by someone who cares, as Linus himself puts it, just for fun.

Posted in Computers, DIY | Tagged , , | Leave a comment

Marksbury Movein


I’ve had a couple neat projects eating up my spring break, but one of the bigger ones has been helping move the KAOS group into UK’s new Marksbury Building. So far it seems nice and very attractive, albeit a little weird – we’re talking 40+% unsuable glassed-in hallways, cubicle farms, and almost no storage space. I have a little cube in the corner of a lab on the first floor to call my own (until it is dynamically reallocated away – everything in the building is wrongheadedly set up to prevent entrenched labs…), which is actually a reasonably nice workspace. On that note, the various bits of furniture in the building have ABSURD list prices; each of the 12 student desks in the lab have at least $2,155 of furniture in them, including a useless drawer-and-a-half wheeled filing cabinet with a $700 list price, and a table(labelled “desk”) with a $368 list price – which is nearly indistinguishable from this $54 number from IKEA. We also have several conference tables where each LEG has a list price in excess of $300, and the whole building is furnished this way. I have no doubt that the institutional discount was deep, but it is still startling to contemplate.

Machine Room

Hotlink from Live-Update Image


One of the cooler bits is getting the group’s new machine room up – total floor space wise it isn’t very large, but has enough power and airconditioning for a couple city blocks of normal residential buildings, and enough exposed glass to make working in it a little like being in a zoo. The airconditioning unit in the back of the room that feeds the raised floor is so loud it is uncomfortable to be in the room without hearing protection, which makes working in it sort of surreal, and gives the adjoining lab a nice “distant waterfall” level of white noise. We’re bringing up somewhere in the neighborhood of 200 machines in there initially, most of them with fairly straightforward single-link Ethernet networks and stateless node configurations – so far two of the smaller machines (cik and emcluster, made of Core2Duos and Opterons respectively) are up with caos NSA and Perceus, as has been our habit of late. Unfortunately, the administrative process still has nonroutable IPs on our drops in the server room, so we can’t SSH in to use the machines remotely yet.

Posted in Computers, DIY, General, School | Tagged , , | Leave a comment

White Family Rotary

My parents were travelling over UK’s spring break, and I was watching their cats. This meant I had some idle time waiting for the indoor/outdoor to do whatever it is he does outside, and generally keeping the cats company in their house, so I wanted a project to play with there.
What I settled on was poking at the old sewing machine my mother had in the attic, because old sewing machines are cool in every way.
White Family Rotary Sewing Machine
Continue reading

Posted in DIY, General, Objects | Tagged , , | 18 Comments

OS Graveyard

In my continuing adventures with computing oddities of the 1990s, I occasionally look around for copies of the various failed operating systems from the era, especially Apple’s, and have built myself a little archive of them. Some are easy enough to run under emulation, I have hardware which can be coaxed to run others, and a few (Such as A/UX) would require I pick up new machines or fix an emulator to run. Two of the “desirables” of that sort are Copland, the full custom microkernel based OS that could have been Mac OS 8, and Rhapsody, the missing link that connects Macs that have things in common with the original Macintosh and NeXTStep, prior to the birth of OS X. There are several versions of the latter in existence, including early versions of OS X Server, but the most interesting isRhapsody DR2, a developer release prior to the OS X name. In the PPC version, it has “BlueBox,” the predecessor to the Classic environment, but perhaps more amusing is the x86 version, showing an early version of the OS X codebase (or really, a late version of the OpenSTEP/Mach codebase with some Apple extensions) running on IA32 almost a decade before the first x86 compatible OS X releases.

During a distraction that reminded me to look, I found my way to a server (amusingly, an apple-hosted “me”/”iDisk” account) containing imaged install media for both Copland (and it’s marketing materials) and Rhapsody DR2. I would have to go get the 6100/66 from my parent’s house to use the Copland image, but the Rhapsody media should include the x86 version, and it apparently plays nice (-ish) with some of the emulation packages…

Obviously COMPLETELY useless software, but things I’ve wanted for my little archive of obscurities for a long time.

Posted in Computers, DIY, Entertainment, Objects | 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