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

samaaron

# Based on conversations with Dan Friedman and Jason Hemann
# To evaluate use Sonic Pi...


define :valof do |exp, env={}|
  return exp      if exp.is_a? Numeric
  return env[exp] if exp.is_a? Symbol
  if exp.is_a?(Array) && exp[0] == :lambda
    lambda do |a|
      x = exp[1][0]

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

xavriley

Degrade effect for Sonic Pi

Our old friend Tidal has a function I quite like - degrade

Tidal is a pattern based language and degrade simply drops an event from a pattern 50% of the time.

input: [1,1,1,1,1,1,1,1]

-> degrade(input)

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:

josephwilk

  require 'rubygems'
  $LOAD_PATH.unshift '/Users/josephwilk/Workspace/ruby/ashton/lib/'
  require "ashton"

class TestWindow < Gosu::Window
  NOISE_FRAGMENT =<<-END
#version 110

// Use 3D Simplex noise, even though the shader operates on a 2D
// texture, since then we can make the Z-coordinate act as time.

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

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"

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,