Jason Creighton's Blog

PyPy GSoC: Wrapping up

2010-08-13T07:36:00.001-07:00

Well, we're reaching the end of the official GSoC period, and asmgcc-64 still has some obscure bugs. I'm going to continue to work on it in the two weeks before my college starts up, but it's hard to make time estimates regarding how long it will take to track down weird failure modes.

But the bottom line is that the main goal of my GSoC was accomplished: A working 64-bit PyPy JIT. Hopefully I'll be able to complete asmgcc-64, and make the JIT even faster.

PyPy GSoC: 64-bit JIT merged to trunk

2010-08-02T10:59:00.000-07:00

Well, that took longer than it should have. In any case, 64-bit JIT support (with Boehm GC only) has been merged to trunk. Please try it out!

The remainder of my GSoC will be work on the asmgcc-64 branch, to allow the 64-bit JIT to work with non-Boehm collectors.

PyPy GSoC: Nearing the merge to trunk

2010-07-26T13:13:00.003-07:00

After some discussion with the core PyPy developers, it's been decided that the 64-bit backend will be merged as soon as possible, with only Boehm GC support. After the merge, I will continue work on asmgcc-64 to provide further speed improvements.

The x86-64-jit-backend branch is keep fairly close to trunk, so I thought the merge would be fairly trivial. Unfortunately, I spent the morning tracking down what turned out to be simple bug in the tests themselves, and the afternoon investigating a regression involving the 32-bit hybrid GC support, which I am still working on. However, I am confident that I will be able fix the regression and complete the merge this week. (knocks on wood)

PyPy GSoC: asmgcc update

2010-07-19T07:26:00.000-07:00

Apologizes for my lapse in updates. And thanks the people who bugged me on IRC for a status update. :)

I spent some time familiarizing myself with the purpose and implementation of trackgcroot.py, then started working on porting it to support the 64-bit instruction set, which has been fairly straightforward.

Currently I am using the asmgcc test suite to iterate through the "run tests -> investigate failure -> fix bug -> repeat" cycle. Once I have 64-bit asmgcc working, I want to eliminate some code duplication that has crept into my codebase. I expect to be working on asmgcc-64 for the rest of this week at the least.

PyPy GSoC: 64-bit JIT working, but GC is slow

2010-07-02T12:50:00.000-07:00

Finally, I have a working 64-bit JIT in my branch, although only with the slow Boehm garbage collector.

Next week, I will start work on adding 64-bit support to the asmgcc root finding strategy in order to make use of one of PyPy's faster, preferred garbage collectors.

PyPy GSoC status update

2010-06-25T13:44:00.001-07:00

Well, the backend is RPythonic again. And I managed to remove some of the boilerplate/duplicated code from the rx86 module, although there is still room for improvement. Also, some common cases of loading a large number of variables from memory locations that are "close" to one another became more efficient.

The main thing this coming week is to address an issue that I only became fully aware of in the middle of this week: Many places in the code use jumps with a 32-bit relative displacement that are sometimes patched later to point to a different destination. The problem is sometimes you need to patch it to point to a location farther away.

This issue had been masked by the fact that on some operating systems (Linux included), you can give the operating system a hint as to where you'd like the memory to be allocated, and as a result, all of the memory used by the JIT was within 32 bits of each other. But we can't count on that working all the time on all platforms, so we need to handle the edge case.

We have a plan for how to fix this while not making the common case any less efficient, and while it is not hugely difficult, it also isn't trivial.

After this issue is taken care of, the next thing will be to port the asmgcc root-finding strategy to 64-bit. (Without this, 64-bit JIT would have to use the very slow boehm garbage collector, which sort of defeats the purpose of a JIT)

PyPy GSoC update: Most tests pass on 64-bit and 32-bit CPUs

2010-06-11T15:12:00.002-07:00

Most JIT tests now pass on both 32-bit and 64-bit CPUs. However, there are some caveats:

I made some changes that make the code no longer "RPythonic", which means you can't actually build a working, JIT-enabled, PyPy with this code quite yet.
The rx86 module has accumulated some code duplication.
There are a number of miscellaneous hacks I had to add that I'd like to get rid of somehow.
64-bit memory references aren't as efficient (in terms of code size) as they could be.

My plan for next week is to spend some time cleaning up the rx86 module, and then working on making the JIT translatable again. If by some miracle I get both of those things done next week, I'll start on the other two items. :-)

rx86 conversion complete, 64-bit work started

2010-06-07T07:13:00.002-07:00

Last week saw the completion of the rx86 conversion: All tests pass, and the JIT works on i386 machines.

Last week I started on actually implementing 64-bit support. Mostly this will be an exercise in "magic removal": Locating those parts of the code that are only applicable to i386, and either adapting them to work with both i386 and x86_64 or else factoring those differences out into arch-specific classes.

One issue specific to x86_64 is the fact that most instructions cannot encode a 64-bit immediate value. I've worked around this by setting aside one register as a scratch register, and loading the immediate to that register first when a case like this arises. In the future I may try to optimize this to output a 32-bit relative displacement in the cases where that could work.

PyPy GSoC update: rx86 encoding almost done

2010-05-31T12:28:00.002-07:00

I've almost reached the first milestone. Almost all tests pass, and I've successfully translated pypy-c-jit and run a few benchmarks. Unless I hit an unforeseen issue, I'll be able to actually start on 64-bit support sometime this week.

GSoC status update: End of week 1

2010-05-21T15:19:00.001-07:00

GSoC doesn't officially start until May 24th, but my classes were over, so I spend this week getting started on my project. I spent the week trying to port the backend to use the new rx86 encoding scheme, as well as extended rx86 as needed. Progress was slowed quite a bit by my unfamiliarity with PyPy; it seemed every couple minutes I had to stop and spend some time just reading code, trying to figure out what it was even supposed to do. However, I was definitely getting more done by the end of the week.

By the end of next week, I hope to be finished porting the backend to rx86. After that, I'll begin actually adding 64-bit support.

Google Summer of Code: PyPy 64-bit JIT

2010-04-27T13:18:00.002-07:00

My Google Summer of Code proposal was accepted! This means that starting May 17th, I'll be working on the PyPy JIT. Per Python Software Foundation requirements, I'll be using this blog to post (at least) weekly updates on my status.

The first milestone that I'll be working on is to take the existing "remove-ri386-multimethod-2" branch and use it as a basis for instruction encoding and then modify the existing 32-bit backend to use the new instruction encoding scheme. Once that's in place, we should be in good shape move on to the other 64-bit specific areas. (register allocation, guard failure handling, calling conventions, etc.)

How to disable Autocorrect in OpenOffice Writer 3.1

2010-04-05T14:35:00.002-07:00

Click on the "Format" menu, go the "AutoCorrect" flyout, and uncheck the "While Typing" option.

That's it. It took me an embarrassingly long time to find something so simple, so hopefully someone else can avoid the same fate.

Oh, Wikipedia, how I love thee

2009-05-09T13:07:00.003-07:00

List of fictional vehicles

The best part is the "Spacecraft" section with links to its own article.

Face it, people, you'll never find this kind of quality information in Britannica.

Ports to forward to host Moonbase Commander behind NAT

2009-04-23T22:27:00.002-07:00

To host a Moonbase Commander game, you need to forward three ports:

2300 (TCP)
2350 (UDP)
47624 (TCP)

Note that I did not test downloading a custom map, since I almost always play on randomly-generated maps with the excellent Moonbase Console random map generation utility, so that capability may not work without opening an additional port.

Hey Paul Krugman

2009-03-22T13:50:00.000-07:00

I find this funny:

Nobody could have predicted this

2009-03-14T12:29:00.001-07:00

Well, maybe someone could have:

The major force shaping economic dynamics over the coming decade is likely to be an unwinding of the extreme leverage that individuals, businesses, and the U.S. itself (via its record current account deficit) have accumulated.

National Security

2009-02-09T23:28:00.000-07:00

Why torture is a bad idea:

Early on the morning of July 22, 2002, a Gulfstream V aircraft, then registered with the FAA as N379P, flew Mohamed to Rabat, Morocco where he was interrogated and tortured for 18 months. In Morocco his interrogators routinely beat him, sometimes to the point of losing consciousness, and he suffered multiple broken bones. During one incident, Mohamed was cut 20 to 30 times on his genitals. On another occasion, a hot stinging liquid was poured into open wounds on his penis as he was being cut. He was frequently threatened with rape, electrocution and death. He was forced to listen to loud music day and night, placed in a room with open sewage for a month at a time and drugged repeatedly.

Read that a couple times, and really think about it. Think about it. Think about what it would mean for you or someone you love to go through that. What did Mohamed do to deserve this treatment? He read the wrong website, apparently:

A British ‘resident’ held at Guantanamo Bay was identified as a terrorist after confessing he had visited a ‘joke’ website on how to build a nuclear weapon, it was revealed last night.

Binyam Mohamed, a former UK asylum seeker, admitted to having read the ‘instructions’ after allegedly being beaten, hung up by his wrists for a week and having a gun held to his head in a Pakistani jail.

It was this confession that apparently convinced the CIA that they were holding a top
Al Qaeda terrorist.

But Obama is closing Gitmo, so this is all behind us, right? Hope and change all the way, right?

Not quite. It appears that a lawyer for the Obama Administration is arguing to preserve ‘state secrets’. So more arguments for preserving “national security” at the cost of individual freedoms. Hopefully Obama will back off on this, but I’m not holding my breath.

Sir Terry Pratchett

2008-12-31T09:49:00.001-07:00

Terry Pratchett has been knighted. As it should be.

gcc is smarter than you

2008-12-23T21:16:00.001-07:00

gcc is pretty clever. Consider the following C program:

#include <stdio.h>  /* printf() */

int factorial(int n) {
   return n == 0 ? 1 : n * factorial(n - 1);
}

int main() {
   int n = 10;

   printf("factorial(%d) = %d\n", n, factorial(n));

   return 0;
}

On my version of gcc (4.3.2 on debian testing), when compiled with no optimizaitons, or -O1, it generates code for factorial() like you'd expect, using a recursive call to compute the value. But on -O2, it does something interesting: It compiles down to a tight loop:

    factorial:
   .LFB13:
           testl   %edi, %edi
           movl    $1, %eax
           je  .L3
           .p2align 4,,10
           .p2align 3
   .L4:
           imull   %edi, %eax
           subl    $1, %edi
           jne .L4
   .L3:
           rep
           ret

Pretty impressive. The recursive call (not even tail-recursive) has been completely eliminated, so factorial now uses O(1) stack space instead of O(N). And although I have only very superficial knowledge of x86 assembly (actually AMD64 in this case, but I don't think any of the AMD64 extensions are being used above), I doubt that you could write a better version by hand. But what really blew my mind was the code that it generated on -O3. The implementation of factorial stayed the same. But main() changed:

    main:
   .LFB14:
           subq    $8, %rsp
   .LCFI0:
           movl    $3628800, %edx
           movl    $10, %esi
           movl    $.LC0, %edi
           xorl    %eax, %eax
           call    printf
           xorl    %eax, %eax
           addq    $8, %rsp
           ret

See the "movl $3628800, %edx" line? gcc is pre-computing factorial(10) at compile-time. It doesn't even call factorial(). Incredible. My hat is off to the gcc development team.

Of course, all the usual disclaimers apply, this is just a toy example, premature optimization is the root of all evil, etc, etc, but it illustrates that compilers are often smarter than you think. If you think you can do a better job by hand, you're almost certainly wrong.

The gulf between us

2008-11-09T15:05:00.001-07:00

“All proof inevitably leads to propositions which have no proof. All things are known because we want to believe in them.”
—Bene Gesserit Azhar Book (Dune)

Last night, I had one of Those Conversations. I had run into the professor for an ethics class that I took a couple years ago, and we talked for a bit and my atheism came up. He’s a Christian, and he was interested in why I had changed my mind.

So we went to a coffee shop, and had the Conversation. It followed the script that it usually does when I talk with a Christian about why I no longer believe: We lay out our respective cases, argue back and forth, make concessions, agree on points, disagree on others. Then we reach a point where, while we agree on almost all the relevant facts, we still come to wildly different conclusions.

We had, I thought, a lot in common in our worldviews. He accepted common descent because of the evidence for it, as do I. He doubts dualism (surprising for a Christian, in my opinion), as do I. He finds the idea of someone suffering forever in hell simply for being born in the wrong time or place intolerable, as do I.

It came down to this: He had had a religious experience which made him think that God is real, and since then, he had not seen any evidence that would force him off of that position. He is more than willing to use science, reason and tradition to reinterpret the Bible and take the fire-and-brimstone edge off of it. He resolves many of the problems I have with Christianity simply by disagreeing with the doctrine in question.

And then there’s me. I’m not willing to do any of that. I see no point. Isn’t it, [I think to myself] obvious that the reason the old testament is filled with atrocities and genocides is because it’s just another book, written by men? Isn’t it obvious that the reason the doctrine of hell exists is because fear is powerful motivator, and religions which exploit that will be more successful than those that do not? Isn’t it obvious that moderate religion is just the projecting of the morals of modernity onto ancient books by picking and choosing which passages should be literal, and which should be metaphor?

But it’s not obvious. Not to him.

I am, it seems, essentially a fundamentalist. I see no point in half-measures, no point in trying to dress up a flawed and brutal document as the words of a benevolent god.

He is a liberal. He is willing to reinterpret, to use the findings of science and modernity to come to a different understanding of the Bible.

How can this gulf between us be bridged? How can our discourse ever rise about the level of each of us saying to the other “It’s obvious to me that you are wrong.”? How can we ever move beyond shouting to each other across a chasm, separated by presuppositions that we are apparently unwilling to reconsider? What evidence or argument, if any, could be brought to bear to make me change my interpretive framework? To make him change his?

My own view is not nearly as bleak and postmodern as the opening quote. I think that there are criteria than can be applied to standards of evidence. (For instance, if your standard of evidence leads you to a contradiction, it’s wrong.) But it’s very difficult to “step outside” your own beliefs to examine them. Think of the conspiracy nut who says that all contradictory evidence is obviously part of the conspiracy.

In the end, all I can do is strive to keep an open mind, try to honestly consider arguments and evidence, and seek to understand why someone else holds a different view then I do rather blindly dismissing or demonizing them.

I hope it’s enough.

The economic crisis explained. (sort of)

2008-10-10T17:44:00.001-07:00

I just wanted to share the clearest explanations of the ongoing economic crisis that I’ve heard so far: Two episodes of This American Life:

If you have the time, give a listen. I haven’t fact-checked what they’re saying against other sources, but they present at least potential explanations, in stark contrast to the empty, one-word talking points (“greed”! “deregulation”!) given by partisans.

Poe's Law Strikes Again

2008-08-28T18:43:00.002-07:00

UPDATE:. Turns out it is photoshopped, as I had hoped.

I have a problem.

I often can’t determine whether something is satire. I always want to believe that it is parody, that it’s all a joke, that nobody is really that stupid.

The technical term for this is Poe’s Law, and I am always falling prey to it.

For instance, look at this picture on the Obama-Osama connection. Did Fox News really run the byline “Obama / Biden. Osama Bin Laden. Coincidence?” It must be photoshopped, right? Surely nobody would be so insane as to imply that a similarity in spelling or phonetics implies similarity in character or policy, right? Right?

I just can’t tell. I tried to find that clip on Youtube, on the grounds that it would be more difficult to forge, with no success. My irrational desire to believe that no-one would stoop to that kind of non sequitur drives me to hope that it’s fake.

But things like the Jack Chick tract First Bite (via Atheist A Go-Go), which I’m certain is not satirical, lead me to believe that my unwillingness to accept something as real simply because it’s absolutely insane is (sadly) not based in reality.

Vote for me

2008-08-12T18:07:00.001-07:00

Screenshot walkthroughs of common applications

2008-08-03T10:43:00.004-07:00

I just wanted to let everybody know about a site which features screenshot walk-through of common applications. If you've ever helped anyone over the phone to configure some piece of software, you'll realize how incredibly useful this is.

If you've never helped anyone configure software over the phone, I envy you.

Were Jesus's Apostles Martyred?

2008-08-02T18:32:00.003-07:00

I’ve often heard the argument used that the apostles of Jesus were killed for their beliefs, so they couldn’t have been lying about Jesus. (And, by implication, weren’t mistaken either.) I’m not going to discuss the validity of the argument, I just want to examine the question of whether or not we have good reason to accept these accounts of martyrdom as being historical rather than apocryphal church tradition.

Indeed, two of the sources I found seemed to issue disclaimers to that effect. In an article entitled What Happened to the Apostles?, about-jesus.org says:

It should be understood that these non-Biblical sources might vary greatly in terms of their accuracy. It should also be understood that it is clear from the Bible and from non-Biblical sources that many early Christians were persecuted and martyred for their beliefs.

Another article, The History of the Early Christian Martyrs warns “It should be understood that the accounts of the martyrdoms of apostles are mainly traditional.”. I don’t know quite what to make of that, other than to understand “traditional” to mean “probably made up”, although perhaps my interpretation is overly uncharitable.

So here’s my list of early Christian martyrs with how they died and the source I used. I’ve included Stephen plus the 10 apostles who are believed to have been martyred. Not included are the 2 other apostles: John, who is traditionally held to have had a natural death, and Judas, who either hung himself or had his guts spill out, depending on who you ask.

Name	Cause of Death	Source
Stephen	Stoned	Acts 7:54-60
James, son of Zebedee (“James the Greater”)	Sword	Acts 12:1-2
Bartholomew	Beaten, then crucified	Martyrdom of Bartholomew (also Foxe)
James, son of Alphaeus (“James the Less”)	Beaten, stoned and clubbed	Foxe’s Book of Martyrs
Andrew	Crucified	Foxe’s Book of Martyrs
Peter	Crucified	Foxe’s Book of Martyrs
Thomas	Spear	Foxe’s Book of Martyrs
Phillip	Crucified	Foxe’s Book of Martyrs
Matthew	Halberd (type of spear)	Foxe’s Book of Martyrs
Thaddeus (Jude)	Crucified	Foxe’s Book of Martyrs
Simon	Crucified	Foxe’s Book of Martyrs

The most interesting source is for the martyrdom of Bartholomew, which, while found in Foxe’s Book of Martyrs, is also found in a text entitled (appropriately enough) The Martyrdom of Bartholomew It should be noted that is it clearly a religiously motivated work, with appearances of angels, demons, people getting strangled by demons, and so on. But other than that simple, self-evident fact, I was unable to track down any useful information about this text, such as when it was written and who wrote it.

But it seems that the main source for this sort of thing is Foxe’s Book of Martyrs, which was written by John Foxe and published in 1563. All the apostles are found in the first chapter but it doesn’t say what sources Foxe used (nor did I expect it to), although I suspect that they were probably the same sort of non-canonical texts like the “The Martyrdom of Bartholomew”.

To conclude, given the (lack of) evidence that I have seen, and the doubts expressed by friendly sources, I think that there is not sufficient evidence to prove the historicity of the apostles being martyred, although I don’t place a huge amount of confidence in this result because I am not Biblical scholar and am not terribly familiar with these sorts of texts. If anyone knows of any better/earlier sources that the ones listed here, please let me know.

Music of the spheres

2008-07-08T16:49:00.003-07:00

I just have two quick tidbits of astronomy related goodness I wanted to share.

The first is Astronomy Cast, a weekly podcast featuring astronomy-related topics. Black holes, missions to mars, tidal forces, the end of the universe, wave/particle duality and other fun stuff. The hosts, Fraser Cain and Dr. Pamela Gay clearly love astronomy and it comes through in the show.

The other is orbiter, a free space flight simulator. It features real and fictional spacecraft with realistic physics: No warp drives here. If you want to go to the moon, you have to take the time to learn about how orbital dynamics and transfer orbits work, which is half the fun. The learning curve is very steep, so be sure to grab the free Go Play in Space e-book as well.

Pseudoscience Kills

2008-05-11T15:12:00.003-07:00

In the last couple days, I've been reading about the wonderful world of HIV denial, whose proponents state that either HIV doesn't exist or that HIV doesn't cause AIDS. This is, of course, dead wrong. If you're interested in how we know this, avert.org has a nice summary of the data, "Evidence that HIV causes AIDS".

And then I ran across the sad, tragic and depressing story of how HIV denier Christine Maggiore's 3 year old daughter died of AIDS-related pneumonia. Mrs. Maggiore is HIV-positive and has written and self-published a book entitled "What if everything you thought you knew about AIDS was wrong?". And as predicted by dissonance theory, Mrs. Maggiore still holds to the view that HIV doesn't cause AIDS. How could she do otherwise? To change her mind now would be to admit to herself and to the world, not only that she's been wrong about HIV all along but also that she is at least partially responsible for the death of her child. It's a terrible thing to face up to, and I doubt that I would have the strength to do so if I was in her shoes.

This is why science, skepticism and open-minded examination of the evidence is so important: Because beliefs have consequences. When we examine the validity of claims like "HIV causes AIDS", we're playing for all the marbles. Reaching the correct answer really does matter.

Pseudoscience kills.

Scott Adams gets it wrong

2008-04-15T18:58:00.003-07:00

Scott Adams, creator of Dilbert, makes up funny sounding BS for a living. Not a bad job, if you can get it. But sometimes he get carried away on his blog. He describes the Monty Hall Problem thusly:

The set up is this. Game show host Monte [sic] Hall offers you three doors. One has a car behind it, which will be your prize if you guess that door. The other two doors have goats. In other words, you have a 1/3 chance of getting the car.

You pick a door, but before it is opened to reveal what is behind it, Monte opens one of the doors you did NOT choose, which he knows has a goat behind it. And he asks if you want to stick with your first choice or move to the other closed door. One of those two doors has a car behind it. Monte knows which one but you don’t.

The trick here is that most people assume it makes no difference if they stick with their original choice or move to the other door. They believe the odds are 50% either way, since there are only two choices and you don’t know anything about either choice. But mathematicians say that is wrong. You substantially increase your odds by switching doors.

That is interesting enough on its own. (I’ll give a link later that explains the math of it.) But here is the freaky part. You only improve your odds by switching doors if Monte Hall knows what is behind each door. If he simply got lucky and opened a door with a goat behind it, your odds are unchanged. In other words, your odds are changed by Monte’s knowledge, and your knowledge that Monte has that knowledge.

If reality were objective, statistics wouldn’t be influenced by knowledge. That means your world is either partly created by your mind, or you are a hologram created by some other mind, and there are a few bugs in the software.

(Emphasis mine)

Nope, sorry, wrong. The odds do not change based on Monty's knowledge. Let's do the math, and for simplicity, let's assume that you picked door #1 initially and that, in each case, Monty "got lucky" and opened a door with a goat behind it without knowing beforehand:

Door #1	Door #2	Door #3	No Switch Result	Switch Result
Car	Goat	Goat	Car	Goat
Goat	Car	Goat	Goat	Car
Goat	Goat	Car	Goat	Car

If you happened to pick the car initially (1/3 chance), switching to the other (unopened) door causes you to lose. In the other two cases, when you picked a goat initially, switching causes you to win. There is no difference in the odds between Monty choosing a door with a goat behind because he knew there was a goat there or because he got lucky. As long as you know that Monty will always open a door, and that the door that he opens is a goat, (either through luck or foreknowledge) you should switch. The odds would be different, if, for example, Monty only offered a chance to switch if the player initially picked the car, thus rendering the switch-strategy a lose-only proposition.

LabelParrot.com - Print PDF mailing labels

2008-03-22T11:59:00.003-07:00

Hey, I just launched my "toy" Ruby on Rails app: LabelParrot.com, a site that lets you upload a CSV and generate PDF mailing labels for common Avery mailing label layouts. Please let me know if you find it useful.

Can justin.tv scale?

2007-04-15T21:56:00.000-07:00

Can justin.tv (wikipedia article) scale?

I don't mean "can their website scale?". I mean, "Could everybody do this?" Could everybody walk around with live, 24/7 camera feeds of their life? They call it "lifecasting", as if it's something that's common, something that people do. But it's not: It's just a publicity stunt.

Right?

Run with me for a minute: Suppose this was refined to the point where you didn't have a lug a backpack full of batteries around; Suppose you had a small, lightweight camera that you wore all (or nearly all) the time that Just Worked. And suppose that everybody did it. I mean everybody. Think about that for a second.

What would it be like? I have this picture in my head: Some friends hanging out in a coffee shop, with a laptop watching other group of people across town. Who are also at a laptop, watching them, watching them. If you follow me.

I imagine nobody being able to get away with anything: Somebody, somewhere was recording the stream. There would probably be a rolling backup of, oh, the last week or so that you could permanently save snippets from. If every important event in your life was recorded from multiple points of view, funerals would probably become tastefully done video presentations. Probably weddings too: None of this nonsense about remembering the first thing you said when you first met when we can play the genuine article on the big screen.

It's not gonna happen, of course, at least not to that extent. Calling it "lifecasting" as if it's going to become an established practice is, in my opinion, mere hyperbole. Not many people are going to willing turn their lives into The Truman Show just yet. But it's kinda fun to think about.

Many color laser printers embed hidden tracking information

2007-02-04T19:00:00.000-07:00

It turns out that many color laser printers embed hidden tracking codes that could be used to uniquely identify the printer that was used to print a given page.

I did not know this. And I wonder how many people who live under oppressive governments are in jail because they didn't know it either.

Firefly Parody: "Mosquito"

2007-01-29T21:13:00.000-07:00

If you're a fan of Joss Whedon's short-lived, cult classic TV series Firefly, you have to watch this parody video on YouTube: Mosquito

Eric on Boundries

2007-01-19T17:41:00.000-07:00

Eric Sink over at Eric.Weblog() has some interesting thoughts on boundries.

A simple regex engine in Haskell

2006-12-31T17:20:00.000-07:00

UPDATE: sorear from #haskell pasted a cool version of this here. His version is a Parsec Parser that returns another Parsec Parser! How cool is that? His version doesn't actually return the matches themselves, just a Bool, but still, it's a clever hack.

I recently wrote a simple regex engine (and parser) in Haskell. The implementation is far from optimal, but I'm still pretty excited about how easy it was, especially the parser. Thanks to psykotic for the inspiration: Without his regex engine in 14 lines of Python as an example, I probably wouldn't have tried something like this.

I'm going to walk over the implementation and give examples. The impatient can skip down to the end to see the full source.

import Text.ParserCombinators.Parsec

data Match = MkMatch String String deriving (Show, Eq)

type Matcher = Match -> [Match]

We'll need Text.ParserCombinators.Parsec later. The "Match" datatype has a single constructor, "MkMatch" (The constructor could have simply been called "Match", but I found that confusing), which takes two strings: The first string is the part of the text that matched, and the second string is the remainder. And the "Matcher" type synonym is for pretty type signatures. Armed with these types, we can write a function that matches (or does not match) a single character:

matchOne :: (Char -> Bool) -> Matcher
matchOne _ (MkMatch _ "") = []
matchOne f (MkMatch xs (y:ys))
  | f y = [MkMatch (xs ++ [y]) ys]
  | otherwise = []

matchOne takes a predicate function and returns a Matcher. We can use it like so:

*Main> matchOne (=='x') (MkMatch "" "xyz")
[MkMatch "x" "yz"]

That works fine to just match one thing, but it's hard to chain things together. We can take advantage of the fact that Haskell's built-in list datatype is a monad:

*Main> [MkMatch "" "xyz"] >>= matchOne (=='x')          
[MkMatch "x" "yz"]
*Main> [MkMatch "" "xyz"] >>= matchOne (=='x') >>= matchOne (=='y') >>= matchOne (=='z')
[MkMatch "xyz" ""]
*Main> [MkMatch "" "xyz"] >>= matchOne (=='x') >>= matchOne (=='y') >>= matchOne (=='z') >>= matchOne (=='a')
[]

Saying =='x' all the time is tedious:

rechar :: Char -> Matcher
rechar c = matchOne (==c)

Example:

*Main> [MkMatch "" "xyz"] >>= rechar 'x' >>= rechar 'y' >>= rechar 'z'                                       
[MkMatch "xyz" ""]

Now that we have matchOne, it's trivial to define the . regex metacharacter:

dot :: Matcher
dot = matchOne (const True)

"dot" is a Matcher that always matches one character. Matching single characters is all fine and dandy, but it's about time we had some more interesting way of combinding Matchers. Here is a simple (and wrong) implementation of the * quantifier:

badstar :: Matcher -> Matcher
badstar f x = (f x >>= badstar f) ++ [x]

It seems to work fine for simple cases:

*Main> [MkMatch "" "xxx123"] >>= badstar (rechar 'x')
[MkMatch "xxx" "123",MkMatch "xx" "x123",MkMatch "x" "xx123",MkMatch "" "xxx123"]

Notice how it returns all the matches, not just the first one. Pretty cool, eh?

But consider this (even simpler) case:

*Main> [MkMatch "" ""] >>= badstar (rechar 'x')
[MkMatch "" ""]

No real surprise here: * means "zero or more, as many as possible". So we're just seeing a zero-width match. No problem, right? Wrong. Look at this:

*Main> [MkMatch "" ""] >>= badstar (badstar (rechar 'x'))
*** Exception: stack overflow

Non-termination rears its ugly head. The problem with badstar is that whatever we're trying to match zero or more of might also have a zero-width match. In other words, in f x >>= badstar f, the list returned by f x may contain x! This leads to infinite recursion. My solution is to simply filter x out of f x:

star :: Matcher -> Matcher
star f x = (filter (/=x) (f x) >>= star f) ++ [x]

Which works how we want it to:

*Main> [MkMatch "" ""] >>= star (star (rechar 'x'))
[MkMatch "" ""]
*Main> [MkMatch "" "xx"] >>= star (star (rechar 'x'))
[MkMatch "xx" "",MkMatch "xx" "",MkMatch "x" "x",MkMatch "" "xx"]

However, I am not 100% sure that this solution covers every case. If anybody has any insight on this, I'd love to hear it.

Moving along, we can write combinators for alteration and sequencing:

alt :: [Matcher] -> Matcher
alt fs x = concatMap ($ x) fs

ordered :: [Matcher] -> Matcher
ordered fs x = foldl (>>=) [x] fs

alt and ordered both "reduce" a list of Matchers to a single Matcher. Remember that Matcher is just Match -> [Match], so we can do concatMap ($ x) fs with no problem.

It seems like ordered is probably a builtin function somewhere, but I couldn't find a standard equivalent.

Now we can write, for example, c(a|d)*r

*Main> [MkMatch "" "caddr"] >>= ordered [ rechar 'c', star (alt [ rechar 'a', rechar 'd' ]), rechar 'r' ]
[MkMatch "caddr" ""]

Rounding out our metacharacters are + and ?

plus :: Matcher -> Matcher
plus f = ordered [ f, star f ]

reoptional :: Matcher -> Matcher
reoptional f = alt [ f, return ]

And that's the basic engine. It's not very good: It use backtracking, but doesn't support any of the fun features (eg, backreferences) that a backtracking regex engine is supposed to have. I haven't done any benchmarks or profiling, but I doubt it's very fast. Also, there's not any sort of anchoring: everything has to match at the beginning the of string. But none of that matters: It's just a toy for me to learn about backtracking.

Now for the parser:

literalchar :: Parser Char
literalchar = letter <|> digit <|> oneOf " ,-_;:'\"" 

parseregex :: Parser Matcher
parseregex = do
  xs <- sepBy1 (many1 atomWithMod) (char '|')
  return (alt (map ordered xs))

parsechar :: Parser Matcher
parsechar = literalchar >>= (return . rechar)

atomWithMod :: Parser Matcher
atomWithMod = do
  a <- atom
  choice (map (\(c, f) -> char c >> return (f a)) mods) <|> return a
  where
    mods = [('+', plus), ('*', star), ('?', reoptional)]

atom :: Parser Matcher
atom = subexpression <|> charclass <|> wildcard <|> parsechar

subexpression :: Parser Matcher
subexpression = do
  char '('
  expr <- parseregex
  char ')'
  return expr 

charclass :: Parser Matcher
charclass = do
  char '['
  xs <- many1 ((try range) <|> parsechar)
  char ']'
  return (alt xs)

range :: Parser Matcher
range = do
  from <- literalchar
  char '-'
  to <- literalchar
  return (matchOne (`elem` [from..to]))

wildcard :: Parser Matcher
wildcard = char '.' >> return dot

matches :: String -> String -> [Match]
matches re str = [MkMatch "" str] >>= (runparser parseregex re)

runparser :: GenParser tok () a -> [tok] -> a
runparser p input = case (parse p "" input) of
  Right x -> x
  Left err -> error (show err)

I'm not going to talk about the parser very much because it doesn't seem nearly as interesting. The parser is fairly simple. It supports subexpressions, character classes, alternation, *, +, and ?. It doesn't support escaping characters, (ie, "\." to match a literal dot character.) but that would be fairly easy to add.

Some fun using the matches helper function:

*Main> matches "[0-9]+(,[0-9]+)*" "1,230,058" 
[MkMatch "1,230,058" "",MkMatch "1,230,05" "8",MkMatch "1,230,0" "58",MkMatch "1,230" ",058",MkMatch "1,23" "0,058",MkMatch "1,2" "30,058",MkMatch "1" ",230,058"]
*Main> matches "((great )*grand )?((fa|mo)ther)" "great great grand mother" 
[MkMatch "great great grand mother" ""]
*Main> matches "c[ad]+r" "caddr" 
[MkMatch "caddr" ""]
*Main> matches "(x*)*" "x" 
[MkMatch "x" "",MkMatch "" "x"]

And that's it. If anybody has any feedback or ideas on how to simplify it, I'd love to hear them. Oh, and here's the full source:

import Text.ParserCombinators.Parsec

data Match = MkMatch String String deriving (Show, Eq)

type Matcher = Match -> [Match]

matchOne :: (Char -> Bool) -> Matcher
matchOne _ (MkMatch _ "") = []
matchOne f (MkMatch xs (y:ys))
  | f y = [MkMatch (xs ++ [y]) ys]
  | otherwise = []

rechar :: Char -> Matcher
rechar c = matchOne (==c)

dot :: Matcher
dot = matchOne (const True)

badstar :: Matcher -> Matcher
badstar f x = (f x >>= badstar f) ++ [x]

star :: Matcher -> Matcher
star f x = (filter (/=x) (f x) >>= star f) ++ [x]

alt :: [Matcher] -> Matcher
alt fs x = concatMap ($ x) fs

ordered :: [Matcher] -> Matcher
ordered fs x = foldl (>>=) [x] fs

plus :: Matcher -> Matcher
plus f = ordered [ f, star f ]

reoptional :: Matcher -> Matcher
reoptional f = alt [ f, return ]

literalchar :: Parser Char
literalchar = letter <|> digit <|> oneOf " ,-_;:'\"" 

parseregex :: Parser Matcher
parseregex = do
  xs <- sepBy1 (many1 atomWithMod) (char '|')
  return (alt (map ordered xs))

parsechar :: Parser Matcher
parsechar = literalchar >>= (return . rechar)

atomWithMod :: Parser Matcher
atomWithMod = do
  a <- atom
  choice (map (\(c, f) -> char c >> return (f a)) mods) <|> return a
  where
    mods = [('+', plus), ('*', star), ('?', reoptional)]

atom :: Parser Matcher
atom = subexpression <|> charclass <|> wildcard <|> parsechar

subexpression :: Parser Matcher
subexpression = do
  char '('
  expr <- parseregex
  char ')'
  return expr 

charclass :: Parser Matcher
charclass = do
  char '['
  xs <- many1 ((try range) <|> parsechar)
  char ']'
  return (alt xs)

range :: Parser Matcher
range = do
  from <- literalchar
  char '-'
  to <- literalchar
  return (matchOne (`elem` [from..to]))

wildcard :: Parser Matcher
wildcard = char '.' >> return dot

matches :: String -> String -> [Match]
matches re str = [MkMatch "" str] >>= (runparser parseregex re)

runparser :: GenParser tok () a -> [tok] -> a
runparser p input = case (parse p "" input) of
  Right x -> x
  Left err -> error (show err)

Fun with bitmaps

2006-12-12T21:02:00.000-07:00

Paul Potts over at Praise, Curse, and Recurse has posted an interesting example of some of the fun you can have printing out bitmaps. For example:

*Main> putStr $ bitPicture unsignedInts 6
                                ################################
                ################                ################
        ########        ########        ########        ########
    ####    ####    ####    ####    ####    ####    ####    ####
  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
*Main> putStr $ bitPicture signedInts 6
################################                                
                ################                ################
        ########        ########        ########        ########
    ####    ####    ####    ####    ####    ####    ####    ####
  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##  ##
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
*Main>

The first example is with the numbers [0..63] (left to right) with the most significant bit on the first line. (ie, unsigned ints in 6 bits.) The second example is the with numbers [-32..31] (ie, signed ints in 6 bits.)

Paul asked for readers to play around with the code and try to make it more concise or "Haskellish". I don't know if my stab at it meets those criteria, but here it is:

import Data.Bits

unsignedInts :: Int -> [Int]
unsignedInts bits = [0..((2^bits) - 1)]

signedInts :: Int -> [Int]
signedInts bits = [-bounds..(bounds - 1)] where bounds = 2^(bits - 1)

boolToChar :: Bool -> Char
boolToChar True = '#'
boolToChar False = ' '

bitPicture :: (Int -> [Int]) -> Int -> [Char]
bitPicture intGen bits = unlines $ map stringAtIndex (reverse [0..(bits-1)])
 where
   stringAtIndex = map boolToChar . bitsAtIndex
   bitsAtIndex idx = [ testBit n idx | n <- intGen bits ]

Verizon Math: 0.002 dollars = 0.002 cents

2006-12-10T15:19:00.000-07:00

Listen to this painful example of someone trying to explain to Verizon that 0.002 dollars and 0.002 cents are not, in fact, the same. (Link courtesy of Good Math, Bad Math)

Pass-by-reference vs pass-by-value in Coldfusion

2006-12-06T09:31:00.000-07:00

I keep getting burned by this at work, so I'm going to blog it so I don't forget:

Structures, queries, and complex objects such as COM objects are passed to UDFs by reference, so the function uses the same copy of the data as the caller. Arrays are passed to user-defined functions by value, so the function gets a new copy of the array data and the array in the calling page is unchanged by the function. As a result, you must handle arrays differently from all other complex data types.

Source: Coldfusion MX 7 docs.

Avoiding skipping audio in Debian etch with a 2.6 kernel

2006-11-24T18:57:00.000-07:00

I'd had problems with audio skipping whenever I did something that required a CPU-intensive repaint in X11. Most often, it was switching to and from Firefox. Avoiding audio skipping in Linux 2.6 was right on the money. However, I'm following Debian testing (etch) and the xserver-common package no longer exists. After a bit of poking around, it appears that it's been renamed to x11-common, so the magic incantation on etch is dpkg-reconfigure x11-common and setting the nice setting to 0.

A Simple RPN Calculator in Haskell

2006-11-11T13:53:00.000-07:00

Of late I have been playing around with Haskell, a pure functional programming language. Last night I hacked up a quick RPN calculator and was pleasantly surprised at how easy it was. Example usage: (Note that because the stack is implemented as a list, the top of the stack is the first element of the list)

> 5 4 *
[20.0]
> 14
[14.0,20.0]
> *
[280.0]
> 2 * 48 -
[512.0]
> log 2 log /
[9.0]
> 2
[2.0,9.0]
> swap
[9.0,2.0]
> **
[512.0]
> 2 * sqrt
[32.0]

Here's the code:

import Char
import IO

type RPNNumber = Double
type Stack = [RPNNumber]
type Operator = (Stack -> Stack)

parse :: [Char] -> [Operator]
parse = map parseOp . words

binaryOp :: (RPNNumber -> RPNNumber -> RPNNumber) -> Operator
binaryOp f = (\ (a:b:stack) -> f b a : stack)

unaryOp :: (RPNNumber -> RPNNumber) -> Operator
unaryOp f = (\ (a:stack) -> f a : stack)

parseOp :: [Char] -> Operator
parseOp "+" = binaryOp (+)
parseOp "-" = binaryOp (-)
parseOp "*" = binaryOp (*)
parseOp "/" = binaryOp (/)
parseOp "**" = binaryOp (**)
parseOp "log" = unaryOp log
parseOp "sqrt" = unaryOp sqrt
parseOp "dup" = (\ (x:xs) -> x:x:xs)
parseOp "swap" = (\ (a:b:xs) -> b:a:xs)
parseOp "pop" = tail
parseOp number = (\stack -> (read number) : stack)

eval :: Stack -> [Operator] -> Stack
eval = foldl $ flip ($)

repl :: Stack -> IO ()
repl stack = do
  putStr "> " 
  hFlush stdout
  line <- getLine
  newstack <- return $ eval stack (parse line)
  putStrLn $ show newstack
  repl newstack

main = do repl []

That's only 42 lines of code, 25 without the optional type declarations and whitespace. The structure is pretty simple: A stack is a list of numbers, an operator is function that takes a stack and returns a new stack. The "parser" just splits a string into words and the maps each of those words to an operator.

binaryOp and unaryOp are helper functions that take functions and make them into operators. parseOp takes a string an returns the appropriate operator. Or, if its argument isn't recognized as an operator, parseOp assumes that it's a number and returns an operator that pushs it onto the stack.

The only function I'll admit to golfing is the "eval" function. Originally, I had it defined as:

eval stack [] = stack
eval stack (f:fs) = eval (f stack) fs

I kept thinking, "that really looks like a fold". The next step was:

eval = foldl (\stack f = f stack)

And from there it was simple to realize that all I had to do was flip the function application operator:

eval = foldl $ flip ($)

Opening a query window quickly in Enterprise Manager

2006-11-03T17:44:00.000-07:00

Enterprise Manager has some handy keyboard shortcuts, but I couldn't find any keybindings to quickly open a query window for the selected table. Enter AutoHotkey, a free, featureful keyboard mapping utility for Windows. Here's the stanza to bind Win+o to open a query window without the useless Diagram and Gird panes and fill in "WHERE" for me:

; Open a query in enterprise manager
#o::Send {AppsKey}oq^1^2{PgDn}{End}{Enter}WHERE{Space}

AutoHotkey can do a lot more than simple rebinding, so be sure to check it out if you have to use Windows for any significant amount of time.

Tip: Scrolling in Firefox with your hands on the home row

2006-10-16T19:27:00.000-07:00

Short Version: You can scroll down in Firefox with the spacebar, and scroll up with shift+spacebar.

Long Version: This was surprisingly hard to find. I couldn't seem to find a definitive list of default keybindings in Firefox anywhere. I ended having to dig through /usr/share/firefox hoping to find some file that has the default keybindings. Eventually, I found platformHTMLBindings.xml (located at /usr/share/firefox/chrome/toolkit/content/global/platformHTMLBindings.xml on my Debian etch installation and presumably can be overridden somehow in your profile directory.)

The lines in question are:

<handler event="keypress" key=" " modifiers="shift" command="cmd_scrollPageUp" />
<handler event="keypress" key=" " command="cmd_scrollPageDown" />

Unique Snowflakes And Really Big Numbers

2006-10-05T22:23:00.000-07:00

I've always suspected that the "no two snowflakes are alike" meme is false because of the Birthday Paradox. So I decided to do a little research (read: Google) to find out for sure.

Of course, it all depends on what you mean by "alike." My personal definition would be something like "if you can't differentiate between them with an optical microscope, they're alike."

So, with that in mind, are any two snowflakes alike?

What do you mean, an African or European snowflake?

It turns out that there are several classes of snowflakes. The linked page explains that really small snowflakes (ie, ten molecules or so) are obviously non-unique. In addition, there are simple, smallish snowflakes that pass the optical microscope test. It goes on to assert vaguely that the possible number of large, complex snowflakes is around 100!. (around 10^158). Which is really huge number.

On the other hand, The Straight Dope uses basically the same argument I had been using: "Lots and lots of snowflakes, gotta be a collision somewhere, right?"

I'm leaning towards the combinatorial argument though. Here's why: Combinations of items grow really, really fast. Way faster than most people expect. (Well, faster than I expect, anyway.)

For instance, the current word size in most desktop computers these days is 32 bits. That means it can hold 2^32 different possible values. (about 4 billion.) If you started counting from one to 2^32 at one number per second, you'd finish in about 136 years.

But some newer PCs have a 64 bit word size. 2^64 doesn't seem a lot bigger than 2^32, but it is. 2^64 is 2^32 times larger than 2^32. If you tried to count to 2^64, you wouldn't finish before the Sun burned out. If you had 2^64 dollars, and you spent a billion dollars (10^9) a second, it would take 584 years to run out. If you could travel at the speed of light, it would take 314,000 years to go 2^64 miles.

So 2^64 is a pretty big number. But 2^65 is twice as large. That's hard to me to remember. At some level, I know how it works. I know that n^(m+1) = n * n^m. But I really have to think about it before it hits home.

And 2^64 is "only" about 10^19. And 100! (about 10^158, remember) is the alleged number of possible snowflakes. Which is, as I said, a really huge. And even if that's off by, say, 60 orders of magnitude, that would still be 10^98, which is more than the number of particles in the known universe.

And that's why I'm beginning to think that it's possible that no two snowflakes are alike.

Ruben's Tube: Awesome Physics Experiement

2006-10-03T18:28:00.000-07:00

You just have to watch this amazing video of a Ruben's Tube.

Microsoft Censors MSN Messenger

2006-09-28T21:57:00.000-07:00

This week I found out that Microsoft silently drops MSN Messenger messages that contain the string "download.php" (Reportedly other strings as well: see the wikipedia article)

Apparently, this is supposed to protect users from scams. That's okay, but the implementation is brain-damaged. You can't turn it off. It doesn't warn the user. It doesn't give any notification. The server just drops your message on the floor. And it's not some specific, known-bad URLs. It's anything with "download.php" in it. Anything. Or "gallery.php", "profile.php?", ".pif" or ".scr" according to the linked Wikipedia article.

So not only is it a blanket filter, it's keyed to some fairly common strings. There must be millions of sites out there with a page called "download.php". Alas, they are not MSN Messenger Compatible. Just another day at Redmond.

The Graphing Calculator Story

2006-09-24T17:06:00.000-07:00

I used to be a contractor for Apple, working on a secret project. Unfortunately, the computer we were building never saw the light of day. The project was so plagued by politics and ego that when the engineers requested technical oversight, our manager hired a psychologist instead. In August 1993, the project was canceled. A year of my work evaporated, my contract ended, and I was unemployed.

I was frustrated by all the wasted effort, so I decided to uncancel my small part of the project. I had been paid to do a job, and I wanted to finish it. My electronic badge still opened Apple's doors, so I just kept showing up.

-- The Graphing Calculator Story (Thanks to A Neighborhood Of Infinity for the link.)

Ruby FUD: Abstraction is bad

2006-09-23T18:41:00.000-07:00

Before I get started, let's get some things out in the open:

I like Ruby.
I've never used Java.

So my perspective on Ruby vs. Java is probably limited, and quite possibly wrong. I probably shouldn't say anything at all.

But when someone posts something like this, I have to rant about it. He makes some valid points. Basically, he says:

Ruby is slow
Ruby doesn't have good unicode support
It's harder to find Ruby programmers than Java programmers
Java has more libraries, better IDEs, etc.

All of these are true. Ruby might be Fast Enough for your application, and it might not be. All of those things will probably change to some extent in the future, but right now they're true.

That said, I'll now throw off my guise of even-handedness and rip into everything else he said. Well, not everything. Specifically, two things:

Ruby proponents seem to measure maintainability in lines of code: the smaller the program, the “cleaner” and more maintainable it is. Check this example on Martin Fowler’s “bliki”:

C# example:
public static IList  Managers(IList emps) {
  IList result = new  ArrayList();
  foreach(Employee e  in emps)
    if (e.IsManager)  result.Add(e);
  return result;
}
... as compared with the equivalent in Ruby:
def managers(emps)
  return emps.select  {|e| e.isManager}
end
I actually prefer the C# version, as the processing isn’t hidden away behind some clever syntax. The Ruby version is creating a list and populating it; you just have to know in advance that that’s what it’s doing. It’s neat and clever in an academic kind of way, and also kind of fun, but multiply this example by several thousand, and you end up with a project full of cryptic code and “implied” things going on behind the clever parser.

If I find myself repeated using some pattern in my code, I like to give the pattern a name and disconnect what I'm doing from how I'm doing it. I call this named pattern a "function". I find this allows me to reason about the program on a higher level and be more productive. Kind of a crazy, academic, not-enterprise-ready idea, but I think it might catch on.

<sarcasm>But for Real Programming in Java, it's just not readable to have "implied" things going on. In fact, the ability to define functions and classes should be removed from Java, since abstraction is such an obstacle to readablity.</sarcasm>

As for the closure example, it's nice, but so what? Why not just add closures to Java (which is being looked into for the Java 7 release)? Better that than to throw away all of Java. In the meantime, I'm happy to wait. It's not as if I've ever felt the lack, but I'm sure closures will be cool when Java gets them.

First of all, I cannot imagine not missing closures. At my day job, I am constantly thinking "this would be so easy with first class functions and closures." The only reason I can see for not "ever [feeling] the lack" would be never really having used them.

Secondly, it's too late to add closures to Java. Sure, you hack them into the language. But every single Java library in the world (Remember? The ones that make Java such a great language to work with?) is writen in a style idiomatic of a language without closures. The cool thing about closures in Ruby is that they've been there from very early on and are used everywhere.

Okay, I'm done. I've almost certainly not been totally fair, so be sure to read the linked post to get the whole story.

Making experts-exchange.com usable

2006-09-23T08:53:00.000-07:00

I've always wondered how Experts Exchange got their PageRank. It seems like every time I search for some problem, their (apparently) useless site is in the results.

For example, look at this question. Notice the large "view solution" buttons. Which, of course, asks you to pay to see the "solution". (Which may or may not be the solution, just the rest of the posts in the thread).

However, if you scroll down to the bottom of the page, past all the ads, the rest of the posts in the thread are visible. What's that? Don't see them? Okay, try this: Delete cookies from experts-exchange.com, and then block cookies from them. Refresh. That's right: It appears that they're using cookies to ensure that you only see the answers once without paying. This is probably so search engines can find them for better SEO, but normal users have to pay. Whatever the reason, you can get around it by blocking cookies from experts-exchange.com

As an added bonus, if you have the Greasemonkey Firefox extension installed, you can install this user script to remove the large block of ads in the middle of the page.

The end is near

2006-06-10T21:03:00.000-07:00

Today I learned about a wonderful piece of software called "ClickYes." I'd like you think about that name for a minute or two. What do you think it does?

That's right.

It clicks "yes."

Seriously. You can read about it here. It comes it two versions, "Express" and "Pro". Again, I'm not making this up. Follow the link.

Godwin's Law as applied to programming

2006-04-17T21:45:00.000-07:00

Godwin's Law states that "As a Usenet discussion grows longer, the probability of a comparison involving Nazis or Hitler approaches one."

Allow me to put forth something similar: "As a Usenet discussion regarding programming language features grows longer, the probability of a comparison involving assembly language or machine code approaches one."

PHP6 will have goto

2006-03-13T13:21:00.000-07:00

I know I’ve been hard on PHP in the past, but it looks like PHP6 is going to be a little better. They’re going to remove the insanity that is magic_quotes, register_globals and safe_mode. And as a concession to the several billion non-english speaking people in the world, they’re going to support unicode.

Then, for an encore, they’re going to add goto. That’s right. Freaking goto. They could add something that the language really needs, like closures and first class functions. But no. It’s goto.

Don’t you just love PHP?

A reddit by any other name

2006-03-06T22:49:00.000-07:00

Is it just me, or do services like del.icio.us, reddit and digg all seem to carry the some stuff?

For instance, a piece called Tour De Babel hit the reddit frontpage a couple days ago. Now, if you look at del.icio.us/popular/programming, you see that the aforementioned essay has the top spot.

Coincidence? Good thing? Bad thing? I have no idea.

Donald Knuth on programming as an art

2006-03-04T17:26:00.000-07:00

Some programs are elegant, some are exquisite, some are sparkling. My claim is that it is possible to write grand programs, noble programs, truly magnificent ones!

The above paragraph is from this essay by Donald Knuth on programming as an art.

IE7 motto: "Almost as good as Firefox!"

2006-02-17T11:15:00.000-07:00

IE7 will offer several exciting new features, including tabbed browsing, "web feeds" (RSS/Atom support), and some revolutionary keyboard shortcuts.

Seriously, kudos to Microsoft for copying Firefox's keybindings. It's nice to see that instead of what Microsoft usually does to standards. (Not that Firefox's keybindings are a "standard" by any means. It's just that Microsoft has a repuation of, er, shall we say, "embracing and extending" standards.)

Obscure UNIX utility of the month: "units"

2006-02-14T11:54:00.000-07:00

The author of The case of the 500-mile email uses a utility I hadn't seen before, "units".

~$ units
2084 units, 71 prefixes, 32 nonlinear units

You have: centimeters/minute
You want: furlongs/fortnight
        * 1.0021455
        / 0.99785914
You have: 720 miles
You want: kilometers
        * 1158.7277
        / 0.00086301554

It can be used non-interactively as well:

~$ units gallon liter
        * 3.7854118
        / 0.26417205
~$

Granted, if have net access, you can just use the Google calculator for this, but it's still pretty neat.

The miracle of IRC

2006-02-04T22:37:00.000-07:00

IRC is great. You can converse in realtime with anybody on the planet, and have deep, meaningful interactions that help us see things from other points of view and remind us that, deep down, we're all just a bunch of selfish jerks. Ha ha! Little bit of blogger humor there.

But seriously, IRC is full of deep, incisive commentary. Like this gem:

<meriad_> Am I just a sappy bloak or is a Walk To Remember frekain sad
<meriad_> IM IN tears here
<meriad_> :
<meriad_> (
<meriad_> :(
* meriad_ sobbss
* meriad_ wANNNNNHHH
<PurpleSmurf> why?
<meriad_> its so sad
<meriad_> PurpleSmurf he falls in love with this chick who has a terminal
and he didnt knoow and shit
<meriad_> PurpleSmurf u gotta see it to understand
        -- Seen on ##linux (freenode)

Just warms the heart, doesn't it?

Playing chess online

2006-01-11T23:09:00.000-07:00

After an 8 or 10 month break, I've started to regain interest in playing chess online. For "normal", realtime games FICS (Free Internet Chess Server) is nice. A couple of days ago I found a free corresponence chess service: Net-Chess.Com, on which I've started a handful of games. We'll see how it goes.

My handle is AndroFlux on FICS, and jcreigh on net-chess, in case anybody wants to play me.

Why blog?

2006-01-08T15:55:00.000-07:00

Lots of people, including me, have a blog.

Why?

Most blogs are senseless, stream-of-consciousness drivel. Including this one. There are, of course, bloggers whose posts are well written, thought provoking and profound. But they are the exception, not the rule.

So my first guess would be that blogs are journals for nerds. That theory fits me. But there's this whole other class of bloggers. You know the ones I'm talking about. They're in their teens, their twenties. They've got a blog on Xanga. They IM. They email. They use the internet (actually, most of them don't know that the internet is. They just use the word "internet" to mean "the web") as primarily a social tool. Why do they blog?

Couldn't tell you. Probably, they know people to whom their posts are significant. But it's hard for me to imagine, because the posts all seem to look like this:

Woke up this morning. Happens every morning, but still surprising. Couldn't decide whether to have eggs and bacon or a muffin. Had both. Wasn't as good as I had hoped. In fact, was the worst breakfast I've ever had. Wanted to kill myself. Listened to Green Day to try and cheer me up. Didn't work. Went to my sucky job. Took the interstate, which I usually don't do, so I got stuck in traffic and was late. My boss yelled at me. Had a bad day. Got home. Decided to blog about my most trivial experiences, decisions and emotions in short, incoherent sentences.

I read posts like that and think, "Who cares about you and your stupid problems? Write about something interesting! Write about something important!". Then I decide to be part of the problem by blogging about it.

Pet Peeve of the day

2006-01-04T23:35:00.000-07:00

Ebay makes you logon in order to search completed items. Why do they do this? Do they think that making me jump through hoops to use their service will make me want to buy more stuff on ebay? Do they like to put obstacles in front of their users? Probably they just like to tick me off.

Blogger bug

2005-12-13T13:13:00.000-07:00

Blogger strips out the newlines in a message posting by email. This makes trying to mark things up with a <pre> tag pretty useless. Observe:

 There should be a newline right here: <- The "<" character should be the first character in this line. This should be a new line as well.

See? I've reported this twice, and nothing has changed.

Disturbing

2005-12-12T11:09:00.000-07:00

While debugging a version of Conway's game of life that I was writing, my program became unresponsive, so I opened another terminal and typed:

 ~$ killall life

rss2email, mutt and lynx

2005-12-02T10:21:00.000-07:00

I've recently begun using rss2email to read RSS feeds in mutt. Of course, to do this, having mutt set up to read HTML emails in a must. In my .mailcap:

 text/html; lynx -assume-charset=%{charset} -dump -stdin; copiousoutput

My my .muttrc:

alternative_order text/plain text/enriched
auto_view text/html

The "alternative_order" is to ensure that in a message that has both text/plain and text/html as alternatives, mutt will select the text/plain. (see the section 5.5 of the mutt manual for more on this.)

Also, I've hacked my local copy of RedCloth to not produce "smart" quotes or other tricky HTML entities, so the produced HTML should be more friendly now.

Scott Adam's take on cloning

2005-12-02T09:44:00.000-07:00

Scott Adams has an interesting take on cloning.

Movies made from video games

2005-12-01T13:47:00.000-07:00

Oddly enough, some of the movies made from video games actually made money.

What's so great about the web?

2005-11-29T16:22:00.000-07:00

Why are blogs web-based? We’ve had mailing lists and NNTP since the dawn of time, and Trackback/Pingback are basically reinventions of cross-posting and the “References:” header.

So why web-based? Why don’t we string together some NNTP servers into a non-usenet network and hand out “newsgroup” names in some standard way. (“country.first.middle.last”?) Then if I wanted to post about something somebody else said, I’d just reply and cross-post it to my blog. Then we get the functional equivilent of comments, RSS, trackback and pingback for free.

So why is it this way? Why do people love the web so much? Why are we trying layer state on top of a stateless protocol? Why are we trying to make desktop applications in browsers with “AJAX”? Would it be so hard to design a protocol that’s actually designed for UI? It’s okay to reinvent the wheel if the current one is square. In our haste to be able to use the web for anything, have we doomed ourselves to having to use the web for everything?

The web has its uses, certainly. But it’s not the protocol. It’s just one. Just a nice way way of getting data from point A to point B. And HTML is just a markup language. It’s amazing what we’ve been able to do with it. But I tire of kludge-up web “applications”. I tire of trying to craft a meaningful UI around the limits of HTML/HTTP. I and think, “there must be a better way!”. But sadly, right now, it appears there is not. As they say, “that’s life”.

Bush Braces As Cindy Sheehan's Other Son Drowns In New Orleans

2005-11-23T15:59:00.000-07:00

I found this funny.

Doom ported to iPod

2005-11-09T23:03:00.000-07:00

After you get Linux running on a digital music player, the next logical step is to get Doom running on it.

Untrusted computing

2005-11-06T17:34:00.000-07:00

Yesterday, I bought Switchfoot’s latest CD, “Nothing is sound”. What I do with all my CDs is immediately make a copy of it, so the original can stay safely in its case, and it’s a CDR that I don’t care about that gets thrown around in the car. When the CDR gets a scratch, I clone off a new one, thus giving my CDs a kind of Duncan Idaho immortality.

I don’t have a burner in my Linux box, so I popped it into my parent’s Window PC to copy it. A window popped up and asked me to agree to a license. I thought “Oh, they’ve put a music video on the CD”, and clicked agree. With no futher prompting, a progress bar marched from left to right, and then I was told that my CD-ROM drivers were to old to read the CD, and that they had been updated, and all I needed to do now was click a little “Reboot Now” button, and the “Enhanced CD” installation would continue after a reboot.

So I rebooting, thinking this is probably some DRM crap but wanting to give them the benefit of the doubt. Big mistake. After the reboot, I copied the CD, put the copy into a CD player and got…static. I began thinking thoughts about the recording industry that, while unprintable, are, in my opinion, completely true.

Whatever patch (“patch” is actually too kind a word. “virus” is more accurate.) was installed, it disabled any sort of digital audio extraction for that CD. I couldn’t even play it a standard player. (Other, standard CDs could read fine, so that’s one thing they didn’t do wrong.) They probably have some little player that gets around their malware, but I didn’t try to find out.

So I ended up ripped the CD with cdparanoia on my Linux box, and copying the wav files over the network and then burning them. And I ran system restore, and after that, I could play the CD in Winamp and probably could have ripped it fine.

I went back and actually read the EULA. It actually says all that will happen if you click agree. So, I was warned that malware was going to be installed on my computer, I just made the mistake of thinking that Columbia Records were not evil corporate weasels. I wonder what their home life is like. “Hi honey, how was work?” “Great! I just screwed millions of legitimate customers!”.

Lesson of the day: Don’t run Windows. If you do run Windows, disable autorun. Programs from major record labels are not to be trusted.

Firefox: Middle click on javascript links

2005-09-27T21:32:00.000-07:00

Smart Middle Click, a firefox extension, makes middle-clicking on a javascript link actually open it in a new tab instead of just opening a blank tab.

Now I merely strongly dislike Javascript links, instead of hating them with a burning passion.

Thud!

2005-09-26T22:11:00.000-07:00

Terry Pratchett has a new book out: Thud!. Excerpt. It’s a Discworld, and it’s about the Watch, so should be fun. I’ve got it on hold at the local library, but there’s probably scads of people ahead of me in line.

Brave New World

2005-09-06T19:56:00.000-07:00

An Australian court has ruled that Kazaa is resposible for copyright infringements on their network. Of course, Kazaa uses FastTrack, a decentralized system, so it’s nearly impossible for them to do anything about it, but that’s beside the point.

The thing that many business models will be unable to cope with is this: The economic cost to transfer information is very close to zero. If somebody wants to get an MP3 of $ARTIST from point A to point B, it’s so cheap to do so that most people would consider it free. (as in free beer.)

I not saying that all information is free as in free speech, or that it should be. It’s just that if two people want to exchange information, whether copyrighted or not, they can, and there’s no way to stop them. There’s things that can be done to make it harder. The RIAA’s current strategy of suing 15-year olds is one. Outlawing crypto entirely is another. But as long as arbitrary information can be exchanged, there will always be some way for a sufficiently determined person to circumvent the obstacles placed in their way.

This is going to be awkward for a while. For instance, if/when usable e-book readers become widespread, there’s absolutely no economic reason why libraries should exist. Libraries exist because there’s a limited number of books. But when the book is stored electronically, everybody can have a copy. But that doesn’t work at all with the concept of selling books, so there’s going to be the same sort of thing going on then with books that’s going on now with music.

It may be that the entire concept of intellectually property will break down, and that no one will be able to make software, books, music, art, or anything else that can be stored electronically, for a living.

Or, it may be that “trusted computing” (“untrusted computing” would be a better word) will become widespread. This would mean that you lose the right to do what you wish with your computer, and in exchange people with IP can make lots of money.

Or, it may be that something else entirely happens. That IP becomes weaker, but does not disappear entirely. That the freedom of the many is deemed more important than the prosperity of the few. That the marketplace adapts to this strange new world where information can be transmitted freely, but doesn’t have to be. That some business models fall by the wayside, but others spring up to take their place. That is what I hope for.

Ready or not, here comes the future.

Star Trek IV

2005-09-05T20:29:00.000-07:00

Just watched Star Trek IV. The plot involves traveling back in time to save the whales. I kid you not. If you don’t believe me, read the Wikipedia article I linked to.

There are several disappointing things about the future. For instance, computer display technology has regressed considerably, and we’ll be back to using EGA 200 years hence. Also, it turns out that they “don’t use money” in the future. Everytime they mentioned this fact, I kept wondering, what do they use in the future? Faster than light travel, okay. Time travel, okay. Whales as a higher intelligence, okay. But communism working? Really now, you expect me to believe that? :-)

Kirk is at his preachy best, calling people in 1986 a “extremely primative and paranoid culture”. People of the 23rd century are, it appears, far superior in every way to 20th century man. Except, of course, that they’re still judgemental self-righteous twits.

Still, that’s what makes Star Trek fun to watch, and in that area Star Trek IV does not disappoint.

Tau Zero

2005-08-30T21:13:00.000-07:00

I just finished Tau Zero by Poul Anderson. Good stuff, read it if you get the chance. Reminded me somewhat of the Isaac Asimov short story The Last Question

If you're wondering who to blame...

2005-08-30T19:01:00.000-07:00

19:20 -!- Netsplit zelazny.freenode.net <-> irc.freenode.net quits: caff-work, stefan, thoran, VeerZ
19:20 -!- Netsplit over, joins: thoran, stefan, caff-work
19:21 -!- Netsplit over, joins: VeerZ
19:22 -!- mrsolo [n=mrsolo@dsl092-025-194.sfo1.dsl.speakeasy.net] has quit ["Leaving"]
19:24 < rue> Is it just me or have we had a lot of splits?
19:25 < imperator> it's you
19:25 < rue> Hm
19:25 < imperator> it's ALWAYS you
19:25 < imperator> netsplits? rue
19:25 < imperator> syntax errors? rue
19:26 < imperator> world hunger, famine, war, disease - rue, rue, rue, RUE!
19:26 < dagbrown> Trolls?
19:26 < imperator> rue
        -- #ruby-lang on freenode

When I first tried to post this via email, Blogger ate the newlines in the message, and since the log snippet is marked up with <pre> it made the log pretty useless. So I reported this problem to Blogger, and then did a cut 'n paste into the web interface, which is somewhat of a pain. I think it's rue's fault. :-)

Who knows what I want better than me?

2005-08-30T18:24:00.000-07:00

A couple months ago, I ran into something I hadn’t seen before. I googled for something, clicked on a link, and found that my search term was hightlighted on the page. Obviously, people are getting clever and looking at the referer to see if it’s from a search engine and pulling out the search term.

Since then, I’ve seen it a couple more times. I don’t like it. If I’d wanted it hightlighted, I would. But it’s a minor thing, so I’m trying to put my finger on why I mind it so much. Maybe it’s a control thing: I don’t want some PHP monkey coder telling me that I’m obviously using a browser without adequate searching features, so he’ll just step in and “fix” it for me. Heck, as long as they think they know what we want better than we do, maybe they should look at the User-Agent and only give highlighting if it’s IE. :-)

PHP Magic Quotes

2005-08-28T12:53:00.000-07:00

PHP has a “feature” called Magic Quotes. Basically, if it’s on, all user data (GET, POST, cookies) is automatically escaped for use in a SQL query. This, in and of itself, is not too horrible, it just makes you have to explicitly un-escape instead of explicitly escape. I still think it’s a bad idea, because it’s designed to let you drop request variables directly into a SQL query without validation, which is still a bad idea, even if SQL injection isn’t possible.

But do you know what they did? They made it an option. That’s right. One PHP hosting service might have it on, and another might have it off, so you have to code for both cases. So you have to wrap getting request varibles into a helper function that checks for you at runtime and does whatever behavior you want.

This means that Magic Quotes actually makes it harder to do the right thing than if the feature didn’t exist! You have to go to extra work to make sure that your program works correctly in all cases.

On the other hand, if you don’t care about doing the Right Thing, PHP might just be for you.

Regrets

2005-08-25T21:04:00.000-07:00

I may not be the man I want to be;
I may not be the man I ought to be;
I may not be the man I could be;
I may not be the man I can be;
but praise God, I’m not the man I once was.
—Martin Luther King, Jr.

Python Challenge

2005-08-24T18:27:00.000-07:00

A couple days ago I found the Python Challenge. It’s a series of riddles designed to be solved with the help of Python. It doesn’t actually have to be Python: Most other languages would work just as well. I’ve been using Ruby. But, as their FAQ explains, a couple puzzles use Python-dependent features. So you might have trouble if you haven’t use Python at all.

Apple's four button mouse

2005-08-21T20:55:00.000-07:00

This is old news, but Apple is selling a four button mouse, which this FoxTrot comic refers to. Why did Apple wait so long?

Google "language" tools

2005-08-17T18:17:00.000-07:00

If you go to the Google Language Tools page, you’ll see some interesting “languages”, including Klingon, Bork, bork, bork!, Pig Latin, Elmer Fudd and Hacker (Unfortunately, Google does not appear to agree with the Jargon File definition, and this is just leet speak. Still hiliarious to view Google help pages, though.)

Fun tetris games

2005-08-15T18:03:00.000-07:00

In the “interesting tetris clone” department, we’ve got bastet, a tetris clone that actually selects the worse possible piece for you on purpose. Pure evil to play. And then there’s 1D Tetris. Yeah, you read that right.

EDIT: Almost forgot. If you ever feel the need to play a good game of Tetris without loading up an entire OS, you can always play ktris, a tetris game written in 8086 assembler that can fit in the boot sector.

Funny slashdot comment

2005-08-15T17:59:00.000-07:00

This comment was posted on a story about a documentary on the BBS era

Quote of the day

2005-08-13T19:46:00.000-07:00

A passage from Surely You’re Joking, Mr. Feynman!

There were a lot of fools at that conference – pompus fools – and pompous fools drive me up the wall. Ordinary foolks are all right; you can talk to them, and try to help them out. But pompus fools – guys who are fools and are covering it all over and impressing people as to how wonderful they are with all this hocus pocus – THAT, I CANNOT STAND! An ordinary fool isn’t a faker; an honest fool is all right. But a dishonest fool is terrible!

Converting text to HTML anywhere

2005-08-11T20:16:00.000-07:00

I posted eariler about how I’m using Textile to convert readable plain text to HTML. I’m using RedCloth, a Ruby library, but there’s also a Textile library for Python

Not extremely interesting in an of itself, (unless you like Python), but the author has posted a bookmarklet that allows you to select text in any textarea, and then click the bookmarklet to convert the selected text to HTML. It passes your text through a Python CGI running on his server, and you’ve got clean, easy HTML everywhere.

Infrequently Asked Questions in comp.lang.c

2005-08-10T21:09:00.000-07:00

Infrequently Asked Questions in comp.lang.c

Very funny non-answers to non-questions.

Posting via email

2005-08-07T15:04:00.000-07:00

Blogger has a nice feature where you can send email to a magic address, and then it automatically posts to your blog. I’ve set up some mutt aliases and send-hooks to filter mail to blogger.com through Red Cloth, which is a Ruby implementation of the Textile text-to-HTML language.

Now I don’t have to worry about matching tags, or making sure everything is properly escaped, and I’ll probably end up posting more often, which may or may not be a good thing.

A Conundrum

2005-08-06T20:02:00.000-07:00

Why can't I remember how to spell "mnemonic" without looking it up?

Assembly-like programming games

2005-08-06T12:22:00.000-07:00

A few days ago, I found AT-Robots, an old DOS game I used to play on my parent's 25Mhz 486SX Packard Bell computer with 4 megs of RAM. The basic idea is you program robots in an assembly-like langauge, and then they fight in an arena. If that sounds boring, this program probably isn't for you, go find something else to read. Anyway, AT-Robots runs fine under dosemu, so I've been trying my hand at making some robots. I wish I had my old ones saved somewhere so I could see if I've gotten any better over the years.

Also of interest is corewars, another programming game using an assembly-like language. What makes corewars different is that instead of telling your robot how to navigate a virtual physical space, you battle over the memory ("core") of a virtual machine, trying to overwrite the other programs. Self-modifing code everywhere. It's really interesting, but much harder for me to wrap my brain around than AT-Robot's simple turn and shoot style of robots.

"Things My Girlfriend and I Have Argued About"

2005-08-05T21:54:00.000-07:00

Wow, my third post today. Just like real bloggers, except without actual content and lower quality of writing. Oh, and since I'm using an off-the-shelf free blogging server, my blog doesn't look as nice, there's no (Ping|Track)backs, and there's a useless little "toolbar" at the top.

But other than that, just like real bloggers

Anyway, this is too funny not to post: Things My Girlfriend and I Have Argued About. Don't read while drinking something.

The future of the space shuttle

2005-08-05T20:43:00.000-07:00

Here's an interesting post about the usefulness of the space shuttle program.

Windows isn't ready for the desktop

2005-08-05T19:09:00.000-07:00

Here's another story about how Linux isn't for the desktop.

All the points he raises are, in my opinion, valid. The typical Linux distribution is not a great OS for the average user. But is Windows ready for the desktop? No, really? Of those "average users", for whom Windows is supposedly such a great platform, how many of them actually think that Windows is a great platform? When I talk to people who use computers because they have to, not because they want to, I've never heard anybody talk about how easy Windows is. I've never heard anybody talk about how everything is simple and clear, and nothing ever goes wrong, and life is good.

You know why? 'cause it's not. Computers are not easy to use. I don't care if you wrap it in a GUI, I don't care if you have a "desktop metaphor", I don't care if you've got tooltips, I don't care if you have a talking paper clip, computers are not easy to use. Period. We don't life in a perfect, happy world where people who's never used a computer before can sit down at a GUI and start clicking, draging and droping within minutes, his face aglow with magic of it all. Sorry, doesn't happen. Please stop telling me that Windows makes it easy for people with no training to use some of the most complex machines ever made. It doesn't, and pretending it does doesn't fix anything.

Of course, all this is just whining. If Windows, isn't good enough, what is? And if "nothing" isn't a good enough answer, then what do we do? I see people struggling to use their computers and I wish it were easier for them. I wish they could just do what they wanted simply and easily and not spend hours trying to fix something that they, and a fundamental level, don't care about. Of course, I'm selfish, so mostly I just wish they would stop having to call me with their problems. I don't know what a good user interface looks like. But I'm fairly convinced it isn't Windows, or anything else that I've seen.

What Business Can Learn From Open Source

2005-08-04T19:11:00.000-07:00

Paul Graham has posted a new essay. Quoting from the link:

When I say business can learn from open source, I don't mean any specific business can. I mean business can learn about new conditions the same way a gene pool does. I'm not claiming companies can get smarter, just that dumb ones will die.

PHP scope when require()'ing

2005-08-02T19:01:00.000-07:00

I know I whined about PHP in my last post, but this behavior ticked me off enough to write once again about the language I love to hate.

if you require() or include() a file, it gets the scope of the caller. So if you have a file like so:

$foo = read_some_db_table();
foreach($foo as $name => $value) {
        $libray_variable[$name] = $value;
}
# Define library functions and classes that use $library_variable

And the if you do a "require()" (or a "require_once()") when you have, say, a $name (or $foo or $value. And, of course, $library_variable, but presumably the risk is lower with prefixed names) variable, it gets clobbered by the required file. To avoid this, you have to stuff the init logic into a function:

function library_init() {
        global $library_variable;
        $foo = read_some_db_table();
        foreach($foo as $name => $value) {
                $libray_variable[$name] = $value;
        }
}

library_init();
# Define library functions and classes that use $library_variable

Okay, maybe I should figure out a better than than using a global to avoid hitting the database more than once. But still, I don't see any good use for having required files use the same scope. It binds you too tightly to the code you're loading: Variables you defined could effect it, and variables it defines could effect you. It's not an abstraction if you have to know implementation details to use it safely.

Once again, the behavior is well documented, but this doesn't seem like a good excuse to me. "Didn't you read the signs? The dragon eats someone every week!"

PHP Pop Quiz

2005-07-29T20:44:00.000-07:00

Quick! What is the output of this PHP script?

[jason@jpc ~]$ cat example.php 
<?php
        $strings = array("/bin/baz", "/usr/bin/foo", "/etc/goober.conf");

        foreach($strings as $string) {
                if(strpos($string, "/bin") == 0) {
                        echo "'$string' begins with /bin\n";
                }
        }

        for($i = 0; i < 5; ++$i) {
                echo "Number: $i\n";
                sleep(1);
        }
?>
[jason@jpc ~]$ php example.php 
'/bin/baz' begins with /bin
'/etc/goober.conf' begins with /bin
Number: 0
Number: 1
Number: 2
Number: 3
Number: 4
Number: 5
Number: 6
Number: 7
Number: 8
^C
[jason@jpc ~]$

What happened?

If you read the documentation for strpos, you see that it returns boolean false when no match is found. Due to PHP rather loose ideas of truth, the statement "false == 0" evaluates to true. You have to use the stricter "===" operator.

But what's wrong with the loop? The problem is the condition, "i < 5". This obviously should be "$i < 5". PHP sees the "i", looks for a constant named "i", and when it doesn't find one, it assumes you meant a string containing the name of a the constant. PHP would issue a warning when doing this, if E_NOTICE warnings were enabled, which aren't by default. So have have the string "i" in a comparision, when PHP then converts to a number. And what does PHP do with strings that obviously aren't numbers? It just uses a zero. So PHP tests for "0 < 5", and we have an infinite loop.

Moral: Always have all warnings enabled in php.ini, and read the docs carefully. (Or, if the option presents itself, don't use PHP.)

The right tools

2005-07-17T18:47:00.000-07:00

When I first installed Linux, I cast about for a good email client. The text-mode ones seemed too complicated. I just wanted to read mail. I can't remember exactly what I tried first. It may have been Mozilla Mail. At some point, I tried Evolution. But they all seemed too slow. Then I found sylpheed, which is pretty snappy compared to Mozilla Mail and Evolution. I used that for about two years, then, due to the way life works, I was without a Linux box for about a month, so I got my mail using gmail's web interface. The best thing you can say about gmail's interface is that it's better or at least as good as other web interfaces. The worst thing you can say about gmail's web interface is that it's a web interface.

So, once again finding myself in a real OS, decided it was time to try mutt. After throwing fetchmail, procmail and msmtp I was ready to go. Well, not quite. Ready to configuring everything, figure out why msmtp isn't sending, get procmail sorting the way I want, and then ready to go. Having only used mutt for an hour or two, I'm obviously not as adept at reading mail in it as I would be in sylpheed, or some other graphical mailer. But I can see how powerful it is, and I can see how, in the very near future, the time I spent setting it up will begin to pay itself back.

A similar thing happened to me when it came to choosing an editor. Emacs and vim were scary, so I used mcedit, a little "just press keys and they go onto the screen" type editor bundled with Midnight Commander. And that was okay. But then I took the time to learn vim, and I can edit much faster now than I could mcedit.

All this to say, the best tools usually have the steepest learning curves. Be nice if they didn't, but that seems to be the way it is. So don't be afraid to learn.

Linux and the greater good

2005-07-16T13:48:00.000-07:00

There's yet another story about how there's too many Linux distributions, too many toolkits, too many packaging systems, and if people don't start cooperating, Linux will never succeed on the desktop, etc.

Notice how people talk about this: "Linux" (ie, the tens of thousands of developers worldwide writing the software that together make up what we call a Linux system.) should have this, "Linux" should have that. Fewer, more powerful distros, tools to do what I want. People who talk likes this are essentially saying to people working for free: "Write my code". If you don't like it, shut up and code.

Secondly, is having lots of distributions really all that bad? For broad view of this, see Rick Moen's excellent essay Fear of Forking. But in the case of distributions, do you ever hear anyone talking about how great it was back when you only could use SLS? I wasn't using Linux then, so I googled to make sure I was right about SLS really being the only game in town early on. I found this LWN article on early Linux distributions. Notice this bit:

SLS dominated the market until the developers made a decision to change the executable format (if you remember the a.out to ELF conversion you'll remember this). This was not well received by the user base. Just around the time this happened Patrick Volkerding had taken SLS and adapted, modified, tweaked and cleaned it up making it a different thing all together. He called it Slackware. With the unpopular direction SLS had taken, Slackware quickly replaced it and became the dominant distribution used by nearly everyone. In fact it's still in use today.

What was, in essense, the first distribution, forked because people didn't like it. People didn't like it, so they changed it, and made it their own. So, in what for the lack of a better word I shall call the "mind" of a Slashdotter, what should have been done? Indeed, would they have supported Linux in the first place? Or would they have said, "There's enough Unixes. Don't make another."?

The other Jason Creighton

2005-07-11T21:58:00.000-07:00

I did an ego search on Google and found this guy. He's an aspiring musician with a frame-based website.

Monitor specifications and common sense

2005-07-11T20:18:00.000-07:00

So I'm trying to find the model name/number on the el cheapo 15" monitor I'm using right now. It says "Mag Innovision" on the front, and the back of the monitor is completely blank. Nothing about FCC compliance, no manufacture date, nothing. They decided to, in a moment of brilliance, put the serial numbers and whatnot on the bottom of the monitor. So to see the model number, you have to turn the monitor around, and tilt it at about a 45 degree angle to read it. Turns out it's a "DX15F". Great, I google for it, find the specs no problem, enter them into xorg.conf, and away I go.

Then it hit me. Why didn't they just print the horizontal and vertical sync ranges on the back? Heck, why not the front? Didn't anybody think of this? Did somebody say "Hey, you know what would be good? If we printed the specs right on the monitor!" and then they didn't do it? This isn't rocket science.

I realize this is a non-issue with modern monitors, as they have some magic way to tell the video card what they support. Come to think of it, I don't even know what that standard is called. It's invisible. It just works. In my experience, anyway. I'm sure lots of people have horror stories to tell. But it's a lot better than having to plug in the numbers yourself, or else use some flickering VESA mode.