Yehuda Katz - Ember.js in Philadelphia

Mozilla, Google, pushing boundaries of the browser, making js more efficient.

Still too much js over the wire ( is 284kb).

Ember Patterns

  • Models should stick around for a while during the lifecycle of the application.
  • Controller is transient, doesn’t need to stick around.
  • Template/view what has focus, etc.

Garbage Clean-Up

Define your object type so Ember can clean up efficiently.


The killer feature of the web.

  • Even single page apps should expose URLs.
  • Sharing URL is key feature of web.
  • The URL is the UI of the web.

Use of URLs

  • Bookmarking
  • Sharing
  • Emailing
  • Cmd-click

“If your app doesn’t have URLs it’s not a web app.”

Building apps in terms of URL state exposes use of URL sharing in unusual places.

Build app with URLs exposed by default.

“It’s never been a better time to be a web developer… except maybe sometime in the future”

asm.js compiles C to JavaScript. What?!

Web Components

Used to build better abstracitons where you can build your own HTML element class

Future Proof

  • Ember is just HTML, builds upon HTML, binds to DOM Via HTML
  • effort into Ember.js is about future proofing design
  • “future proof yourself, future proof your frameworks”

Coming Down the Pipeline

  • Modules
  • Classes
  • Object.observe
  • Array.observe
  • Proxies
  • Web Components


Object and array observers coming soon in chrome, Ember will be moving toward these patterns.

Angular.js compares every object to every object in DOM when something changes.

You don’t have to get/set is a plus but the hit on performance is a big minus.

Ember is not sacrificing short term performance for convenience. Ember will wait for features like proxies to ship in browsers before jumping the gun.

Don’t forget the feature that made the web in the first place: URL.

What’s New in Chef 11 at PhillyDevOps

Nathen Harvey Opscode, Food Fight Show co-host



Chef is automation platform to capture infrasturecure as code.

Think about infrastructure as collections of resources: users, files, directories, etc.

Your infrastructure evolves and can quickly grow out of control.

Chef configuration management to the rescue!

“Golden images are not the answer”

You can rebuild your entire business with 3 things:

  • bare metal resources
  • backup of data
  • source code repo

Chef recipes provide declarative interface into resources.

“Discoverable and searchable infrastructure”

first, what’s out in chef 11?

  • couchdb
  • ruby-based chef-server-api
  • depsolver, gecode, treetop
  • merb
  • openid support in webui

that’s cool but what’s new in chef 11?

  • postgresql
  • erchef
  • nginx
  • rails
  • bookshelf - abstraction on top of file system, much like s3
  • omnibus-chef server
  • chef-apply - allows to apply recipe without writing out full cookbook
  • partial search
  • users with key par
  • partials in templates

why rewrite chef server in erlang?

  • concurent, fault tolerant
  • distributed systems
  • complete chef server api rewrite

Hosted chef currently runs on mysql, but licensing complications forced opscode to ship open source chef with postgres only.

chef-server-ctl command to manage chef-server

chef-apply is the answer to problem of writing entire cookbook just to test something out chef-apply /path/to/recipe_file

partial search

partial_search(:node, ‘role:web’, keys: { ‘name’: [‘name’] }.each do |result| puts result[‘name’] end * instead of entire node, just the pieces you want * massive reduction in bandwidth and memory

Nodes are updated with ohai during chef run and then saved to node at end of chef run

cookbook - whitelist attributes

  • list attributes you want to return to the server
  • re-opens method and strips out attributes not on whitelist

knife user

  • users can have key pairs, just like clients
  • knife actions as a user instead of a client
  • post a public key when you create a user/client
  • knife user (11.2.0)

partials in templates

partials just go in with the templates. as you do.


  • treat local chef-repo and chef-server like a filesystem
  • knife download
  • knife diff
  • knife show
  • knife upload cookbooks/apache2
  • knife list

breaking changes

  • shef now called chef-shell
  • interactive shell for chef
  • no implicit node attr
  • no more node[‘foo’] = ‘blah’
  • attr files can access role and environment attributes
  • delayed nofiications run after failed converge
  • encrypted data bag item format change
  • chef-client lock so safe from simultaneous runs


  • Is their Opscode support for open source chef server? Yes.

  • Suggestion to send restart notifications via Chef only if file modified time is less than time service was last started. -@matschaffer

  • What does Chef use rabbitmq for? Persisting data into Chef search index. -@bear

  • Organizations don’t really exist in open source chef, you split them into separate chef servers to mock orgs. WebUI is also slightly different between open source chef and hosted chef.

  • What happens when two users edit a data bag simultaneously? You can encounter race conditions. There is no solution for this currently. -@justincampbell

Chef Workflows at Chef NYC With Etsy, SecondMarket, and Paperless Post


Daniel Schauenberg

The Etsy Way

  • every node runs chef client every 10 minutes
  • github enterprise
  • production env, dev env, testing env (runs every new version of cookbook on chef server)
  • knife-spork for workflow
  • run shef on dev vm to detect syntax errors, debugging
  • using a tool called Review (in house Etsy) to automatically create branch and pull request

The Etsy Workflow

$ knife spork check apache
$ knife spork bump apache
$ git commit
$ git push
$ knife spork upload apache

Changes should be in github before pushing to chef server so no one can ever override someone else’s changes on chef server.

knife spork upload is basically an alias for knife cookbook upload --freeze


production deploy

$ knife node flip testing
$ knife role flip test_role testing

$ knife spork promote apache
$ git commit
$ git push
$ knife spork promote  apapche --remote (production deploy)

other tools Etsy uses

  • chef-handlers - push failed run stack trace to gist, push to chat
  • knife-lastrun

  • github enterprise

  • dev vms
  • shef as dev env
  • chef server and knife spork as dev system
  • monitoring, notifications, graphs


Julian Dunn

how not to trample others when making changes

The SecondMarket Way

  • break cookbooks into individual repos
  • chef-cookbooks/{repo}.git
  • allows for independent development, tracking and merging from upstream and contirbuting changes
  • roles contain only data, roles do not contain run-lists
  • use a roles cookbook with all data versioned within cookbook, point to this for run list (?)

cookbook development

  • vagrant and virtualbox
  • unit tests with chefspec
  • integration tests: test kitchen with minitests
  • missing databags and search
  • develop against a chef server
  • chefspec can mock
  • cheftest environment
  • plugins:


  • spork, change versions per env, notifications to hipchat (hipchat handler runs on all nodes)
  • semantic versioning
  • auto updated along with jira

the future

  • more people touching chef
  • move toward more modular cookbooks: easier to change, one change doesn’t update entire infrastructure repo
  • improve unit test and integration tests
  • cookbooks in CI
  • code reviews

Paperless Post

Aaron Quint

The Paperless Post Setup

  • 5 staging environments (1 per team, 1 pre-prod)
  • 4 full time ops
  • 16 devs who can make changes
  • many different apps and technologies managed by chef
  • private vmware/vsphere backed cloud
  • hosted chef

$ /bin/knife kill me --now

the agony

  • managimg multiple versions of cookbooks for different devs in each environment
  • wanting to test small changes on different environments
  • lack of visibility when deploy changes
  • impossible to correlate changes in git with state in chef-server

The Paperless Post Workflow

  • chckout feature
  • name branch
  • do work
  • commit
  • pull request for code review
  • merge branch into staging
  • deploys to environment
  • sends alerts via email and campfire
  • runs deploy in viewable jenkins environment

The Paperless Post Deploy

$ pp chef deploy earth organization/repo

  • check out locally
  • merge
  • git diff to check all cookbooks changed in that diff
  • check latest versions of cookbooks in chef server
  • bump version in metadata and environment.json
  • commit and push to env
  • send deploy to jenkins
  • jenkins uploads cookbooks and environment file
  • send notifications to campfire/email

the minor discomforts

  • dealing with conflicts is hard, especially in metadata
  • $ pp chef boom resets one environment to match another environment version
  • version number becomes meaningless
  • doesn’t handle change to roles in that you cant scope a role to an environment or new cookbook very well
  • chef server consistency is problematic

to improve

  • more code review as part of process
  • simple roles that map to recipes so roles can be managed and tested at environment level
  • using secondary store to keep track of versions, perhaps with zookeeper
  • chef versions could be tied to SHA instead of SemVer

RedSnakePhilly 2013

A Field Guide to Ruby and Python

Pam Selle

Geek Kingdoms:

  • Python born in 1991
  • Ruby born in 1995

“Spaces are ultimately important in Python”

“In Ruby parenthesis are a vestigial appendage”

Ruby is known for:

  • readability
  • web dev with rails
  • ops

Python is known for:

  • data
  • scientific apps
  • use at google

Ruby ops tools:

  • vagrant
  • chef
  • capistrano
  • travis
  • puppet

Python ops tools

  • buildbot
  • some others

Ruby web tools:

  • rails
  • radiant
  • sinatra
  • padrino

Python web tools:

  • web apps
  • django
  • plone
  • pyramid
  • web2py
  • flask

Ruby science and data tools:


Python science and data tools:

  • pandas
  • numpy

Ruby interactive shell: pry/irb

Python interactive shell: ipython

Rails 4 / Ruby 2

Jearvon Dharrie

Goal: spark conversation about Ruby ecosystem as a Ruby programmer who wants Ruby to stick around

Ruby council proposal by Brian Shirai to combat the solo Matz benevolent dictator decisions.

Big changes between Ruby 1.8 and 1.9:

  • vm
  • encoding
  • io
  • threads
  • apis

RubySpec prososal:

  • know what works between versions with comprehensive test suite
  • runs against Ruby to keep versions on common spec


  • some shortomcings
  • no concurrency
  • no jit compiler
  • code base is messy, tests aren’t great

“When people say Ruby sucks, they mean MRI sucks”

Alternative Ruby implementations:

  • Rubinius
  • JRuby
  • Topaz
  • Maglev

Brian Shirai’s process:

  • documentation
  • RubySpec
  • implementation
  • debate
  • vote

We should all care about Ruby because it builds the langague ecosystem.

Testing Python Web Applications at Scale

Jeffrey J. Persch

If you’re a startup and you’re doing things right, you’re running fast and getting crushed by a wave.

Small scale mock ups with lots of ways to start testing.

What about load testing 1x vs 10x

Just log everything. Store it forever.

We love Python because it allows us to simply express complex ideas with readable code.

Monetate can test load against traffic from a previous day by replaying logs, replaying all traffic against different configurations. It’s a great way to learn things about your infrastructure you wouldn’t have anticipated.

Use Python to make simple tools to push your systems to the test

Using RubyMotion for rapid iOS development

Justin Campbell

1st iOS app:

  • iphone 3g
  • new app store
  • first mac
  • inexperienced
  • everything was under NDA so it was hard to get answers

2nd iOS app:

  • worked at philly startup
  • consultant built app
  • only mac guy in the office
  • app in phonegap
  • telephony c library
  • hard to understand

3rd iOS app:

  • RubyMotion
  • May 2012
  • prototype app in 4 hours
  • finished and polished in 1 month

RubyMotion released by @lrz

  • Former MacRuby dev @ Apple
  • created hipbyte company
  • $199 for RubyMotion
  • not including iOS developer license

Ruby compilier for iOS

  • not a cross compiler, does not compile into Objective-C
  • rake workflow
  • 1.9ish core library
  • missing require, binding, and eval (app store doesn’t want arbetrary code running)
  • adds named parameters

What else is cool about it? It has types, selector shortcuts, pointers, concurrency.

To create a new app you just:

$ motion create some_new_app

Ruby 3x more concise than Objective-C (LOC comparison)

Also! * rake on command line * use any editor you want * amazing community



Vision Spreadsheet: An Environment for Computer Vision

Scott Determan

  • Spreadsheet meets computer vision meets SciPython
  • Numeric spreadsheets: grid of cells with numbers
  • Visual spreadsheet: cells contain images or image computation, measurements, plots
  • Change a call visually, all dependent cells change

Example project to identify white blood cells based on image analysis

  • image manipulation to extract intensity to get a usable represetnation of the image
  • slider to move threshold of image attribute
  • can write Python code to inject into a cell and manipulate data
  • and you can manipulate video in cells too whoa!

The Patterns You Can’t {See, Refactor}

Kyle Burton

Lisp macros are worth your time to learn, most powerful feature for expressiveness in your code.

Language features that you don’t yet understand, the ones that look weird, they likely wield a lot of power. Get to know them.


  • if, for, while
  • class, function, var, package
  • def, try, catch, throw

special powers

  • reduce syntax
    • clojure has “..” macro to chain together method return to another method call
  • defer execution
    • easy way to say when some condition “when” - expands out to if statement you would have written
  • introduce bindings
  • reorder computation

With great power comes great responsibility. Macros can change semantics of your code. Watch out for the sharp edges!

C++ templates

Dave Richardson

Lots of good C++ advice in here that my brain couldn’t keep up with :(

Apologies to the speaker for not getting notes on this.

Hector Castro Building Command-line Applications with Ruby

Hector Castro

Types of command line interfaces

  • non interactive (e.g. mv command)
  • interactive (e.g. ssh-keygem, vim, emacs)


  • reduce interactivity and unnecessary output
  • emit accurate exist status
  • have a concise name
  • respect single and multi-leter options (-h and –help)
  • ensure you provide a –help option
  • use stdout correctly
  • use stderr correctly


Subclass a Thor class to build your command line app.


Aruba executes backticked code within cucumber tests.


Takes markdown and creates html and man pages.

Using SimPy to Model AWS Autoscaling for Realtime Computation

Dan Williams

CheckVideo - smart camera to classify objects as people or vehicles

ARM processor with digital signal procssor

Tell camera what types of objects are of interest, alert when items of interest are in view

Capture a 10 second video clip of event. Requires accuracty in image recognition and serious computing to do this.


  • turn up sensitivity on devices
  • send more events

Event load is very cyclical per day.

Use AWS EC2 autoscaling to create pool of servers that increase and descrease size based on aggregate cpu load.

SimPy - use discrete event simulation to model proposed solution to problem. Python framework uses 3 main object classes: * process * resource * monitor

Uses Python generators as a sort of co-routine.

Output plot results, simulate n cameras, see how system responds to time varying load.

Working in production for 2 years with no tinkering required.

Building Android Apps with JRuby and Ruboto

Rob DiMarco

Android basics

  • Java based SDK
  • byte code compiled into Dalvik executables
  • code, data, and resoruces packaged

Android components

  • activities (single screen)
  • services (background processes)
  • content providers (data management)
  • broadcast receivers (receives system messages)
  • manifest file


  • 100% Java implementation of Ruby
  • most Ruby standard lib is implemented, 1.9 compatible
  • easy integration with Ruby and Java


  • opens up full Android SDK in Ruby
  • Ruby components whenever possible
  • build and deployment framework
  • requires Java, JRuby and Android SDK
  • packaged as a gem

Device installation is as simple as a rake install start

Deployment details

  • compile Java code
  • build package
  • install on emulator

Run on device

Roboto core platform app or bundle JRuby jars in package

Ruby script update

rake update_scripts

Getting it onto physical devices

  • sd card/usb
  • dropbox
  • github with qr code
  • google play

Oh and you can use Ruboto IRB!

How the Python gogolet it’s stripes: Simulating nature’s patterns with Numpy

Tom Adelman

This was awesome! Lots of really impressive methods of replicating of natural patterns with algorithms. Apologies to speaker for not having better notes on this.

GitHub Team Management and Repo Security

TL;DR follow the GitHub users you will be adding to teams or repos and prevent embarrassing mistakes.

Following users on GitHub to keep up on their activity is an awkward feature that doesn’t get a ton of play. Here is a practical use for the GitHub follow that makes team management better and even safer. This applies whether you are using GitHub Teams within an organization or managing collaborators on a public project.

Following a user automatically pushes them to the top of the user search fields on the team/collaborator management page. So instead of potentially having to exactly type their username to add them to a team or project, you can just type the first couple letters and you will see them appear at the top.

Here’s an example to illustrate. Let’s say I want to follow fromonesource. I type f and it brings up the first few matching users.

Because I’m not currently following fromonesource I’d likely have to match on many more characters before I found the user I was looking for. But once I follow the user they now show up at the top. So to follow the user, I go to their profile page and click the follow button.

Now that I’m following this user, when I type f in the find user field, users I follow whose usernames begin with the letter f are shown at the top.

This makes user management much simpler. If you are adding the same user to many teams or repos, it will speed up the time it takes to add them.

I think there’s an important security aspect to this as well. Imagine you’re administering your organization’s GitHub teams and you accidentally grant the wrong user access to your organization’s code. Whoops. Hopefully you realize your mistake before the user discovers you’ve granted them pull rights to the source for your organization’s secret sauce, or worse.

Taking a few minutes to follow the users who should have access to your repos will help ensure you don’t fat finger a malicious user into a role where they could wreak havoc with your code base.

Removing Select Elements From a Ruby Array With Keep_if

Array#keep_if has been in Ruby since 1.9.2 and works much like Array#select but in reverse. The main difference is that elements in the array are removed if the block evaluates false. It’s a useful array method to use when you want to empty your array, except for values that match some condition.

arr = ["thing","thang","thong"]
arr.keep_if{|v| v != "thing"} #=> ["thang", "thong"]
arr.keep_if{|v| v == "thang"} #=> ["thang"]

Array#keep_if is essentially an alias for Array#select!, the bang method cousin of Array#select, but with a much more intuitive method name. Array#select! is a destructive method so the bang is appropriate but it’s a misleading method name for sure.

Javascript Testing. EnvJasmine Co-Creator, Trevor Lalish-Menagh.


  • Care about their work
  • Want to produce quality work
  • Treat their work as more than a dayjob
  • Are proud to show off their work
  • Strive to create work that they are not afraid to change

The only way to avoid being afraid of changing your code is to write tests.

If you don’t test it, you’re up a creek.

Writing quality JavaScript is hard. It’s dynamic. You have to think of the edge cases and things you don’t need to consider in a statically typed language.

Let JSLint help you learn how to write JavaScript the right way.

  • Namespace your functions.
  • Declare your vars up top.
  • Encapsulate your code in brackets (IIFEs immediately invoked function expressions).
  • Don’t use “with”, it’s ambiguous.
  • Don’t abuse eval, almost everything you can do with eval you can do without eval.

False consensus effect: If I could figure this out, anyone else surely can because I’m not that smart. None of us are perfect. We all write bad code, especially bad JavaScript. Your future self will think your past self is a jerk because of the code you’re writing now.

Thanks to EnvJasmine, now front end engineers can break the build, which is a good thing. No JavaScript is untestable. You can use guard to run tests automatically.

Easy Jenkins integration copying path of the pom.xml file.



Connascence Examined. Jim Weirich, Chief Scientist at Edge Case.


  • The common birth of two or more at the same time; the production of two or more together.
  • That which is born or produced with another
  • The act of growing together.

Connascence between two modules means when I change module A, module B should change.

Connascence of Name: “def foo” must match with calling “foo”

Connascence of Position: Order of parameters must match.

  • def bar(name,title,address); end; bar(‘jim’,’cs’,’chicago’);
  • At four-ish parameters, start to question whether connascence of name to be traded in place of connascence of position.

Connascence of meaning: Where data values have particular meanings that must be interpreted consistently across the program. Migrating toward named connascence is good in general.

Control coupling: Occurs when one component passes a piece of information that is intended to control the internal logic of the other. Warning signs: function uses OR in its description, data that has no intrinsic meaning (symbols, true/flase, nil)

Connascence of algorithm: Occurs whenever two components must agree on a particular algorithm.

Connascence of Value: Occurs when the values of two components are related.

Connascence of Timing: Occurs when the timing of execution is important.

Connascence of Execution: Occurs when the order of execution of two components is important.

Connascence of Identity: Occurs when two components must refer to the same object.

Connascence of Type: Set of data and a set or operations on a data type (stack: push, pop, empty). Involves connascence of name, connascence of position, connascence of expectation. Occurs whenever two components must agree on the same type.

Contranasence: If you change the child you possibly break the parent. Occurs when two components must agree on different names. A problem with the inheritance chains.

Actions to take:

  • Reduce degree of connascence 
  • Increase locality
  • Don’t repeat yourself
  • Single responsibility principle
  • Prefer stability

Slides and full video from talk available from Chariot Solutions.

This Is Not a Rails Shop. Chad Fowler, VP Living Social.

How to build a system, a team, and a professional practice that can survive.

“Morked”. Used to describe Visual Basic developers who are given tools to use (and training sometimes). They get dragged along by a company and are told what to use and how to use it.

You can get used to building defense systems, personal immune systems against the Mork mindset.

If you’re doing something right, the Morks are usually doing something wrong. But you can get blinders put on by doing this all the time. ”DHH is a charismatic leader who can effectively rally the troops.” Left unexamined, binding your opinions to those of a leader can become like a religion.

Rails is not a work queue. Not a messaging queue. Not an event processing engine. Not an analytics engine. Not a service bus. Use Rails for its strengths and use other technologies where needed. Very few apps are just MVC web apps, so very few web apps should be just Rails.

(Note: I don’t think DHH would suggest Rails is any of those things, so not sure why Chad is tying these two points together.)

Rails does scale. Using MVC architecture to solve problems that it wasn’t meant to solve does not scale. Rails scales when you use way more than just Rails.

Avoiding SQL at all costs typically sets a “Rails Mork” aside from someone who uses Rails to deliver a front end.

The Big Rewrite blog series by Chad Fowler

Don’t be afraid to throw away your architecture if it is not the right fit.

Another definition of legacy is “gift”. Do we ever think of our legacy software that way? Can we write our legacy software in such a way that it can be a gift for others to work with in the future?

Nobody will remember your work when you die. Statistically speaking, we’re all just going to create some transient crap that will be replaced.

Working Effectively With Legacy Code by Michael Feathers

Characteristics of Legacy Code: Fear, Stasis, Difficult to Change

Your Code.. It’s Alive.. by Michael Feathers

Design Beyond Human Abilities by Richard P. Gabriel

How do we create software systems that outlive us? Why can we, as complex systems, survive but our software cannot?

Our body relies on homeostasis, the ability to regulate itself, in order to stay alive. An inability to maintain homeostasis may lead to death or a disease known as homeostatic imbalance.

You are dying right now. There are 50 trillion cells in your body, 3 million die per second. We are completely different cells from what we used to be. Maybe this is the key to surviving systems. Systems that survive are made of tiny cells that can be replaced frequently and easily.

What is a cell in software development? What is a system? When do you build a system vs building a cell? Are you building the right one now?

Killing and replacing cells regularly forces you to work with small components. Homeostasis requires killing and replacing cells frequently. Keep components small and kill and replace often for healthy systems.

If something is hard, do it all the time. What if we did that with rewrites? What if we did rewrites all the time?

Force heterogeneity. Have simple interfaces.

Hire the best programers, not the best ruby programmers.

Books to read:

Get a strong grasp on HTTP:

  • Read a web server’s source (try Unicorn)
  • Write a simple web server.
  • Read and memorize all HTTP status codes.
  • Deeply understand and implement HTTP caching.

Full video from talk available from Chariot Solutions.

Emerging Programming Languages. Alex Payne, CTO Simple Bank.

Evolution of programming languages does not end. Not talking about R, D, Groovy, Fantom, Lua, Scala, Clojure, F#, Haskell, Erlang.

There are different languages for different jobs.

Starting with most boring to least boring:

A Better Java


  • Java++ (or Scala–?) from JetBrains
  • Static
  • OOP
  • Generics
  • Closures
  • Scala with the complicated parts removed


  • “A pragmatic language for the JVM”
  • Static
  • OOP
  • Generics
  • Closures
  • Like Java and Scala after a wild night out with Ruby.


  • Redhat’s updated Java
  • Static
  • OOP
  • Generics
  • Interceptors
  • Keywords more explicit than Java, more readable

A Better JavaScript


  • “JavaScript + structured concurrency”
  • Concurrent
  • Asynchronous



  • Clojure -> JavaScript
  • Dynamic
  • Functional
  • Lisp style


  • Google’s JavaScript replacement
  • Classes
  • Generics
  • Optional typing
  • JavaScript with classes


  • Functional code into JavaScript from Atlassian
  • Monads
  • Type interface
  • Pattern matching

Web Development


  • A unified platform for web apps
  • Source-to-source
  • OOP
  • Metaclasses
  • Produces ocaml
  • Has XML literals assigned to variables


  • DSL for web applications
  • Functional
  • Static
  • Metaprogramming

Systems Programming


  • Revenge of the 1970s
  • Compiled
  • Concurrent
  • Garbage collected
  • From bell labs
  • Modernized C
  • Focused on fast compiling and a pleasurable development experience
  • Go has a community model that other languages could borrow from


  • Safe
  • Concurrent
  • Practical
  • Compiled
  • OOP
  • Functional
  • Static
  • Amalgamation of maintaining years of C++ code bases
  • Looks like C++ but like Scala plus an “everything and the kitchen sink” functional programming language


  • C + Objects + More
  • Compiling to c99
  • Source-to-source
  • OOP
  • Metaclasses
  • Compiles to c99 so can be used anywhere

Dynamic Programming


  • A dynamic language on Rubinius VM
  • Dynamic
  • OOP
  • Actors
  • Looks like Ruby and Python with JSON inside


  • A modern Smalltalk
  • Dynamic
  • Prototypes
  • Streams
  • Macros


  • “Modern programming for the Erlang VM”
  • Dynamic
  • Protocols
  • Records
  • Macros
  • “A lot of people look at Erlang and their monocle falls out”

Technical Computing


  • “Make physical calculations simple”
  • Embeddable
  • OOP
  • Unicode
  • “It’s a calculator, but a really smart calculator”
  • A language and a database with facts about our physical world embedded into the language.
  • Definitions of gravity, pounds and feet right in the language without having to import a library.
  • If you read one documentation this week, make it the Frink documentation
  • Embeddable in JSP
  • Ported to mobile devices
  • Being pushed in every direction


  • “High-level, high-performance technical computing”
  • Dynamic
  • Compiled
  • Parallel
  • “Think of the language you wish you were writing in when you’re writing in R”
  • Julia tries to be a dynamic, readable language for people doing dynamic computing.
  • Julia is much faster than R for calculations
  • Not as advanced as R at the moment


  • A language for DSP and synthesis
  • Functional
  • Source-to-source compiled
  • Language for manipulating audio and doing synthesis
  • Can build interfaces for things like virtual guitar pedals
  • Compiling down to C++ under the hood
  • Tax-funded research product in France

Querying Data


  • A language for set algebra
  • Functional
  • Persistency
  • Distributed
  • A database that comes with a language, a language that comes with a database.
  • Language tied to the persistency model: could be the downfall of the language or the winning feature


  • A language for analytics
  • Declarative
  • Functional
  • Composeable
  • Light-weight, functional language

Makes You Think


  • “Different and special”
  • No variables
  • No functions
  • No objects
  • Build up patterns and transitions between patterns
  • Wheeler builds a graph of all the things it knows about and when you call them the graph is traversed.
  • Programing languages can be whatever you want them to be, maybe they won’t be practical but they will change how you think about working with a  computer everyday.


  • Programming for kids on XBOX
  • Visual
  • Interactive
  • Iterative

Explosion in platforms partially responsible for explosion of languages: Java, CLR, JavaScript (V8, etc), Rubinius, LLVM, Erlang VM, PHP, XBOX

Explore, experiment, commit, loop.

You need a strategy for how to use these languages and put in use rather than just as a curiosity.

Have an ambient awareness of where the programming world is going.

This is a group project that requires input from everyone.

Loop it: go through the process every few years to see what fits best fits your problem set.


Slides and full video from talk available from Chariot Solutions.