Time for some nostalgia with Sonic Pi…

 

Recently one of my brothers unearthed a music manuscript book entitled
The Tunes of the family of the Sidney Newmans containing some pieces that my Father wrote in the early 1940s for my elder brother Julian when he was very young. Julian had various companions such as Edward Bear and Johnny Pen (a penguin), and these pieces and later ones were an important part of our lives, and indeed later one, one or two had arrangements done whereby the whole family joined in playing them, including one with five hands on a piano,

Here are four of the pieces. You can copy and paste the code for each into Sonic Pi.

You can listen to them here

The first is called Edward’s March.

#Edwards March Composed by Prof. Sidney Newman (my Father) in early 1940s
#written for my elder Brother Julian, who had a teddy bear called Edward
#coded for Sonic Pi by Robin Newman, October 2019
use_bpm 120
use_synth :piano
#n1 tune, n2 right hand fill,n3 left hand
#suffix b second half of tune
#b1,b2 first and second time endings fr second half of tune
#notes....
n1=[:f5,:f5,:f5,:f5,:f5,:eb5,:d5,:c5,:bb4,:f4,
    :bb4,:eb5,:d5,:bb4,:eb5,:f5,:g5,:eb5,:f5,
    :f5,:f5,:f5,:f5,:f5,:eb5,:d5,:c5,:bb4,:f4,
    :f5,:bb5,:f5,:bb5,:f5,:eb5,:d5,:c5,:bb4]
n1b=[:f5,:ab5,:g5,:f5,:f5,:bb5,:ab5,:g5,:f5,
     :f5,:ab5,:g5,:f5,:bb5,:eb5,:d5,:c5,:bb4,[:c5,:f5],
     :f5,:f5,:f5,:f5,:f5,:eb5,:d5,:c5,:bb4,:f4,
     :f5,:bb5,:f5,:bb5,:f5,:eb5,:d5,:c5,:bb4]

n2=[[:bb4,:d5],[:g4,:bb4,:eb5],[:f4,:bb4,:d5],[:g4,:bb4,:eb5],
    [:f4,:bb4,:d5],[:eb4,:g4,:f5],[:d4,:f4,:f5],[:c4,:eb4,:f5],
    [:bb3,:d4],[:bb4,:f5],[:bb4,:f5],[:bb4,:f5],:bb4,:bb4,:bb4,:a4,
    [:bb4,:d5],[:g4,:bb4,:eb5],[:f4,:bb4,:d5],[:g4,:bb4,:eb5],
    [:f4,:bb4,:d5],[:eb4,:g4,:f5],[:d4,:f4,:f5],[:c4,:eb4,:f5],
    :bb4,:eb5,:bb4,:eb5,[:bb4,:f5],[:a4,:f5],[:d4,:f5]]

n2b=[[:bb4,:d5],[:c5,:eb5],[:bb4,:d5],[:bb4,:d5],[:c5,:eb5],[:bb4,:d5],
     [:bb4,:d5],[:c5,:eb5],[:bb4,:d5],:bb4,:bb4,:bb4,:bb4,:a4,
     [:bb4,:d5],[:g4,:bb4,:eb5],[:f4,:bb4,:d5],[:eb4,:g4,:f5],
     [:f4,:bb4,:d5],[:eb4,:g4,:f5],[:d4,:f4,:f5],[:c4,:eb4,:f5],
     :bb4,:eb5,:bb4,:eb5,[:bb4,:f5],[:a4,:f5],[:d4,:f5]]

n3=[:bb1,:eb2,:bb2,:eb3,:bb3,:r,:r,:g3,:f3,:d3,:g3,:c3,:f3,:f2,
    :bb1,:eb2,:bb2,:eb3,:bb3,:r,
    [:bb3,:d3,:f3],[:g3,:bb3,:eb4],[:f4,:bb4,:d4],[:eb3,:bb3,:c4],
    [:f3,:bb3,:d4],[:f3,:c4,:eb4],:bb3,:bb2]
n3b=[[:bb2,:bb3],[:ab2,:ab3],[:bb2,:bb3],[:bb1,:bb2],
     [:bb2,:bb3],[:f2,:f3],[:bb2,:bb3],[:bb1,:bb2],
     [:bb2,:bb3],[:f2,:f3],[:bb2,:bb3],[:d3,:d2],
     [:c2,:c3],[:g2,:g3],[:f2,:f3],[:f1,:f2],
     [:bb0,:bb1],[:eb1,:eb2],[:bb1,:bb2],[:eb2,:eb3],
     [:bb2,:bb3],:r,
     [:bb3,:d4,:f4],[:g3,:bb3,:eb4],[:f3,:bb3,:d4],[:eb3,:bb3,:c4],
     [:f3,:bb3,:d4],[:f3,:c4,:eb4],:d4]
n3b1=[:r,:bb3]
n3b2=[:r,:bb3,:bb2]
#durations.....
d1=[1,1,1,1,0.75,0.25,0.75,0.25,1,1,1,1,1,1,0.75,0.25,0.75,0.25,2]*2
d1b=[1,0.75,0.25,2,0.75,0.25,0.75,0.25,2,
     1,0.75,0.25,1,1,0.75,0.25,0.75,0.25,2,
     1,1,1,1,0.75,0.25,0.75,0.25,1,1,
     1,1,1,1,0.75,0.25,0.75,0.25,2]
d2=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]
d2b=[1,1,2,1,1,2,1,1,1,1,1,1,1,1,
     1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]
d3=[1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,
    1,1,1,1,1,1,1,1]
d3b=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
     1,1,1,1,1,3,1,1,1,1,1,1,2]
d3b1=[30,2]
d3b2=[30,1,1]
#functions plays note lists. Handles chords.
define :pl do |nt,dur,vol=0.5| #default volume 0.5
  nt.zip(dur).each do |n,d|
    if n.respond_to?(:each) #check if a chord
      n.each do |nv| #oplay each note in chord
        play nv,sustain: d,amp: vol
      end
    else #otherwise play single note
      play n,sustain: d,amp: vol
    end
    sleep d
  end
end
n3End=[n3b1,n3b2] #allows first time second time variant
d3End=[d3b1,d3b2] #allows first time second time variant
sleep 0.2 #allows data setup to complete
with_fx :level,amp: 2 do #boost overall levels
with_fx :level,amp: 0 do |v| #control dynamics by varying amp
  set :v,v #store pointer to fx control
  dt =0.05 #allows initial settling
  b=4 #beats in a bar
  #dynamic changes with timings. each parameter pair level and time_slide
  at [dt,dt+b*8,dt+b*11,dt+b*14,dt+b*16,dt+b*19,dt+b*22],[[0.45,0],[0.7,0],[1,4],[0.45,4],[0.7,0],[1,4],[0.45,4]] do |lev|
    control get(:v),amp: lev[0],amp_slide: lev[1]
  end
  
  with_fx :reverb, room: 0.8,mix: 0.7 do #add some reverb
    #play parts in threads together
    #first part
    in_thread do
      pl n1,d1,1
    end
    in_thread do
      pl n2,d2
    end
    pl n3,d3
    2.times do #second part twice
      in_thread do
        pl n1b,d1b,1
      end
      in_thread do
        pl n2b,d2b
      end
      in_thread do
        pl n3b,d3b
      end
      pl n3End.tick,d3End.look #change endings using tick to select
    end
  end #reverb
end #level
end #level boost
sleep 1
cue :go1

The second is called Edward’s tune for Julian

#Edward's tune for Julian composed by Prof. Sidney Newman in the early 1940s
#My elder brother had a bear called Edward.
#coded for Sonic Pi by Robin Newman, October 2019
use_bpm 125
use_synth :piano
#functions plays note lists. Handles chords.
define :pl do |nt,dur,vol=0.5| #default volume 0.5
  nt.zip(dur).each do |n,d|
    if n.respond_to?(:each) #check if a chord
      n.each do |nv| #oplay each note in chord
        play nv,sustain: d,amp: vol
      end
    else #otherwise play single note
      play n,sustain: d,amp: vol
    end
    sleep d
  end
end
#use_synth_defaults attack: 0.01,vel: 0.57,hard: 0.44
n1=[:d4,:g4,:fs4,:g4,:a4,:d5,:c5,  :b4,:g4,:b4,:a4,:fs4,:d4,
    :g4,:fs4,:g4,:a4,:d5,:c5, :b4,:a4,:g4,:d5,:d4,
    :g4,:fs4,:g4,:a4,:d5,:c5, :b4,:g4,:b4,:a4,:fs4,:d4,
    :e4,:g4,:e4,:d4,:d5,:c5,  :b4,:g4,:a4,:g4,:d5,
    :e5,:g5,:e5,:d5,:g5,:b4,  :c5,:d5,:c5,:b4,:g4,:b4,:d5,
    :e5,:g5,:e5,:d5,:g5,:c5,  :b4,:a4,:g4,:d5,:d4,
    :g4,:fs4,:g4,:a4,:d5,:c5, :b4,:g4,:b4,:a4,:fs4,:d4,
    :e4,:g4,:e4,:d4,:d5,:c5,  :b4,:g4,:a4,:g4]
    
d1=[0.5,0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,0.5,0.5,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,1,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,0.5,0.5,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,1,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,0.75,0.25,0.25,0.25,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,1,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,0.5,0.5,0.5,
    0.75,0.25,0.5,0.5,0.5,0.5,  0.5,0.5,0.5,1]
    
n2=[:r,:r,:fs4,  :g4,:r,:r,:fs4,  :g4,:fs4,:r,  :r,:fs4,
    :g4,:e4,:fs4,:r,
    :r,:d4,:e4,  :d4,:c4,:b3,:r, :g4,:g4,  :g4,:fs4,:g4,:r,
    :g4,:g4,:fs4,  :g4,:g4,:fs4,:r,  :r,:fs4,  :g4,:e4,:fs4,:r,
    :r,:d4,:e4,  :d4,:c4,:b3]
d2=[0.5,1.5,1.5, 1,2, 1.5,1.5, 1.5,1,0.5, 1.5,1.5,
    1,0.5,1,0.5,
    1.5,1,0.5,1,0.5,1,0.5, 1.5,1.5, 1,0.5,1,0.5,
    1.5,1,0.5, 1,0.5,1,0.5, 1.5,1.5, 1,0.5,1,0.5,
    1.5,1,0.5, 1,0.5,1]
puts n2.length,d2.length

n3=[:r,:b3,:d4,:c4,:d4,  :g4,:d4,:c4,:a3,  :b3,:d4,:c4,:d4,
    :g3,:b3,:c4,:a3,  :b3,:d4,:c4,:d4,  :g3,:cs4,:d4,:fs3,
    :g3,:fs3,:g3,:e3,:fs4,:g3,:r,  :c4,:b3,:a3,:g3,:r,
    :c4,:b3,:a3,  :g3,:cs4,:d4,:c4,  :b3,:d4,:c4,:d4,
    :g3,:cs4,:d4,:fs3,  :g3,:e3,:fs3,:g3]
d3=[0.5,1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,2,0.5,0.5,1,0.5, 1.5,1.5,1.5,1,0.5,
    1.5,1,0.5,  1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5,  3.5,0.5,0.5,1]

n4=[:r,:g3, :g3, :g3,:d3,  :c3,:b2,:c3, :d3,:g3,:r,  :c4,:b3,
    :a3,:g3,:r, :r,:e3,:d3,:r, :g3,:d3,:c3,:b2,:c3,:d3,:d3,:g2]
d4=[0.5,6, 6, 4.5,1.5,  1.5,1,0.5, 1.5,1,0.5, 1.5,1.5,
    1.5,1,3.5,  1,0.5,1,0.5,  4.5,1.5,1.5,1,0.5,1,0.5,1]

with_fx :reverb,room: 0.8,mix: 0.6 do
  3.times do
    use_transpose [0,12,0].tick
    with_fx :level,amp: [0.8,0.5,1].look do
      in_thread do
        pl n1,d1,1
      end
      in_thread do
        pl n2,d2
      end
      in_thread do
        pl n3,d3
      end
      pl n4,d4
    end
  end
end
sleep 1
cue :go2

The third is called Johnny Pen’s Wedding March

#Johnny Pen's Wedding March composed by Prof. Sidney Newman in the early 1940s
#coded for Sonic Pi by Robin Newman, October 2019
use_bpm 125
use_synth :piano
#functions plays note/duration lists. Handles chords.
define :pl do |nt,dur,vol=0.5| #default volume 0.5
  nt.zip(dur).each do |n,d|
    if n.respond_to?(:each) #check if a chord
      n.each do |nv| #oplay each note in chord
        play nv,sustain: d*0.9,amp: vol
      end
    else #otherwise play single note
      play n,sustain: d*0.9,amp: vol
    end
    sleep d
  end
end

n1=[:c5,:a4,:g4,:a4,:f4, :d4,:f4,:c4,:c4,:c4, :c5,:a4,:g4,:f4,:d4,:c4,
    :bb4,:a4,:g4,:a4,:f4,:r]
d1=[1,1,0.75,0.25,1, 1,1,1,0.75,0.25, 1,0.75,0.265,0.75,0.25,1,
    0.75,0.25,0.75,0.25,1,1]
n2=[:a4,:f4,:bb3,:a3, :bb3,[:g3,:bb3],:a3,:bb3, :c4,:c4,:bb3,:a3,:bb3,:a3,
    [:d4,:e4],:c4,:bb3,:c4, :a3,:r]
d2=[1,1,1,1, 1,1,1,1, 1,0.75,0.25,0.75,0.25,1,
    0.75,0.25,0.75,0.25,1,1]
n3=[:f2,:c3,:f2,:c3, :f2,:c3,:f2,:c3, :f2,:c3,:f2,:c3,
    :c2,:c3,:f2]
n3e1=[:r,:c3] #alternate endings
n3e2=[:r]
d3e1=[15,1]
d3e2=[16]
d3=[1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1]
flag=0 #used to select different ending last time
cnt=0 #used to select different ending last time
sleep 0.3
with_fx :reverb,room: 0.8,mix: 0.6 do
  3.times do
    with_fx :level,amp: [0.8,0.5,1].tick do
      use_transpose [0,12,0].look #second time up an octave
      2.times do
        cnt+=1
        in_thread do #play parts together using threads
          pl n1,d1,0.8
        end
        in_thread do
          pl n2,d2
        end
        in_thread do
          pl n3,d3
        end
        flag=1 if cnt==6
        pl [n3e1,n3e2][flag],[d3e1,d3e2][flag] #switch ending last time
      end
    end
  end
end
sleep 1
cue :go3

The final one is called Julian’s Tune

#Julian's Tune composed by Prof. Sidney Newman in the early 1940s
#coded for Sonic Pi by Robin Newman, October 2019
use_bpm 125
use_synth :piano
#functions plays note lists. Handles chords.
define :pl do |nt,dur,vol=0.5| #default volume 0.5
  nt.zip(dur).each do |n,d|
    if n.respond_to?(:each) #check if a chord
      n.each do |nv| #oplay each note in chord
        play nv,sustain: d,amp: vol
      end
    else #otherwise play single note
      play n,sustain: d,amp: vol
    end
    sleep d
  end
end
#use_synth_defaults attack: 0.01,vel: 0.57,hard: 0.44
n1=[:eb5,:db5,:c5,:bb4,:ab4,:g4,  :f4,:bb4,:eb4,:ab4,  :bb4,:eb5,:c5,:ab4,
    :bb4,:eb5,:c5,:eb5,:db5, :c5,:bb4,:ab4,:g4, :f4,:bb4,:eb4,:ab4,
    :bb4,:eb5,:c5,:bb4, :ab4,:ab5,:g5,  :f5,:ab5,:eb5,:ab5,
    :f5,:ab5,:eb5,:ab5,  :f5,:eb5,:db5,:c5,  :bb4,:ab4,:eb5,:ab4,
    :bb4,:eb5,:c5,:ab4,  :bb4,:eb5,:c5,:ab4,  :f4,:bb4,:g4,:f4,:g4,  :aB4]
d1=[0.25,0.25,1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.25,0.25,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5, 2.5,0.25,0.25, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,0.75,0.25,0.5, 2.5]

n2=[:r,:eb4,:db4,:c4, :db4,:c4, :eb4, :eb4,:r,
    :eb4,:db4,:c4, :db4,:c4,:eb4, :f4,:eb4,:db4, :c4,:c5, :db5,:c5,
    :db5,:c5, :ab4,:ab4,:f4,:g4,:ab4, :eb4,:d4,:eb4,:eb4,
    :f4,:g4,:ab4,:f4, :eb4,:eb4,:eb4, :bb3,:bb3, :c4]
d2=[0.5,1,0.5,1.5, 1.5,1.5, 3, 2.5,0.5,
    1,0.5,1.5, 1.5,1,0.5, 1.5,1,0.5, 2.5,0.5, 1.5,1.5,
    1.5,1.5, 1,0.5,0.75,0.25,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1.5,1,0.5, 2.5,0.5, 2.5]

n3=[:r,:ab1,:eb2,:ab2,:eb3, :f3,:g3,:ab3,:f3, :g3,:eb3,:ab3,:f3,
    :g3,:eb3,:ab4,:r, :ab1,:eb2,:ab2,:eb3, :f3,:g3,:ab3,:g3,:r, :ab3,:eb3,:ab2,:ab1,
    :db2,:f2,:ab2,:c3, :db3,:f3,:ab3,:c4, :db4,:c4,:bb3,:ab3, :g3,:f3,:eb3,:c3,
    :db3,:eb3,:f3,:f2, :g2,:eb2,:ab2,:c3, :db3,:bb2,:eb3,:eb2, :ab1,:eb2,:ab2]
d3=[0.5,1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,3,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5,
    1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1,0.5, 1,0.5,1]

n4=[:r,:r,:ab2,:ab2,:eb2, :r,:ab2,:c4,:db4,:bb2,:eb3,:f3,:g3,:r,
    :db3,:c3,:bb2,:ab2, :g2,:f2,:eb2,:r, :r]
d4=[0.5,1.5,4.5, 5.5,0.5, 1.5,4,0.5, 1,0.5,0.75,0.25,0.5, 9,
    1,0.5,1,0.5, 1,0.5,1,0.5, 11.5]
sleep 0.3
with_fx :reverb, room: 0.8,mix: 0.6 do
  3.times do
    use_transpose [0,12,0].tick
    with_fx :level,amp: [0.7,0.5,1].look do
      in_thread do
        pl n1,d1,0.8
      end
      in_thread do
        pl n2,d2
      end
      in_thread do
        pl n3,d3
      end
      pl n4,d4
    end
  end
end

They can all be loaded and played individually into Sonic Pi, or you can use the program below to play them in sequence using the run_file command, although you will have to set the pathname to the files as appropriate for your system, and make sure the filenames match what you have saved.

#Four pieces of music composed by my Father for my Brother Julian in the early 1940s
#Edward was the name of his Bear. Transcribed for Sonic Pi by Robin Newman, October 2019

run_file "~/Documents/SPfromXML/NewmanMusic/Edward'sMarch.rb"
sync :go1
sleep 1
run_file "~/Documents/SPfromXML/NewmanMusic/Edward'sTuneForJulian.rb"
sync :go2
sleep 1
run_file"~/Documents/SPfromXML/NewmanMusic/JohnnyPen'sMarch.rb"
sync :go3
sleep 1
run_file "~/Documents/SPfromXML/NewmanMusic/Julian'sTune.rb"

I hope you like them. You can listen to them here