An old idea in a new context is new.

“Ideas don’t spring fully formed from the mind of an individual. Ideas emerge between people.”

Avdi Grimm, in his closing keynote at Southeast Ruby, told how when he sets out to write a talk, he wants to go out on his deck and walk back and forth until he squeezes the ideas out of his brain. “That works a little, but it’s a slow trickle. Then I phone a friend, and the ideas gush out.”

People think together. Through direct conversations, and through what we write and what we make.

Also at Southeast Ruby, Brandon Weaver talked about how programming languages like Ruby evolve by incorporating ideas from other languages (with a magic book! and 62 original drawings! of lemurs!). When people write horrifying gems to make Ruby to look like Scala, that’s a step in the evolution. Why do it? because we can. To let people see something new. That’s art, man.

And in the opening keynote, I talked about how ideas don’t belong to one canonical source. If some idea has been around (published) since the 70s, and someone recently made it useful in a new library, that is new work! If you find an idea in an article and apply it in your context, that is new work! If you explain a concept to someone who didn’t understand it before, new work! Heck, if you send a link to someone that gives them the explanation that they needed in this situation, that contributes to the idea. It draws a line between the idea and a person, in a context where it is useful.

But what about attribution, about credit?

If you find use in work published by someone in academia, please go to lengths to give them credit, and link to their work publicly. Attribution is currency in academia; it’s scarce and necessary to careers.

My favorite part about naming people who carried an idea to me is that it shows that nothing springs fully formed out of my brain. Everything is a synthesis, a reapplication in a new situation, a restatement — all these are new work.

For me personally, attribution is not scarce. Spreading ideas has intrinsic value. That value also appears between people, in conversation. The reward is who I get to talk with.

In his keynote, Avdi quoted Abeba Birhane‘s work, on “A person is a person through other persons.” None of this is worth anything, alone.

Before balance, separation.

We don’t program in a language, these days: we program in systems. I may write Clojure, with ring and schema and clj-http and clj-time and test.check and lein and jetty and many more inclusions. I may write Scala, with akka OR with scalaz and Shapeless, or a weird combination.

We never programmed in a language: we always programmed in systems. Dick Gabriel discusses the subtle paradigm shift when researchers separated the two, when the science and engineering of software parted ways in the 1990s. Before that, “language” and “system” were used interchangeably in some papers.

This is a valuable separation: now we can optimize each separately. In particular, languages are designed for extensibility, for building systems on. Both Scala and Clojure aim for this, in different ways. Let’s have all the existing components on the JVM available to us, and make it clean for people to build new ones. Languages are seeds of systems, and language designers seed of communities.

Take Node.js — it is not a new language, but it might as well be: it’s a new system. ┬áThe creators of Node and npm seeded a system: they left obvious necessities unimplemented, and made it easy to implement them. A community formed, and built something bigger than one small team could sustain.

When you choose a programming language, recognize that what you’re choosing is a whole ecosystem and the group of people who work on it, growing and evolving that system. Do you want that to be stewarded by a strong company? or full of individual discoveries and advances, in many open source communities? to hold you to a good style or offer free combinations of multiple styles? to be welcoming to beginners, or full of serious thinkers?

[Game: Match each of these generalizations with a community: Clojure, Scala, Haskell, .NET, JVM, Ruby.]

I’m glad that people separated languages from systems, because we can build better languages and better systems from the decoupling. Both are important, and need each other. I thought about this today while my child separated her S’Mores Goldfish into marshmallow, chocolate, and graham. She used this to produce a perfectly balanced bite.

And then she ate all the marshmallows.

Humility in programming languages

John Backus (pdf) distinguishes two parts of a programming language: “First, its framework which gives the overall rules of the system, and second, its changeable parts, whose existence is anticipated by the framework but whose particular behaviour is not specified by it.”

The framework part is all the built-in language constructs.

The changeable parts are everything we create in the language. Classes, methods, functions, modules, libraries.

Backus’s point is that strong languages are a platform for developers to build on. Adding a bunch of framework — for loops, case statements, new syntax — might increase productivity, but it’s what we can build on top of the language that makes it take off.

When Scala tries to be a SCAlable LAnguage, this in part of what scalable means. The language lets developers add to it.

For example –

Java and C# give us case statements, very restricted matching mechanisms that only work on constants. It was a Big Deal when Java added Enum and supported in case statements, in addition to int.

Scala has more pattern syntaxes, including matching strings and lists and arrays and tuples etc. Scala gives the program access to the matched parts.

F# goes one better and lets the programmer define patterns. Active patterns let the programmer create whatever matcher is needed, exponentially increasing the power of pattern matching.

For details and examples on active patterns, read my article at developerfusion.

In general, functional languages please Backus because they let the programmer create and use changeable parts in all sizes with minimal ceremony. F# active patterns exemplify this goal.

Let the language remain humble, and let its framework get out of the way of the changeable parts.