Ivar Tormod Berg rstavik Faculty of Informatics and e-Learning Sr-Trndelag University College Trondheim, Norway

Forms of time and chronotope in computer programming Run-time as adventure time?

Abstract Applying a Bakhtinian perspective to computer programming, this paper discusses how computer programs and fundamental processes of computer programming are rooted in social and cultural discourse. Drawing on Bakhtin's concept of "chronotope" and his analysis of the relationship between the "hero" and "adventure time" in ancient Greek novels, we analyse how programmers create their perceptions of a "programme" and its "run-time environment". Like the man-made constructions in the novel and communication in general, the programmers constructions of "programme" and "runtime" in modern programming are fundamentally oriented around a crafted fusion of time and space, i.e. some notion of chronotope. With this interdisciplinary approach we attempt to illustrate how we can perceive and create new programmes and system environments that exploit different perceptions of time and space. The paper presents computer programming as a useful new arena for pursuing dialogic perspectives, thus exploring their validity as a general theoretic framework for communication and technology studies.

Introduction to chronotopic analysis In Forms of time and chronotope in the novel, Bakhtin (1981) analyses the construction of time and space in literature. The main motivation behind chronotopic analysis is to describe different literary genres related means for appropriating [temporal and spatial] aspects of reality and their historical development (ibid.: 84). To achieve this ambition chronotopic analysis can be seen as a two step process. The first step is to analyse and describe how temporal and spatial aspects of reality are appropriated and constructed by writers and readers of different novelistic genres. The second step compares such analysis of different genres to illustrate how they relate to each other and are part of the same historical development. My motivation for analyzing chronotopic relationships in computer programming is this methods potential for illuminating the creative processes of our imagination. These creative processes are essential to programming and have much in common with their literary counterparts. As in literature, the construction of fictional worlds is pivotal for programming and, as in literature, these fictional worlds are not only a means to an end, but often also the end itself. In addition, we cannot help but be strongly impressed by the representational importance of the chronotope (ibid.: 250). The chronotope has a striking omnipresence in our conceptual figurations (ibid.: 257), both in literature and in computer programmes. Therefore, chronotopic analysis seems as an appropriate place to start our analysis of how we construct programmes in our minds. Lastly, the analogies between the adventure-time chronotope of Greek romance novels and the runtime chronotope of modern programming paradigms are unmistakable. This implies that the perceived disparity between the writing of novels and the writing of programmes is upheld more by an academic, cultural divide than differences between the practices in themselves. In sum, these three arguments suggest that applying chronotopic analysis to computer programming can further both academic understanding and practical applications for conceptualizing programmes and the virtual environments sustaining them.

Chronotope as an analytical category At the centre of chronotopic analysis is the term chronotope. The term chronotope is used as an analytical category describing the intrinsic connectedness of temporal and spatial relationships that are artistically expressed in literature (ibid.: 84). It is worth noting that the term chronotope is not used to describe the entire fictional worlds as we imagine them. As an analytical category chronotope is only used to describe the imagined time-space relationships or systems that are constructed together with these fictional worlds in order to sustain them. This distinction between the fictional world in our mind and the equally fictional timespace system that sustains it (i.e. chronotope) is useful because it illuminates the representational importance of the chronotope (ibid.: 250). Focusing on the temporal and spatial relationships within these fictional worlds highlights the necessity of such a chronotopic ground for our imagination and abstract thinking. The chronotope, functioning as the primary means for materializing time in space, emerges as the center for concretizing representation, as a force giving body to the entire novel. All the novels abstract elements philosophical and social generalizations, ideas, analyses of cause and effect gravitate towards the chronotope and through it take on flesh and blood, permitting the imaging power of art to do its work (op.cit.). Without a time-space system of some kind, our conceptual perceptions and constructions would have no ground to stand on and no time to exist in. Thus, chronotope as an analytical category directs our attention towards a basic and intrinsic foundation for our imagination. When presenting chronotope as an analytical category, Bakhtin (ibid.: 84) stresses the inseparability and intrinsic connectedness of space and time. The concepts of time and space, which we form in literary dialogue, cannot be understood separately, but must be viewed as a concrete whole. But, in my view an isolated chronotope is not a self-sufficient category. In order to form a complete analytical perspective, the

chronotope must also be seen in relation to an actor category of some kind. The image of man is always intrinsically chronotopic (ibid.: 85), but the chronotope too is always related to people (Bostad 2004: 173). Therefore, based on my reading of Bakhtins use of the chronotope as an analytical category and based on my experience applying this category in analysis of computer programming, chronotopes must be viewed in relation to a person, an image of man, a participant, a programme or some other actor(s) that can fill the chronotope with life and meaning. This co-dependency between the two categories of chronotope and actor becomes especially evident in computer programming. In programming we imagine extreme and bizarre fictional worlds and chronotopes. These worlds and chronotopes bear little resemblance to our everyday world, and this makes it especially difficult to implicitly place an image of ourselves, the image of man, or any other familiar actor in these worlds. Seen void of any actor and in isolation, these worlds become nonsensical and meaningless. In my view, chronotopic analysis therefore implicitly or explicitly needs to see chronotope in relation to an actor that can fill its inside with content, events and meaning. Before beginning the chronotopic analysis of computer programming, I will first summarize the results from Bakhtins chronotopic analysis of Greek romance novels. As mentioned, the chronotope typifying this genre, adventure-time, and its relationship to the hero are in many ways indicative to the chronotope characteristic of traditional Java programming, run-time, and its relationship with the programme. Understanding the make-up of the adventure-time chronotope is therefore directly informative to my later analysis of computer programming. Chronotopic analysis of Greek romance novels: Heroes in adventure-time The Greek romance novel is an early genre of novelistic literature written in ancient Greece. The basic plot of these novels is simple. The novel starts with a boy and a girl meeting and falling passionately in love. Then the young couple is separated by faith, and they must go through a series of adventures in order to get back together. The novel ends happily with the lovers united in marriage. (ibid.: 88).

The adventures that the young lovers, the heroes, go through constitute the body of each novel. These adventures take place in a constructed, fictional world, and it is the chronotope sustaining this fictional world that is the subject for chronotopic analysis. Typical for the Greek romance novels are the chronotope called adventure-time, and the relationship between this adventure-time chronotope and the heroes. There are primarily two aspects of the adventure-time chronotope and its relationship with the heroes that is of relevance here: The relationship between time and the heroes, and the initiative and flow of control between the chronotopic world and the heroes. Time is the dominant principle in the chronotope (ibid.: 86), and as such time also plays a key role in establishing the relationship between the fictional world and the hero. Time in the adventure-time chronotope works unconventionally and follows its own internal logic. In adventure-time the heroes can experience a most improbable number of adventures (ibid.: 90) which are just counted within each adventure, but that does not affect the heroes in any way. Time does not change or affect anything or anyone in the fictional world adventure-time: the world remains as it was, the biographical life of the heroes does not change, their feelings do not change, people do not even age. This empty time leaves no traces anywhere, no indications of its passing. (ibid.: 91). Since the passing of time does not change anything in this fictional world, isolated events have no impact on each other and can each be reversed without causing the fictional world to break down. This creates a synchronic, almost still timeline of moments where anyone, anything and any event can be taken out of its temporal context and placed in another. Contrasted to a world that is based on a more customary timeline where time affects and changes the causal connections between events, a vital force for creating conceptual causality disappears. This creative, rational force of time must be replaced, and in its place comes the creative, but irrational force of chance. All moments of this infinite adventure-time are controlled by one force chance. [] In

this time, persons are forever having things happen to them (ibid.: 94-5), and adventure-time is therefore also a chance time. The force of chance has a special effect on the relationship between the actor and the chronotope. In a world where the causality of different events is linked in time, the actor has the opportunity to take the initiative, alter the sequence of events and take control of his or hers environment. But in the world of adventure-time, all initiative and power belongs to chance and never to human beings (ibid.: 100, 95). In the fictional worlds of adventure-time the flow of control must therefore always lie with chance in the environment and cannot be passed to the hero. Why chronotopic analysis of computer programming? Creating computer programmes is both a technical craft and an art. Approached as a craft, the construction of computer programmes is primarily observed from the outside. With this approach, aspects that stand out are the end-product, its qualities, the external problem to be solved, participants and phases in the development process, etc. etc. (cf. Pressman 2000, Jacobson 1999). However, this perspective fails to capture the artistic, creative processes of computer programming. To capture such processes the researcher must view programming from the inside out and see the becoming of both the computer programme and its world from the programmers point of view, not from the customer, user or project managers external viewpoint. However, seeing the world and computer programmes from the programmers viewpoint is far from simple for outsiders. Computer programmes are written in symbolic systems that on the surface bear little resemblance to our everyday languages. Therefore, recognizing the human touch in abstract, complex programme texts becomes almost impossible. Similarly, the world of the computer can seem both extremely intricate and complex, operating at both a speed and level of detail that we cannot follow. Our inability to immediately see the inner workings of the programmes world greatly hinders our understanding of them and makes their world seem inhumane. In order to see the programmes and their world from the programmers viewpoint, we

must therefore rely on other resources than just our everyday language and our immediate senses. One such resource for seeing computer programmes and their world is chronotopic analysis. Originally chronotopic analysis helped us see how we construct fictional worlds and their inner workings in literature. But, computer programmes and their world can barely be glimpsed using our immediate senses, and we therefore need extended perspectives to understand how they come to be. Applying chronotopic analysis can extend our senses in such a way. A central goal of chronotopic is therefore to illustrate how we see computer programmes with our minds inner eye and how we can create conceptual images and figurations in computer programming. Chronotopic analysis of Java programming: Programmes in run-time In traditional Java programming a programme is always written to run on a platform called the Java Run-Time Environment (JRE). From a programmers perspective this environment surrounds and sustains the programme, and a Java programme cannot run without a JRE. When creating a programme, a programmer must therefore also create or use an environment in which his programme can exist. Like the ancient Greek novelists describing the scenery in the fictional worlds surrounding their heroes, todays programmer writes programme statements and rearranges files to establish an environment in which his programme can run. In his mind the programmer must therefore see before him both the programme and the environment surrounding and supporting it: The programme is not an isolated actor, but an actor existing in a system environment, a conceptual world. The Java programming paradigm contains a specification of the environment in which Java programmes should run, called the Java Virtual Machine (Lindholm 1999). In practice, the Java Virtual Machine specifies the constraints for platform implementations (JREs). But the Java Virtual Machine also establishes conceptual borders for how a Java programme can be written and some central aspects for how it can operate. To establish these borders the Java Virtual Machine describes some grammatical requirements for Java programme texts and how Java programme texts and

through them Java programmes will behave when run in a proper environment. These behavioural descriptions are concerned primarily with the time, sequence and manner in which programmes, the environment and their functionality evolves and the spatial dynamics in which this evolution takes place. Thus, this highly detailed and normative definition partially describes the chronotope sustaining traditional Java programming. So, what chronotopic relationships does the Java Virtual Machine portray? And what does a Java programme and its virtual environment look like from a programmers viewpoint? Time in the virtual environment surrounding Java programmes is generally referred to as run-time. This time dimension has its own temporal logic not bound by the constraints of time in our immediate world. Like the special time system of adventuretime, the special logic of run-time saturates the environment of the Java programme and the programme itself. As such, run-time constitutes a vital part of the Java programming chronotope (hereafter run-time chronotope).1 Typical for the run-time chronotope is the level of accuracy and determinism between time and events. The evolution of a programmes and its environments functionality and the occurrences of events at run-time is an exact science where nothing is left to chance. In the run-time chronotope the spatial relationships are also highly detailed, specific and finite. The space in the environment can grow to accommodate the programmes need (dynamic allocation), but the direction, timing and position of future growth is always known. A programme can for instance relate to a database of unlimited size, but when accessing the database, the programme specifies precise spatial areas within this database. This creates an atmosphere were the time and place of every event is known or can be deduced from other events. This highly rational, rigid and detailed run-time chronotope shapes the environment in its image and directly contrasts parallel qualities in adventure-time.

The concepts and inner workings of run-time chronotope in traditional Java have much in common with other programming paradigms. This chronotopic analysis is therefore quite indicative of other programming paradigms and modern object-oriented programming in general.

Further, this run-time chronotope is only meaningful if there is a programme, an actor, filling its inside with life and colour. In stark contrast to the hero in adventure-time, the programme is envisaged operating in a world where nothing happens by chance. This makes a passive, initiative-free actor reacting to new and sudden events lifeless. Instead, the programme must itself take the initiative to all actions, make everything happen, and can never let go of this control until it has completed its mission and stops. Analogous to the heroes utterly reactive role in adventure-time, the programme takes on an utterly proactive role at run-time. To give an example of how a programme controls and initiates its actions, I will here give a short description of the use of a so-called Listener (Darwin 2001: 377). A Listener is a programme part that obtains information from the environment. In order for a programme to for instance be able to hear and react to a user clicking a mouse button in its environment, the programme must first be fitted with a program part which purpose is to actively wait and listen for this specific mouse click at a specific period during its execution, a Listener. When the mouse button is used at the foreseen time and place, the Listener will then control how the programme shall react, or more precisely continue to act. Every input the programme receives from its environment, be it from a user, another programme or other parts of the environment, the programme must first actively acquire using this or a similar technique. Limited by these techniques the programme becomes completely self-centred and control-freakish. The deterministic, specific run-time chronotope of the programme world also affects the programmes need to change itself. In a world where nothing is left to chance and everything is considered known, the surroundings of the programme does not change. If unexpected events were to occur in this environment, it would either be considered a bug or a fault on the part of the programmer. The programme does not need to change in order to keep up with its surroundings. The programme may certainly change states within a defined register of states, but it does not need to for instance draw any experience from its environment or its actions in order to alter the composition of its functionality. A programme that would behave in such a way, i.e. a programme that

learns, rewrites its own code or similar, would conceptually act within and relate to a different chronotopic environment than a traditional Java programme. The run-time chronotope and the programme as an actor form a basis for how programmers view programmes and the worlds that surround and support them. As the adventure-time chronotope typify the genre of ancient Greek romance novels, the runtime chronotope typify the paradigm of traditional Java programming. This insight is in itself a valuable contribution to our understanding of the creative, social and cultural processes involved in computer programming. But, the run-time chronotope also form the basis for possible narratives (Bakhtin 1981: 216) for Java programmes. This basis enables us to conceive and build programmes in a certain way. To further shed light on the particularities of the direction in which the run-time chronotope leads us to think, I will now contrast this analysis with an analysis of a different programming paradigm: agent-based programming. In this analysis I will try to illustrate how we might envisage and build other kinds of computer systems by envisaging other chronotopes and programme actors. Chronotopic analysis of agent-based programming: Agent community The idea of agent-based programming (Jennings 2000, OHare 1996, the.hist.no 2005) is to model and build large, distributed computer systems as communities of many small, generic actors called agents. These system communities function by letting many agents collaborate in order to solve large, complex tasks of the community as a whole, in many ways similar to ants in an anthill. But to model such agents and agent communities is not a straight forward process. Resources for envisaging systems in existing programming paradigms can often lead programmers in the opposite direction: when confronted with a large, distributed problem that could be modelled as an agent community, the tools and literary practices available often lead a programmer to design traditional, self-centred programmes instead. The emergence of an agent-based paradigm could have stopped here had these traditional programmes been practical. However, traditional programmes quickly

10

become too large and complex to manage in our minds, and it is due to the problems created from this complexity that agent-based programming persists as an alternative strategy (cf. Jennings 2000: 282). Programmers set to develop agent-based systems are usually trained to modelling traditional programmes. These culturally and historically situated programmers base their activities on methods, tools and practices from existing paradigms, and through the programmers customs and preconceptions the agent-based programming paradigm gets linked to traditional programming conceptions. Despite of its motivation to depart from the representational foundation of existing paradigms, agent-based programming still inherits and is influenced by the conceptual figurations it wishes to change. Such tacit influence between programming paradigms is problematic and needs to be understood before fundamental change in our perceptions can be made. Because of this cultural heritage the run-time chronotope and the traditional programme actor still dominate the conceptions in agent-based programming. As an isolated actor, each agent runs in an environment that apparently gives it the same possibilities and restrictions as a traditional programme. Thus, the computing world of the agent appears to resemble traditional programmes run-time environment, and in order to function in this world, the agent must therefore to some extent emulate the programme. From the perspective of an agent-based programmer an agent can therefore in some respects still be viewed as a programme, an agent programme, and the world in which it exists can still in many respects be thought of as a run-time environment. Despite of these parallels created by necessity and association, an agent programme is also perceived as substantially different from a traditional programme. Unlike a traditional programme that conceptually performs its tasks on its own an agent programme is a social participant that collaborates in order to complete tasks. The environment of the agent programme is therefore also a social scene, similar to that of an anthill or a beehive, whereas the traditional run-time environment does not emphasize such social relationships.

11

But how does this social dimension of agent-based programming affect the programmers perceptions? In a traditional run-time environment every event is controlled by the passing of time and their position in space, and all these events fall under the domain of an individual programmes initiative and control. The agents environment on the other hand is filled with other agents acting on their own initiative. From the viewpoint of a single agent programme, the actions of other agents fill its environment with socially erupting events. In the environment outside each agent programme there therefore exists a creative, social force that also can initiate and control actions and events. This forms a new chronotopic context, a social run-time, where both the environment and the individual agent programme can initiate and control events, and where the environment surrounding each agent can suddenly change. Due to these new chronotopic relationships, the agent programme must relate to its environment differently than a traditional programme. First, the presence of other agents acting on their own initiative and the need to relate to these actors in order to collaborate, the agent programme can no longer be viewed as the sole possessor of initiative and control. Control and initiative must flow from agent to agent and can be possessed by more than one agent at the same time. Therefore, the agent programme can no longer just proactively initiate actions and events in its environment, but must also react to events initiated and controlled by other agent programmes. Second, in order to react to other agents actions and events, the agent programme must also relate to other agents situation in time and space. In addition to focusing on the time and space of its own tasks, the agent programme must also be open for the time and space in which other agents tasks are situated. Third, actions and events initiated by other autonomous agents in the environment cannot be foreseen by each individual agent. This means that the environment surrounding and supporting the agent programme changes, and therefore the agent programme must be able to adapt in response to such changes. The chronotopic relationships between the agent programme and its social run-time environment also greatly influence the perception of an individual agent. However, in this case the concept of an individual agent is based on the concept of a traditional programme. This creates a potential conflict between the conceptual figuration of an

12

actor inherited from the traditional programming paradigm and the conceptual figuration of an actor that is developed to suit a new chronotopic environment. To understand and solve this conflict, it is necessary to understand which perceived qualities of the traditional programme that are bound to the relationship between the traditional programme and its environment. To do so I will return to the analysis of the heroes in adventure-time. Many of the qualities of the heroes are defined by their relationship to their adventuretime environment. [The heroes] have gone through something, something that did not, indeed, change them but that did (in a manner of speaking) affirm what they, and precisely they, were as individuals, something that did verify and establish their identity, their durability and continuity. The hammer of events shatters nothing and forges nothing it merely tries the durability of an already finished product. And the product passes the test. (Bakthin 1981: 106-7). The qualities of the heroes, their durability, continuity and steadfastness, are not isolated aspects of the heroes in themselves, but rather a product of their relationship with their adventure-time world. Thus, the chronotopic relationships between the actor and its environment can influence how we perceive an actor in isolation. But these qualities do not necessarily apply to other actors in different environments. The relationship between a traditional programme and its run-time environment is unchanging due to the rigid and regulated flow of control between the two: thus, a good programme is considered solid, stable and firm. An agent on the other hand must operate in a changing environment. Therefore, in response to change, a good agent programme should perhaps not be considered solid and firm, but rather adaptive and sociable, relying on and responsive to other agents. This means that in order to build good agent-based systems, a programmer cannot simply conceive it as a group of good traditional programmes.

13

Technical results Such rewriting of quality criteria for agent programmes is technically controversial. But in our own work with building agents and agent environments (the.hist.no 2005), we have found such changes necessary and useful. Our findings suggest that for instance certain grammatical means can heavily persuade the programmer to write both the environment and programme in the traditional manner described above. In addition to established lexical resources and writing practices such as the Listener, more fundamental, grammatical language resources such as the semantic checks by the Java compiler of all inter/intra-textual references and the need to specify this inter-textual area outside the programme texts in the form of a so called classpath, hinders the programmer in writing programmes that can change run-time. Therefore, in order to write agent programmes that could change in relation to each other, we found it necessary and highly beneficial to extend the grammar and pragmatics of the Java programming language. We therefore created a new syntactical form for programmers to refer to past, present and future objects and methods that by definition is supposed to be implicitly located in the time and space. In addition we changed the morphological form for inter-textual references (i.e. type references) so that programmers much more easily could write references to classes located in a social space accessible to any agent programme. These two linguistic extensions enabled us to write programme texts in which change is anticipated and in which different programmes quite easily could relate to each others tasks in a conceptually indefinite time and space. The resulting programming methodology called theJ can be studied and tried out at http://the.hist.no (2005). Possible implications on the science and art of programming In this paper I have used perspectives and analytical tools from literary studies to understand and illustrate how the creative processes in computer programming can influence both the programmers mind and the resulting systems. This interdisciplinary endeavour breaches the lines between the arts and the sciences, and this move changes

14

the frontline of research from both sides. I will therefore conclude this paper by shortly commenting on the possibilities of chronotopic analysis of computer programming in different disciplines. For dialogic studies the use of chronotopic analysis on computer programming tests a central method and analytic perspective of the Bakhtinian circle on a new field of human interaction and creation. Such tests are vital to sustain the claim of dialogic researchers that their theories have a more general cultural and philosophical validity. Scratching below the surface of new technologies and aiming at the heart of this new form of technocratic reality that we seem to stumble into, is especially important if dialogic studies are to be made valid within this and other emerging areas of human creation, interaction and culture. For computer science chronotopic analysis of computer programming claims that computer programming is not just a technical craft that can be analyzed objectively, but also an art that should be understood more subjectively and interpretatively. This would require the use of perspectives and methods from humanities that has not been widely applied in the field. Including subjective and interpretative methods could open up for new insight insight that might help to illustrate the creative aspects of programming. Attention to the creations of the mind can nourish them, and such nourishment can yield both practical and academic results. Thus, chronotopic analysis of computer programming contributes to the interdisciplinary project of studying the art of programming. The differences of traditional and agent-oriented Java programming paradigms, shows how the cultural, social, historical and conceptual forces can influence both the programmers mind and the resulting systems. To reflect on our consciousness as it constructs and uses programming languages and fashions everything from silicon, electronic impulses and software into meaningful, cultural artefacts, is studying the art of computer science. References:

15

Bakhtin, M. M. 1981. The Dialogic Imagination: Four Essays. Translated by Emerson, C. and Holquist, M.(ed.). Austin: Texas University Press. Bostad, F. 2004. Dialogue in Electronic Public Space: the Semiotics of Time, Space and the Internet. In Bostad, F. (ed.), Bakhtinian Perspectives on Language and Culture: Meaning in Language, Art and New Media. New York: Palgrave MacMillan. Darwin, I. F. 2001. Java Cookbook. Sebastopol, CA: OReilly. Jacobson, I. 1999. The unified software development process. Boston: Addison-Wesley. Jennings, N. R. 2000. On agent-based software engineering. Artificial Intelligence (117), 277-96. Lindholm, T. and Yellin, F. 1999. The Java Virtual Machine specification (2nd ed.). Boston: Addison-Wesley. OHare, G. M. P. and Jennings, N. R. 1996. Foundations of Distributed Artificial Intelligence. New York: John Wiley & Sons. Pressman, R. S. 2000. Software Engineering: A Practioners Approach: European Adaption (5thed.). London: McGraw-Hill Publishing Company. the.hist.no 2005. The official site of theJ programminglanguage. http://the.hist.no/

16