Author: Mike Zhu

This paper covered varied insights into topics including: what “live” means in a live performance; the role of the performer and the laptop plays in a set; and what is improvisation like in a live coding performance, etc. One part that really attracts me is the 5th chapter, in which the author tried to interprete the computer-based improvisation act with the old school free improvisation which is deeply rooted in the history of jazz. Jazz developed its own methods for unplanned performance, shaped by shared history and physical instruments. When transferred to a digital system, these methods must be adjusted for tasks such as bringing uncertainty with the random functions, or play with different parameters to create unpredictable sound effects.

The chapter also brings up the idea of the computer as a partner rather than just a tool. In many jazz settings, each musician has a voice in the group’s shared sound. The author proposes that a laptop or other digital device can also “respond” in real time, acting like an extra player. This suggests that computer-based improvisation is not strictly about striking keyboards or entering code—it can be performers manipulating external devices to adjust codes on the computers in the NIME field. This reminds me of a possible application: control the patterns based on EEG from both the performers and the audiences, so that everyone can engage in and create something based on their continuous brain pulses which reflect their feelings on the performance seems to be interesting.

For this project, I wanted to place strong focus on the drum patterns in my music. In the first section, I used a central rectangle and changed its form through twisting and scaling. These transformations were chosen to represent different shifts and spikes in the drum beats. By distorting the rectangle, I tried to show how the percussion moves and grows during the track. This is a big challenge since it is hard to find the values that exactly match the strengths and the frequencies of the drums.

When the piece reaches its middle section, I remove all the drum parts after a brief lead-in and leave only an ambient synthesizer. I also take away the moving rectangles in the center to keep the visuals in step with the music. Afterwards, the bass brought some energy to the piece, and made me think of adding some glitchy patterns in Hydra together with some crushing and distorted sounds.

In the final section, I used only a Moog synth. I wanted the sound to be stretched out and slow to fit the outro of the entire composition and to make it stand apart from the earlier chaotic bass lines. I also adjusted the pattern to be more organized, and it shifted in step with the Moog as it gradually slowed down.

Code for Hydra:

shape(
  () => 3 + Math.floor(cc[0] / 10),
  () => 0.2 + cc[0] * 0.001,      
  () => 0.1 + cc[0] * 0.0005         
)
.modulateRotate(
  noise(
    () => 2 + cc[0] / 10,       
    () => 0.3 + cc[0] * 0.001        
  ),
  () => 0.3 + cc[0] * 0.003          
)
.out(o0)

shape(
  () => 3 + Math.floor(cc[0] / 10),
  () => 0.2 + cc[0] * 0.001,      
  () => 0.1 + cc[0] * 0.0005         
)
.modulateRotate(
  noise(
    () => 2 + cc[0] / 10,       
    () => 0.3 + cc[0] * 0.001        
  ),
  () => 0.3 + cc[0] * 0.003          
).layer(
  shape(
    () => 4 ,
    () => 0.15 + cc[1] * 0.008,
    0.02
  )
  .rotate(
    () => (time * 0.05) + (cc[1])
  )
  .colorama(() => cc[1] * 0.1)
  .scale(() => 1 + cc[1] * 0.002)
  .luma(0.2, 0.1)
)
.out(o0)

src(o0)
  .layer(
  shape(
    () => 4 ,
    () => 0.15 + cc[1] * 0.008,
    0.02
  )
  .rotate(
    () => (time * 0.05) + (cc[1])
  )
  .colorama(() => cc[1] * 0.1)
  .scale(() => 1 + cc[1] * 0.002)
  .luma(0.2, 0.1)
)
.out(o0) 


src(o0)
.layer(
  noise(
    () => 1 + cc[2] / 20,
    () => 0.2 + cc[2] * 0.001 
  )
  .rotate(() => cc[2]) 
  .kaleid(() => 2 + Math.floor(cc[2] / 20)) 
  .colorama(() => cc[2]*3) 
  .luma(0.3, 1)
)
.layer(
shape(
  () => 4 ,
  () => 0.15 + cc[1],
  0 // change to 0 after silence
)
.rotate(
  () => (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => Math.random())
.luma(0.2, 0.1)
)
.out(o0)

src(o0)
.layer(
  noise(
    () => 1 + cc[2] / 20,
    () => 0.2 + cc[2] * 0.001 
  )
  .rotate(() => cc[2]) 
  .kaleid(() => 2 + Math.floor(cc[2] / 20)) 
  .colorama(() => cc[2]*3) 
  .luma(0.3, 1)
.rotate(
  () => (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => Math.random())
.luma(0.2, 0.1)
)
.out(o0)

hush()

osc(
    () => 10 + Math.random() * 20,
    0.1,
    () => 0.8 + Math.random() * 0.2  
  )
  .modulate(
    noise(
      () => 2 + Math.random() * 3,
      () => 0.1 + Math.random() * 0.05
    )
  )
  .rotate(
    () => time * 0.05 * Math.random()
  )
  .out(o0)  


src(o0)
    .layer(
    shape(() => 3 + Math.floor(Math.random() * 5), 0.2, 0.05)
    .scale(() => 0.8 + Math.random() * 0.4)
    .luma(0.4, 0.1)
    .rotate(() => Math.random() * 2)
    .colorama(() => Math.random() * 2)
    )
    .rotate(() => cc[3] * 0.03)
    .kaleid(() => 2 + Math.floor(cc[3] / 15))
    .colorama(() => cc[1] * 0.1)
    .scale(() => 1 + cc[3] * 0.001 + cc[3] * 0.001)
    .out(o0)


solid().out()

Code for Tidal:

d1 $ s "arp:3*4" >| note (scale "<major>" ("[<-2 -5 -1 -3>,2](3,8)") + "c7")
  # room 0.4
  # krush 6
  # lpf 100
  # gain 1.5

d2  $ ccv "<40 60 80 100>"
    # ccn "0"
    # s "midi"

d3 $ s "bass*4" >| note (scale "<major>" ("[-5,2](3,8)") + "c4")
  # krush 8
  # lpf 100
  # gain 2
  # legato 2
  # room 0.4

d4
  $ struct "t*4"
  $ ccv "<30 60 90 120>"
  # ccn "1"
  # s "midi"

d3 $ s "bd:3(2,8) bd:3(3,8)" # krush 6 # gain 2 # legato 2

d5 $ struct "<t(2,8), t(3,8)>"
 $ ccv "<40 80 10 120 150>"
 # ccn "2"
 # s "midi"

d4 $ s "arp:5*4" >| note (scale "<major>" ("[<-2 -5 -1 -3>,2]") + "c4")
    # lpf 200
    # krush 4
    # gain 1.5
    # legato 2

d3 silence

d3 $ s "808bd:3*4" # room 0.7 # krush 6 # gain 1.2

d3 $ qtrigger $ filterWhen (>=0) $ seqP [
  (0,1, s "808bd:3*4"),
  (1,2, s "808bd:3*8"),
  (2,3, s "808bd:3*16"),
  (3,4, s "feel:6(3,8)")
] # room 0.7 # krush 6 # gain 1.2

boom = do
  d1 $ qtrigger $ filterWhen (>=0) silence
  d2 $ qtrigger $ filterWhen (>=0) silence
  d3 $ qtrigger $ filterWhen (>=0) silence
  d4 $ qtrigger $ filterWhen (>=0)
    $ s "<feel:6(3,8), feel:6(5,8,1), feel:6(3,8)>"
    # room 0.85
    # speed "<1.2 0.8>"
    # gain 1.2
    # krush 3
    # pan (slow 4 sine)

boom
  
d5
  $ s "moog"
  # note (scale "aeolian" (irand 8))
  # sustain 8
  # release 8
  # gain 2

d4 silence

d7
  $ struct "t"
  $ ccv "<30 60 90 120>"
  # ccn "3"
  # s "midi"

hush

Dissected, “de-natured,” and distilled into abstract sounds and images, natural phenomena become eccentric compositions, revealing the wonders contained within.

Ryoichi Kurokawa’s artistic approach reminds me of deconstruction—the process of breaking down natural forms, sounds, and movements into abstracted components before reassembling them into new configurations. His work does not aim to capture nature as it appears to the naked eye; rather, he dissects it, isolates its underlying structures, and reconstructs it through audiovisual synthesis. This act of deconstruction is not about destruction but rather about rediscovery, revealing hidden layers of complexity that are often overlooked in everyday perception.

In Octfalls, Kurokawa takes the movement of water—something familiar and continuous—and deconstructs it into disjointed yet synchronized audiovisual fragments. The cascading motion of waterfalls is translated into sharp, digital interruptions, reframing the fluidity of nature as something mechanical, algorithmic, and layered. In this process, he distills the essence of motion rather than merely illustrating it, allowing the audience to experience nature in a new, mediated form.

This act of reconstruction aligns with the Japanese aesthetic concept of wabi-sabi, which values imperfection and the beauty of decay. Kurokawa’s work does not seek to present a polished, idealized version of nature; instead, he embraces its instability and unpredictability. His compositions often feature glitches, distortions, and irregularities, mirroring the natural world’s inherent disorder. Through deconstruction, he does not strip nature of its essence but rather uncovers its transient, ever-evolving nature, which keeps the audience continuously engage in the nature system.

In my research project, I explored FoxDot. FoxDot is a live coding platform with Python and SuperCollider. The platform is designed for improvising and composing music, which is similar to Tidal Cycles. The significance of FoxDot is its Python driven environment, and is the major reason why I chose this platform: I am more familiar with the syntax of Python.

One Fun Fact Discovered While Researching:

The creator of FoxDot, Ryan Kirkbride attributes the inspiration of building a live coding platform to Alex McLean, the creator of Tidal Cycles and the term algorave. It turned out that Alex McLean mentored Ryan Kirkbride in the computer music field when he was pursuing his master degree.

Why Python?

With FoxDot I wanted to create an application that bridged the gap between software engineering and Live Coding so that users who were entry level to programming, composition, or both would still be able to grasp the concepts and make music.

What makes Python stand out? First is its object oriented programming. The object oriented design makes it easier to trace the current states of different variables as the image showed below:

The changes applied to p1 can easily be tracked based on the output showed on the terminal. Its clean syntax helps both live coders and the audiences to follow the code. A wide range of third-party libraries greatly expands what live coding can achieve. For example, tkinter package to build a customized GUI; extensions that can support Sonic Pi, voice renderization…

From a beginner’s perspective, the rapid auto-completion feature significantly improves coding fluency. This responsiveness is a notable advantage over platforms like Tidal Cycles, which can be laggy in practice.

Cultural Impact

Broad compatibility expands creative expression. FoxDot works well with many libraries and software tools, allowing artists to mix different digital resources and create unique audiovisual experiences.

User-friendly language lowers the learning curve. The simplicity of Python as the programming language makes it accessible to beginners and non-programmers, lowering the barrier to entry and encouraging more people to engage in live coding.

Creates a large live coding community. By making live coding more approachable, FoxDot has built a sizable and active community. This community supports idea sharing and collaboration, drawing a diverse range of artists and enthusiasts into the live coding culture.

Demonstration of Performance

The following video is me trying to play with some functions and effects in FoxDot:

Electronic music has long been entangled in a debate about its humanity—whether it lacks the “soul” that traditional acoustic music embodies. However, as history has shown, electronic music is not detached from human expression; rather, it continuously interacts with historical and cultural narratives, reshaping the way we perceive sound, memory, and identity. From the early drum machines like the Roland TR-808 to modern synthesizer-based music, electronic sounds have evolved from mere functional tools into carriers of nostalgia, cultural significance, and artistic innovation.

One of the most striking examples of electronic music’s transformation is the Roland TR-808 drum machine. When it was released in the early 1980s, it was considered a cheap, artificial alternative to real drummers. The machine’s rigid quantization and synthetic drum sounds lacked the microtiming and organic fluctuations found in human performance. Because of this, many in the traditional music industry dismissed it. However, the TR-808 did not disappear. Instead, it found a second life in genres like hip-hop, house, and techno. For early pioneers in these genres, a cheap yet powerful tool for production was preferred. This historical background introduced them to the drum machine and its futuristic sound.

Another way electronic music gains its “soul” is through the use of samples, where producers incorporate fragments of existing recordings into their compositions. Renowned artists like Daft Punk, Jamie xx, Fred again.., and The Avalanches have mastered this technique. I remembered that in a Pitchfork interview with The Avalanches, the group mentioned their passion for western movies, and adopted the horse sound as a recurring sample in their album Since I Left You. This approach demonstrates how sampling is not merely a technical tool but a form of musical storytelling—one that connects generations of sound and reimagines stories behind the artists.