It’s all just 1’s and 0’s…

I am making a habit of catching on late on cool things…first the blog, now I caught on with podcasting. The idea of podcasting (by a fellow dutchmen, Adam Curry) is really cool, better than I thought it would be. Sure it was intended first for music and shows and stuff, but last week I stumbled on a random weblog entry (through the excellent Tao of Mac blog) about handing out CDs of Paul Graham’s speech about Great Hackers.

Being able to hear Paul Graham live is good, even though I had already read most of the transcript and he is not such a great public speaker. But still, it is nice to hear it told as it was meant to be told.

Then I went on and search ITConversations.com for some more interesting interviews and speeches. So far I’ve been listening to Kent Beck on Developer Testing (and accountability), an interview with Joel Spolsky and most inspiring so far is this two hour long speech by Steve Wozniak.

Hearing him talk about just what he’s wants to talk about is very inspiring and makes trainrides a lot more interesting. I can really recommend podcasts to everyone, it’s really worth all the money you pay for a small MP3 player.

On the one hand there’s spyware, adware, viruses, trojans, keyloggers, popups and on the other hand there’s (almost) nothing. Just the difference between Windows and OS X.

But people seem to be taking these things for granted. An excerpt from a related article on SecurityFocus:

But for some reason people are taking the whole plethora of malware, the need to buy extra software to protect your computer (no Windows machine is safe without at least a firewall and a virus scanner. Windows XP even reminds you daily if you don’t have them). PC Magazine even thinks that you need a second core to drag windows along:

And finally another quote from that SecurityFocus article:

I just don’t get it…

Yesterday I stumbled upon Guido van Rossems weblog and I was struck once again by how beautiful and simple expressions in Python can be.

In a post about some complicated functions that aren’t really needed (filter(), map() and reduce()) he showed elegant other ways of creating lists on the fly. I had always known they were there, but by showing them here I hope to remember them a bit better… Anyway, on to the examples:

[x for x in S if P(x)]

and

[F(x) for x in S]

In this last example, most of the time you don’t need to even create the list, you can just use a generator expression. For example:

max(len(line)  for line in file  if line.strip())

Now I am not even beginning to think about how to write this in Java.

For a while now I was bothered by the different font in Thunderbird in Unicode encoded messages. Today I happened to be browsing through the configuration (using the about:config extension) and came across them.

The following configuration entries should be changed to fix this:

• Change font.name.<font-type>.x-unicode (where font-type is the type you use (being one of monospace, sans-serif or serif)) to the font name you use. You can look up the value at font.name.<font-type>.x-western.
• There is also the values: font.name.cursive.x-unicode and font.name.fantasy.x-unicode (no idea what they are for).
• The size of the font is also defined in another place: change the following values for that: font.size.variable.x-unicode and font.size.fixed.x-unicode to match their x-western partners.

Programming in Java is like having a really short attention span.

Let me explain why I am saying this: If you program according to the OO principle, you keep your methods/functions short. This means that most of your function calls are internal, to methods you wrote yourself, to do some work on objects you created yourself. However, if you program in Java you need to check the data type everytime you do a function call or even in function calls where you need to create temporary variables (e.g. when you want to do something with every element in an array).

In other words, I give you an apple, you take it, check if it’s really an apple and take a bite. So far so good. But then you want to put it down: you have to determine it really is an apple and put it down. Say you change your mind right after you put it down. Then you’ll have to determine if that object you left at that exact spot over there is really an apple, pick it up, check if it’s still an apple, take a bite, etc.

Now even with using Eclipse this means you have to do a whole lot of finger typing and brain cycles to make the compiler happy with things you know already and can cope with in your program easily. Especially using test-first coding and proper tests, this compulsive checking of types is really unnecessary.