created for teaching, selling, sparking imagination, e.g. minix, mother of all demos, spacewar!
unlike a prototype, they are not a first version of a more elaborate thing, they are rather philosophical statements inscribed as computer programs
“to write a system in miniature is to reorganize the same ideas” e.g. tailspin as a miniprogram ended up being used as the core of Sims 3
ref: inside computer understandings: five programs in miniature
sack did a javascript “translation” (rather than “port”), called narrative: spinner.
literate programming has a next step in the juoyter notebook environment
demos are created as arguments […] they’re built to see what is possible to do.
chap. 6 of the book software arts deals with rhetoric (an audience member said that there is also a non-verbal part to the rhetoric)
a work can succeed aesthetically but fail functionally (he argues that beautiful art is one that is devoid of purpose, but after duchamp, there is a reunion of the functional and non-functional in art)
sol lewitt says ideas are a machine to make art, le corbusier says a house is a machine for living
miniature: pedagogical demo: persuasive artwork: pleasurable
yeah, and actually the demo would also live in other traditions: craftspeople have demos, finance have alpha funds -> in order to inspire trust in your product
programming practice: (e.g. understanding the runtime, the semantics)
ethics perspective with the technical aspect at the center
the practices of programming that are seemingly technical are actually essentially ethical programmers transpose structures of practices into other domains
when you do runtime analysis, for instance, you abstract away the “planetary network of labor and energy” into discreete steps, just as apples at the grocery store invisibilize their network through their single price tag
technical practice is hegemonic (it has a unique power in disciplining the body), and a microcosmic training ground
which kinds of ethics? - ethics as values, in the data, or in the algorithm - ethics as consequences, uses and impacts
having students consistently reflect on thair practices (how are you applying what you’ve learned technically to the class? e.g. how does your interaction with food delivery change as you learn about functional abstraction?)
if programming embeds a certain capitalist order, can it also transform that order? is there anything essentially defining in a programming practice that “destines” it to being in a particular way?
-> programming and capitalism are actually co-productive
simon penny -> making sense robin hill -> expamples of phenomenology in computing simon agre -> computation and human experience
the quantity of meaning compressed into small space by algebraic signs, is another circumstance that facilitates the resasoning we are accustomed to carry on by their aid charles babbage
so, interestingly (blum size theorems), if you have a language that guarantees termination, the program size in such a language ends up being much larger than one written in a language that does not guarantee termination
“if you want to optimize your code, you have to write more code”
ref: subrecursive programming systems: complexity and succintness
the difference between theorems and programs is that theorems must be surveyable, while programs are ok if they’re not surveyable (most programs are actually non-surveyable since they’re abstracting all the time)
phenomenology: - zuhanden/reayd-at-hand is about the “smoothly operating processes/relationships, which carry less cognitive load” - vorhanden/present-at-hand is non-cooperating processes
gerald holzmann: nasa’s 10 rules for safety-critical code
ref: wadler: propositions as types ref: soare, computability and recursion
a phenomenology of program size is needed
what is most important? the totality (program termination) or the size? he says size, but not why
conceptual integrity: coherence (fred brooks), consistency (dave parnas) disturbances: theory and death (naur)
modes of programs: - programs as equipment - programs as performance
conceptual integrity is not correctness, it is not correctness (e.g. changing market demands), is not about fit (e.g. it is possible to construct coherent interfaces that are quite awkward, such as MS-DOS), is not simplicity (dave parnas)
they keep mentionning phenomenology, but maybe they just mean formal, sensual representation
phenomenological progams: - how one reads programs - how one writes programs
gilbert ryle’s theory is explicit, while peter naur’s theory is implicit
seeing theory as equipment is based on a referent, equipment is in its sense usable for something. having a theory is the tool that allows us to be ready to think with it
conceptual integrity as equipmentality: when we see how clean the theory is, it becomes a tool to work with
better to have a reflection of one set of design ideas, rather than a bunch of unconnected ideas
can integrity be understood as resilience? open question
programming languages as linguistic frameworks
the question is: what are programming languages?
the language as metaphor view: PL are not an object of investigation, they do not develop “naturally”, they are not acquired as first languages, they do not serve human-to-human communication
the point is to think of PL from a Natural Language NL perspective. (in a wider semiotic view, though, like software studies, it already is a language)
ref: marina umaschi bers at tufts has a cognitive study on this, similar to evelina fedorenko (the language of programming) ref: janet sigmund: studying programmming in the neuroage: a crazy idea?
the invention of higher PL is not developed to be better understood by machines, but to be better understood by humans
PL gave enormous cognitive advantadge, as they exploint our linguistic abilities, which has impications in the design of PL as a form of linguistic engineering
so the philosophy of tech was always focused on artefacts, but one could move towards the study of symbols, discourses, and phil of PL is the perfect moment to do so
PL do lack many features of full-fledged NL, but stand in some relationship with NL. yet, they are complete with respect to their ‘situational use’
both wittegenstein’s primary languages and frege’s begriffschrift can be called restricted languages, which develop in a community of speakers, sharing specialized knowledge and/or specialized activities (in linguistics, these can be called fachsprachen, controlled languages, sublanguages)
so the machine-centered account is too limited, the linguistic account recognizies the languagehood of programming, which happens through restriction processes
how PL represent a knowledge about a system is semantic representation
jean krivine - collège de france (2019) about knowledge representation
mathematical frameworks can be expressive, but still diverge in terms of semantic representation
and then he makes the example of taking a process p1 activated by p2 itself activated by a click. when you represent this with a bigraph on one side and lambda on the other side, there are differing results depending on whether you’re doing reactive programming, or non-reactive (function reducation)
if you’re doing reactive, bigraph is 2 step, and lambda is 4 steps. if you’re doing non-reactive, you need 4 steps for bigraph, and 1 step for lambda (meaning semantics need to be distorted sometimes)
but is it even possible to find one framework for two types of instructions (currently a debate in reactive programming communities)
quantitatively, some representational systems do result in more steps depending on the task /!\
i’m not sure what is the relation between expressiveness and knowledge representations
and even when you move from diagramming from source code, you’re actually changing the epistemic criteria (code has different implications than diagramming), one should then find a “ground truth” that happens across
ref: temporal semantics of reactive systems
why is hello world useful? it’s neither required nor sufficient
re: 3. it allows you to learn how to use the objects, the paradigms of sequentiality, literalness, sanity check
the usefulness of the term ‘,ateriality’ is thjat it identifies those constituent features of a technology that are readily available to all users (leonardi, materiality, socio-materiality)
hello world is useful insofar as it is teaching not the algorithm, but the tool use: the tools are program code rather than hammers and engines. hello world focuses on the interface, the programming environment, its materiality. what kind of materiality is that? what are the other levels of expertise?
tension between the unicity of the notion of program vs. diversity of existing programs
comparative analysis: few and isolated classifications / heterogeneous goals / minor subject matter but they are useful in their abstractions
brooks: flexibility / architecture lehman: more scientific / technical
classifications have to deal with current state but also have to deal with anticipating future programs
one approach can be through signs (human reading, machine reading, both)
kinds of machines (physical machines, abstract machines)
interesting question: today people don’t speak of programs, they speak of apps. what is the difference?
machine program: a layout of assigns aimed at determining the beahviour of a machine in an environment
turns out that compilers can change the meaning of programs, which defeats the dream of having logic supremacy when it comes to designing programs
logic as motherland, implementations as colonies
we need notational pluralism for meaningful programs!
human <–> program interface <–> machine
the point of programming languages has been to try to decouple themselves from a machine
but sometimes the machine strikes back (moore’s law coming to an end, for instance)
virtual machines: don’t exist, but can see them tranparent machines: exist, but can’t see them
so the argument is that it is important to consider the machine (consider new architectures, ASIC, GPGPU, etc.), and it allows us to shed a new light on how software is written
they also use a lot of energy (e.g. obv blockchain)
a system is a stabilised heterogeneous situation. its parts, we usually call members. in the case of computing, computing = computers + all the files + all the users
in an open state, in hacker culture, everyone has to take care of everything, implicit knowledge is bound to people
in programming, there are also systems like type-in systems that are beautiful because they are closed. because they have a self-repair through extensive naming/tagging of what is what. this strict structure helps with the maintenance
explication of unity (systemd, all these different parts of a linux distribution come together) vs. explication of multiplicity, vs. implication of multiplicity
does complexity close the system? by making it too obscure, etc.?
ranges from undecidability to np completeness to space complexity, to time complexity, to correctness
computing is the interaction of the human with the human, the computer, and the model
a program is reified future (and as such, it might be magic, with ref from: alfred gell, the technology of enchantment and the enchantment of technology)
an ideal program is one which 1 should work under all circumstances and 2 should work according to its purpose
but under “all circumstances” means everything, and sadly there is no specification of “everything” because by definition, a specification is special
abstraction is the process of forgetting (neglecting, rpressing, hiding) something concrete; ignoring aspects, selecting only some (color, type, index)
def: concrete objects cause the convergence of determinations, e.g. everyday objects unify touch and sight, an entry in a database unifies memory state and data access
concreteness implies immediate recognizability, abstractness requires indirect access, abstraction means organizing indirectness
so, in a sense, abstraction does also have some aspects of concreteness, since it reduces
the physical time of machines syncs up with the psychophysical world of human beings, needing a reciprocity of perspectives
fetzner: there are five layers of models at play:
propositional theory of meaning: associating expressions of the language to entities (propositions). this is how this stuff gets connected to one another. otherwise, in PL, there’s also denotational semantics (associating instructions of math functions) or operational semantics (associating programs to actions/automata)
c
int x = 0;
bool go_on = true;
while (go_on) {
x = x + 1;
[]
go_on = false;
}
by djikstra
then, floyd (1967): a non-deterministic program is not governed by efficient causes (cause preceding effect), but by final causes (goals lead to choosing causes for effects).
We may say that there algorithms are non-deterministic, not in the sense of being random, but in the sense of having free will.