XPUB
/
project.xpub.nl
65
1
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4b4512d7bd'
${ noResults }
project.xpub.nl/poetic-software/index.html

349 lines
51 KiB
HTML
Raw Normal View History Unescape Escape

alex updated site
5 years ago
<html>
<head>
<meta charset="UTF-8">
<style>
#main{font-family: monospace;
max-width: 50%;
font-style: normal;
line-height: 16px;
}
.post{font-style: normal;
}
h1{
display: inline-block;
font-size: 13px;
font-style: normal;
font-weight: normal;
margin: 0;
padding: 0;
text-align: justify;
text-justify: inter-character;
width: 100%;
text-align-last: justify;
}
h1:after { /* Justify last line */
content: '';
display: inline-block;
text-align: justify;
text-justify: inter-character;
text-align-last: justify;
width: 100%;
}
.divider{
display: block;
position: absolute;
height: auto;
width: auto;
white-space: nowrap;
}
.divider2{
display: block;
position: absolute;
height: auto;
width: auto;
white-space: nowrap;
}
.mono{}
img{
width: 100%;
}
hr{
border: 0.5px solid black;
}
.title{
cursor: pointer;
color: blue;
text-decoration: underline;
}
.references{
display: block;
font-style: italic;
padding-bottom: 10px;
max-width: 50%;
}
.content{
padding-left: 50px;
display: none;
}
#ascii{
font-size: 0.9vw;
line-height: 0.9vw;
}
@media only screen and (max-width: 700px) {
#main{font-family: monospace;
max-width: 100%;}
#ascii{
font-size: 1.5vw;
line-height:1.5vw;
}
}
@page {
margin: 20pt 20pt 20pt 20pt;
}
@media print {
.title{
page-break-after:avoid;
}
h1{
page-break-before: auto;
}
.content{
display:block;
}
#main{
max-width: 100%;
}
img{
max-width:50%;
}
}
</style>
</head>
<body>
<div id="main">
<span class="mono">
<h1>POETIC </h1><h1>SOFTWARE</h1><br>
<span class="divider2"></span>
<br>
<i>generated static html from <a href="poetic.software">poetic.software</a> on 28. June 2019</i><br>
<span class="divider2"></span>
<br>
<br>
<pre id="ascii">
::::::::: :::::::: :::::::::: ::::::::::: ::::::::::: ::::::::
:+: :+: :+: :+: :+: :+: :+: :+: :+:
+:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
+#++:++#+ +#+ +:+ +#++:++# +#+ +#+ +#+
+#+ +#+ +#+ +#+ +#+ +#+ +#+
#+# #+# #+# #+# #+# #+# #+# #+#
### ######## ########## ### ########### ########
:::::::: :::::::: :::::::::: ::::::::::: ::: ::: ::: ::::::::: ::::::::::
:+: :+: :+: :+: :+: :+: :+: :+: :+: :+: :+: :+: :+:
+:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
+#++:++#++ +#+ +:+ :#::+::# +#+ +#+ +:+ +#+ +#++:++#++: +#++:++#: +#++:++#
+#+ +#+ +#+ +#+ +#+ +#+ +#+#+ +#+ +#+ +#+ +#+ +#+ +#+
#+# #+# #+# #+# #+# #+# #+#+# #+#+# #+# #+# #+# #+# #+#
######## ######## ### ### ### ### ### ### ### ### ##########
</pre>
<br>
<span class="divider2"></span>
<br>
LINKS
<button id="printbutton3" onclick="location.href='#';">PDF THESIS</button> <button id="printbutton2" onclick="location.href='#';">UPSETTING SETTINGS</button> <button id="printbutton" onclick="window.print();return false;">print</button>
<br>
<span class="divider2"></span>
<br><br>
DESCRIPTION<br><br>
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.
<br>
<span class="divider2"></span>
<br><br>
BIOGRAPHY<br><br>
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.
<a href="www.alexroidl.de">alexroidl.de</a>
<br><br>
<span class="divider"></span>
<br>
<br>
<h1>INTRODUCTION</h1>
<div class="post">
<p>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.&nbsp;</p><div>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.&nbsp;<div><div><br></div><div>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.&nbsp;</div></div></div><p></p></div>
<br>
<h1>THESES ON SOFTWARE</h1>
<div class="post"> <a class="title"><p>1. Software is not neutral</p></a><p><a class="title"></a> </p><div class="content" ><div>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.<br></div><div><br></div><div>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.<br><br>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.<br></div><div><br></div><div><span class="references">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.</span></div></div></div>
<div class="post"> <a class="title"><p>2. Software can be non-functional</p></a><p><a class="title"></a> </p><div class="content" ><div>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&nbsp;(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? <br></div><div><br></div><div>“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)<br></div><div><br></div><div>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)<br></div>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. <br><br><i>The imperfection of software</i><br><div>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.</div><div><br></div><div><span class="references">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]. <br></span></div><div><span class="references">Winograd, T. A. and Flores, F., 1995. Understanding Computers and Cognition: A New Foundation for Design. New ed. Boston: Addison Wesley. <br></span></div><div><span class="references">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].</span></div></div></div>
<div class="post"> <a class="title"><p>3. Software is Art is History</p></a><p><a class="title"></a> </p><div class="content" >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).<br>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. <br>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. <br><br>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. <br><div>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. <br></div><div><br><span class="references"></span></div><div><span class="references">Laurel, B., 2013. Computers as Theatre. 2nd ed. Upper Saddle River, NJ: Addison-Wesley Professional. <br></span></div><div><span class="references">Cramer, F., 2002. Contextualizing Software Art, 9. <br></span>
<div class="post"> <a class="title"><p>4. Software is a product</p></a><p><a class="title"></a> </p><div class="content" >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).<div><br></div><div>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.<br>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. <br>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. <br></div><div><br></div><div><br></div><div><span class="references">Horkheimer, M. and Adorno, T. W., 2007. Dialectic of Enlightenment. 1 edition. Stanford, Calif: Stanford University Press. <br></span></div><div><span class="references">Greene, T., 2018. Someone paid $432K for art generated by an open-source neural network [online]. The Next Web. Available from: https://the
<div class="post"> <a class="title"><p>5. Software is physical</p></a><p><a class="title"></a> </p><div class="content" ><div>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. <br></div><div><br></div><div><img class="textimage" src="img/mapofinternetandrails.png"><span class="imgsub">The internet in its physicality. Cables are following old railroad routes. (from Hu 2016, p. 3)</span></div><div><span class="imgsub"><br></span></div><div><span class="imgsub"><img class="textimage" src="img/satellite_target.jpg"><br></span></div><div><span class="imgsub">The software of satellites manifests in the form of calibration targets in the dessert (Google 2019).<br></span></div><div><br></div><div><br></div><div><span class="references">Kitchin, R., 2011. Code/Space - Software and Everyday Life. Cambridge, Mass: MIT Press. <br></span></div><div><span class="references">Hu, T.-H., 2016. A Prehistory of the Cloud. Reprint edition. Cambridge, Massachusetts: MIT Press.</span></div><div><br></div><br></div></div>
<div class="post"> <a class="title"><p>6. The noise in software needs to be amplified</p></a><p><a class="title"></a> </p><div class="content" ><div>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. <br></div><div>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.<br>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. <br>Eventually, this might be the way back to the noise that Kittler was calling for.&nbsp;</div><div>»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) <br></div><div><br></div><div><span class="references">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].</span></div></div></div> <div class="post"> <a class="title"><p>7. The user is not a consumer</p></a><p><a class="title"></a> </p><div class="content" >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. <br><br>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 oth
</span>
</div>
<script>
var getNextSibling = function (elem, selector) {
// Get the next sibling element
var sibling = elem.nextElementSibling;
// If the sibling matches our selector, use it
// If not, jump to the next sibling and continue the loop
while (sibling) {
if (sibling.matches(selector)) return sibling;
sibling = sibling.nextElementSibling
}
};
var coll = document.getElementsByClassName("title");
var i;
for (i = 0; i < coll.length; i++) {
coll[i].addEventListener("click", function() {
this.classList.toggle("active");
var content = getNextSibling(this, '.content');
if (content.style.display === "block") {
content.style.display = "none";
} else {
content.style.display = "block";
}
});
}
makedividers();
function makedividers(){
var dividers = document.getElementsByClassName("divider");
var fontSize = 12;
var frame = document.getElementById("main");
for(var i = 0; i < dividers.length; i++)
{
dividers[i].style.fontSize = fontSize;
var height = (dividers[i].clientHeight + 1) + "px";
var width = (dividers[i].clientWidth + 1) + "px"
dividers[i].innerHTML = '';
while(dividers[i].clientWidth<frame.clientWidth){
dividers[i].innerHTML += '#';
}
}
var dividers = document.getElementsByClassName("divider2");
var fontSize = 12;
var frame = document.getElementById("main");
for(var i = 0; i < dividers.length; i++)
{
dividers[i].style.fontSize = fontSize;
var height = (dividers[i].clientHeight + 1) + "px";
var width = (dividers[i].clientWidth + 1) + "px"
dividers[i].innerHTML = '';
while(dividers[i].clientWidth<frame.clientWidth){
dividers[i].innerHTML += '-';
}
}
}
window.onresize = function(event) {
makedividers();
};
var text = ["print", "poetic", "software","website"];
var counter = 0;
var elem = document.getElementById("printbutton");
var inst = setInterval(change, 800);
var text2 = ["Upsetting Settings", "book", "Upsetting Settings", "publication"];
var elem2 = document.getElementById("printbutton2");
var text3 = ["pdf", "thesis", "pdf", "thesis"];
var elem3 = document.getElementById("printbutton3");
function change() {
elem.innerHTML = text[counter];
elem2.innerHTML = text2[counter];
elem3.innerHTML = text3[counter];
counter++;
if (counter >= text.length) {
counter = 0;
// clearInterval(inst); // uncomment this if you want to stop refreshing after one cycle
}
}
</script>
</body>
</html>