amacdougall

// simple state machine using a state variable

/* States can be anything -- strings, integers, whatever. In C examples, you'll
 * see integers, because they take up less space in memory. In Ruby, they'd be
 * symbols; in Java, they'd be Enumerations or something. In JavaScript, it's
 * generally wise to make them strings, for easy debugging.
 *
 * These example states are for an imaginary ship.
 */
var ANCHORED = "anchored";

amacdougall

;; Some examples of Clojure syntax. ClojureScript is almost entirely identical
;; to Clojure.

;; Anything preceded by semicolons is a comment. Double-semicolons are
;; generally doc comments; single semicolons are developer comments.

(def message "Hello world!")

message ; simply naming something returns its value

amacdougall

#!/usr/bin/ruby
#
# Prevents commit, with an informative message, if any of the following
# conditions are true:
#
# Any js file in the src directory does not pass eslint.
#
# Any js file in the src directory requires formatting with js-beautify.
#
# Must have eslint and js-beautify installed as CLI apps. If they are not

amacdougall

#!/usr/bin/ruby

# delete branches which exist on the origin repo but not locally
 
WHITELIST = [
  "master",
  "production",
  "earth",
  "wind",
  "water",

amacdougall

Design Tool Planning

We began with a single question: "what next?" The one-word answer was obvious: "testing." From there, we discussed three topics: what kinds of tests to write; how to write and run them; and what refactorings might best support the tests.

Each topic led to less consensus than the preceding one, but I will attempt to summarize the competing views.

What Tests We Need

Smoke Tests

amacdougall

/**
 * Given any number of functions, returns a single function which acts as
 * if each function were called in right to left order. The result of each
 * function will be the argument to the next.
 *
 * To put it another way, compose(f, g)(x) should have the same result
 * as f(g(x)).
 *
 * @param {...Function} functions - Any number of input functions.
 */

amacdougall

;; Bogey (sets the :current boolean for each player)
(defn select-player [app player]
  (om/transact! app :players (fn [players]
                               (mapv (fn [p]
                                       (assoc p :current (= p @player)))
                                     players))))

;; Birdie -- but I feel like it's more cognitive load
(defn select-player [app player]
  (let [set-current #(assoc % :current (= % @player))]

amacdougall

// Make a function called pipeline that accepts a value as a parameter, as well as any number of functions as additional parameters.
// The function will return the value that results from the first parameter being used as a parameter for the next function and so on.

var double = function(val) { return val * 2; }
var addOne = function(val) { return val + 1; }
var addThree = function(val) { return val + 3; }

/**
 * Given an initial value and any number of function arguments,
 * returns the value obtained by applying each function to the

amacdougall

#!bash
#
# bash/zsh completion support for core Git.
#
# Copyright (C) 2006,2007 Shawn O. Pearce <[email protected]>
# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
# Distributed under the GNU General Public License, version 2.0.
#
# The contained completion routines provide support for completing:
#

amacdougall

// This works, but since it has to take `n, f1, ...` instead of `n, [f1, ...]`,
// we need to do a messy concat/apply at the end.
function pipeline(n) {
  var actions = rest(arguments);
  if (_.isEmpty(actions)) {
    return n;
  } else {
    return pipeline.apply(null, [first(actions)(n)].concat(rest(actions)));
  }
};