The James Test

A simple way to estimate how interested I’ll be in a given project. It’s a checklist; for each item, if the project fits the description, add the associated points. Points can be negative.

I will work face-to-face with peers: +100. On my own, I get demoralized, bored, edgy, stressed, and find it hard to concentrate. I want to speak face-to-face to my colleagues. Skype is not a substitute. I want to pair program. I want to moan about little problems and celebrate little successes. (If I work face-to-face with clients, that’s also good, but my main concern is working with peers.)

The project has clear, simple leadership: +50. This means I know who the client is, I know who is driving the project, and there is an unambiguous, short chain of command from them to me.

The project has a clearly written mission statement: +50. Projects without this are ambiguous, unfocused, and prone to feature creep.

The product market is zero-sum: -50. For example, high-frequency trading, or the military. I would like for my work to actually benefit society.

My role involves design and specification: +30. Design is more interesting than implementation. I like to work with clients to translate vague English requirements into program specifications suitable for implementation.

Uses a product produced by a company associated to my own: -30. This causes a conflict of interest and results in technological decisions being made for political/financial reasons.

The problem involves proper algorithmics: +10. Do I have to think about technical problems at a higher level than “how to implement this interface”?

The project is open source: +20. This is more about improving my profile than any moral stance on closed-source software.

The client asks for “experience of IDE x”: -20. This is a strong indicator that they are asking for a code monkey.

The project is not a pure web/app project: +50. I would like to get out of this box and work with unfamiliar technology, like low-level or esoteric hardware; or emerging fields, like biotech or Bitcoin.

The implementation language lets me program with values: +20. Are lists/sets/maps values? Are functions values? Are IO actions values? Are expressions referentially transparent?

The implementation language has a decent type system: +20. Decent basically means “well-typed programs can’t go wrong”. Polymorphism, variant types, no null.

The implementation language has a written formal semantics: +20. This is an objective test of subjective qualities: simplicity, integrity, and good documentation.

.             Values/20     Types/20     Semantics/20     TOTAL/60
Haskell 20 20 20 60
Standard ML 15 20 20 55
OCaml 15 20 10 45
Racket 15 10 20 45
Rust 10 20 10 40
Erlang 15 0 10 25
Clojure 15 10 0 25
Java 5 0 20 25
Swift 10 10 0 20
C 0 0 20 20
Scala 10 10 0 20
Lua 5 0 10 15
JavaScript 5 0 10 15
Python 5 0 10 15
C++ 5 0 10 15
PHP 5 0 10 15
Go 5 0 0 5
Obj-C 5 0 0 5

Uses Spring Framework: -20. I’ve apparently used it for over two years, and still don’t really know what it does or how it works. Annotations are for people who haven’t heard of macros or first-class functions.

Uses Maven: -10. Whoever designed this thing did not understand simple vs. easy.

Uses a SQL database: +30. “NoSQL” is meaningless. The only schemaless database is /dev/random. ACID is not just a barrier to ‘web scale’. Graphs are trivially modelled with two tables.

Uses an ‘ORM’: -10. The problem is your objects, not your relations.

The opinions above are my own, and not necessarily those of my employer.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.