jindrichmynarz

use_debug false
use_bpm 130

# Our mixer!
master = (ramp *range(0, 1, 0.01))
kick_volume = 1
bass_volume = 1
revbass_volume = 1
snare_volume = 0.5
hats_volume = 0.5

philandstuff

Codemesh 2014, London

keynote: complexity is outside the code

• @jessitron and @tastapod
• slides

when I started programming:

• architecture was always:
  • box - box - cylinder
• then layers:
  • ideally:

postspectacular

# Live coding example for Retune conference 2014
# 1) Press Run (Cmd+R) to start
# 2) Make changes (e.g. comment in/out various lines in :beats & :amen)
# 3) Press Run again (changes will only be audible from next queue point)

# compute loop length (4 bars), bar & quarter note durations
dur = sample_duration :loop_compus
bar = dur / 4
quart = dur / 16

weavejester

(ns jme3-example.core
  (:import com.jme3.app.SimpleApplication
           com.jme3.material.Material
           com.jme3.math.Vector3f
           com.jme3.scene.Geometry
           com.jme3.scene.shape.Box
           com.jme3.texture.Texture))

(defn application
  "Create an jMonkeyEngine application."

xavriley

Sample slicing DSL in Sonic Pi

I'm stealing/playing around with ideas from the tidal language here.

Tidal is more focussed on creating loop based music and manipulating samples. It has a good (although initially scary looking) DSL for this purpose.

  every 6 (density 2) $ jux (iter 8) $ every 8 rev $ 
  every 5 (0.25 <~) $ sound "[808a/4*16, 808a/2 [808a/3 ~ ~ 808b] [~ 808b/3 808b/3 ~] [~],  [~ ~ ~ [~ 808b/2]]/2]"
 |+| speed "[1 1 1 [1.5 0.8] 1 1 1 [1 0.5]]/8"

cassiel

theNotes = [:a2, :a3, :e3, :a4, :g4, :e4]

define :foo do |samp, n|
  sample samp,
    rate: pitch_ratio(note(n) - note(:a3)),
    sustain: 0.05,
    release: 0.1,
    amp:3
end

meh

defmodule Fun do
  def arity(fun) do
    case :erlang.fun_info(fun, :arity) do
      { :arity, arity } ->
        arity
    end
  end

  def adapt!(fun, 0) do
    fn -> fun.([]) end

daveray

(ns mr-jr
  (:refer-clojure :exclude [shuffle])
  (:require [clojure.string :as string]
            [clojure.core.async :as async]))

(defn async-group-by
  "Kinda like clojure.core/group-by, but takes a channel and returns a channel"
  [f g ch]
  (->> ch
       (async/reduce

rogerallen

(ns explore-overtone.beethoven
  (:use [overtone.live]))

;; Beginning with some of the ideas in Sam Aaron's example[1],
;; let's see about trying to get rid of the limitation on sequence
;; length.
;;
;; I'd like to create a composition outside the server in "beat space"
;; (play note N at beat B).  This should allow for composing notes via
;; an abstraction that a library like Leipzig [2] provides.  But,

jackrusher

(ns overtone-playground.heart-murmur
  (:use overtone.core
        overtone.inst.sampled-piano
        overtone.samples.piano))

;; (boot-server)
;; (sampled-piano)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reproducible randomness