All this got me thinking about and reminiscing about compilers. In the early days of computers the only way a high school nerd could practice programming was to get shared time on a mainframe. I recall when I was young it was possible to do that for a time by paying some money to Northwestern. Of course you had to go there which meant you had to schedule it and, being a suburban student, arrange a ride all the way down there from your parents. This would have been a slow way to learn programming but was the only option for kids a few years older than I.

By the time my brother Alex and I were getting into programming you could get a personal computer in your house and use it whenever inspiration struck. For us that was essentially every day after school. We started programing in BASIC and it was amazing for kids like us. You programmed instructions and ran the program and sometimes it did what you thought it was going to do! Mostly it just did something weird because, being a child, you had programmed a bug into it. Some of our finest bugs were accidental infinite loops because you had to make the call about how long had it been running and was it just a slow operation or was it never going to hit the loop exit condition. We bought books and wrote code and learned to program by doing.

Alex was a proper nerd obsessed with Star Trek and wanted to write a Star Trek game. Even back then this was hardly an original idea. That was probably the first thing the first guy who took delivery of a commercial mainframe wrote. But this was going to be great, the best Star Trek game ever!

BASIC was too slow so we switched to Pascal which was the first language we learned which was compiled. This promised superior speed but involved a time consuming compilation step. “Time consuming?” my young imaginary reader is now chuckling. That’s right, back then compilation of small programs took time, like enough time that you could get up and go do something else and come back and see if it had finished.

Teenage boys aren’t exactly known for their patience and I was probably bad even by those standards. But Alex, normally mild mannered Alex, would turn into a rage machine when compilation would fail. I mean imagine it, we program twenty minutes straight compile for five, ten, fifteen (am I exaggerating in my memory?) minutes and then it would fail with a bug and Alex would slam his fists down on the keyboard! They built hearty keyboards back then probably for exactly this reason.

You had to be careful, so very careful. And in a way it could make you a better programmer. Better in the kind of way that craftsmen pride themselves. That planning, that following of procedures and incorporating systems built around old mistakes, even ancient mistakes made by someone else, becomes your pride. You can produce good work that way, great work even, but it limits you. It sets maximum sizes of projects. It make collaboration difficult. Good work ends up limited to the most a given practitioner can fit in his head.

Over the decades compilers got faster until compilation seemed like nothing. That’s great for someone like me who is foundationally impatient. You can see results right away. It shows you all the bugs at once. Depending on your language choice, the compiler catches a bunch of things that would have screwed you at runtime.

This makes you lazy. You type something you think is right but don’t check the documentation to make sure your syntax is correct because that would take more time than letting the compiler catch it. You get, by old standards, sloppy. You don’t get as many things right the first time. You feel a little guilty.

But then you find that freed from the need to focus obsessively on syntax and typos and similar concerns, you have brain space for higher level concerns. This in turn makes it possible to create progressively larger projects. It makes more advanced elegant solutions more likely to emerge because the ability to be less perfect as a coder frees you to know more about a domain (such as medicine) and to focus more on the user experience. Faster compilers is one of the reasons we have PhotoShop, GarageBand, Google, The World Wide Web, YouTube, Amazon.

That in turn got me thinking, not “where are the better tools for medicine” but rather “what would be better tools for medicine?” What are or will be the GarageBand and faster compilers of digital medicine?

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s