icon to open the header menu
Beauty and understanding

Representing textual worlds in literature

The relationship between syntax and semantics is most obvious in the written arts, and there is no doubt that textual, sensual form communicates mental spaces113 . Literature as a cognitive device relies, as we've seen in  Ideals of beauty   , in part on the use of metaphors to provide a new perspective on a familiar concept, and hence complement and enrich the understanding that one has of it. While Lakoff and Johnson's approach to the conceptual metaphor will serve a basis to explore metaphors in the broad sense across software and narrative, we also argue that Ricoeur's focus on the tension of the statement rather than primarily on the word will help us better understand some of the aesthetic manifestations of software metaphors, without being limited to tokens, but going beyond to statement and structure. Following a brief overview of his contribution, we examine the various uses of metaphor in software and in literature, touch upon the cognitive turn in literary studies, and conclude with an account of how this turn involves further thinking into the spatial and temporal properties of the written word.

Literary metaphors

Writing in The Rule of Metaphor , Ricoeur operates two shifts which will help us better assess not just the inherent complexity of program texts, but the ambivalence of programming languages as well. His first shift regards the locus of the metaphor, which he saw as being limited to the single word—a semiotic element—to the whole sentence—a semantic element ( Ricoeur, 2003) . This operates in parallel with his attention to the lived feature of the metaphor, insofar it exists in a broader, vital, experienced context. Approaching the metaphor while limiting it to words is counterproductive because words refer back to "contextually missing parts"—they are eminently overdetermined, polysemic, and belong to a wider network meaning than a single, Aristotelician, one-to-one relationship. Looking at it from the perspective of the sentence brings this rich network of potential meanings and broadens the scope for and the depth of interpretation. As we develop in  Semantic layers   in our reading of    , not all of the evocative meaning of the poem are contained exclusively in each token, and the power of the whole is greater than the sum of its parts.
Secondly, Ricoeur inspects a defining aspect of a metaphor by the tensions it creates. His analysis builds from the polarities he identifies in discourse between event (time-bound) and meaning (timeless), between individual (subjective, located) and universal (applicable to all) and between sense (definite) and reference (indefinite). The creative power of the metaphor is its ability to both create and resolve these tensions, to maintain a balance between a literal interpretation, and a metaphorical one—between the immediate and the potential, so to speak. Tying it to the need for language to be fully realized in the lived experience, he poses metaphor as a means to creatively redescribe reality. In the context of syntax and semantics in programming languages, we will see that these tensions can be a fertile ground for poetic creation through aesthetic manifestations. For instance, we can see in    a poetic metaphor hinging on the concept of the attribute. In programming as in reality, an attribute is a specificity possessed by an entity; in this code poem, the tension is established between the computer interpretation and the human interpretation of an attribute. Starting from a political target domain (the constitution of the United States of America), the twist happens in the source domain of the attribute. Loosely attributed by the people in writing, the execution of the declaration (that is, the living together of the United States citizens) implies and relies on the fact that power resides in the people, as is being stated in a literal way. However, from the computer perspective, the definition is not rigorous enough and the execution of the code will throw an error that is shown on the last line—the People  class was never defined in the poem, and thus undermines the endeavour of the program text.
cynical-preamble

title = 'Constitution of the United States'

preamble = { 'Preamble': "We the People of the United States, \
in Order to form a more perfect Union, \
establish Justice, insure domestic Tranquility, \
provide for the common defense, promote the general Welfare, \
and secure the Blessings of Liberty to ourselves and our Posterity, \
do ordain and establish this Constitution for the United States of America." }

WEPOTUS_power = { 'ordain_and_establish' : lambda x, y : Constitution(x, y )}

WEPOTUS = People("We the People of the United States", WEPOTUS_power)

WEPOTUS.GOALS = [ "form a more perfect Union",
"establish Justice",
"insure domestic Tranquility",
"provide for the common defense",
"promote the general Welfare",
"secure the Blessings of Libery to ourselves and our Posterity"
]

USConstitution = WEPOTUS.power['ordain_and_establish'](title, preamble)

AttributeError: 'People' object has no attribute 'power'
- Cynical American Preamble, by Michael Carlisle, published in code::art \#0  ( UNKNOWN AUTHOR, 2019)
In such case, the expressiveness of the program text can be said to derive from the continuous threading of metaphorical references, weaving the properties of computational objects and the properties of conceptual objects in order to deep the mapping from one unto the other.
So while Lakoff bases poetic metaphors on the broader metaphors of the everyday life, he also operates the distinction that, contrary to conventional metaphors which are so widely accepted that they go unnoticed, the poetic metaphor is non-obvious. Which is not to say that it is convoluted, but rather that it is new, unexpected, that it brings something previously not thought of into the company of broad, conventional metaphors—concepts we can all relate to because of the conceptual structures we are already carry with us, or are able to easily integrate.
Poetic metaphors deploy their expressive powers along four different axes, in terms of how the source domain affects the target domain that is connected to. First, a source domain can extend its target counterpart: it pushes it in an already expected direction, but does so even further, sometimes creating a dramatic effect by this movement from conventional to poetic. For instance, a conventional metaphor would be saying that "Juliet is radiant" , while a poetic one might extend the attribution of positivity and dramatic important associated with brightness and daylight by saying "Juliet is the sun 114 .
Poetic metaphors can also elaborate , by adding more dimensions to the target domain, while nonetheless being related to its original dimension. Here, dimensions are themselves categories within which the target domain usually falls (e.g. the sun has an astral dimension, and a sensual dimension). Naming oneself as The Sun-King brings forth the additional dimension of hierarchy, along with a specific role within that hierarchy—the sun being at the center of the then-known universe.
Metaphors gain poetic value when they put into question the conventional approaches of reasoning about, and with, a certain target domain. Here is perhaps the most obvious manifestation of the non-obvious requirement, since it quite literally proposes something that is unexpected from a conventional standpoint. When Albert Camus describes Tipasa's countryside as being blackened from the sun 115 , it subverts our pre-conceptions about what the countryside is, what the sun does, and hints at a semantic depth which would go on to support a whole philosophical thought, knowns as la pensée de midi , or the noon-thought 116 .
Finally, poetic metaphors compose multiple metaphors into one, drawing from different source domains in order to extend, elaborate, or question the original understanding of the target domain. Such a technique of superimposition creates semantic depth by layering these different approaches. It is particularly at this point that literary criticism and hermeneutics appear to be necessary to expose some of the threads pointed out by this process. As an example, the symbol of Charles Bovary's cap, a drawn-out metaphor in Flaubert's Madame Bovary ends up depicting something which clearly is less of a garment and more of an absurd structure, operates by extending the literal understanding of how a cap is constructed, elaborating on the different components of a hat in such a rich and lush manner that it leads the reader to question whether we are still talking about a hat ( Nabokov, 1980) . This metaphorical composition can be interpreted as standing for the orientalist stance which Flaubert takes vis-à-vis his protagonists, or for the absurdity of material pursuit and ornament, one which ultimately leads the novel's main character, Emma, to her demise, or for the novel itself, whose structure is composed of complex layers, under the guise of banal appearances. Composed metaphors highlight how they exist along degrees of meanings , from the conventional and expected to the poetic and enlightening.
We have therefore highlighted how metaphors function , and how they can be identified. Another issue they address is that of the role they fulfill in our everyday experiences as well as in our aesthetic experiences. Granted a propensity to structure, to adapt, to reason and to induce value judgment, metaphors can ultimately be seen as a means to comprehend the world. By importing structure from the source domain, the metaphor in turn creates cognitive structure in the target domains which compose our lives. Our understanding grasps these structures through their features and attributes, and integrates them as a given, a reified convention—in what Ricoeur would call a dead metaphor. This is one of their key contribution: metaphors have a function which goes beyond an exclusive, disinterested, self-referential, artistic role. If metaphors are ornament, it is far from being a crime, because these are ornaments which, in combining imagination and truth, expand our conceptions of the world by making things fit in new ways.

Literature and cognitive structures

Building on the focus on conceptual structures hinted at by metaphors, the attention of more recent work has shifted to the relationship between literature (as part of aesthetic work and eliciting aesthetic experiences) and cognition. This move starts from the limitation of explaining "art for art's sake", and inscribing it into the real, lived experiences of everyday life mentioned above, perhaps best illustrated by the question posed in Jean-Marie Schaeffer's eponymous work— Why fiction?  ( Schaeffer, 1999) . Indeed, if literary and aesthetic criticism are to be rooted in the everyday, and in the conventional conceptual metaphors which structure our lives, our brains seem to be the lowest common denominator in our comprehension of both real facts and literary works ( UNKNOWN AUTHOR, 2015) .
This echoes our discussion in  Knowing-what and knowing-how   of Polanyi's work on tacit knowledge, in which the scientist's knowledge is not wholly and absolutely formal and abstracted, but rather embodied, implicit, experiential. This limitation of codified, rigorous language when it comes to communicating knowledge, opens up the door for an investigation of how literature and art can help with this communication, while keeping in mind the essential role of the senses and lived experience in knowledge acquisition (i.e. integration of new conceptual structures) ( Polanyi, 2009) .
Some of the cognitive benefits of art (pleasure, emotion, or understanding) are not too dis-similar to those posed by Beardsley above, but shift their rationale from strict hermeneutics and criticism to cognitive science. Terence Cave focuses on the latter when he says that literature "allows us to think things that are difficult to think otherwise . We now examine such a possibility from two perspectives: in terms of the role of imagination, and in terms of the role of the senses.
Cave posits that literature is an object of knowledge, a creator of knowledge, and that it does so through the interplay between rational thought and imaginative thought, between the "counterfactual imagination" and our daily lives and experiences. Through this tension, this suspension of disbelief is nonetheless accompanied by an epistemic awareness, making fiction reliant on non-fiction, and vice-versa. Working on literary allusions, Ziva Ben-Porat shows that this simultaneous activation of two texts is influenced by several factors. First, the form of the linguistic token itself has a large influence over the understanding of what it alludes to. Its aesthetic manifestation, then, can be said to modulate the conceptual structures which will be acquired by the reader. Second, the context in which the alluding token(s) appears also influences the correct interpretation of such an allusion, and thus the overall understanding of the text. This contextual approach, once again hints at the change of scale that Ricoeur points in his shift from the word to the sentence, and demands that we focus on the whole, rather than single out isolated instances of linguistic beauty. Finally, a third factor is the personal baggage (a personal encyclopedia) brought by the reader. Such a baggage consists of varying experience levels, of quality of the know-how that is to be activated during the reading process, and of the cognitive schemas that readers carry with them. Imagination in literary interpretation, builds on these various aspect, from the very concrete form and choice of the words used, to the unspoken knowledge structures held in the reader's mind, themselves depending on varied experience levels. By allowing the reader to project themselves into potential scenarios, imagination allows us to test out possibilities and crystallize the most useful ones to continue building our conception of the fictional world.
The work of imagination also relies on how the written word can elicit the recall of sensations. This takes place through the re-creation, the evokation of sensory phenomena in linguistic terms, such as the perceptual modeling of literary works, which can be defined as (linguistic) simulations relying on the senses to communicate situations, concepts, and potential realities, something at work in the process of creating a fiction. This connects back to the modelling complexities evoked in  Modelling complexity   : both source code and literature have at least the overlap of helping to form mental models in the reader.
This attention to the sense calls for an approach of literary criticism as seen through embodied cognition, starting from the postulate that human cognition is grounded in sensorimotricity, i.e., the ability to feel, perceive, and move. Specifically, pervading cognitive process called perceptual simulation, which is activated when we cognitively process a gesture in a real-life situation, is also recruited when we read about actions, movements, and gestures in texts.
Depiciting movement, vision, tactility and other embodied sensations allows us to crystallize and verify the work of the imaginative process. As such, literature unleashes our imaginary by recreating sensual experiences—Lakoff even goes as far as saying that we can only imagine abstract concepts if we can represent them in space117 . It seems that the imaginative process depends in part on visual and spatial projections, and suggests a certain fitness of the conceptual structures depicted. By describing situations which, while fictional, nonetheless are possible in a reality often very similar to the one we live in, it is easy for the reader to connect and understand the point being made by the author. So if literature is an object of knowledge, both sensual and conceptual, offering an interplay between rational and imaginative thought, it still relies on the depiction of mostly familiar situations (the protagonists physiologies, the rules of gravity, the fundamental social norms are rarely challenged).
A first issue that we encounter here, in trying to connect source code and computing to this line of thought, is that source code has close to no perceptible sensual existence, beyond its textual form. In trying to communicate concepts, states and processes related to code and computing, and in being unable to depict them by their own material and sensual properties, we once again resort to linguistic processes which enable the bringing-into-thinking of the program text.
unhandled-love

class love{};

void main(){
    throw love();
}
- Unhandled Love, by Daniel Bezera, published in \{code poems\}  ( Bertram, 2012)
The code poem listed in    suggests a similar phenomenon when it comes to perceiving motions and sensations through words. The key part of the poem here is the use of the keyword throw  : as a reserved keyword in some of the most popular programming languages, it is known and has been encountered by multiple programmers, as opposed to a word defined in a specific program (such as a variable name). This previous encounters build up a feeling of familiarity and of dread—indeed, the act of the throwing in programming is as dynamic and as violent as in human prose. To throw an object in programming, is to interrupt the smooth execution flow of the program, because something unexpected has happened,—that is, an exception. Additionally, the title of the poem hints at a supplemental implication of the poems motion; any exception that is thrown should be caught, or handled, by another part of the program, in order to gracefully recover from the mishap and proceed as expected. If it's not handled—as is the case in the poem—the program terminates and the source code itself aborts all function.
Unhandled Love provides a commentary on the agency of the entities involved in the execution of the program-text. Who is throwing love, and who is receiving it? It seems that the programmer is the one instructing the throw, but the receiving end is not clear: if the computer is not instructed to catch the love/error (as in a try/catch  ) block, then who is, and where does the call to love end up? Here, the lack of explicit handling is immediately equated with negative uncertainty, while a human understanding of love might account for uncertainty as a poetic and romantic approach to the other.
Vilem Flusser considers poetic thinking as a means to bring concepts into the thinkable, and to crystallize thoughts which are not immediately available to us118 ; through various linguistic techniques, poetry allows us to formulate new concepts and ideas, and to shift perspectives. Rendered meaningful via this code poem, a certain conception of love is therefore depicted here as an exception that must be handled (with care) , and the use of a particularly dynamic keyword elicits such a feeling in a reader who previously had to throw and handle exceptions.
Another example of how source code can communicate concepts can be seen in    . In this case, we can see in the relation between the name of the function, find  and the three local variables high  ,  low  and probe  , that the act of finding is going to imply some sort of search space . The search space is going to be traversed in an alternating way, called the binary search in computer science terms119 .
binary-search

package binary;

public class Finder {
    public static int find(String[] keys, String target) {
        int high = keys.length;
        int low = -1;
        while (high - low > 1) {
            int probe = (low + high) >>> 1;
            if (keys[probe].compareTo(target) > 0)
                high = probe;
            else
                low = probe;
        }
        if (low == -1 || keys[low].compareTo(target) != 0)
            return -1;
        else
            return low;
    }
 }
- Binary search, implemented by Tim Bray in highlights variable names ( , , ) as indicators of the spatial component of the function's performance .  ( Bray, 2007)
Here, we thus have two indicators, syntactical and structural. First, high  and low  , imply the space in-between, a space to be explored via probe  120 . Second, the use of only two statements inside the while  loop represents the simplicity of the search process itself, a search process which, as (high - low > 1)  tells us, implies a shrinking search space121 .
By paying attention to the spatial and embodied implicit meanings held in the syntactic structures used in both literature and source code, we can start to see how a certain sense of understanding being extracted from reading either kind of texts depends on embodiment. In the case of program texts, the point is to reduce computational space into humanly embodied space; similarly, literature engages in communicating different kinds of space.

Words in space

Beyond the use of metaphor, literature allows the reader to engage cognitively with the world of the work, and the interrelated web of concepts that can then be grasped once they are put into words. This process of putting down intention, through language and into written words, is also the process of transforming a time-based continuum (speech) into a space-based discrete sequence; a process called grammatization, explored further in ( Bouchardon, 2014) . This is valid both for human prose and machine languages: the unfathomably fast execution of sequential instructions is manifested as static space in source code.
Literary theory also engages with the concept of space. We have seen in the subsection above that there is a particular attention being given to movement in space, through embodied cognition; in that case, the use of a specific syntax can elicit a kinetic reaction in the incarnated reader. We now pay attention to how spatiality interplays with meaning in literature, looking at the spatial form of the text in general, and to spatio(-temporal) markers in the text in specific.
First, we leave behind some traditional concepts in literary theory. We have seen that, due to source code's non-linearity and collaborative aspect, concepts such as narrative and authorship are somewhat complicated to map across fields.
We have mentioned above that the fictionality of a text provides a kind of text-based simulation for a combination of events, characters and situations. While soure code, by its actual execution, might tend to be classified rather as non-fiction, we nonetheless show here that, by evoking interconnected entities, it also participates to the construction of mental models.
Here, we pay particular attention to fictional space: the web of relationships, connotations and suggestions that hint at a broader world than the one immediately at hand in a work of literature. This fictional space, or storyworld is not to be equated to what we have denotated as the problem domain. Rather, it is what exists through, yet beyond, the text itself; we refer to it as the world of reference .
To focus on the specific tokens denoting space, we rely on the distinction operated by Marie-Laure Ryan on the topic ( Ryan, 2009) . The starting point she offers is to consider how the spatial extension of the text, its existence in a certain number of dimensions122 impacts the readers' perception of the narrative.
spatial_extension

class Space:
    def __init__(self, dimensions):
        self.dimensions = dimensions
        alone = True

def new_space():
    new = new Space(4)
- This bespoke snippet shows how the spatial extension of the text—its indentation—corresponds to the structural semantics of the code, in the Python programming language.
At the simplest level, we see this illustrated in    . In this listing, we can see how the most direct spatial perceptions of the program text, its indentation, actually represents semantic properties: the indent on class_space  is related to it existing at a different level (scope) than the variables dimensions  and alone  , just like the indent before def __init__  differs from the one before def new_space  also signify changes in lexical scope.
Moving beyond this immediately visual spatial component, Ryan shifts to the spatial form of the text. Rather than looking at the space in which it is deployed, it is considering
a type of narrative organization characteristic of modernism that deemphasizes temporality and causality through compositional devices such as fragmentation, montage of disparate elements, and juxtaposition of parallel plot lines. ( Ryan, 2009) .
Narrative, in its traditional sense of coherent, sequential events whose developments involve plot and characters, is seldom mentioned in writing source code. In source code, narrative is already deemphasized and the spatial form of the text mentioned above is therefore better suited to match the material of the code. Indeed, Ryan continues:
The notion of spatial form can be extended to any kind of design formed by networks of semantic, phonetic or more broadly thematic relations between non-adjacent textual units. When the notion of space refers to a formal pattern, it is taken in a metaphorical sense, since it is not a system of dimensions that determines physical position, but a network of analogical or oppositional relations perceived by the mind. ( Ryan, 2009)
Space, along with interactivity, is a core feature of the digital medium123 . Janet Murray also puts spatiality as one of the core distinguishing features of digital media, at the forefront of which are digital games124 .
An example of this intertwining of flat textual screen and spatial depth is the overall genre of interactive fiction, which displays prompts for textual interaction on a screen, accompanied with the description of where the reader is currently standing in the fictional world. Exploration can only be done in a linear fashion, entering one space at a time; and yet the system reveals itself to contain spaces in multiple dimensions, connected by complex pathways and relationships. The listing in    shows how the execution processes of a program text can be expressed spatially in the comments, and then textually in the rest of the file. Since comments are ignored by the computer, this depiction is only to help the human reader in their spatial representation of the executed program.
mac_sched

 * Part 1 -- Initial checks
 *
 *      * . called by
 *      |   MAC clients
 *      v                     . . No
 *  +--------+  +-----------+ .   +-------------------+  +====================+
 *  | mac_tx |->| device    |-*-->| mac_protect_check |->v Is this the simple v
 *  +--------+  | quiesced? |     +-------------------+  v case? See [1]      v
 *              +-----------+            |               +====================+
 *                  * . Yes              * failed                 |
 *                  v                    | frames                 |
 *             +--------------+          |                +-------+---------+
 *             | freemsgchain |<---------+          Yes . *            No . *
 *             +--------------+                           v                 v
 *                                                  +-----------+     +--------+
 *                                                  |   goto    |     |  goto  |
 *                                                  |  Part 2   |     | SRS TX |
 *                                                  | Entry [A] |     |  func  |
 *                                                  +-----------+     +--------+
 *                                                        |                 |
 *                                                        |                 v
 *                                                        |           +--------+
 *                                                        +---------->| return |
 *                                                                    | cookie |
 *                                                                    +--------+
- This listing includes as a comment an execution flow diagram inside the program text, testifying to the inherently fragmented and non-linear execution of source code.  ( Mustacchi, 2019)
As Murray mentions, these features are not limited to those playful interactive systems presented as works to be explored (be it e-literature or digital games), but are rather a core component of digitality. Beyond the realm of fiction, one can see instances of this in the syntax used in both programming languages and programming environments (see  Tools as a cognitive extension   and our overview of IDEs). For instance, the use of the GOTO  statement in BASIC, of the JMP  and MOV  instructions in x86 Assembly, or the use of the return  in the C family of programming languages all hint at movement, at going places and coming back, representing the non-linear perception of program execution125 .
And yet, Ryan hints at anothe aspect of spatial form specifically in the digital medium:
But an even more medium-specific type of spatial form resides in the architecture of the underlying code that controls the navigation of the user through a digital text. ( Ryan, 2021)
As writers and readers of this architecture, of which source code is the blueprint, we gather information through syntax about developments in space and time into a cognitive map or mental model of narrative space126 .
Mental maps are therefore dynamically constructed in the course of reading and consulted by the reader to orient herself in the program. A very simple example of spatialization of meaning, both visually and conceptually, can be seen in    . There, the spatial component is rendered specifically through the syntax of HTML. HTML, as a markup language, has a specific ontology: it is fundamentally made up of elements who contain other elements, or are self-contained. When an element is contained into another, a specific semantic relationship occurs, where the container influences the contained, and vice-versa. Therefore, what we see at first is layout spatialization, which leads to this specific triangle shape. By using the semantics of the language, in which certain elements can only exist in the context of others, this layout spatialization127 also comes to delimit certain semantic areas. This explicitly poetic example takes religion, and the representation of God as its problem domain; its expressive force comes by describing it as both the all-including and the all-included, and thus escaping the implicit rules of everyday spatiality, that a thing cannot contain itself.
nested

<GOD>
    <universe>
        <galaxy>
            <solarsystem>
                <earth>
                    <island>
                        <town>
                            <garden>
                                <flowerbed>
                                    <snowdrop>
                                        <petal>
                                            <molecule>
                                                <proton>
                                                    <quark>
                                                        <GOD>
                                                    </quark>
                                                </proton>
                                            </molecule>
                                        </petal>
                                    </snowdrop>
                                </flowerbed>
                            </garden>
                        </town>
                    </island>
                </earth>
            </solarsystem>
        </galaxy>
    </universe>
</GOD>
- Nested, by Dan Brown and published in \{code poems\}  ( Bertram, 2012)
A more concrete example can be seen in    . Written in the style of software engineers, rather than poets, this listing describes a function which gracefully shuts down a HTTP server. Essentitlly, the function Shutdown()  regularly checks if the number of connections to the server is zero. If it reaches zero, it considers the process completed without errors; it waits until it receives an error from the context, or if it receives a tick from a timer setup in advance.
shutdown

func (h *http2Listener) Shutdown(ctx context.Context) error {
	pollIntervalBase := time.Millisecond
	nextPollInterval := func() time.Duration {
		// Add 10% jitter.
		//nolint:gosec
		interval := pollIntervalBase + time.Duration(weakrand.Intn(int(pollIntervalBase/10)))
		// Double and clamp for next time.
		pollIntervalBase *= 2
		if pollIntervalBase > shutdownPollIntervalMax {
			pollIntervalBase = shutdownPollIntervalMax
		}
		return interval
	}

	timer := time.NewTimer(nextPollInterval())
	defer timer.Stop()
	for {
		if atomic.LoadUint64(&h.cnt) == 0 {
			return nil
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-timer.C:
			timer.Reset(nextPollInterval())
		}
	}
}
- This listing represents the various steps taken in order to shutdown a HTTP server, and shows multiple aspects of temporal complexities represented spatially  ( WeidiDeng, 2023)
The first reference we can look at is mostly spatial, and takes place at the declaration of nextPollInterval  . By being another function declaration, it is both self-contained, but also has access to variables in its declarative environment, such as pollIntervalBase  . A long, dynamic series of statements which double a timer interval everytime it is called is thus compressed into a single token, nextPollInterval  , and can then be passed as an argument to timer functions. Here, the space of the timer interval's calculation is compressed and abstracted away.
The second reference is primarily temporal. The keyword defer  in the line defer timer.Stop()  specifically marks the deferred execution of this particular function to the specific moment at which the current function ( Shutdown()  ) returns. This reference is not absolute (as is the timer on the line above, even though it might not be determinate), but rather relative, itself dependent on when the current function will return. Here, the programming language itself makes it simple to express this relative temporal operation.
Finally, we can take a look at both the last select  statement of the function to see a more complex interplay of both space and time. There are two things happening there. With the specific <-  arrow, the pictorial representation shows how a message is incoming, either from ctx.Done()  , which itself comes from outside the current function, given as an argument, or from timer.C  , which comes from the timer that has just been declared in the current function. Both of these messages come from different places, one very distant, and the other very local, and might arrive at different moments. Here, the <-  denotes the movement of an incoming message, expliciting where the messages come from, and in which order they should be treated, and thus facilitates the handling of event with varying spatio-temporal properties.
The listing    shows not only different spaces of executions, nor only different moments of execution, but very much the intertwining of space and time. One of the earlier approaches to the specific tokens which represent space in the traditional novel has also related it to time: the chronotope is described by Mikhail Bakhtin as the tight entanglement of temporal and spatial relationships that are artistically expressed in literature. Those markers execute a double function, as they allow for the reification of temporal events and spatial settings during the unfolding of narrative events128 .
While Bakhtin introduces the concept from a marxist-historical point of view, analyzing notions of history, ideal, epics and folklore through that lense, it is nonetheless useful for our purposes. Chronotopes are a kind of marker which enable the understanding of where something comes from (such as an explicit module declarations in header files, or inline before a function call), or when something should happen (such as the async/await  keyword pair in ECMAscript denoting the synchronicity of an operation or the defer  keyword indicating that a specificied function will only be called when the current function returns).
Thus, the chronotopes give flesh to the events described in (and then executed from) source code. As such, they function as the primary means of materializing time in space. From a network of these chronotopes, along with metaphors and other devices that are explicited in  Cognitive aesthetics in program texts   , emerges a concretization of representation which the reader can use to constitue a mental model of the program text.
-
Syntactical literary devices allow readers to engage cognitively with a particular content; they enable the construction of mental models a particular narrative, through a network of metaphors, allusions, ambiguous interpretations and markers of space and time. We have shown that these literary devices also apply to source code, especially how the use of machine tokens and human interpretation suggest an aesthetic experience through metaphors, and with particular markers that are needed to make sense of the time and space of a computer program, which differs radically from that of a printed text. This making sense of a foreign time and space is indeed essential in creating a mental map of the storyworld (in fiction) or the world of reference (in non-fiction).
The use of the term map also implies a specific kind of territory, enabled by the digital. As a hybrid between the print's flatness and code's depth, Ryan and Murray—among many others—identify the digital narrative as a highly spatialized one. This feature, Ryan argues, is but a reflection of the inner architecture of source code. Pushing this line of thought further, we now turn to architecture as a discipline to investigate how the built environment elicits understanding, and how such possibilities might translate in the space of program texts.
icon to reference a footnote
icon to reference a footnote
icon to reference a footnote
icon to download the pdf of the thesis