Academic Statement

Language is ... is a live coding performance that critically engages with the aesthetics, epistemologies, and ontologies of digital art through the act of coding as a performative gesture. The work reclaims the screen not merely as a technical interface but as a site of philosophical inquiry, visibility, and vulnerability. In doing so, it challenges the conventions of electronic music and digital performance by foregrounding the processual and linguistic dimensions of code.

The performance unfolds within a custom-built environment composed of Bash scripting, SoX audio synthesis, and the Terminology terminal emulator, all operating on a minimalist Linux system devoid of graphical user interfaces. This deliberate reduction of visual mediation emphasizes the raw materiality of code and the embodied labor of its execution. The screen becomes both stage and score, where each line of code is simultaneously a compositional act and a philosophical proposition.

Responding to critiques of opacity in laptop-based performance, Language is ... aligns with the ethos of the live coding movement—“show us your screens”—but extends this imperative into a deeper ontological reflection. The work interrogates the nature of language as both constraint and possibility, drawing on philosophical traditions from Chomsky’s generative grammar to Wittgenstein’s language games, from Foucault’s discourse analysis to Heidegger’s meditations on technology.

The performance is structured around a series of Bash functions, each functioning as a compact, executable unit of meaning. These functions are not merely utilitarian; they are conceptual artifacts that encode philosophical reflection. For instance, the recurring function noema references Husserlian phenomenology, suggesting a sonic residue of intentionality and perception. In this way, the work operates at the intersection of computation, poetics, and phenomenology.

Language is ... is not a spectacle in the traditional sense. It is a discursive event that invites the audience to witness the emergence of sound and image in real time, while simultaneously reflecting on the conditions of their production. It foregrounds the tension between human agency and machinic logic, between expression and execution, and between the visible and the executable. In doing so, it reclaims the language of machines as a medium for critical thought and aesthetic experience.

Artist Statement

This performance is a response to a long-standing tension in digital art and electronic music: the opacity of the machine. In Language is ..., I confront the fourth wall of the laptop screen not by removing it, but by turning it into a stage. The code becomes visible, audible, and performative. It is not hidden behind interfaces or GUIs—it is the interface, the gesture, the voice.

My approach to live coding is driven by a desire to understand the limits of language—both human and machine—and to explore how creativity can emerge from constraint. I chose to work with Bash, SoX, and Terminology not because they are convenient, but because they are minimal, raw, and unforgiving. These tools force me to confront the structures that shape my actions and to ask: where does my agency begin, and where does it end?

The performance is built around a set of custom Bash functions—compact scripts that generate sound, trigger video, and manipulate the terminal environment. Each function is a distilled gesture, a micro-language that carries both technical function and conceptual weight. The recurring function noema, for instance, is a nod to phenomenology—a reminder that every sound is also a trace of perception.

Language is ... is not a demonstration of technical prowess. It is a philosophical inquiry, a poetic act, and a refusal to separate code from meaning. It is a space where the limits of syntax become the conditions for expression, and where the machine becomes a mirror for thought.

Through this work, I invite the audience to witness not only what is made, but how it is made—and to consider what it means to make anything at all in a world increasingly governed by code.


          # ~/.bashrc: executed by bash(1) for non-login shells.
          # see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
          # for examples
  
          # If not running interactively, don't do anything
          case $- in
            *i*) ;;
              *) return;;
          esac
  
          # don't put duplicate lines or lines starting with space in the history.
          # See bash(1) for more options
          HISTCONTROL=ignoreboth
  
          # append to the history file, don't overwrite it
          shopt -s histappend
  
          # for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
          HISTSIZE=1000
          HISTFILESIZE=2000
  
          # check the window size after each command and, if necessary,
          # update the values of LINES and COLUMNS.
          shopt -s checkwinsize
  
          # If set, the pattern "**" used in a pathname expansion context will
          # match all files and zero or more directories and subdirectories.
          #shopt -s globstar
  
          # make less more friendly for non-text input files, see lesspipe(1)
          [ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
  
          # set variable identifying the chroot you work in (used in the prompt below)
          if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
            debian_chroot=$(cat /etc/debian_chroot)
          fi
  
          # set a fancy prompt (non-color, unless we know we "want" color)
          case "$TERM" in
            xterm-color|*-256color) color_prompt=yes;;
          esac
  
          # uncomment for a colored prompt, if the terminal has the capability; turned
          # off by default to not distract the user: the focus in a terminal window
          # should be on the output of commands, not on the prompt
          #force_color_prompt=yes
  
          if [ -n "$force_color_prompt" ]; then
            if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
              # We have color support; assume it's compliant with Ecma-48
              # (ISO/IEC-6429). (Lack of such support is extremely rare, and such
              # a case would tend to support setf rather than setaf.)
              color_prompt=yes
            else
              color_prompt=
            fi
          fi
  
          if [ "$color_prompt" = yes ]; then
            PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
          else
            PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
          fi
          unset color_prompt force_color_prompt
  
          # If this is an xterm set the title to user@host:dir
          case "$TERM" in
          xterm*|rxvt*)
            PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
            ;;
          *)
            ;;
          esac
  
          # enable color support of ls and also add handy aliases
          if [ -x /usr/bin/dircolors ]; then
            test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
            alias ls='ls --color=auto'
            #alias dir='dir --color=auto'
            #alias vdir='vdir --color=auto'
  
            alias grep='grep --color=auto'
            alias fgrep='fgrep --color=auto'
            alias egrep='egrep --color=auto'
          fi
  
          # colored GCC warnings and errors
          #export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'
  
          # some more ls aliases
          alias ll='ls -alF'
          alias la='ls -A'
          alias l='ls -CF'
  
          # Add an "alert" alias for long running commands.  Use like so:
          #   sleep 10; alert
          alias alert='notify-send --urgency=low -i "$([ $? = 0 ]
          && echo terminal || echo error)" "$(history|tail -n1|sed
          -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
  
          # Alias definitions.
          # You may want to put all your additions into a separate file like
          # ~/.bash_aliases, instead of adding them here directly.
          # See /usr/share/doc/bash-doc/examples in the bash-doc package.
  
          if [ -f ~/.bash_aliases ]; then
            . ~/.bash_aliases
          fi
  
          # enable programmable completion features (you don't need to enable
          # this, if it's already enabled in /etc/bash.bashrc and /etc/profile
          # sources /etc/bash.bashrc).
          if ! shopt -oq posix; then
            if [ -f /usr/share/bash-completion/bash_completion ]; then
            . /usr/share/bash-completion/bash_completion
            elif [ -f /etc/bash_completion ]; then
            . /etc/bash_completion
            fi
          fi
  
  
          ########################
          ######## MY FUNCTIONS GT
          ########################
  
  
          # PERFORMANCE 1
  
  
          # atom   note/s  duration  gain
  
          function noema(){
          terminology -b b11.jpg -g 20x2+$[ ( $RANDOM % 1900 ) + 1 ]+$[ ( $RANDOM % 1000 ) + 1 ] -e "bash -c \"
            if [ $# == 3 ]; then
            play -n synth $2 sine  $1 fade .2 $2 gain $3 && exit;
            elif [ $# == 4 ]; then
            play -n synth $3 sine  $1 sine $2  fade .2 $3 gain $4 && exit;
            elif [ $# == 5 ]; then
            play -n synth $4 sine  $1 sine $2 sine $3 fade .2 $4 gain $5 && exit;
            elif [ $# == 6 ]; then
            play -n synth $5 sine  $1 sine $2 sine $3 sine $4 fade .2 $5 gain $6 && exit;
            elif [ $# == 7 ]; then
            play -n synth $6 sine  $1 sine $2 sine $3 sine $4 sine $5 fade .2 $6 gain $7 && ex$
            elif [ $# == 8 ]; then
            play -n synth $7 sine  $1 sine $2 sine $3 sine $4 sine $5 sine $6 fade .2 $7 gain $
            fi
            exec bash\""&
          }
  
  
          # tremolo note/s duration tremolo_speed tremolo_depth gain
  
          function tremolo() {
          terminology -g 2x15+$[ ( $RANDOM % 1900 ) + 1 ]+$[ ( $RANDOM % 1000 ) + 1 ] -e "bash -c \"
            if [ $# == 5 ]; then
            play -n synth $2 sine  $1 fade .2 $2 tremolo $3 $4 gain $5 && exit;
            elif [ $# == 6 ]; then
            play -n synth $3 sine  $1 sine $2  fade .2 $3 tremolo $4 $5 gain $6 && exit;
            elif [ $# == 7 ]; then
            play -n synth $4 sine  $1 sine $2 sine $3 fade .2 $4 tremolo $5 $6 gain $7 && exit;
            elif [ $# == 8 ]; then
            play -n synth $5 sine  $1 sine $2 sine $3 sine $4 fade .2 $5 tremolo $6 $7 gain $8 && exit;
            elif [ $# == 9 ]; then
            play -n synth $6 sine  $1 sine $2 sine $3 sine $4 sine $5 fade .2 $6 tremolo $7 $8 gain $9 && exit;
            elif [ $# == 10 ]; then
            play -n synth $7 sine  $1 sine $2 sine $3 sine $4 sine $5 sine $6 fade .2 $7 tremoolo $8 $9 gain $10 && exit;
            fi
           exec bash\""&
          }
  
  
  
          function this(){
          terminology -g $[ ( $RANDOM % 20 )  + 1 ]x$[ ( $RANDOM % 20 ) + 1 ]+
          $[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ] -e "bash -c \"
          play -n synth 7 sine $[ ( $RANDOM % 200 ) + 150 ] fade 0 5 2 gain -10 && exit
          exec bash\""&
          }
  
          function followed(){
          sleep 3.5 &&
          terminology -g $[ ( $RANDOM % 20 )  + 1 ]x$[ ( $RANDOM % 20 ) + 1 ]+
          $[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ] -e "bash -c \"
          play -n synth 7 sine $[ ( $RANDOM % 200 ) + 150 ] fade 0 5 2 gain -10 &&
          sleep 2 && play -q wow.wav && exit
          exec bash\""&
          }
  
  
  
  
          function thanks(){
          play -q crowd-laugh.wav  && exit
          }
  
          function language(){
          terminology -g $[ ( $RANDOM % 20 )  + 1 ]x$[ ( $RANDOM % 20 ) + 1 ]+
          $[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ] -e "bash -c \"
          play abc.wav  fade 0 0 .2 gain -3 && exit
          exec bash\""&
          }
  
  
  
  
          function debate(){
          terminology -g 2x20 -e "bash -c \" play noam.ogg trim $1 $2 fade 1 $2 gain 0 && exit
          exec bash\""&
          }
  
  
          function so(){
  
          play confusion.wav gain -10 fade t 0 10 3
  
          }
  
  
          function u(){
          terminology -g 2x10+$[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ]
          -e "bash -c \" for i in {1..5}; do play confusion.wav trim $[ ( $RANDOM % 100 ) +
           1 ] $1  pad 0 5 gain -5 reverb && sleep 1; done && exit
          exec bash\""&
          }
  
          function beauty(){
          terminology -g 30x20+$[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ]
           -e "bash -c \" tybg minchia.ogv
          exec bash\""&
  
          }
  
          function meaning(){
          terminology -g 40x15+$[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ]
          -e "bash -c \" tybg fagioli.ogv
          exec bash\""&
          }
  
          function limit(){
          tybg beethoven.ogv
          }
  
          function world(){
          tybg asilvio.ogv
          }
  
  
  
  
          function viz(){
          shuf -r -e -z '               	' $(echo -e "\e[3$1m$2\e[0m") '                            	'
          }
  
  
          function bye(){
          terminology -F -e "bash -c \" shuf -r -e -z '               	'
          $(echo -e "\e[33m$1\e[0m") '                                  	' &  play wow.wav
          exec bash \""&
          }
  
  
          function glit(){
  
          terminology -g $[ ( $RANDOM % 20 )  + 1 ]x$[ ( $RANDOM % 20 )  + 1 ]+
          $[ ( $RANDOM % 1900 )  + 1 ]+$[ ( $RANDOM % 1000 )  + 1 ] -b b$[ ($RANDOM % 10 ) + 1 ].jpg
          -e "bash -c \"
          play 0-glitch$[ ($RANDOM % 12 ) + 1 ].wav gain $1 &&
          exit
          exec bash\""&
          }
  
  
          ###########################
  
          function frand(){
  
          ###########################
  
          v=$[t100 + (RANDOM % 100)]$[1000 + (RANDOM % 1000)]
          v=0.${v:1:2}${v:4:3}
          echo $v
          }
  
          ###########################
          ###########################
          ###########################
          ##########################
          ##########################
          ##########################
  
          function loop(){
  
          ###########################
  
          re='^[0-9]+$'
  
          if ! [[ $2 =~ $re ]] ; then
  
              if [ "$1" -gt 0 ]; then
  
                for ((i=1;i<=$1; i++));
                do
                ${@:3} && sleep $($2);
                done
  
              elif [ "$1" -eq 0 ]; then
  
                while true;
                do
                ${@:3} && sleep $($2);
                done
  
              fi
          else
  
                if [ "$1" -gt 0 ]; then
  
                        for ((i=1;i<=$1; i++));
                        do
                        ${@:3} && sleep $2;
                        done
  
                elif [ "$1" -eq 0 ]; then
  
                        while true;
                        do
                        ${@:3} && sleep $2;
                        done
  
                fi
  
          fi
  
          }
          ##########################
          ##########################
          ##########################
        
Language is ... image 1

Language is ... image 2

Language is ... image 3

Language is ... image 4