generated static html from poetic.software on 28. June 2019

:::::::::   ::::::::  :::::::::: ::::::::::: :::::::::::  ::::::::
:+:    :+: :+:    :+: :+:            :+:         :+:     :+:    :+:
+:+    +:+ +:+    +:+ +:+            +:+         +:+     +:+
+#++:++#+  +#+    +:+ +#++:++#       +#+         +#+     +#+
+#+        +#+    +#+ +#+            +#+         +#+     +#+
#+#        #+#    #+# #+#            #+#         #+#     #+#    #+#
###         ########  ##########     ###     ###########  ########

 ::::::::   ::::::::  :::::::::: ::::::::::: :::       :::     :::     :::::::::  ::::::::::
:+:    :+: :+:    :+: :+:            :+:     :+:       :+:   :+: :+:   :+:    :+: :+:
+:+        +:+    +:+ +:+            +:+     +:+       +:+  +:+   +:+  +:+    +:+ +:+
+#++:++#++ +#+    +:+ :#::+::#       +#+     +#+  +:+  +#+ +#++:++#++: +#++:++#:  +#++:++#
       +#+ +#+    +#+ +#+            +#+     +#+ +#+#+ +#+ +#+     +#+ +#+    +#+ +#+
#+#    #+# #+#    #+# #+#            #+#      #+#+# #+#+#  #+#     #+# #+#    #+# #+#
 ########   ########  ###            ###       ###   ###   ###     ### ###    ### ##########



Poetic Software challenges the default mode of software as a tool where functionality and productivity are predominant through an intervention that involves software as a non-functional, emotional, and cultural object of artistic practice.


My name is Alexander Roidl. I am a graphic / web / designer / artist / developer. I graduated from Hochschule Hof in Germany (Mediadesign) and I am currently studying in the Master’s program Mediadesign: Experimental Publishing at the Piet Zwart Institute in Rotterdam, Netherlands. My work explores the intersection of networks, interaction and visual culture. alexroidl.de


Software has taken command of our daily life. It is omnipresent and most of our Western society would come to a halt without it. At the same time software has become so ordinary, that it is often overlooked. Software is taken for granted while it is increasingly entangled in our life and continuously adopts new tasks. Our computers seem to become smarter through new kinds of algorithms. This leads to new challenges in understanding software – not only from a scientific point of view but also from a cultural, political and social perspective. Software has also found its way into the art and vice versa, but there are still gaps in the relation between the two. I assume that the interaction between software and art can be productive and helpful for the research in both of the disciplines. 

The question that I am asking is: How can artistic methods be used to elicit critical reflection on software as a cultural object beyond the interface? The current perception and use of software are significant parts of this research, especially in contrast to the original culture around software, that included hacking and that required every artist to write their own software. This publication explores the multiple layers of software with a particular focus on the assumptions and imaginations that arise around and through software. 

I consider poetic as a reference to the emotional, subtle and artistic expression that software can have. This work is not about considering the code of software as poems or as literature. It points to the non-neutral and imaginative character that software already has and that can be used for further artistic engagement. It also embraces the potential non-functional attributes of software and acknowledges the metaphors that software uses. It reflects on the different layers of interpretation and execution that software can have and leaves the result open for interpretation. Poetic software provides the possibility to create new artistic software, that is beyond the interface and beyond the expected mode of operation or depiction of software. Poetic software does not need to function but comes with an inherent call for statements about issues of software. 


1. Software is not neutral

Software comes with an embedded bias. Software is made by humansand therefore the creators enforce their perspective on software. Oneexample where we encounter this non-neutrality everyday is the userinterface.

The user interface enables aconvenient way to display software (or at least parts of it). Thisrepresentation is however only an interpretation of what the designerthought is the best way to display it (Hadler et al. 2016, p. 7). At the same time, it looks like this user interface is the only truth that the program holds. It does certainly not become evident that this interface is not neutral. The GUI instead hides. It hides the processes, manyfunctions, the source code, the possibilities or the decision it takesfor you.

The need for a human approach to software also becomesvisible from the great use of Graphical User Interfaces. The so-calledGUI is not part of the original imaginary of computation, where commands were being filled in via a command line. However, today’s average useris only surrounded by software displayed via a “window”, encounteringthe terminal only by chance. Not only does the GUI simplify commandsinto buttons and mouse-actions, but also does it make software morehuman. A button that has a 3D effect, the on/off function is displayedvia a switch, the mouse transforms into a hand or the form that lookslike a letter, which of course you fill in by pressing a pen symbol(Fuller 2008, p. 175). This is also known as skeuomorphism. It meansthat objects of the real world are being used for representing digitalfunctions or interface objects. Humans anthropomorphize and usemetaphors to communicate the complexities of a less well-known domain(the digital) via the vocabulary and concepts associated with awell-known domain (the physical world). The skeuomorphism in GUIs is anexcellent example of that.

Hadler, F., Haupt, J., Andrews, T. L., Callander, A., Flender, K. W., Haensch,K. D., Hartmann, L. F., Hegel, F., Irrgang, D., Jahn, C., Lialina, O.,Szydlowski, K., Wirth, S., and Yoran, G. F., 2016. Interface Critique.Berlin: Kulturverlag Kadmos Berlin.

2. Software can be non-functional

We can get a spark of what execution of code means and how software really acts and performs when it fails or when it is taken out of its context (Winograd and Flores 1995). In the following, I want to argue that for a serious engagement with software it is also necessary to look at the non-functional and the stuff that is in-between the pixels and conducting paths. We expect software to run seamlessly, but what if software fails or malfunctions? What, if software has no function?

“Most people notice infrastructures only when they are put in the wrong place or break down. This means that public knowledge of them is largely limited to their misplacement or malfunction.” (Parks 2009)

While The Alliance for Code Excellence imagines »[a] world where software runs cleanly and correctly as it simplifies, enhances and enriches our everyday life is achievable« (Constant 2018, p. 11) I argue that the malfunctioning of code can also be something positive that is revealing and holds a value. The interruption of a seamless flow, makes undeniable apparent, what could not be seen before. We can use things without being immediately aware of their presence, but the “breakdown” makes them visible. So the malfunctions “reveal[e] to us the nature of our practices and equipment, making them 'present-to-hand' to us, perhaps for the first time.” (Winograd and Flores 1995, pp. 77–78)
The way how software is set up, can embrace the fact that software is failing or not. In the case of seamless software that tries to hide failure, the user does not get any insight. In contrast, when the setup is embracing its unstable character, the user knows that there is a potential for crashes. It means that engagement is undeniable. At the point when it crashes, you are able to get a glimpse of the inner workings of software and possibly be able even to fix it.

The imperfection of software
Digital systems are often considered to be perfect, without the inconsistency and noise that analog systems contain. Instead, also digital applications become inaccurate. This is also a result of the dependencies and glitches as pointed out before. Software can even have the same noise as non-digital objects have. When Casey Reas wrote about the new Processing1 he pointed out the high precision that computers have compared to similar art-forms like Sol LeWitt practiced it. »[…] [M]achines can draw lines with absolute precision so all the imperfections in a physical drawing are removed, giving the rendering different characteristics than those intended by LeWitt.« (Reas 2019) In reality, it turned out that after a few month processing produced the same inaccuracies (glitches) as a drawing by LeWitt would show. This was due to updates and changes in the language.

Constant, 2018. The Techno-Galactic Guide to Software Observation.Reas, C., 2019. {Software} Structures by Casey Reas et al. [online]. Available from: https://artport.whitney.org/commissions/softwarestructures/text.html [Accessed 28 Feb 2019].
Winograd, T. A. and Flores, F., 1995. Understanding Computers and Cognition: A New Foundation for Design. New ed. Boston: Addison Wesley.
Parks, L., 2009. Around the Antenna Tree: The Politics of Infrastructural Visibility. [online]. Available from: http://www.flowjournal.org/2009/03/around-the-antenna-tree-the-politics-of-infrastructural-visibilitylisa-parks-uc-santa-barbara/ [Accessed 28 Feb 2019].

3. Software is Art is History

The attempt to use Software artistically can be exemplified with Software Art. Software Art describes the »artistic preoccupation with software production« (Cox 2007, p. 147). This means that Software Art is using either the software itself or code as its material. The subjects it addresses are mostly the cultural concepts of software. Software Art does not take software for granted and therefore it also acknowledges the importance of the creation process of software (Cramer 2002).
To put focus on the process instead of the end product is not new in the art world, but Software Art exemplifies this approach »appropriate to contemporary conditions« (Cox 2007, p. 147). This creates the possibility to think of software in terms of performance. While the result is not necessarily a fixed product, that is visible, it can be a run-time application, that never reaches the state of finishing. An approach like this opens up new discussions and new ideas. An example of this is the application »Every Icon« by John F Simon Jr. It is a simple 32 by 32 grid that iterates through every possible combination of black and white squares in the grid. The application has been running since January 14, 1997 and will continue for many years. The application only becomes visible, when you visit the website, which displays the current state. Other than that, it performs on its own, reaching formations that will never be seen. In an elegant way this work challenges the viewer’s imagination about limitations of computation, while automatically producing new, unique images.
Only if the role of software itself is questioned or at least acknowledged in the creation of artworks can the creativity be freed again from the dependencies of the culture industry as pointed out above. This method of Software Art is helpful for both the artist and the user, that receives the artwork. Firstly, it opens new ways for the artist to work with software and secondly, the recipient will gain a different perspective on software.

We can see from this that art is occupying practices that can be useful to evoke critical insight into software. Art has shown in its history that it can research complex and abstract issues and deliver critical insights for its recipients. Software is so complex in its relations and so versatile in its effects that it might be hard to go about a structured analysis. Instead, art might provide a field of exploration and experimentation, which can question and enrich the culture around software, at the same time. Artistic practice can occupy fields that are difficult to understandable on a solely rational level, like in the field of literacy or theater. Brenda Laurel describes Computers as a theatre, due to the factors of runtime, interaction and space (Laurel 2013). The execution of software can be seen as a performance. When the program is executed machine code turns into machine actions. Software can create emotions and art is able to elicit them. Art offers the opportunity to deeply engage with certain aspects of software and connect the cultural to the scientific realm. Software creates new ways of expression for artists. Artists can generate experimental software, that doesn’t need to function as a program but can work as a cultural object, a critique or a question.
Art has famously shown that it can re-contextualize and question objects of our daily life, that have become invisible. Art can make software visible again, and question how software is used. It is therefore crucially important for artists who work with software, to understand it’s internal functioning.

Laurel, B., 2013. Computers as Theatre. 2nd ed. Upper Saddle River, NJ: Addison-Wesley Professional.
Cramer, F., 2002. Contextualizing Software Art, 9.
Cox, G., 2007. Generator: The Value of Software Art. In: Rugg, J. and Sedgwick, M., eds. Issues in Curating Contemporary Art and Performance. Intellect Books, 147–162.

4. Software is a product

In the chapter The Culture Industry in “Dialectic of Enlightenment” Adorno and Horkheimer state that culture is infecting everything with sameness (2007, p. 94). They point out, how culture has become part of mass production and standardization. Adorno and Horkheimer argue that commercial marketing of culture robs people’s imagination and takes over their thinking (2007, p. 98). As an example, they name the transition from telephone to the radio. While everyone was able to communicate through the telephone, the radio transformed the once free actor into a mere listener (Horkheimer and Adorno 2007, p. 115). The reason for this is the commercialization of culture and the resulting relation between consumer and industry. This means that the industry creates culture solely for profits. The consequence for art is that it is also only a product and therefore loses its critical factor and its autonomy (Horkheimer and Adorno 2007, p. 147).

Obviously, most software exists to provide financial benefits to the creators (and owners of marketplaces). Also, software has become an object of the culture industry. It means that the user is a consumer now and that software is guiding people’s thinking thus limiting their imagination. Software is made to be used by as many people as possible, therefore it has to be simple and generic. Additionally people are made dependent on proprietary software to get as much money out of them as possible.
Art is confronted with this issue on two different layers. Artist that use software not only have to deal with the limited, commercialized software, but are also taking part in cultural production actively by distribution their art. Following Adorno and Horkheimer’s assumption that art has lost its critical character through commercialization this means that firstly the software limits the art or the practice of the artist, secondly the output of the artist is again constrained, through their commercialized artwork. So instead of criticizing the condition they works in, artist potentially amplify the effect of mass produced culture through the use of commercialized software.
These two layers can be seen from the superficial use of software. The User Interface dominates the perception of software for most users. A lot of digital arts, like Generative Art, are focused on output and mostly consider software as a tool (Galanter 2003). They take over the focus on the surface into their practice. The artistic use of machine learning is a great example of a user that is “stuck” on the interface layer. Instead of engaging with the inner functions of neural networks, artists generate obscure images while mostly talking about rather popular topics like datasets, utopia or dystopia (Greene 2018). The deep dream1 is not deep indeed. The use of these algorithms is very flat and mostly concentrates only on the output (which is easy to sell). These morphed images are being generated on high-resources machines using libraries that are provided by for-profit corporations. This creates a dependence on fast computers and on libraries of third parties. Furthermore, when using those libraries, the user is obedient to the big companies creating such frameworks. Additionally, it also obscures the processes and hides software once more, affirming its already hidden character. So Generative Art doesn’t really find a way out of the limitations that come with commercial software, being caught in exactly that loop of cultural production that Adorno and Horkheimer criticize.

Horkheimer, M. and Adorno, T. W., 2007. Dialectic of Enlightenment. 1 edition. Stanford, Calif: Stanford University Press.
Greene, T., 2018. Someone paid $432K for art generated by an open-source neural network [online]. The Next Web. Available from: https://thenextweb.com/artificial-intelligence/2018/10/25/someone-paid-432k-for-art-generated-by-an-open-source-neural-network/ [Accessed 28 Feb 2019].
Galanter, P., 2003. What is Generative Art? Complexity Theory as a Context for Art Theory [online]. Available from: https://www.philipgalanter.com/downloads/ga2003_paper.pdf [Accessed 28 Feb 2019].

5. Software is physical

Space is a recurrent scheme in computation. Computer Science tries to shrink and expand at the same time. It is almost like a play that can be observed on different layers. The »compression of space« into the size of a microchip is opposed with the exploding need for power or, to remain within the metaphor of space, disk space (Kitchin 2011, p. ix). The expansion of the digital does not remain within the computer, but it is actively becoming part of our real space. »[S]oftware generates behaviors and opportunities, and traffics in meanings, readings, and interpretations« (Kitchin 2011, p. ix). To figure out these exact moments of influence and these borders between computers and the real world might be very hard to accomplish, if not impossible. As Hu points out, the material and the digital world are interwoven more deeply than we think. For example, the imagination of the internet as a cloud manifests in the real world as cables that get placed across oceans, and buildings that hold thousands of servers (Hu 2016, p. 6). Therefore it becomes clear that a separation between the digital and the material world does not make sense.

The internet in its physicality. Cables are following old railroad routes. (from Hu 2016, p. 3)

The software of satellites manifests in the form of calibration targets in the dessert (Google 2019).

Kitchin, R., 2011. Code/Space - Software and Everyday Life. Cambridge, Mass: MIT Press.
Hu, T.-H., 2016. A Prehistory of the Cloud. Reprint edition. Cambridge, Massachusetts: MIT Press.

6. The noise in software needs to be amplified

The polished interface makes us forget about what programmers struggle with every day: the noise that surrounds computation. It is the same noise that should make us aware of how imperfect and subjective software is, but in many cases, this noise is being suppressed. Every small glitch is being removed out of software and every irregularity is considered as a bug. All this noise might instead be the possibility to explore new opportunities with code and its execution further. Maybe the beauty of software lies in exactly this noise, that is being forgotten about in-between the logical operations with 0s and 1s.
Deeper artistic engagement with software is promising to find a balance between beautiful artistic expression and fundamental discussion around software usage and production. Poetic Software can be playful and serious, subjective and emotional, inspiring and revealing, helpful and funny at the same time. What is important is that it shows genuine engagement while not falling into the trap of commercial and thoughtless software usage.
It might be a way to emphasizes the glitch, or use the narrative, to show what software is not, and what else software could be.
Eventually, this might be the way back to the noise that Kittler was calling for. 
»The inverse strategy of maximizing noise would not only find the way back from IBM to Shannon, it may well be the only way to enter that body of real numbers originallyknown as chaos« (Kittler, 1992, p. 147)

Kittler, F., 1992. There is no Software. [online]. Available from: https://monoskop.org/images/f/f9/Kittler_Friedrich_1992_1997_There_Is_No_Software.pdf [Accessed 28 Feb 2019].

7. The user is not a consumer

Nowadays the software that is required to use a machine comes pre-installed and ready to use. Software can be downloaded from centralized marketplaces: App Stores. This causes an immense dependence on the producers, who are in return depending on owners of these marketplaces (including their platform framework and policies). These producers have developed an infinite selection of apps, which is another example of the »explosion« of software that was previously mentioned. The flood of applications causes software to become a mundane occurrence. The danger here is that we take software for granted. When we have a problem, there is an app for it. Nobody thinks about the possibility of editing software and adjusting it to one’s need. This is not only because usually it is not possible to edit the software due to DRM but also because the average user is not a user anymore. Instead, people are being educated by companies to be consumers instead of users let alone creators.1 It is in the companies’ interest to make their clients dependent on their product. Therefore companies are not interested in opening up their products, but they are instead locking it up. They are then slowly feeding their clients with updates and new fancy features. This is great for users who just need to get their job done and who want to be in contact with technical struggles as little as possible. On the other hand, it means that for one, the use of software is dictated by companies and secondly that if you want to engage with your software more in-depth you cannot do so. Often you cannot look at the source code, reuse parts of it or modify the program to your needs.

Of course, there is also software that embraces an open and reusable character. This also provides an excellent source for discussion about software. The problem is that such software often requires other programs and more technical knowledge. The average user is not willing to invest that kind of effort. There are also other kinds of software, that embrace the user as an active agent, while still enabling a simple use on the surface. For example, the MediaWiki software allows for accessible editing on the browser, while still providing an infrastructure to extend the functions easily.

8. Software is culture

»We shape our tools and, thereafter, our tools shape us« (Davis 2016) says a famous quote by John Culkin from 1967. If we look at the dependencies of software one could also say: we shape tools and these tools shape new tools. Transferring this idea to the notion of software as a cultural object, the interrelation between shaping and being shaped could be formulated as follows: software creates and influences culture, and therefore this culture shapes new social conditions under which the construction and use of software itself are altered. This might become clear when looking at the example of software hacking. The distribution of proprietary software with Digital Rights Management (DRM) lead to multiple groups cracking and circumventing software limitations. These cracks are then distributed as new software.
The original culture of software was actually built around a free culture, that distributed code openly and freely. Early software production was very dependent on this openness. (Mansoux 2017, p. 31). Without the sharing of software and code, the development would have been very tedious, if possible at all. It is this openess that nowadays has to be defended, like the free software movement does. Free software is not self-evident anymore, because companies commercialized software for their profits.

Davis, F., 2016. We shape our tools and, thereafter, our tools shape us. Medium [online]. Available from: https://medium.com/@freddavis/we-shape-our-tools-and-thereafter-our-tools-shape-us-1a564cb87484 [Accessed 27 Feb 2019].
Mansoux, A., 2017. Sandbox Culture: A Study of the Application of Free and Open Source Software Licensing Ideas to Art and Cultural Production. [online]. Available from: https://monoskop.org/images/e/ea/Mansoux_Aymeric_Sandbox_Culture_A_Study_of_the_Application_of_FLOSS_Licensing_Ideas_to_Art_and_Cultural_Production_2017.pdf [Accessed 28 Feb 2019].

9. Software is emotional

The perception of software is anything but neutral. Software tells stories, through its metaphors, its contents, its performance. The digital medium offers new ways of telling stories. This becomes obvious not only due to different structures, like the form of the database as Lev Manovich points out but also because of the different modes of intervention software takes in our life (Manovich 1999, p. 82). The medium keeps evolving at inexorable speed and so does software, leaving space for new ways of how to tell and what to tell about computation.

That humans tend to anthropomorphize not only their surroundings but also computers and technology, in general, has been a well-researched topic among computer sciences & psychology. Among others, “The media equation” had shown, that we as humans consciously and unconsciously anthropomorphize computers (Reeves and Nass 2003). In addition to that humans have a vivid and diverse imagination about invisible processes. This includes software. Often digital media black-boxes certain processes and therefore provides much space for imagination and narratives that can be constructed around it (Finn 2017, p. 229). Narratives have been used for the purpose of marketing, and there have been attempts to create relatable stories within applications. A popular example is Joseph Weizenbaum’s Eliza, a digital application, that acted as a therapist, chatting with the user. This piece of software gave convincing proof of how humans anthropomorphize even simple digital applications (Wardrip-Fruin 2012, p. 27). Tech giants have put great effort into implementing relatable characters into their systems, e. g. voice assistants. An assistant that is helpful and funny that gathers your data with great pleasure. However, in the past there have also been unsuccessful attempts to add anthropomorphizing elements to programs, only to remind quickly about Microsoft’s famous Clippy (Cain 2017). These stories in applications and around it make technology more understandable, but can also be a source for misconceptions. A current example seems to be the fear of singularity after machine learning enables applications to »magically« generate or label images. The gap between the real potential and the imagination about it is significant. I don’t want to support an uncritical or blind approach towards technology – I think it is important to be realistic, critical and playful equally with these algorithms, only then turns engagement into insight.

Another case of narratives is the narrative that exists outside the software. It lies in its performance. How it acts, where and when. The realization that people relate to software on an emotional level makes it possible to create software that tells more than its function. It’s possible to tell stories only by how software works. This kind of narrative has been used in some works of Software Art. For example a work by Luca Bertini which can be found on runme.org. The work is about two viruses in love. »They search for each other on the net, running through connected computers« (Bertini 2019).

Manovich, L., 1999. Database as Symbolic Form. Convergence, 5 (2), 80–99.Bertini, L., 2019. runme.org - say it with software art! [online]. Available from: http://runme.org/project/+ViCon/ [Accessed 28 Feb 2019].
Wardrip-Fruin, N., 2012. Expressive Processing: Digital Fictions, Computer Games, and Software Studies. Cambridge, Mass London: The MIT Press.
Cain, A., 2017. The Life and Death of Microsoft Clippy, the Paper Clip the World Loved to Hate [online]. Artsy. Available from: https://www.artsy.net/article/artsy-editorial-life-death-microsoft-clippy-paper-clip-loved-hate [Accessed 28 Feb 2019].
Finn, E., 2017. What Algorithms Want: Imagination in the Age of Computing. Cambridge, MA: The MIT Press.
Reeves, B. and Nass, C., 2003. The Media Equation: How People Treat Computers, Television, and New Media Like Real People and Places. Reprint. Stanford, Calif: Center for the Study of Language and Inf.

10. There is software

In his well known essay from 1992 Kittler argues what the title anticipates: »There is no Software«.
This text very early became one focus of my interest and research. The text offers an excellent source for thinking about software today. Because in the essay from 1992 Kittler is not negating the existence of software, instead he wants to emphasize the materiality, that is being neglected in his opinion. This is a huge tension that we can also recognize in computation today. Even if we do not dismiss the existence of software, it becomes more and more invisible. Workflows are so seamless it seems almost like there is no software.

Although software is depended on hardware, it does not mean that there is no software. A deeper engagement with software means taking software seriously. Even though it might be argued that software is only the representation of machine operations, it is vital to acknowledge software as an independent object of study.
Cramer points out that »if any algorithm can be executed mentally, as it was common before computers were invented, then of course software can exist and run without hardware« (Cramer 2002). Following this argument, it points to the idea of software in a very conceptual way, not only defining software as a program that is running on particular hardware. A recent example of this would be that people compute blockchains by hand to demonstrate the math involved. Eventually, all layers of diminishing abstraction on top of hardware deserve attention. Still, it is important to recognize both of the perspectives for their importance – the materialistic and the cultural/political.

There is no clear border between software and hardware. Where does software begin and hardware end? Is it when the Code is being compiled or is it when the machine code is transformed into electrical signals? In the end, the exact point where the software transforms into hardware is not clearly perceivable (Tenen 2017, p. 88).

Cramer, F., 2002. Concepts, Notations, Software, Art [online]. Available from: http://cramer.pleintekst.nl/essays/concept_notations_software_art/concepts_notations_software_art.html [Accessed 28 Feb 2019].
Tenen, D., 2017. Plain Text: The Poetics of Computation. Stanford University Press.


1. Slow Turtle

Slow Turtle is a server that responds to Slow Lorris.
Usually Slow Lorris is a not very welcome guest. It is the name of a well-known cyberattack. It is a Denial of Service Attack, → denial of service attack that sends many very slow requests towards a server. Some server software is brought to it's limits due to the many slow requests. Slow Turtle is a server that responds as slowly as Slow Lorris and therefore does not go down. 

You see the webpage on the left is greeting slow lorris

For at git.xpub.nl/aaaa/slow_turtle

2 Python programs, one acting as Slow Lorris, and the other one as Slow Turtle. 
Slow Turtle is a very simple HTTP server that responds super slowly. 

2. Wifi Poem

SSIDs that make up a poem that is dependend on your position in the space. 

3. Bootloader Publication

A publication that comes in the form of a bootloader. → bootloader When booting into, it displays the projects of the Graduation Show 2019 of the Piet Zwart Institute.

Feel free to make your own publication and fork the bootloader here: git.xpub.nl 

start screen of the bootloader publication


Multistage bootloader, written in Assembly.
Initial 512 bytes program, that loades 6 individual assembly programs into the memory.
The bootloader facilitates BIOS interruption calls and therefore only runs on systems providing a legacy BIOS.
Contemporary computers use a framework called UEFI to boot the Operating System. UEFI is not supported by this bootloader, so it may be that you have to downgrade your system in order to use it.


PC with Legacy BIOS boot option
USB slot


1. Shut down computer
2. Plug the USB Stick into an empty USB slot
3. Restart the computer
3. Enter the BIOS Menu by pressing a button as instructed on bootup (often F1 or F12)
4. Change the boot-disk to the plugged USB Stick or change the boot-priority with the USB Stick first
5. Change the boot-mode to legacy boot mode, be sure to disable secure boot options
6. Save and reboot
7. The BIOS will automatically boot into the bootloader

4. PSP: Software Minigame

As your computer breaks down, you get caught on the CPU fo your computer. Meet Kittler and convince him that Software exists, to edit the maze and break free.

PlayStation Portable with custom firmware. → bootloader  
Stackless Python to run the minimal game, with an abstraction of pygame. 

follow the instructions in the game

5. Palm & Fingers

My Palm stays calm while I am trying to write. I follow the instructions.
I am aware of the software that I use. I am aware of the software that I use. I am aware of the software that I use. I am aware of the software that I use. I am aware of the software that I use. I am aware of the software that I use.

This exercise relies heavily on the idea of instructions and the user becoming the software. Please follow the instructions.

The gestures result in different results as the shapes of the letters are being draw

Palm Z22, with Graffiti handwriting recognition running.

1. Pick up the palm next to you
2. If the screen is black, press the button on the lefthand side
3. Use the pen to draw the following shapes (figure 1).

figure 1: draw these shapes to the screen of the Palm using the pen

6. Minimal writing

What is the most simple writing application that exists?
Can it reveal poetic values?Minimal writing program in C, letters with key-codes create concrete poetry

minimal text editor to write and save .txt files in 16 lines of python

7. Software Depicting Software

A piece of software that looks up images of software online.
How does software depict itself?

8. My iPod is bored

Through many different new technologies, the iPod has become an obsolete device. It is left only with its memory. So it discovers itself,playing with its own memory. → memory 

Old iPod Classic, with custom software (Rockbox) installed. 
Written in C.

1. Scroll to reveal the story of the bored iPod 

9. Pin Printer

The pin printer uses 9 pins in a vertical order to print to paper. Through the holes in the paper, it gets dragged through the machine.
I use the pin printer to publish this very same publication in an interactive way. Like a classical Terminal it lets you navigate trough the publication by typing commands (like you would do in the shell). It interactively reacts to user input.

pin printer with keyboard, ready to type


Python script fetching the user input and printing to the Microline 9-Pin Printer (320)
The content of the publication is called through a API from poetic.software


1. Press any key to start the publication
2. Read the instructions given on the screen
3. You have to type commands to assemble parts into your own individual publication 
4. To finish the publication type "exit"
5. Tear off the paper at the perforation and take it with you

10. Para.dox

A writing interface that allows for reading, writing and running software.
Reflecting on the writing environments that we use on a daily basis on the computer. 

The para.dox writing environment 

Flask application with SQlite database 

Fork at git.xpub.nl



Memory exists on different levels in computation. Most importantly the Random-Access Memory (RAM). This part of the computer is used to store data for running processes. In this sense it can be considered as a short-term memory, while the hard drive is more of a long-term storage.


In the original sense the computer does not have a notion of interaction. The way user input e.g. through typing is handled with interrupts. The interrupt literally interrupts the system and stops processes to handle the user input. In that way the input through users gains priority over other processes running on the computers.


To load the Operating System (OS) the system needs to load it into its memory and setup certain parameters to make the OS executable. In order for the computer to know, where to start with the execution it just uses a fixed address to look for the HEX code 00AA at the 512th byte of the bootdrive. If it finds this numbers it considers the drive to be bootable and starts the execution of the program. These first 512 bytes are part of the bootloader. From this position the bootloader may then load a second (bigger) bootloader.

denial of service attack

A denial of service attack is a cyberattack towards a machine. The aim is to make to target unreachable or unusable. "Appropriately enough, denial-of-service attacks [are] usually abbreved DoS." (Powers, S. and Peek, J., 2003, p. 973) It is used for political or blackmailing purposes. There are different ways of taking a resource down in a network.

Powers, S. and Peek, J., eds., 2003. UNIX power tools. 3rd ed., updated and expanded. Sebastopol, CA: O’Reilly.


Concept to archive grey-scale appearance on bitmap images (black andwhite only), by the way pixels are distributed. There are differentalgorithms that arrange pixels differently. E.g. Error diffusion,Floyed-Steinberg.


Because the computer doesn’t have a real notion ofrandomness, most Unix systems have a device mounted to the system thatcollects noise from current processes on the system. From this noise itis possible to generate more »real« randomness.