Bits and Bytes

Mac Software

I just wrote a nice long email to a new Mac owner listing software that I think would be of interest. I’ve done this a couple times, and figured it’d probably be a good time to put it up some place public, where I can link to it and edit it. So, I am posting this now, I’ll hopefully add to and edit it and amend it later, although honestly, I’m not sure how much longer I’m going to be a Mac user. Apple has been pissing me off a lot lately, and though most of it hasn’t been driving me away from OS X per se, I see a significant non-zero probability that one day they will.

It’s worth noting (and completely coincidental) that all but one of the programs listed below are open source in some way or another. As far as I know, all of these are Snow Leopard compatible. Without further ado…

I could not use my mac without Quicksilver. It’s a launcher (type ctrl+space to bring up a QS window, type in the name of an application, and you can launch it), but it’s also much more. You can drag and drop to and from it, so you don’t have to open up a new finder window, or you can have it look in your address book to look people up without having to open the app. After you install, edit the preferences to enable plugins and edit the catalog (which chooses which items it searches when you start typing).
A browser by some company in Mountain View, CA. The mac version doesn’t support extensions, yet, but it will. It’s awesome and fast, but have occasionally run into problems with its interactions with flash on the Mac. These seem to have been alleviated after I deleted all my flash cookies.
The sole non-open member of this list. This is the same Mountain View company’s desktop client for managing photos. It does sweet things like face recognition, and some sweet basic editing (try the “I’m Feeling Lucky” button on photos that aren’t quite right – sometimes it doesn’t do much, but sometimes it is awesome). You can link it to a Picasa Web Albums account, or not. There are also plugins to post to Facebook, etc.
Multi-protocol IM – I like it a lot better than iChat, although the video chat capabilities are worse (so I open up iChat when I need to do that). You can log into AIM, Google Talk, Yahoo messenger, Facebook chat, and others all in one buddy list. Also has Growl notifications, which is nice.
Growl should be included when you download Adium, but if not, you can download it separately. Growl is a notification system that will show you alerts when applications send them. You can, e.g. configure it to show you IMs in a translucent window when they come in (I do this so I know when I do/don’t have to go to my IM window), or along with a nifty Quicksilver module, show you track info from iTunes as a nifty music video-style overlay. A bunch of other apps use Growl, and you can control all their notifications easily from the Growl preference pane in System Preferences.
Utility for burning discs. Simple, easy to use, does what I need.
This is “the swiss army knife of video codecs”. It adds avi, divx, xvid, and a bunch of other video support to OS X.
Handbrake makes ripping DVDs to local video files easy.
VLC is a great open source video player. If VLC can’t play it, it’s probably a broken file.
Basic, open source audio editor for the Mac. People who know how to use Pro Tools will probably want Pro Tools. For the rest of us, this is a decent recording/editing app.
This is kind of a cool utility – when you install it, it creates fake audio-out and audio-in devices. If you set an application (or your whole system) to output to a Soundflower device, you can choose the same device as the input of any other app so that you can easily feed sound from one app to another.
Fugu is a client for SCP and SFTP file transfer. You may not need this, but if you do need to do secure file transfer using those protocols, it’s pretty good.
This is a useful little gadget – it lets you set a global keyboard shortcut (I use Ctrl+Apple+L) to lock the computer. I am in the habit of always pressing this when I get up from my work computer.
This is a handy utility for keeping windows on top and changing their transparency. It doesn’t work with all apps, but I use it with Chrome to keep popped-out Hulu windows on top. Sometimes, I also make them transparent so I can still see what’s going on behind them.
Not that you would use this to download anything illicitly, but in case you want to download an ubuntu install disk or one of the many albums legitmately distributed via bittorrent (like Harvey Danger’s or Nine Inch Nails’), Transmission is a great bittorrent client.
Xiph Quicktime Components:
This installs Quicktime codecs to support Ogg Vorbis and Ogg Theorea. Adds support for these formats to iTunes, iMovie, Quicktime player, etc.

Bits and Bytes

Comments (8)


Steaming Java (or: A Nice, hot Cup of Joel)

First a quick note to my readers from the LJ syndicated feed – please post comments in the original article at . I don’t always see comments on the syndicated feed, and they disappear when the articles expire.

So, I’ve been saying it for years, but not that Joel on Software says it, everybody starts talking about it. Well, I’m going to reiterate because I feel that the article makes very good points, but misses a few, and doesn’t elucidate certain facets enough.

This is one of my favorite topics, as some of you may have heard. For the rest of you, pull up a chair. Let me start my argument thusly: I loathe the shift towards java as the language of choice in teaching intro computer science/programming. (For the 60% of you that are bored already, you’re excused – it just gets worse.) In the interest of full disclosure, I’m not a big fan of Java in any milieu, though I’ve become much less rabid, even accepting, but I’m still praying for Ruby or something similar to take on Java in its own niche.1 I will write java code, and I certainly appreciate how much easier (and thus more bug-free) it can make certain tasks, but I still have irreconcilable differences with the language.

I feel that there are two pedagogically pure ways to teach introductory CS, and that Java is the ugliest in-between ever.

Approach 1: Bottom-up. This is how I learned, and probably the way a great many people learned, before this Java craze swept education. The idea being that you teach students the fundamentals of computers – bits, bytes, math. And then, you give them a language, like C++ which literally encompasses (almost) every concept in modern programming, even if it’s slightly ugly. C++ has the advantage that your first program can be three lines long, with each line having a simple explanation that doesn’t require knowledge of higher-level programming concepts. Compare a simple “hello, world” in Java – from the beginning, you’re forced to either explain what a class is (a difficult concept when you don’t even know what a function or even a variable is), or gloss over it and tell the students “we’ll explain that later”. In addition, the concept of “pass by reference” can be astonishingly confusing to students who have no context for it.

From that first C++ program, each new facet is an iterative growth, and each new concept can be added. One can easily write (I know because this is how I started) essentially managed C++ simply by not even knowing about pointers until one is comfortable without worrying about garbage collection. And then the progression becomes simple. We start with the basic structure of a program, the syntax of statements, procedural coding, the declaration and use of variables, the use of functions, the declaration of functions, etc. all before one even comes near pointers (and garbage collection), references, object-orientation (and everything that goes with it) or other advanced topics. Thus, each student can gain intimate knowledge of the concepts.

On the other hand, there is:
Approach 2: Top-down. The other approach, and the one I experienced when I took my first AI course in high school, is the top-down approach. Here, the student is started with pure, mathematical concepts, and gradually brought down into the nitty-gritty. Typically, you start in a nice functional, LISP-like language (I learned using Common LISP, but it seems Scheme is more popular), and thus you start out with something everybody hopefully understands – algebra and functions. With a little coaching, most people can start to adjust to prefix notation, and everybody will be on relatively even footing. From there, one can begin to explain things like side-effects, and start to shift to other languages. I feel, however, that while this technique can make the relationship between the math and the CS more clear, in the end it ends up being an acclimatization tool, and that eventually one has to revert the bottom-up technique.

However, both techniques have the important characteristic that they imbue the student with a solid framework for looking at all kinds of problems, not just the ones that a particular tool set solves. A student thus armed is well prepared to take on a wide variety of novel tasks in novel languages, which is, after all what higher education is really about (or should be). In graduating a student from a respected university, we are not trying to give them specific trade skills to do a job–after all, it’s well known that the tools of the trade in education are frequently years behind the tools in industry, a gap that’s simply unacceptable in such a quick-changing field. Rather, we are attempting to provide them with the requisite ability and basis to learn those skills that are necessary to do a job. A student with a basic understanding of how the underlying bits work can quickly and easily learn to program in Java, and may in fact be thankful for the eased burden it provides. However, a student without the slightest clue of how to manage memory will have a long and arduous task in front of him when asked to write a virtual machine, or maintain an OS kernel, or write a new language. In my experience, when we create Java kids, we create students who cannot easily adjust to not having certain things done for them, or to looking at non-OO paradigms.

None of this is by way of saying that knowing Java isn’t a valuable skill, or that writing good Java (or other OOP) is easy. I’m saying that teaching students Java is excellent training, but what universities should be doing is educating. The sad fact is that by teaching students in Java (and especially keeping them in pure Java curricula), we are locking ourselves out of innovation and deeper understanding. The irony is that most of the students formed by such curricula could never create a Java VM.

The last point that I want to address was a minor point in Joel’s article, but one that’s near and dear to my heart. He says that the reason that a CS grad from MIT is more respected than one from Duke is this difference – that the MIT grad comes out prepared to tackle any problem, while the learning curve for the Duke grad is much steeper, and there’s no guarantees that he/she can handle it. This problem of reputation is especially important to me, because I’m in what should be considered a top-tier department in what is considered a top-tier university. In four years as an undergrad, however, I worried that a disproportionate amount of time was spent in oversimplifying things to make them accessible to everyone, rather than challenging everybody to rise to the challenge of really understanding things. I don’t know whether there’s some drive to have more CS majors enjoy/pass (and thus stay in) their classes – department funding is probably tied to head count, after all. But as an alumnus, it is of interest to me to make sure that regardless of the number of students who come out of the department, that they all be of the absolute highest caliber–that the department has a reputation for creating students who are not one-trick ponies, but who can take on any job. To fail to uphold those standards will only cheapen my degree.

1Java to me (and to everybody – this is why it was created) is too much unnecessary compromise. In fairness, it did spark the mass movement of using VMs and byte compilation, and it still is the only language to adequately fill its cross-platform niche. But it’s been ad hoc from the beginning and thus is always playing catchup. It suffers from a lack of design purity, as well as closedness that compounds the problem. I don’t mean closedness only in that its compilers are closed-source – I mean that Sun Microsystems routinely extends or changes its software (the de facto standard) with only partial documentation. There is no definitive reference for what must and must not be implmented in a compiler or VM, and for a language whose only goal is cross-compatibility, that’s unforgivable.

Bits and Bytes

Comments (1)