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.

I don’t blog here any more; see https://jameshfisher.com. Also see Vidrio for Mac, the holographic presentation app from the future: https://vidr.io