I see lots of things online that I’d like to share. Often I do that via Twitter, but inevitably the number of browser tabs climbs, each representing something that I feel is owed further thought or attention. This is that. The only organizing principle is that these notes are tech-centric; It should be unsurprising that some go back months.

Think Like The Web · Most good startups and even quite a few enterprises have sort of figured out which way the Web’s grain runs and how to avoid cutting across it. But I still see people and organizations being foolish in their obliviousness to how things work round here. So some of you might want to bookmark this piece by the estimable Jon Udell, because it concentrates as many core Web lessons in as small a space as I’ve ever seen done.

On Typing · In general, where possible, I prefer to create software using language with dynamic typing, such as Ruby and Erlang. In particular, I, along with many other seasoned developers, have pretty well run out of patience with the excessive ceremony and verbosity involved in creating Java programs.

Lots of people (lots of smart people) think I’m wrong, and that the benefits of static typing, particular in large-scale software, are huge. The next “secret weapon” in programming presents this argument at length, but with a new twist: It does not hold Java forth as an example of static typing, pouring scorn on that type system, saying things that I suspect will resonate with quite a few software geezers.

I’d find it convincing, except for two things. First, the alternatives on offer (Haskell and OCaml) have had a good long run and show no signs of becoming mainstream; the observation seems to be that nobody’s produced a language with a first-rate type system that ordinary developers want to use.

The second is that, in practice, I don’t observe that programs constructed with dynamic languages are more fragile and bug-ridden, or less maintainable, than those with static underpinnings; and I do observe that they get built more quickly.

The Ghetto · Much and all as I love Ruby, I also acknowledge that in many cases, its libraries are Not What They Should Be. It behooves us as a professional community to acknowledge this an think about how to fix it. In which spirit I offer Mike Perham’s The Ruby Stdlib is a Ghetto, with which I couldn’t agree more.

TDD Faster · Over on the 37signals blog (and does anyone else find the path /svn/posts a little weird as a place to anchor your blog? But I digress) we find The road to faster tests, which I thoroughly enjoyed. It’s plausible to disagree about the finer points, or even the ultimate necessity, for test-driven development, but it’s painfully obvious that, whatever your testing discipline is, when your tests take too long to run, that is A Bad Thing. Here’s how 37signals attacked that problem.

Tablet Sizes · There’s been an amusing back-and-forth about whether or not the iPad will get Apple’s “Retina Display”. Various usually-clueful people including John Gruber argued that if iPad pixel count is going to increase, it’d have to quadruple (twice as wide, twice as high) to simplify the scaling calculations. This contention seems absurd to me, for the following reasons:

  • The scaling problem just isn’t that serious and we pretty well know how to solve it. It’s easier on the Android side, which lets developers sort their graphical assets into a bunch of density buckets to make things easier, but I’d be surprised if it were going to cost Apple engineering that much lost sleep.

  • Quadrupling the pixel count is bloody expensive because in many (not all) situations, it means quadrupling the amount of computation to do basic things like animate a map or fill a page with text.

  • The Retina display just isn’t that interesting. Yeah, when you’ve been spending quality time with a super-high-res device like an iPhone 4 or Nexus One, you notice that the iPad screen looks a little fuzzy here and there. But who cares? Not the kazillions of people who are buying iPads. I also note that over on the Android side, the builders and the customers seem to like the trade-off of bigger screens with no more pixels.

    The Retina display is a fantastic engineering accomplishment, and as a typography geek I love it, but I don’t think it’s why the iPhone 4 is selling well.

Cross-Platform Nastiness · Alex Payne’s Shortchanging Your Business with User-Hostile Platforms is about why choosing “cross-platform” tools to build your outward-facing app might be a really big mistake.

This is something that hits pretty close to home, for me. At the end of the day I’m a huge advocate for portable Web technologies wherever they can possibly be used. But it might not be the end of the day just yet, because my day job is all about using a platform-specific software toolkit to deliver software. Yeah, it’s open-source and there are a lot of other reasons to like it, but still, I worry. Alex’s piece resolved my unease quite considerably.

Phone Money · If you’ve been to Japan, you’ve probably seen people paying train turnstiles and vending machines by waving their phones at them. This is based on a technology called Near field communication (NFC) which is fast arriving in phones outside of Japan. Tim O’Reilly argues, independently of NFC, that phones are powerfully attractive as payment instruments. I think he’s right.

Blackberry · I’m an Android guy and a RIM competitor, but I’m also a Canadian and I’d like to see Blackberry make a go of it. One of the things they’ve historically done wrong, in my opinion, is developer tools: crippled low-interoperability flavors of Java that you had to be on Windows to try to use.

I recently ran across BlackBerry WebWorks Development, which suggests they’re joining the current millennium in terms of developer tools. I have no idea what the right number of mobile platforms is (aside from being sure that it isn’t “one”), but I hope whichever selection survives includes Blackberry.

Android Stuff · There’s a GTVHacker web site, which has on offer Steps to get root. Which seems to me a good thing.

The Android API framework has always been pretty nice, but the testing tools have lagged behind. I don’t think this is due to lack of concern, but rather that it’s a hard problem, as anyone who’s written an Android app knows. I keep nearing noise about new Android testing frameworks coming out of the underbrush; for example Introducing Calculon – A Java DSL For Android Activity Testing.

I’ll be watching.

CoffeeScript · This isn’t news who’s been following Web tech closely, but I hadn’t previously run across this particular CoffeeScript page and I liked it. No, I haven’t tried yet.

Aaron Swartz · He’s this guy who’s 100 years younger than me and always has interesting things to say. In evidence of which I offer Squaring the Triangle: Secure, Decentralized, Human-Readable Names and A Censorship-Resistant Web. Read ’em and think.


Comment feed for ongoing:Comments feed

From: Ciaran (Jan 25 2011, at 03:35)

I don't disagree that 'Steps to get root' is a good thing. But buying a piece of hardware that requires you to hack and exploit loopholes in it to get control of it is not a good thing. I wish people would stop doing it, but I don't suppose they will.


From: John Hart (Jan 26 2011, at 16:54)

"The second is that, in practice, I don’t observe that programs constructed with dynamic languages are more fragile and bug-ridden, or less maintainable, than those with static underpinnings; and I do observe that they get built more quickly."

Exactly. I can't even think of the last time I had a bug in a dynamic language that would have been prevented by static typing.

How often does one really try to put the wrong type of thing into a collection?

Perhaps there are advanced types of static typing (monads, etc) that would let me make *helpful* declarations about program behavior that are currently inexpressible, but in 20 years of doing this I haven't used any. disclaimer: I have never used Haskell!


From: Andy Lee (Jan 29 2011, at 07:54)

Bruce Eckel also argued for dynamic languages in "Strong Typing vs. Strong Testing": https://docs.google.com/View?id=dcsvntt2_25wpjvbbhk

Linked from here: http://www.mindviewinc.com/Blog/OldestIndex.php

"...I began noticing that despite an apparent carelessness about type checking, Python programs seemed to work quite well without much effort, and without the kinds of problems you would expect from a language that doesn't have the strong, static type checking that we've all come to "know" is the only correct way of solving the programming problem."


author · Dad · software · colophon · rights
picture of the day
January 24, 2011
· The World (144 fragments)
· · Life Online (272 more)

By .

The opinions expressed here
are my own, and no other party
necessarily agrees with them.

A full disclosure of my
professional interests is
on the author page.

I’m on Mastodon!