Ubuntu 9.10 Xsplash

Every once in a while, I’ll come into contact with something that I can’t seem to put down: something that makes me giddy, like poptarts for breakfast or a really intriguing story. What has compelled me to curiosity? What new toy has challenged my tinkering spirit? Xsplash, part of the new “boot experience” in Ubuntu 9.10.

When I first installed the latest Ubuntu release (then in Release Candidate form, a few days before the official launch), I was wowed by the boot splash that led up to the login window. It was very smooth and sleek; far nicer than the louder, more pronounced background used in 9.04. As chance would have it, I managed to break the splash screen (but that story is unrelated), and so I went on a relatively short and uneventful journey to restore it back to its former glory. I found a few posts around the web providing information on changing background, and I was able to set things right again.

Customized Xsplash

But the story doesn’t end there! See, I have this neverending quest to attain the perfect blend of functionality and eyecandy on my desktop (well, that’s subjective, but my taste suits me). The magic started to fade after installing 9.10 on two other computers in my house. They all shared the same boot splashes, so, of course I didn’t feel special anymore. I wanted something new. Specifically, I wanted to keep the login background in sync with my desktop wallpaper. That’s what this post is about: customizing your xsplash theme.

Getting your hands dirty

Xsplash details have been pretty rare as far as I can tell. A search for “xsplash documentation” yields… well, nothing really useful, so I’ve had to figure certain things out myself (and other people as well). One of the complaints leveled against xsplash and the new GDM is that there aren’t any official configuration tools yet. This has led some to believe that it’s impossible to customize the appearance, but that’s simply a lack of ingenuity on their part: You just need to know where to look!

Your first stop should be /usr/share/images/xsplash. This directory has a few different images xsplash uses to create all the pretty effects. The filenames are very specific: The background image, logo, and throbber must all conform to their own naming schemes. I have not tested which logo or throbber file is used, but it appears that xsplash will only use a background image named bg_2560x1600.jpg (regardless of whether it’s actually 2560×1600 or a JPEG image—I’ve tested with a 1440×900 PNG image!).

Fire up your terminal

The first thing we want to do is backup the xsplash directory, just in case this blows up and we’re left with a messy, broken xsplash. So start that terminal and type in one of these:

sudo cp -r /usr/share/images/xsplash /usr/share/images/xsplash.bk

cp, of course, copies files from one location to another. Now, we’re going to replace the old xsplash background with whatever our current wallpaper is. I’m sure you already know the path and filename of the image, but that’s not fun to type every time you change your wallpaper. Instead, we can use gconftool to automate this:

bg_file="$(gconftool --get /desktop/gnome/background/picture_filename)"
sudo rm /usr/share/images/xsplash/bg_2560x1600.jpg
sudo cp "${bg_file}" /usr/share/images/xsplash/bg_2560x1600.jpg

The first line retrieves the value of the /desktop/gnome/background/picture_filename property—this is your current wallpaper. The second line removes the xsplash wallpaper, and the third line copies your wallpaper to the xsplash directory, replacing the old image. At this point, you can test your new xsplash by issuing the following command in the terminal:

sudo xsplash

It will disappear after a few seconds (but if you’re in a hurry you can press the ESC key on your keyboard). If your wallpaper appeared instead of the default image, perfect! If it messed up somehow, you’ve still got all the original files backed up, so you can restore them at any time (you can also reinstall the original artwork with sudo apt-get install --reinstall ubuntu-xsplash-artwork). Note that the throbber and logo should also appear (if you left them as-is).

This can be easier…

…so let’s automate the entire thing. I wrote a script that will keep the GDM, Xsplash, and desktop backgrounds in sync. You can get the file here. Whenever you change your wallpaper, just run the script and everything will be taken care of. Admittedly, it’s not as easy as it could be (it is possible to turn it into a wallpaper monitoring daemon), but it was sufficient for my needs.

So, what are you waiting for? Go have some fun customizing xsplash!

“Wolde you bothe eate your operating system, and have your operating system?” I’m sure that’s what John Heywood would have said if he were in my shoes, anyway (and if he weren’t busy talking about cakes—the glutton!). I like to use what I have on my computer (Ubuntu), but there are times when I must use other peoples’ computers, and they don’t always use what I like. In fact, I’ve never met another person (in person) who does! So, it’s inevitable that I run into those little once-in-a-while differences. Here’s an incomplete list of things that noticeably change my computing experience.

Quick copying and pasting. The X Window System has a mechanism whereby any selected text is stored (separate from the <ctrl>c “clipboard”). The aforementioned text can be pasted with the middle mouse button. I make frequent use of this feature when my hand is on the mouse because it’s just so quick to use.

Interacting with inactive windows. Another X feature that I frequently use is the ability to keep interacting with “inactive” windows when the active window is in the way. Let’s say I’m talking to someone and reading an article at the same time. I want to keep my conversation window focused and on top, but I also need to scroll down on the article’s window to read the next paragraph.

In Windows, I have to click on the inactive window (with the article), which brings it in front and obscures the conversation window, scroll down, and then rummage through the taskbar to get to my conversation again. In X, I don’t need to lose focus of the conversation window at all because I can still send mouse events (like scroll) to inactive windows. I only need to move the mouse over the article window and use my mouse’s scroll wheel—the conversation never becomes the inactive window.

Always on top always available. A nifty feature of the Gnome desktop environment (and I’m sure KDE) is that each window’s “window menu” (accessible from the icon in the title bar, by right-clicking the title bar, or by right-clicking the entry in the panel) has an “always on top” setting. Some programs in Windows do have this feature, but it’s not applicable everywhere. I realized that a few months ago when I was using my brother’s laptop.

I miss the terminal. It makes me feel special.

Compiz. At first, I thought Compiz was only for the eye candy. It does have a lot of silly things that don’t actually help you accomplish any tasks besides impressing your friends (or—in my case at least—nephew). But there sure is something to be said for how fluid and alive some modest settings for “wobbly windows” can make your desktop feel.

Nice font rendering. This gripe really only extends to Windows XP, which sports no smoothing whatsoever unless it is turned on. Unfortunately I don’t know many people who have turned it on. Luckily, I don’t come across Windows XP very much anymore! (And thankfully no one turns it off in Vista.)

Software repositories and package managers. Every once in a while I’ll have to install some software on someone’s computer. This is a real chore in Windows, because I have to search online for what I need, then (unless I already know of some trustworthy software) I usually research what I’ve found to make sure it doesn’t come with any nasty surprises. For an accurate depiction of the problem, check out “software installation in linux is difficult.”

The Gnome applications menu. I love the Applications menu in Gnome. Why? Well, because the only things it lists are applications. The Windows “start menu” has quite a bit more than that—most software gets its own submenu in the menu with the program itself, documentation, maybe some links to websites, etc. Some program submenus even have submenus of their own! They’re all thrown in there willy-nilly as well. The other thing I love about the Gnome Applications menu is that software is categorized (accessories, games, graphics, internet, sound & video, et cetera). I always know where to find what I’m looking for.

So have I observed:

• A good Code Monkey should know C++, Java, or both. (I have evaluated C# as well, but a lot of .NET and Mono programmers seem genuinely interested in getting things done, so they are therefore disqualified.) As a bonus, a good Code Monkey should take classes on either language. These classes are perfect because they don’t actually teach you anything.
• A good Code Monkey should disregard most other languages, except as toys, and should become familiar with the word “powerful” (but they should not give it any substantial definition in an argument). They should, however, avoid words like “expressive” (and any occurrence of the word should be remapped to “toy”).
• A good Code Monkey knows that if it can be done in 5 lines of code in a toy language, it deserves to be done in 50 in a real language.
• A good Code Monkey, further, knows that programming languages were not made for humans; they were made for computers.
• A good Code Monkey knows that programming languages only exist as a source of income. It is not, as toy programmers seem to spout, about solving interesting problems, culture, art, history, fun, or anything intellectual (unless followed by property). It is only about the enterprise.
• A good Code Monkey knows that if it does not exist in C++ or Java, it is probably not worth it, because all you need are pointers and long class names.
• A good Code Monkey should learn the object oriented paradigm, because it is the only one that matters in an enterprise environment. However, they should not be lured into toy languages that utilize the object oriented paradigm in non-standard ways (see Ruby, a toy language): It is only necessary that they can create deep class hierarchies.
• A good Code Monkey should also never be tempted to learn other programming paradigms, because if they want to make it in the world, there is only one way that they are required to think.
• A good Code Monkey knows that a strong language has two key features: static typing (because all errors happen at compile time) and native machine code compilation (Java has been forgiven). As an added bonus, the more code that must be produced to have a working solution means that it is a stronger solution.
• A good Code Monkey is able to judge a language based on the development environments that are available for it. As an added bonus, the harder it is to write code in a language without the full support of an enterprise-class IDE, the better the language is.

It’s inevitable that clothes get dirty with time. It’s inevitable that you have to change out of your dirty clothes and into clean clothes. It is inevitable that the dirty clothes will need to be washed. I can accept these three principles as laws of nature without needing all the math. Unfortunately, it’s also inevitable that, when all is said and done, the clothes will come back to me. Why is that so bad? It has to do with storage. At the foot of my bed, and about a foot away from my door, there’s a fancy wooden dresser that keeps my clothes and other items. It has six drawers. The two on the top row house an odd collection of bits and bobs, such as pictures, letters, lethal weapons, a hard drive or two, and a deck of cards. Below that is the underwear and sock drawer, which, coincidentally, also has a Shirasaya Wakizashi. Below that is a drawer full of books that I don’t read. Below that, my shirts. Below that, my pants.

Now, I really hate putting my clothes away. I hate getting them out too. Why? What’s so bad about my setup? Well, sequential access doesn’t facilitate my workflow. It’s very inefficient that I have to stack my clothes sequentially when I don’t have any fixed outfits. This would be easier if I could stack them in such a way that I would always be able to take the top item from my shirts and pants drawer, but I like to mix things up.

I have concluded that random access clothing storage (RACS for short, or “closet space” if you want to sound boring) is definitely the way to go. My RACS capacity is unfortunately very limited, so I will have to continue using sequential access clothing storage. I am currently looking for funding and sponsorship for large-scale usability tests to come up with new innovations in RACS. MIT has shown interest. If you want to sponsor me or send me money, please contact me via comments and I will surely get back to you.

At the end of February, I went to the Dell website to order a brand new laptop with which to surprise my brother. I navigated to the “open ource” section first to check the availability of a laptop with Ubuntu. Unfortunately, the one I had seen previously was no longer listed. I knew that ordering Windows XP would add another $150 to the price of the laptop, so I opted for “the-worst-case-scenario-as-far-as-I’d-been-told,” Vista. Everyone’s familiar by now with the multitude of criticism and backlash the two year old has suffered, so I won’t spend any time preaching its condemnation here. Instead, I’ll summarize my experience with it over the past few days. It’s not a complete rundown of every feature in Vista—just a few things I wanted to comment on.

First impressions

After primarily using free and open source software for so long, setting up an OEM installation of Windows is a little bit shocking. Now, you should understand that to us die-hard, liberated-from-shackles, grab-your-1740-replica-Katana-and-rebel open source guys, an EULA is sort of like an affront to our personal freedom (yeah, deep down we know it’s kinda silly, but have some sympathy for us—we’re delicate). But true to form, I looked on in horror as several EULAs had to be accepted to use both Vista and the software that came with the computer.

When Vista was fully installed and usable, it was the familiar routine of plucking out the things we didn’t want or need. The control panel is a lot nicer in Vista. For some reason, I couldn’t ever find anything in the XP control panel unless I switched to the class view. (It might’ve been all the blue disorienting me.)

Not long after, our first order of important business was to use Microsoft’s Glorified Firefox Download Software™ (ie., IE) for obtaining a web browser.

Style

Certainly, one of the most publicized features of Vista is its updated look and feel. I’ve never really talked to anyone who feels neutral on this subject. They either love it or hate it. I like it, but I’m not satisfied with the handling of themes and theming in Windows. I’ve been spoiled by the wealth of customizations that are available  in GNOME, KDE, and other free desktop managers for Unix-like systems (Linux, BSD, …). In comparison Windows has always been extremely limited here. Theming is possible, of course, as a myriad of websites will show you; but it is not easily doable and usually requires third party software.

Instead of being built into Windows, theming is the responsibility of the individual applications that wish to implement it. (Safari has its own look, Advanced WindowsCare has its own look, et cetera.) I would rather have all the applications look the same. Some of my friends have said that I’m just boring, but a level of uniformity in the look and feel of each application allows me to know what to expect: It helps straighten the learning curve when I’m using new software.

Explorer

One of the features that I liked in Explorer was that the music directory showed album covers as if they were pages in an open folder. Unfortunately, it’s not an equal opportunity feature—even though I had installed the Ogg/Vorbis codec, it would only fetch information and art for the few mp3s in my collection (this one-sided behavior continued in Windows Media Player). About 85 to 95 percent of my music collection is Ogg/Vorbis. In the end, this feature is more of a novelty than a necessity, but it would have been nice to see it play well with the geeky kids across the street.[1]

I like how the breadcrumb trail has been separated into segments as well, although it doesn’t realize its full potential. For example, in Nautilus (the GNOME file manager), files can be dragged to different segments to move or copy them to that location. This is a useful feature when you want to move files or directories up a few levels. Other useful features it’s missing are tabs or split views, and a quick directory search (like Firefox’s quick find).

Still lacking a lot

A lot of things are still lacking or impossible in Windows that are easy to do in other operating systems. For example, I wanted to mount an ISO image. This is a two click operation in many Linux distributions, or a single line in the terminal, but a search for how to mount an ISO image in Vista revealed that I would need to download third party software.

There are many glaring issues with software management as well. Installing and uninstalling software often requires a restart, and is still a series of unintuitive “click next” screens. There is no package management available; to obtain any software I have to go find it “in the wild.” I’m not really comfortable doing this, especially when it comes to closed source software (I found three programs for mounting ISOs, and only one was not reported to have malicious software of some kind).

I feel naked without a comprehensive set of command line utilities. Sometimes it’s just a whole lot easier to tell the computer what you want to do with words, not clicks and motions.

Conclusion

If I were still a Windows user, I would definitely upgrade from XP to Vista. Microsoft has taken a step in the right direction, and I’m looking forward to seeing what Windows 7 puts on the table. But I’m a Linux guy at heart. I have a different mindset when it comes to operating systems, from a design perspective and a usage perspective. Vista feels cumbersome because “the Windows way” doesn’t facilitate my workflow.

Ironically, almost none of my criticisms here are aimed at Vista in particular. I experienced the majority of these problems in XP as well. The core issues like look and feel, software management, and the “one true way” approach to design are true for all Microsoft operating systems to this date. However, I do understand that not everyone feels the same way I do. To them I’ll say that Dane is right: Give it a fair go before you throw it in the trashcan. You might even like it!

…

But if your heart is still set against it, try one of the free alternatives.

[1] My brother finally got the album information to display in WMP. Unfortunately, we only know how to do it one album at a time.

Here is another set of articles with which to feed your brain. This time around the main focus of my article-scrounging is history and conduct, although a few general programming articles are still there. History is especially important for programmers to understand because it gives us a basis for why things are the way they are today. Last time, I focused on dynamic programming languages (programmer brainfood, part 1).

How to Disagree

We all disagree on things. Sometimes we get carried away, or don’t exactly know how to disagree. This article by Paul Graham is a great overview of the argument pyramid, and a great set of guidelines for your next argument!

Let’s Talk About Python 3.0

Although this article is focused on Python 3.0, the introduction is very insightful and applicable to many areas of life, programming included. (And if you’re interested in Python, go ahead and read the rest as well.) I had always agreed with the lesson of the introduction in some way or another, but reading it there really put things into perspective for me: reasons are important.

Execution in the Kingdom of Nouns

Another long one by Steve Yegge. This time he’s focusing on “noun oriented programming” (which some also affectionately call “object obsessed programming”).

Things You Should Never Do, Part 1

Joel Spolsky talks about a big mistake that a lot of people have made, and I’m no exception: throwing away code. “It’s important to remember that when you start from scratch there is absolutely no reason to believe that you are going to do a better job than you did the first time.”

How To Become A Hacker

“There is another group of people who loudly call themselves hackers, but aren’t. These are people (mainly adolescent males) who get a kick out of breaking into computers and phreaking the phone system. Real hackers call these people ‘crackers’ and want nothing to do with them.” Eric S. Raymond, long-time Unix hacker and author, presents an article and FAQ about (real) hacker culture.

The Art of Unix Programming: Chapter 1, Philosophy

Although it’s worthwhile to read the entire chapter, the focal point here is the list of rules that support the Unix philosophy. It’s filled with software design wisdom. Some of my favorites are “separate policy from mechanism” and (paraphrasing) “a programmer’s time is expensive; a machine’s time is not.”

The Art of Unix Programming: Chapter 2, History

Even if you have never used a Unix descendant, such as Linux or BSD, it has such a rich history that it is worth knowing. The birth of the Internet, the C programming language, and the Open Source Movement are all closely related to Unix. (The book is also available as a pdf.)

…and that’s why cell phones are dangerous.

Here’s another story.

Leading up to the end of my first college semester, my software design course swallowed its anchor chain and abruptly changed direction. We had spent nearly three fourths of the course studying basic programming concepts, with some rudimentary diagramming and an overview of object oriented design (I think high-level structural programming concepts like first-class functions are more interesting, but that’s another post) mixed in. Where, then, did the anchor fall? Unfortunately, it fell during my month-long illness, but after one missed class I found out that we were far south of our high-level comrades: We had come to an archipelago called 3AA0 1FA0 2F41 2F43 … sorry, “Machine Language.” We used a RISC-like machine simulator with 15 registers (0 through F) and 255 main memory “cells” (00 through FF), where each instruction occupies two cells (two bytes). I’ll spare the other details.

So here we are in this foreign archipelago (let me stress that most of the adventure was point-and-click), and I can tell that the crew is getting disoriented. A few weeks passed and Mr. Mendonsa gave word of our final test. Lucky for us, nothing that we covered in the first three fourths was on it — instead, the entire thing was about binary, hexadecimal, and our fabled machine language. One of my classmates asked if the test was to be taken there or online, to which the response was a resounding, “I’ll let you know” (paraphrasing).

Another week passed and I was becoming particularly worried that I wouldn’t be able to take the test at home. On the day of the test, about two and a half hours before class was supposed to start, an e-mail arrived bearing great news: The test was online! I could stay home! Furthermore, we had until the 15th of December to submit all unfinished work (including the test). This was on the 9th.

On the 10th, I took the test. There were 30 problems spread across 30 pages. Many of the problems required multiple answers (eg., “suppose you want to complement the middle four bits of a byte while leaving the other four bits undisturbed. What mask must you use together with what operation?”). The test had a possibility of 78 points. I was able to answer many of the questions with a fair amount of certainty (although this may have been because of my calculator, a two’s complement calculator I found online, and testing the machine language problems in the simulator before giving an answer… but hey, who’s counting?). The only problems I had to guess were the ones that I just didn’t really grok (I’m looking at you, binary fractions).

When I came to the final page, I had been taking the test for nearly one and one half hours. The problem was unceremoniously easy: “What is the hexadecimal value of 1001 0101 0110 1111?” I selected my answer (it’s 956F for the uninitiated), but I was not yet satisfied enough to press the submit button. Instead, I paraded around the livingroom, knowing that I had done well on the test. Lo that as soon as I returned to submit the test to my teacher, Firefox and some Java applet decided to go crazy and lock up my computer so that I had to restart.

Panic! Horror! The test remains unfinished!

Well, when I was able to use my computer again, I logged back into Blackboard to see if I had caused any major damage. I ventured onto the assignments page, clicked the final test link, and it told me to press “OK” to take the test. “The test is complete. Press OK to view the results.” “The test is incomplete. You cannot view the results. Press OK to continue.”

It was at this point that I wrote an e-mail to my teacher about my technical mishap. Two days passed with no response, so I decided to write another e-mail, just in case the first one had been lost. That didn’t yield any results either. Saturday rolled around, which meant that my teacher wouldn’t be checking his school-related mail. On Monday (if you’re keeping track, Monday was the 15th — The Last Day), there was still no reply.

Just to be sure, I went into Blackboard and checked the grades page. The results for my test had finally landed, but it wasn’t something to celebrate: Although it recognized that most of my answeres were correct, my score looked a lot like a 0.

Panic! Horror! I failed the class!

Instead of chancing another e-mail, I took the direct approach and called his office. Very fortunately for me, he answered, and I was able to go over the problem again. He explained that he had been too busy to check his e-mail over the week and that he was glad I called. He looked over the original e-mail, then went to Blackboard and manually scored my test. I ended up with a 71/78, not a 0. As the semester came to a close, my grand total came to a 96. I got an A. (The average grade on the test was a 34, but I suspect it was so low because certain layabouts didn’t take the test!)

What’s the moral of this story? Cell phones are still dangerous.

When I get to class, I

1. insert my Kingston DataTraveler and go through the barrage of “new hardware detected or installed or please open this in Windows Media Player!” (what?),
2. set the resolution on the monitor to something sane,
3. turn on cleartype for slightly nicer font rendering,
4. get rid of the search bar on the taskbar,
5. adjust the mouse speed so that it doesn’t take an hour to get from one end of the screen to the other, and
6. open Firefox Portable to check on things before the teacher gets in.

There has to be a better way to get my education.

One of my favorite pastimes is scouring the internet for stuff to read. Much of the time I search for interesting articles about programming (in a broader sense than “just writing code”). These are the fruits of my labor. (This is taken from a post I made on a forum.)

Teach Yourself Programming in Ten Years

Many books claim to teach technical subjects in so-and-so days or hours. Peter Norvig disagrees with this approach and instead offers his own recipe for success, which includes teaching yourself over a span of ten years — not days.

Knowing Java is not knowing much

This article puts forth the idea that simply knowing a language doesn’t mean that you know a whole lot, whether it be Java, C, or something else. It’s a good, brief message.

Design Patterns of 1977

I’ve seen a lot of people try to throw design patterns around to make things less painful, and while well-implemented ones can help out a whole lot, it doesn’t address a core issue: Design patterns show a deficiency in the language.

Static Typing, Dynamic Language Performance, V8 and Tracing JITs

“For optimisation, more is known about a program written in a dynamically typed language at runtime than is known about programs in statically typed languages at compile time.” Dynamic languages are getting much faster. This article drives the point that performance needn’t be a trade-off, and that the more you know about a program’s characteristics at runtime, the more it can be optimized.

Dynamic Languages Strike Back

This is an entertaining and long (transcribed) talk that Steve Yegge gave earlier this year. It goes over a *lot* of stuff (when he’s not rambling ) and may take a while to read through, but it’s still enjoyable.

Beating the Averages

Paul Graham argues that all languages were not created equally, and shares what he believes “power” actually means. This is one of my favorite articles, and I highly recommend it to all programmers. (It is at least worth reading the “blub paradox” section.) He has other interesting essays posted on his website as well.

Write more to write better

From the comments: Someone once asked Somerset Maugham if he wrote on a schedule or only when struck by inspiration. “I write only when inspiration strikes,” he replied. “Fortunately it strikes every morning at nine o’clock sharp.” Not strictly for programmers, but just as effective!

Strong typing vs. Strong testing

Bruce Eckel of “Thinking in [Java, C++]” fame offers the argument that strong testing, even in dynamically typed languages, trumps the presumed safety of static type systems. (Note that “strong typing” here refers to static typing.)

Have some of your own? Feel free to share them!

They canceled the course I was taking.

>:(

When one (or four) boards a boat, one (or four) usually knows what they’re doing. I’m not really a boating man, and I don’t know much about being out at sea (basic survival skills apply, but uncharted waters will be uncharted waters). But still I find myself tripping at the big dock of life and falling into an unfamiliar boat called “college.”

I enrolled in a ten week summer class called “Software Design,” taught by one Mr. Mendonsa. Although it’s called software design, its purpose isn’t how to tell me how to create the next overpriced product on the market; and instead offers an overview of computer science so that we understand what goes on in the secret lives of computers while we are designing our software. This includes several fundamentals, like binary, hexadecimal, data storage, et cetera. (For the record, we start programming in C near the 6th week.)

This is all very new to me: I’ve never really been exposed to a classroom setting, and certainly not one where I have to worry about a grade, so I didn’t know what to expect.

My mom, brother, and I left our house at around 5:15 PM. After dropping my brother off at Synagogue, we trudged through insanely slow-moving traffic from Norfolk to Chesapeake… a treck that ideally would have taken about twenty minutes. Still, we arrived at around 6:30 and I hurried awkwardly to classroom 2038. Standing in front of the room was none other than my teacher (I didn’t know it at the time), who directed me instead to room 2010. Luckily I knew where it was because I went the wrong way upon building entry.

I brought along my new Kingston DataTraveler 4GB flash drive (on sale now, buy buy buy) just in case we were in a room with computers. I’m not good at writing by hand, so that I thought I might be able to take notes that way. Unfortunately we were in a small room with rows of chairs squashed together in a stick-your-gum-under-the-desk-and-pass-notes sort of way.

It’s a small class of seven people, but of the Enrolled Few, only four showed up. I sat as far back as I could. There was a brief discussion on intelligence where we were asked to give our opinion of what it is. Knowing this was going to turn into a “computer intelligence” shpiel, the best answer I could come up with was “the ability to learn.” For the moment I felt proud of my answer, until we had to expound upon why we said what we said… that’s where I start tripping over my words.

Incredibly and much to my disbelief I survived the fiasco (but not before saying that computers had to be “encouraged”). The rest of the lecture was focused on binary. Logical operations with binary, math with binary, shorthand binary, how binary relates to storage units, binary representing text… binary. Binary for three hours. Have you ever listened to someone talk about binary for that long? It does a number on your brain (or two numbers—I’m sure you can guess). It’s more interesting than it sounds, it’s just that I had to clean up the brains that leaked out of my ears when we were finished. Much of it I already knew, but Mr. Mendonsa was able to connect the pieces that were fragmented for me, so apart from trying to be an answer hog I was able to do some learning.

Class finally ended (late) and I was able to go home. It was nearly 10.