Jay Fields

That is pure and utter FUD I'm afraid. My team has been working with Clojure for over 8 years now. We have tons of code in production, and we don't have any problems maintaining these projects. Furthermore, there's absolutely no empirical evidence to support the notion that static typing results in statistically significant reduction in defects, speed of development, or ease of maintenance. Considering how long both disciplines have been around, and the sheer amount of software written in each, that's quite the elephant in the room. I also have no idea who the people migrating from Clojure to OCaml, Haskell, or F# are. I don't think I've seen a single story about a company doing that.

My experience is that dynamic typing is problematic in imperative/OO languages. One problem is that the data is mutable, and you pass things around by reference. Even if you knew the shape of the data originally, there's no way to tell whether it's been changed elsewhere via side effects. The other problem is that OO encourages proliferation of types in your code. Keeping track of that quickly gets out of hand.

What I find to be of highest importance is the ability to reason about parts of the application in isolation, and types don't provide much help in that regard. When you have shared mutable state, it becomes impossible to track it in your head as application size grows. Knowing the types of the data does not reduce the complexity of understanding how different parts of the application…

I have to agree that PP loses value when you have many senior level programmers on the team. The biggest value in PP, in my personal experience, is transfer of knowledge and experience. This applies mostly to teams with huge gaps in experience (juniors vs. seniors) or new team members that need to be caught up to speed with the codebase.

If the talent level is the same (and by talent I mean having the innate passion and ability to learn, not having actual knowledge) the knowledge of the collective team members will eventually equalize through the initial PP sessions.

Like the author said, the context of the team and the general strategy of the company (i.e. maintaining a project vs developing new features) are the most important signals when determining the programming tactics (i.e. PP and self-learning) to reach those goals.

P.S. The link at the bottom of the article (http://blog.jayfields.com/2011/08/life-after-pair-programming.html), provides two great team contexts for when pair programming succeeds and when it fails. Definitely take a read on that.

This is great, and it is also worth reading "Destructuring in Clojure and Ruby":

http://eyeofthesquid.com/blog/2013/09/29/destructing-in-ruby-and-clojure/

which has some great comparisons. As it says:

"As with many things in Ruby, the better question than “Can it be done this way?” is “Is it wise?”. "

There is a lot that you can do in Ruby that is more gracefully done in Clojure. Brian Carper brings this out even more clearly with his post "Keyword Arguments: Ruby, Clojure, Common Lisp":

http://briancarper.net/blog/579/keyword-arguments-ruby-clojure-common-lisp

That post shows the exact point where keyword arguments in Ruby can become ambiguous, which is the exact moment that Clojure's clarity becomes obvious.

Also, Jay Field's post on the subject of Clojure destructuring is where I got a lot of practical starting ideas (such as using the :keys directive):

http://blog.jayfields.com/2010/07/clojure-destructuring.html

> What we call technical debt is really best analogous to an uncovered short sale

Steve Freeman famously described it as an unhedged call option:

https://jaxenter.com/bad-code-isnt-technical-debt-103059.html

The key difference between a short position and a call option is that the former is linear, whereas the latter is not: if things let a little bit worse, a short will lose a little bit of money, whereas a call will cost nothing, but if things get a lot worse, a short will lose a lot of money, and a call may lose an enormous amount of money.

Someone who actually works at some dodgy trading company argued that some kinds of debt are like options, and some are like debt - and so potentially, some are like shorts:

http://blog.jayfields.com/2011/03/types-of-technical-debt.html

So now we just need to calculate our technical debt portfolio's delta, beta, vega, theta, rho ...

Whether to pass in a single dict/object/map/assoc-list or individually separated arguments is a tale as old as LISP (JS has some FP roots if you squint hard enough) and most LISPs (and JS has started doing this as well) mitigates this with destructuring:

Common Lisp: https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node252.html

Clojure: http://blog.jayfields.com/2010/07/clojure-destructuring.html

JS: https://simonsmith.io/destructuring-objects-as-function-parameters-in-es6

Vaguely interesting article to me. It's basically a reality check for this: http://blog.jayfields.com/2009/01/cost-of-net-negative-producing.html

In short the reasons why you a good programmer can't remove all the "bad programmers"

1. Working out who is good and bad is hard
2. It would involve too much politics that you may not be good at
3. You look like a jerk if you besmirch your co-workers
4. It's easiest for companies to hire based on "years of experience"