The Polyglot Programmer

Big risk: prototype goes into production, as happens so often.

Go ahead and use these languages in production. Most of them are very mature and stable. Many of them interact with or run on existing tech (JVM, CLR).

Will you be able to find developers to support this new code and expand on it? Let your developers use some of these and I claim you'll be beating away good developers with a stick. Have only mediocre developers? Let them get better — or cut away dead wood that refuses to learn new things and keep the ones that enjoy learning and applying their new-found knowledge.

The ability to change, at run time, the way the language works (for example, message passing a la method_missing), the way that types behave, or change the way the type system behaves. Examples: method_missing, using Class#inherited to add methods to a class at run time.

Remember: metaprogramming is jus tprogramming.

Program is a series of mathematical functions. No side effects, state, or mutable data.

No side effects means after the execution of a function nothing else in the system has changed — no state changes, and to the ultimate extreme no input or output!

Makes code easier to test and easier to verify correctness.

Message passing between independently running chunks or objects. Autonomous individuals.

The difference doesn't matter for this talk.

Concurrent code is made up of multiple streams of execution. Streams can communicate and interact with each other. Concurrent code may be executed in parallel. Concurrent programs may use shared memory or message passing to communicate between concurrent subsystems.

Database transactions for memory.

State that can not change. Makes it easier for compilers and runtimes to reason about the code and what side-effects it may have, and make optimizations.

Software runs on different machines but acts as if it's running on one machine.

Read-Eval-Print Loop.

Code that writes code.

Code and data are stored in the same format. Lisp is the most famous example. Makes many things like code manipulation easy.

Defined below.

More syntax to support them. All implement a common supertype "sequence".

Runs on the JVM. Fewer parens than Java!

Unified set of functions that works on all seq-able types

Infinite lists

JVM doesn't support recursion directly (yet), so have loop/recur and supports trampolining.

A.k.a. pattern matching. Pull pieces out of data structures (lists).

State: your age Identity: who you are

In Clojure, identities (variables, references, actors) reference different descriptions of state over time.

Changes in state over time can be implemented very efficiently because of immutability. Values are immutable, persistent data structures. Updating an identity does not destroy old values.

• Reference (coordinated, sync access)
• Atom (uncoordinated, synchronous)
• Agent (async, fire (pass a function) and maybe forget)
• Vars (thread-local)

Coordinated vs. uncoordinated, synchronous vs. asynchronous.

Transients let you break out of strict rules around synchronized STM access, for efficiency's sake.

Define abstract types

…so pretty efficient

Traits: methods and field definitions. Mixins. Can mix any trait into any class.

• Hindley-Milner type inference
• Great for simple cases
• Overly complex if trying to build a library or for certain types of Java interaction

Pattern matching: destructuring. Used with match statements and case classes.

Useful for (X)HTML templating, I suppose.

• type system
• slow compiler
• IDE support still weak
• language still changing, not always backwards compatible
• docs not the best; books don't always cover everything you need

Unix and Windows

• Functional: can't change var's value after assignment
• Distributed programming with actors
• Concurrency
• Bit and byte stream
• Pattern matching (destructuring)
  • Used on method params and in match statement
• Tuples, Records
• Recursion
• List manipulation, great — string manipulation, not so hot
• REPL

• 300,000 on one machine no problem
• Pass data and functions
• Uses a mailbox

loop(State)
  %% ...
  loop(NewState).
  %

• Framework for Slave/Master monitoring and fail over

• Distributed database
• ACID
• Query using Erlang
• Cassandra, CouchDB

• Actors typically run in a loop, calling the loop func recursively at the end. If you pass in a new function that implements an improved version of the loop or even completely new code, your loop can call that function at the end, replacing the old loop with the new code. Voila! Hot code swapping.

No inheritance, generic types, or method overloading.

Interfaces are close to duck typing: define a set of functions. If your type implements those methods then you can be used wherever the interface is used. No need to declare that in your type, IIRC.

Trick: generic collections via use of the empty interface. The type of the thing that implements the empty interface is kept.

Inter-process communications. "in" and "out" channels produce and consume pieces of data (characters, ints, objects). Often used with goroutines.

Infinite lists, generators.

Cross-machine.

Small, lightweight threads. Executed in parallel.

Idiom: channel running in goroutine acting as consumer or producer.

• Functional, Hindley-Milner type inference

• Ruby: gems
• Python: eggs
• Perl: CPAN
• Groovy: ??
• Squeak/Pharo Smalltalk: Montecello
• Scala: sbaz

No Framework Needed: http://37signals.com/svn/posts/3103-no-framework-needed 37signals

REPL for building Spring apps

• lein for project management (dependencies, building)
• cake for pre-forking and more

There are a few, but I've read that if you use them you're doing it wrong. The standard library includes HTTP servers, templating, and more.