Week 3 (4/8,10): Computer Programming

[Gio-Choi]

In the 18th, 19th and early 20th Century, computers were people engaged in a complex division of labor surrounding the calculation of large quantities, wherein programming involved management of the distributed calculating enterprise, or the thoughtful arrangement of calculations by the computers themselves. With Babbage's analytical engine, in which he separated the mill (central processing) from the store (memory) later determined by Alan Turing (1936) to be a universal calculating machine (or 'Turing Machine'), the potential for a new Cartesian dualism re-emerged that separated the muscle of computing from the mind of thinking, planning and designing. But how did that unfold? What are the difficulties of managing a computer with a program--how do they differ (or remain the same) from those associated with managing a computing staff? What did programming allow that building computing machines make difficult? And programming is "all mind", then what are the implications of different programming "languages", spoken by different minds with different experiences?

Post your response as a Comment in reply to this message.

[meeradasgupta247]

On the Tools of Production
Meera Dasgupta

It may be uncomfortable for individuals to consider themselves as tools in the larger machinations of capitalism. When one’s labor is alienated from themselves, such that they produce for the purpose of creating surplus for others rather than for themself, their value is ascribed by time sheets and attributed to evidence of productivity. Then, when we label computers as tools, we must ask ourselves whether they may also be skilled laborers - and, if this is true, what rights may computers have, if any? Though “When Computers Were Human” by David Alan Grier (in When Computers Were Human, Princeton University Press) and “Programming” by Matt Jones (in Information: A Historical Companion, ed. Ann Blair, Paul Duguid, Anja-Silvia Goeing, and Anthony Grafton) illustrate the history of humans acting as computers, both texts also provide evidence to the humanness of computers in the context of labor and decision-making.

First, we may begin with an analogous example within land rights discourse. In the Second Treatise of Government, John Locke differentiated property from the common, or rather, Nature, by expressing that if one applies their labor to alter “Products of Nature” (“Of Nature”, Second Treatise of Government, Ch.5), they are given ownership of those products (“Of Nature”, Second Treatise of Government, Ch. 5). However, in recent times, the right of the land to exist on its own has become a more argued topic within environmental discourse. In constructing policy to protect the land, the idea of non-human rights has gained traction as not only a practical means of thinking about our interactions with nature but also a way of thinking about the living tools which feed into capitalist systems.

In “When Computers Were Human”, Grier begins by illustrating how Smith’s division of labor was optimized through mathematics. Computers, in particular, were people who were given computation-oriented tasks. They seemed to have been dehumanized and assigned ownership so that their title became their line of work - fine tuned to the point where less computers (or resources) were required for the same or even more labor than in prior iterations of the same work, as was evidenced by the development of almanacs by Maskelyne’s computers (Grier, p.33). Hence, the divide between the non-human computers and human computers seems less clear than we would perhaps like to believe. Just like laborers, the modern computer is also optimized - by humans - to work harder and faster on its own; Babbage’s machine took multiple operations and unified them into one tool, allowing for an internal division of labor to progress into a unified form of labor than could be used in other external forms of labor division (Grier, p.41).

Perhaps the distrust which arises from unsupervised machines (Grier, p .43) arises from the belief that highly supervised forms of human labor are more trustworthy - that human error is better than machine error. In “Programming”, Alan Turing was quoted for the following: “most of the programs which we can put into the machine will result in it doing something we cannot make sense of at all” (Jones, p.707). This black-box reflects how computers do transcend our control despite them being made in our image. Though intelligence is nebulous, there may be a time where we must re-humanize the things we had taken as intelligent only in production and not process. For both land and computers, this would look like a re-evaluation of what it means to live symbiotically on this planet and the line between resource and exploitation/overuse.

Discover

I think I had previously read somewhere that people were called “computers” depending on the task that they were employed for. However, in “When Computers Were Human” by David Gier it was interesting to specifically read about the development of the almanacs under Maskelyne by the computers - as the division of labor by Smith had optimized their performance (p.33). The lunar distance method, in particular, was something which I had not read about in such depth though seeing how people interfaced with the cosmos at this point in time was something of note - especially given that our relationship with space has changed over time into space exploration now.

Citations

“The Children of Adam Smith” by David Gier in When Computers Were Human, 2005. Princeton University Press: 26-45.

“Programming”, Matt Jones, chapter 5 in Information: A Historical Companion, ed. Ann Blair, Paul Duguid, Anja-Silvia Goeing, and Anthony Grafton. 2021: 703-708.

John Locke, “Of Property”, in Second Treatise of Government (1690) The University of Chicago Press
https://press-pubs.uchicago.edu/founders/documents/v1ch16s3.html

[cavanbgon]

Babbage, despite his name lacking the “heft” of a Leibniz or Pascal, contributes the most revolutionary for the idea of computing thus discussed. In some sense, each of the prior theorizers limited their incipient notions of computing to what can be considered basically “computation” per se. This is not to distinguish too sharply the material motivations, practical challenges, or indeed the understood goal of Babbage’s model of the computer from his predecessors. Each of these remains in our period of study basically the same. This is to say that the computer is motivated at each step by a desire for the extension of human faculties – particularly in the performance of some “inelegant,” largely repetitive tasks – that attempts at production are made impossible by a failure to unite anti-scientific schematizing with the hard-learned realities of mechanical production, and that the computational device at the core of each device is understood as recapturing prior understood schematics of human reasoning. What distinguishes Babbage’s attempt is his basic optimism for the permeability of computation-motivating physical problems and, indeed, the physical world in general to what can be called “computational” intelligence – or at least an extension of it (Babbage, 110).

              Though prior writings on the computer invoke some notion of an elegant universe, mathematically describable, such invocations have been largely in line with promoting establishing the “naturalness” of a computing device. An elegant universe “should” give rise to such inventions. Leibniz comes the closest to Babbage’s computational optimism, proposing a computational engine capable of addressing the “higher” problems of moral philosophy. Leibniz’s actual reverence for moral philosophy aside, it is critical that Leibniz is always narrowly interested in transmitting universally applicable principles into a mechanically suitable form. Once so transmitted, he allows the computer to simply “untangle” complications previously unresolvable by sheer complexity. There is nothing in this description that suggests some material sense in which computational force, as distinct from human reasoning, is especially well suited to address any of relevant problem. Babbage works in the opposite direction. To him, the universe is best understood by computational parsimony, the first characteristic example being Newton’s inverse-square law (Babbage, 58). From this vantage, Babbage ponders further extensions of human computational intelligence, allowing for an understanding of natural systems of arbitrary complexity (Babbage, 110). Whatever perhaps regrettable pseudo-ecclesiastical dimensions this rosy view of computation comes to take on (notably in his response to Hume), its value to the development of computing is unquestionable. With basic respect given to computation as a task and further computational intelligence as an ambition, Babbage has given room for the introduction of computational/informatics problems as a general category. From this, the distinct beginnings of the essential dual structure of the computer emerge naturally.

              This is quite ironic. It is further reverence for the task of computation that allows forces out direct computation per se – as opposed to flexibility in addressing a whole host of broadly computational problems - as the designated end of a computer’s design. This tension, perhaps paralleled by the codification of rules of productive efficiency - of which Babbage was undoubtedly not unaware – is echoed in the subsequent history of computing (Gier, 40). Note the tension between increasing mathematical formalism in computer science and the loss of “computational intuition” as a necessary trait for the programmer, as bemoaned by Djikstra (Jones, 703). Djikstra’s gripe is perhaps proven to suggest a far more profound intuition on computing in general by the progress of AI having followed a breaking from the “high church of symbolic logic” (Jones, 707).

Discovery:
Exploring Turing’s paper in full is daunting. It is thankful (one way of seeing this) that the single most brilliant and essential of Turing’s arguments is expressed quickly and with limited abuse of notation. As I can understand and express quickly (maybe not concretely), what essentially limits the capacity of a general algorithm from being formed to, in finite time, evaluate in general whether other algorithms are themselves resolved in finite time is the necessary problem of such an algorithm being able to evaluate itself. In other words, up to some putative limiting end step of such an algorithm’s run, it requires data of the putative limiting step in the algorithm’s run to be able to effectively evaluate this limiting step. Thus, no limiting step can be established in general. This is broadly reminiscent of many other problems in the establishment of a strongly descriptive mathematical logic whereby the axioms of such a system are not capable of making sense of objects whose distinguishing properties make direct reference to the underlying axiomatic system. The “obvious” step of constructing sets whose inclusion property refers to distinguishing inclusion properties among sets in general leads to this problem. The result is a need for a kind of axiomatic flexibility that admits objects that would have seemed before unsatisfactory (the most obvious examples are in mathematical analysis).

[evancholerton]

It was fascinating to learn from week's readings how deeply entangled the history of computing is with the history of capitalism. In Grier’s account of human computers, it’s clear that the emergence of computing practices wasn’t just about doing math faster, it was about managing labor more efficiently. Whether it was Maskelyne’s almanac or de Prony’s trigonometric project, the goal was to break down complex intellectual work into repeatable, routine tasks that less-skilled (and cheaper) workers could perform (Grier, pages 26-36). It’s a perfect example of Adam Smith’s division of labor applied not to factory work, but to knowledge production.

De Prony’s inspiration came directly from Smith’s pin factory, and what he created was basically an industrialized system of thought: planners (the “managers”) would develop the algorithms, and legions of former wigmakers and servants (the “workers”) would execute them line by line without understanding the larger picture (Grier, p. 36). That structure, where intellectual work is divided and hierarchized, feels like an early version of the knowledge economy under capitalism. It’s also eerily similar to how we treat algorithms and automation today: the intelligence gets centralized, while the labor gets fragmented and deskilled.

In the same vein, Babbage's Difference Engine and later writings weren’t just about building a machine, they were about making a system that could control and streamline labor itself. He saw how industrial capitalism needed predictable, reliable outputs, and he wanted machines that would do for calculation what steam engines had done for manufacturing. That also meant encoding decision-making into machines in a way that could eliminate human error, or for that matter, human resistance.

Jones picks up this theme by showing how programming languages and software development methods are shaped by and respond to the pressures of capitalist production. Agile programming, for instance, emerged as a reaction against rigid, top-down systems that couldn’t keep up with market demand (Jones, page 704). It reframes programmers not as assembly-line workers, but as self-organizing teams - still focused on productivity, but through flexibility rather than strict control. It's capitalism learning to be leaner, faster, and more iterative.

And yet, even as programming becomes more “mind” than “muscle,” as Jones puts it, the capitalist logic remains. The black-box nature of modern computing doesn’t challenge control, it just shifts it. Now we’re not managing workers, we’re managing uncertainty, outcomes, and user behavior (Jones, p. 707).

All three texts show that computation emerged completely in sync with the modern capitalist mode of production. In fact, computers were from the start one of its most powerful tools, both for organizing labor and for abstracting it. Whether the labor is human or machine, the capitalist drive to extract value runs more efficiently through every stage.

Discovery

One thing that stuck with me was how Grier described the way de Prony’s team used “planning committees” to reduce complex math into tasks that almost anyone could do, as many of the workers “had no knowledge of arithmetic beyond the two first rules” (Grier, page 36). That felt like an early blueprint for what we now call platform labor or even crowdsourcing, a la Amazon's Mechanical Turk. You don’t need your workers to understand the whole system; you just need them to click the right boxes, label the right image, run the code someone else wrote. It shows how computation and capitalism have always worked hand in hand to deskill labor and maximize output, even in the most “intellectual” fields.

[eeengland1]

Adam Smith’s influence can be clearly seen in When Computers Were Human; his belief in the division of labor to increase efficiency, as highlighted by David Grier, proved to be highly effective in Maskelyne’s production of Almanacs, utilizing the work of human computers, and then Prony. Maskelyne’s division of labor yielded notable results, albeit perhaps not complex: a team divided into two computers for the current Nautical Almanac along with a comparator, and two more computers for the next volume in the sequence were put to work in completing these, and despite the issues in producing the first 1767 volume, this team was very quickly able to gain efficiency in this daunting task and eventually produce volumes 6 years in advance of schedule—furthermore, the number of human computers applied to this task was reduced by one.

Later, Prony, who attempted to produce trigonometric tables for the new angle measurement system, applied the same idea, enhanced. Eight planners and a vast number of computers would work together in producing the calculations, the former developing simple guidelines for the latter to follow and also checking the latter group’s work. This resulted in an (to be expected) incredible increase in efficiency, as the same calculations performed by the likes of Clairaut and co. would have taken 150 years. Smith glimpsed a tiny fraction of the efficiency of the modern era; Prony too seemed to reduce the humans performing the calculations to nameless computers, optimizing for productivity in their specific fields, yielding (relatively) outstanding results when working in parallel.

And yet the advance of computing was seen to increase drastically to the point of our own incomprehension in the late 1900s: the NSA first realized their inability to strictly regulate and control software systems in the 1970s as outlined by “Programming” in Information: A Historical Companion. The existing software systems were described as a “gilded cage”, the complex ones an “alien force” (706)— this only got worse as our efforts continued toward AI. At this point, it’s questionable whether we understand the computing that we’ve worked forward to for so long. And so we’ve placed ourselves in a disturbing predicament where our lack of understanding is impeding humans on improving computation further, and more importantly, regulating it.

Diverging from the advance of computation, Babbage, in his ninth Bridgewater Treatise, attempts to discuss how scientific focus can also aid understanding of God and the divine— as well as claiming that miracles are preordained instead of created through divine intervention. Babbage tries to show how his experience in scientific inquiry, and perhaps more importantly to our focus, his work in programming, could help him understand the acts and designs of God, tying over two concepts that seem to be perpetually at odds with each other. Retrospectively, science and religion have been reconciled to some degree, but not much, in my opinion, and so the effect of Babbage’s treatise seems to be easily missed.

Discovery: It’s interesting to observe the effect that Turing’s definition of a computable number with his Turing Machines had on society, proving the limits of computation. I do wonder to exactly what extent the impact of his work affected the relevant computing circles at the time, and to what extent the foundations of modern computing were developed by him.

[mhmanek]

I find it remarkable that at one point "computers" were, in fact, people. The role of managing human calculators was in some sense a craft of 'social engineering'. Even though this human system was more vulnerable to error, miscommunication, and unpredictability, it had a personal quality to it that machine execution lacks. Supervisors didn’t just supervise - they were mentors who cultivated individual talents. There was a tangible sense of human connection in how problems were divided up and then reassembled into a coherent answer.

The challenges in managing a machine versus managing a group of human calculators are fundamentally different. With human computers, the hurdles were often in communication, coordinating diverse mental frameworks, and mitigating individual errors. In contrast, programming a machine demands a discipline of clarity, precision, and unambiguous thought. Every instruction must be meticulously crafted because a machine won’t improvise or interpret context the way a person might.

Enter Charles Babbage with his analytical engine - a machine that marked a paradigm shift in how we conceptualize computation. Babbage’s innovation lay not in eliminating the human element but in reassigning its role. By separating the processing unit (“mill”) from storage (“store”), he redefined the very nature of what it meant to compute. This separation hinted at a philosophical shift too - a division between the “muscle” of computation and the “mind” that designs it. Suddenly, the intellectual labor of designing a sequence of operations became as significant as the mechanical act of calculation.

Moreover, programming languages themselves are a mirror of human thought. They are a codification of philosophy, culture, and experience. Each language carries within it the biases and worldviews of its creators. This means that when we write code, we are not merely instructing machines - we are also expressing our own narratives. The structured, formal nature of programming brings out the creative tension between innovation (the abstract, creative planning) and execution (the mechanical, error-free following of instructions). It is said that all biography is in some sense, autobiography (the biography of the subject is inevitably influenced by the personal beliefs and worldviews of the biographer). A similar thing seems to apply to programming languages.

My favorite book Gödel, Escher, Bach has this wonderful, apt quote:
Programming in different languages is like composing pieces in different keys, particularly if you work at the keyboard … certain kinds of figurations “lie in the hand” in one key but are awkward in another … This shows how a notational system can play a significant role in shaping the final product.

Discovery
It was inspiring to try to read Turing's original paper and it's relations to the questions posed by David Hilbert. I am reading the book 'The Annotated Turing' to try to make sense of it.

[peterzhou-cs]

The primary difference between programming on computer and programming with human computers roots in the distinction between mechanic and human labor. The former is objective, deterministic, and would function as instructed with accuracy, at least in idealistic situations. The latter is self-trained, might make mistakes, and take time to be trained to produce computations efficiently. The accuracy with mechanical computing units comes at the cost that instructions have to be detailed and precise, adding tremendous workload to the programmer. Dealing with the underlying physical units is simply too hard, and one adds intermediate levels to facilitate programming. This is parallel to the human labor-computation program seen in France, 19th century, where the computation work of logarithms table consists of three lays: the bottom layer consists of hairdresser/servant who can only do addition/subtraction, the middle layer consists of experienced computer that overseen the bottom computations and dividing the complicated goals into addition/subtraction tasks. The top layer consists of mathematicians who have an overall control of the outline and the calculational algorithm/goals. This is also how programmers work; nowadays the bottom level computations have implemented fixed set of logic and the work is automated, so that programmers do not need to be mathematicians.

One notable feature is that when one atomize the task of computing with human computers, the seperation between computing and programming becomes even clearer, and the system works more mechanically. Maskelyne trained his computers on his efficient algorithms such as interpolation by cubics; the computers, while their task seems mechanical, still had the 'freedom' to 'acquire the skills to compute efficiently. Those skills are not planned by the programmer, and are nontrivial to develop (the computers came from second tier of astronomical specialization). In the computation of logarithm table in France, the labor is divided further, and the basic computations of additions/subtractions become simpler and most computers (typically untrained) do not acquire any special skills to perform the computation. The basic computers roles are thus standardized, and intellectual labor is even more concentrated to programmers. In a mechanical computer, such skills to perform certain complicated computation tasks must be taken care of by the programmer. Thus, a mechanical programmer extracts every single bit of 'nonrepetitive', 'creative' parts in the project and ideally leaving only repetitive work to computers.

If we consider wider aspect of the difference, we end up finding a gap in the social and economical implications between human/mechanical computers. In terms of cost, human computers need salary, while mechanical computers demand the cost of manufacture and maintainence. The key difference seems to be that mechanical computers are assets, unlike human computers. The former is often optimized by further division of labor, while the latter could be optimized by the programmer's skill besides benefits from improvement in the computer industry. It is interesting to note that to further divide the labor often implies a further impersonalization of human computers, and a deepened polarization in the income/intellegence/social status between the human computers and programmers. Meanwhile , human computers morally shall be awarded some credit of the consequence of their computations, while machines themselves do not share intellectual credit (credit goes to the designer of the machine). Indeed this is pretty debatable. There is one last obvious difference: arranging human computers demand social skills, and optimization in the realm of social organization is required to accomplish computations. Such demand is not seen in the same scale mechanical computations. (Programmers communicates, but for different purposes.)

A brief comment of how personal background gets into programming: the 0 and 1s in the computing machine themselves are universal and objective, and most foundational algorithms and operations are made fixed and are quasi-universal in the sense that most programmer uses the same thing. The difference of programming languages influence the style/structure of the code in a large program where complicated functions are developed to achieve a general goal, and personal experience play a central role in choosing the goals themselves, which are dominant in the outcome and implications of programming to our society. The building blocks are mechanical and universal, the implementation of the same feature could take multiple paths, but it is the communication of ideals that is beyond all technicalities.

Discovery: Turing's short paper of computable number is illuminating. It is surprising to see how axiomatized abstract computing machines/concepts to acquire concrete implications, akin to other miracles found in mathematics. e.g. real algebraic numbers are computable. The key method of universal machine is ingenious.

[ucachyut]

Managing a computer program is fundamentally different from managing a computing staff, primarily because programs are "dumb"—they cannot interpret or infer. This means programming requires the translation of vague, intuitive thoughts into a language that is extremely specific and unambiguous. Unlike human computers, who can work with flexible natural language instructions, a machine needs everything to be defined in detail. This duality—where the machine executes but does not think—reflects the kind of Cartesian separation envisioned in Babbage's analytical engine, which separated the mill (processing) from the store (memory), and later inspired Turing’s concept of a universal machine.

This shift introduced new challenges. With a computing staff, the manager can adjust instructions dynamically and rely on human judgment for error correction or contextual interpretation. But with a program, every possible contingency must be accounted for in advance. This is both a limitation and an advantage: while it demands greater precision in design, it guarantees that the machine will do exactly what it's told—no more, no less. In this sense, programming resembles modern mathematics, where informal intuitions—like the idea of a “number”—must be recast in precise terms, such as definitions in set theory.

Cost and efficiency also mark a major difference. Maintaining a computing staff is expensive and slow by modern standards. A single computer, once programmed correctly, can perform vast computations far more efficiently. And yet, despite these advances, the core difficulty remains: bridging the gap between human thought and machine execution.

Interestingly, with the rise of AI, computing with natural language is again becoming possible. But ambiguity remains a fundamental challenge. AI models often cannot directly perform basic arithmetic reliably, but they can use tools just as a human would. For example, while it may be inefficient to ask an AI to directly multiply two large matrices, it can efficiently write a C or Python program to do so. In this way, managing AI is becoming similar to managing a computing staff—except the "staff" now works faster and costs less.

Another shared challenge between managing people and managing programs is the need for constant maintenance. Human workers need training and oversight; programs require updates, debugging, and optimization. The work does not end with the initial instruction.

The emergence of different programming languages, written by different minds, highlights the idea that programming is “all mind.” These languages reflect different levels of abstraction and different ways of thinking. However, at the lowest level, programming is objective and involves direct manipulation of memory—manually placing a ‘1’ in a memory location, a ‘2’ in another, uploading these to a register, performing the addition, and storing the result. This would be done in assembly language, requiring intense micromanagement.

A slight abstraction above that brings us to languages like C. Here, memory is still directly accessed, but many details—such as register management—are automated. Further abstraction leads to languages like LISP, which blur the line between functions and variables and treat them more uniformly.

Languages like Python and Julia go further, allowing users to define complex data structures and focus on higher-level logic. Though they differ syntactically, Python and Julia operate at a similar level of abstraction and are largely interchangeable in functionality. This supports the idea that the primary difference between programming languages lies in their abstraction level.

Going even more mathematical, as Dijkstra advocated, we reach languages like Haskell. These are grounded in rigorous type theory and strict logical structures, emphasizing formal correctness over flexibility. Each language reflects a different philosophy of thought, shaped by the experiences and priorities of its creators.

Discovery:
It was illuminating to read Turing’s original paper on computable numbers. I was struck by how Turing was able to formalize the concept of a general-purpose computer purely through mathematical reasoning, long before modern computers existed. This shows the incredible power of abstraction and the ability of mathematics. I also found it fascinating that Turing’s model was based on how a human would carry out a computation step-by-step, showing how closely early computation theory was tied to human reasoning. His result that there can be no general algorithm to solve all mathematical problems—the undecidability of the Halting Problem—was particularly striking, offering a computational perspective on the same fundamental limitations revealed by Gödel’s Incompleteness Theorem.

[suryachinnappa]

The sorts of machines conceived of by Charles Babbage and his successors, described in this week’s readings, highlight a conceptual separation between the mechanical and the mental, while simultaneously bringing them closer together. Prior to the conceptual development of machines like Babbage’s Analytical Engine, computing was considered a rote, mechanical task, which required of its performers a level of mental ability and knowledge, but arguably, required no intelligence. I define intelligence here as the capacity (or perhaps more accurately, the tendency) of an agent to operate at a degree of abstraction away from its mechanical task, so as to recognize higher level structures and patterns in the mechanics. By this definition, intelligence is crucial for the design of algorithms, what we may refer to simply as programming, as no amount of mechanical work within a given system can reveal truly novel insights about this system. I’m reminded of the book Flatland, which explores dimensionality in a similar way; the main character is only able to gain an all-encompassing understanding of his 2-dimensional existence once he is lifted into the 3rd dimension; things are revealed to him which would be impossible to know while confined to only 2 dimensions.

In a similar way, the development of programming facilitates the recognition of a degree of abstraction away from mechanical computation. Indeed, the modern diversity of programming languages showcases varying degrees of abstraction away from mechanical computation. Things that require intelligent design in assembly language are mechanized in a systems-level language like C; similarly, things that require intelligent design in C can become rote in a higher-level language like Python. The last reading muses on machine learning as a way for computers to program themselves as an extension of this; this hierarchy of intelligent-mechanic relationships continues in such specialized endeavors—the machine learning library PyTorch makes rote processes that require intelligent design in base Python.

We can consider the implications of this hierarchy to the Cartesian dualist question posed. It seems like what is mind at one level can be machine at the level immediately above it, and the mind at this level can be the machine of the level immediately above that. We may be tempted to conclude that human mentality is the crux of our understanding, and some more sophisticated, superhuman mind may observe our cognition and behavior as mechanistic; this is by no means an invalid interpretation. But I’m tempted by another possibility. Human mental life is characterized by, among other things, introspection: the same Mind (capitalized for distinction from the static-level mind) that carries out a mechanistic task is capable of reflecting upon the process of carrying out that task, and is thus judged to be intelligent, at least with respect to the mechanistic task. However, crucially, the very same Mind is able to reflect on the process of reflection itself, identifying patterns in its own cognition. This pattern can theoretically be repeated recursively, creating infinite levels of abstraction, each of them accessible to this Mind (I could even argue that noticing this pattern even further proves it). It may be that this is what characterizes true Intelligence; that the quest towards true Mindedness may end when we are able to construct a machine capable of this infinitely-recursive reflection.

Discovery:
Reading Turing’s paper on computable numbers was fascinating; I don’t think before this I fully grasped that the limitations on computability were so intimately tied to Gödel’s incompleteness results. I’m reminded of when I once posed a question to a friend, regarding whether with infinite computational power we would be able to solve all of math. Turing’s sketch of a computing engine in a world without incompleteness seemed to address this, showing that were incompleteness not the case, a machine could go through the list of all theorems and prove them, sooner or later proving each and every one. My friend’s answer to this question was of a different nature, emphasizing that mathematics was all about creativity; we can’t solve all of mathematics computationally because mathematical constructs are invented to address issues of importance; many concepts in math are informed by their applications to physics, for example. A potentially less elegant example is that of number system bases; the Analytical Engine was conceived of in base-10, as it is the system most native to humans, but modern computers use base-2, which is more useful to facilitate the nature of modern computation. Ultimately, these are two modes of representation, constructions used to make sense of abstract relationships that mathematics helps us model.

[Alex7692]

The evolution of programming language effectively actualizes a new set of possibilities for operationalizing computers. Programmers are enabled to directly "communicate to" the machines by adopting a standardized, high-level language that which can flexibly adapt to different work scenarios. Essentially, computers could then be thought of not just a fixed, mechanistic gadget that strictly obeys a set of pre-established rules but a multiply functional system with hypothetically greater efficacy. But this has also generated a set of new problems as software development enters into focus. The semi-materiality of programs make it easily expandable at the same as they interweave into a sophisticated web. Increasingly it demands for extra human resources to debug and maintain the programs, which in turn fosters further specialization in the task of a programmer, as opposed to that of a human "computer" whose sole responsibility is to compute according to "pre-programmed" algorithm.

Hence, as the conglomeration of codes far surpass individual capacities to interpret, optimization becomes an issue. It is impossible for anyone to posses the adequate knowledge to address every specific glitch. It is as if the software obtains a degree of autonomy as a "social reality". And it is interesting to remark how a "post-Fordist" mode of production emerges simultaneously to cope with the problem: that is, a further individualization / modularization of labor relations, the completion of tasks in segments and small, bite-size batches, that effectively decentralizes, or flattens the regulative / administrative hierarchy production. It is only with this accentuated flexibility, ideally with a globalized community of programmers who could each contribute uniquely to the developmental process (i.e. open-sourcing), that programs are able to effectively iterate according to customer needs. Alternatively, we would have to push for a further autonomy on the side of the computer by developing mechanisms of self-learning.

What happens, then, suppose we push for the mentalistic metaphor and consider a potentially pluralistic ontology of "minds" as instantiated by different programming languages? Intuitively, the premise is not as preposterous as it may be; that is, as we treat each programming language, or "language-game", as a distinct logical syntax that governs the production and communication of propositional knowledge. To the extent that each model is trained differently and placed in a unique "space of reason" according to different grammatical rules, we may well naturally associate it with the existing set of questions regarding "translatability" across distinct conceptual schemes as identified by unique languages (think: Quine and Davidson). Interfaces, plugins, etc. are required to translate and adapt one set of rules with another.

Discovery

I read Turing's paper on the Halting problem for exploration; of which some of the ideas on undecidability I've been previously exposed to together with Gödel's two incompleteness theorems. On the very conceptual level as I've understood it, this limitation of computability results from a certain strange loop of self-referentiality that recurs ad infinitum -––– which, as one may propose, may serve to further the analogy between programs and mind (but at the same time one would risk a reduction of mental operations to that is definable using first-order logic?) Very superficially, the lack of restriction to what we may conceive as computable thereby reveals the limits of language and thought as such, which in turn requires a more fundamental inquiry into the sense of sense-making prior to all possible judgements (and I personally doubt the Carnapian vision of ideal language that is still, as of now, characterizing the mainstream of anglophone philosophy).

[Laurelli7]

Charles Babbage’s Analytical Engine represented a major shift in computing from manual labor to symbolic operations. He introduced the separation of a "mill," which we now call the processor, and a "store," which we call memory. This idea was later expanded by Alan Turing in 1936, who described the concept of a universal Turing Machine. Turing’s idea showed computation as purely symbolic—something separate from the physical machine itself. This transition from specialized mechanical calculators to a universal, programmable machine took place over a century.
Managing a computer with a program is very different from managing a group of human calculators. When people did calculations, managers had to carefully organize tasks and constantly check for human mistakes. Errors could come from simple things like tiredness or miscalculations, so management required close supervision and repeated checking.
In contrast, programming a computer shifts all the focus to logic and planning. A computer will carry out instructions exactly as given, without error (not in the sense of not causing errors but no discrepancy with the given instruction). So, the challenge becomes carefully thinking through each step ahead of time. Programmers must anticipate logical errors, debug their code, and ensure their instructions are correct. Unlike managing humans, where the challenge is dealing with human error and coordination, programming involves ensuring that the program’s logic itself is flawless. In terms of this quality, programming enables certain capable individuals to accomplish huge achievements that could require thousands of human labors to do in the old days without computing.
Programming also made it easier to solve a wide variety of problems without needing to build new machines every time. Before programmable computers, new computational tasks often meant constructing specialized equipment or rearranging human teams, which was expensive and slow. Programming allowed one machine to tackle many different tasks by simply changing instructions. This flexibility opened up new possibilities for creativity and exploration. Problems of great complexity could now be solved by repeating simple operations millions of times—something impractical with manual calculations or specialized hardware.
Because programming mainly happens in our minds, different programming languages potentially could affect how we think about and solve problems because each language—such as FORTRAN, COBOL, Lisp, or Python—encourages a unique way of approaching tasks. For example, FORTRAN helps programmers think in mathematical terms, COBOL focuses on handling data in structured, business-like steps, Lisp emphasizes symbolic reasoning, and object-oriented languages focus on interactions between separate objects. However, absurdly, for the current programming language conception, especially along the evolution pattern of popular programming languages, this is not always the case. The popularity of C is primarily due to the adoption of Unix operating systems, and recent popular languages like Rust are widely used in industry because it is memory safe and fulfills the object oriented representation need. However, I believe it is more beneficial to consider programming languages as significant to our society as an actual spoken language due to how software is now everywhere in our life and we see great potential to further lower the entry of difficulty for programming using AI tools.
Discovery:
After reading Niklaus Wirth’s “A Brief History of Software Engineering,” I discovered the absurdity in the way how the widely adopted programming languages evolved. The prevailing of C is just due to a convenience of a operating system(Linux) on microcomputers, which I believe demonstrates how short-sighted the software engineering community is. It makes me wonder whether LLMs are the next C because we can all tell it is not actually huge step towards AGI but are just popular and hyped due to certain industry results which seems similar to how C is adopted. After C is adopted, despite the serious security issues it keeps generating, the mass community of software engineering shows a huge inertia of abandoning it. I believe when a technology is too accessible among society, we need to think of it from a social behavior. I wonder there might be some social science interpretation of this pattern.

[benkim04]

The change from computing staff to programming relies upon the skill of groups versus the skill of the individual. Maskelyne, for example, had a very thorough process of creating the almanacs in which there were two individuals who would complete a calculation independently, and then a third would verify and correct the calculation (Gier, 30). This means that each calculation is done at least twice, and sometimes even three times. This is inherently due to the fallibility of the computing staff. In opposition to that, it is often sometimes difficult to cross reference the outputs of a program with a “true” answer. It is almost entirely reliant on the integrity of the programmer and how far they are willing to bullet-proof the program. One common thread between managing a computer program and managing computer staff is the up-front costs of both. For Maskelyne, “the process of recruiting and training his computing staff proved to be more difficult than he had anticipated” (Gier, 30). That is, it takes time in order to teach each individual the high-level concepts and then the low-level computations for such tasks. We experience similar front-end costs when programming, in that we must first have a programming language, understand it, and also understand the problem we are trying to solve. Programming itself is significant in that it reduces the chance of human error. Computing machines were difficult to build, and thus were delicate to use and could have manufacturing defects that could cause errors in calculation. Even further, it is possible that the human simply performs the calculations incorrectly even with the aid of the machine. Through programming, it reduces human error by ensuring that the calculations are performed correctly every single time, as well as enhancing reproducibility by simply running the program again to get the same calculation rather than having to ordinarily double a workload. Different programming languages are indeed products of different minds of different experiences, but often comes down to preference and ease. For example, many prefer to program in python because it is simple, and intuitive. On the other hand, it is unlikely that many individuals still program using belts and hole-punched paper machines. That is to say, one is much more accessible, powerful, and universal than the other despite both technically being able to complete the same task. Beyond that, individuals may have preferences between functional programming languages and object-oriented languages. Some may be more suitable for data processing tasks like R while others are built for efficiency like C. It then follows that individual experiences, like what language they first learnt, what applications they will use it for, and other factors irrefutably influence the language chosen for each mind.

Discovery:
I was particularly drawn into how elaborate the hierarchy needed to be when creating the Almanac with computing staff. We often take into granted in the modern day the convenience, speed, and complete accuracy of our calculating machines. In the modern day, when a program does not yield the results we wish, it is never because the language is faulty or the computer isn’t functioning. It is always because the user who created it made a mistake. Even further, with the advent of accessible LLM’s that are proficient in programming, the program may even save the user from making mistakes in the first place, further eliminating the human errors that are present with computing staff.

[TonyYZ]

Response
Programming involves the organization of computational resources with which previous attempts to create computational machines have grappled in similar ways. Due to the initial incompatibility of different tools and platforms, programmers need to write programs that mediate between them, thus the “material embedding of all programming” (Jones 706). Whereas Maskelyne provided a rough guide on computing the nautical almanac for his computers, De Prony divided the workers into “planners” and less knowledgeable computers and let the former give specific instructions to the latter (Grier 36). This difference arose from the diverse skill backgrounds of these computers and the need for their collaboration. In this sense, the programmers are like De Prony and Maskelyne, who face not only the mathematical problem of producing the correct equations but also the practical problem of employing computing resources.
With the development of computational infrastructure, one may consider the practical problem part of the mathematical problem since algorithms also deal with resource allocation. Therefore, humans would delegate both problems to the computers and be only responsible for designing high-level algorithms that implement this delegation. Computers would produce lower-level algorithms by themselves that account for the rest of the problems. However, such a vision of computers designed to “program themselves” was proved to be futile in the last century because the machines lacked the “inductive learning” ability (Jones 707, 708). The flaw highlights the materiality of mathematics, as the search space of algorithms is vast, and the creative process of a mathematician requires intuition and heuristic exploration to reach a discovery from a known set of theorems. In other words, mathematicians are also deeply framed in computational resources despite the abstractness of mathematical concepts. Thus, the concern transforms into considering the mathematical problem as part of the practical problem, not the opposite.
On the other hand, programming abstracted the entire preparation process for computation, from attaining the tools to organizing and executing them. While mathematicians like De Prony and Maskelyne had to recruit resources on different levels, such as people, ink, and money, the computer, in the sense of a mechanical device, integrated these factors and flattened the recruiting process into programming, where every step is performed through the essential components of a computer – CPU, keyboard, screen, and so on. Babbage’s design of the difference machine demonstrated such a preference for flattening: the machine “reduces the entire [computational] process into the simple operation of addition” (Grier 41). Similarly, the analytical machine presented a programming prototype through its punch card, a way to standardize the set of available operations. Therefore, programming simplifies the language of organizing computational resources into more fundamental units. Compared with the materiality of programming, the complexity of material reality and the wish to simplify computation continued to act as two forces that shaped programming as an ambiguous and dynamic practice.

Discovery
I am interested in the development of programming languages and their underlying philosophy. While Babbage tried to establish the basis of automating computations with his analytical machine by starting from simple mathematical operations like assembly language, recent programming languages focused on improving the readability and intuitiveness of code. This development culminated in chatbots’ prompt engineering, where programming could be done entirely in natural languages. I wonder if Babbage’s work had continued, would it have resulted in machines that enabled communication in a language closer to natural language, according to his plan?

[aadarwal]

These readings were definitely a lot more interesting to me because I was able to directly explore how the relationship between between labour for humans and for compute was able to come about - a relationship I feel like I had just assumed to be the standard before these readings and given how we use the latter today. Firstly, it showed how computers have always historically been human aides who were simply used to perform both mental and physical "labour" in the arduous and boring sense - effectively a theme of replace humans where they are not needed. Babbage talks about how separating the two marked a return to this Cartesian dualism— properly and effectively separating physical execution from intellectual planning. The next steps from that point then were more about managing these computers to be much better programmable. For humans, this meant things like addressing training, and social issues and revolved around motivational problems and their solutions rather than knowledge problems. Machines on the other hand had knowledge problems in the form of software logic, debugging, hardware issues. These problems means that programming evolved into a craft-like skill resistant to be automated as easily because of both these motivational and knowledge problems not being as easily solvable initially.
The one difference, however, was that programming was much much more flexible because of the nature of these problems being more iteratively solvable. For instance, it became evident that unlike humans, software allowed rapid and incremental development. The "move fast and break things" kind of motto that we see today was the kind of thing that seems to have given software its first break in the first place, even above the human management issues of social problems. Programming languages furthered this approach and BASIC, COBOL, FORTRAN, -- even Lisp in my opinion -- were able to address specific knowledge problems, whether in science of business. This fast iterative process of getting better while being able to address such specific problems meant that programming languages created a unique space of intellectual ability to within computing capabilities that had not been seen before, and it is the large scale adoption of them that has enabled us to reach this point of duality even today.
Discovery
What I found to be the most interesting part of this reading was Charles Babbage defense of religion and his idea of the pursuit of truth. For him to say that it was an "injustice" for those who pursued science abstracted away from religion was not something that I expected, and contrasted with many of the other thinkers of the age who explicitly seemed to be in pursuit of some "truth" he seemed to stand out to me for this very reason. In fact in his attack on Mr. Whewell's Bridgewater Treatise I was really fascinated to see that he held these views while simultaneously positing that there were no "higher regions" than mathematical truth, as I had not previously thought about a way to be able to work with the idea of higher truths being cohesive with religion and God before, especially from a scientists point of view, and so I found Babbages' ideas on the same to be particularly enlightening.

[ciara-kinney]

Large scale computing has been a collaborative effort since its origin, although the nature of this collaboration has varied hugely. I am sure that there are earlier examples of which I am not familiar, but the first we engaged with in this weeks readings was Maskelyne’s team of computers calculating naviational charts, organized in a cottage industry system. Though soon eclipsed by far more efficient methods of calculation, Maskelyne’s team was innovative in its approach and set up the fundamental dynamic of systematized computation which has propagated to the modern day. Two computers would complete a calculation which would then be send to a third to compare and correct any mistakes or discrepancies. Essentially, a concrete division between production and revision was developed. This system relied on conversation, as without the process of “double computing”, errors would most certainly occur and propagate. The conversation was at once lateral, as all the computers involved were educated in mathematics, understood the nature of their calculations, and could thus engage in a productive defense or repudiation of results, and simultaneously vertical, as the development of separate production and revision roles elevated one as more inherently discerning and reflective.

The integration of Adam Smith’s idea of the division of labor into computational processes revolutionized human capacities took this division and intensified it as individuals such as De Prony divided computation into its component parts, deskilling the work required to produce complex calculations, and changing the nature of human collaboration within computational systems. The human computers carrying out the work did not require a formal mathematical education, but were rather only employed in simple calculation, which was prescribed and reviewed by a second class of trained workers who assembled the mathematical fragments into a coherent product. Though they were not yet transformed into abiotic machine, the individuals carrying out the basic computation were not engaged with the highly intellectual process of designing, prescribing and validating calculator results, but were rather already relegated to the role of simple mechanism. Lateral conversation between classes disappeared within this system, as it was a system of simple command fulfilment. Complex conversation and exchange of ideas remained integral to those designing the computational processes and issuing commands, but did not extend to those actually producing the computations.

This picture is not so distant from modern engagement with computers. The producer is of course now no longer human, but the general dynamic of prescriber and producer is maintained. Changed, however, is the method of directing this producer. Directing another human is nuanced and maintains room for implication and imprecision. Directing a machine generally gives no such allowances, as every command must be exact and specific. The development of modern programming has thus produced a multitude of different approaches to this direction across time and niche. Programming experienced a “mathematical infusion” (Jones, 704) in the 1960s, which fundamentally changed methods of commanding machine. Although these methods of commanding computation are thoroughly incompatible with different substrates (ie human vs machine), in the abstract, they maintain quite a few interesting similarities.

Discovery:
For my explore section, I read part of Stephen Wolfram’s 2020 “A Class of Models with the Potential to Reproduce Fundamental Physics” and the Scientific American article which accompanied it. Although I certainly found his paper interesting, as I was reading the Scientific American article, I was reminded of a quote from Programming (which actually originated from the Mythical Man-Month paper) which said, “Men and months are interchangeable commodities only when a task can be partitioned among many workers with no communication among them… This is true of reaping wheat or picking cotton; it is not even approximately true of systems programming” (Jones, 1). One of the primary complaints that is raised against Wolfram is his lack of engagement with the broader scientific community until his publication of a paper hundreds of pages long with no prior, incremental, introduction to his ideas. Developing a grand theory thoroughly independently is understandably compelling, but also has its obvious drawbacks. The importance of peer review and outside input is not minimal, and refusal to engage with these systems evidently can render a project sidelined and potentially underdeveloped.

[faizHilaly]

Through his creation of what Turing coined as the ‘Turing Machine’, Charles Babbage enabled the decoupling of thought and material execution. This marked a fundamental shift in how intellectual processes could be executed, as they were no longer constrained by managing both computational and memory limitations of the mind or conventional methods.

Although Babbage was the first to illustrate this decoupling with a machine, Grier demonstrates a similar concept emerges through the early development of computing labor force. Grier draws a parallel between human computers in the 18th and 19th century and the workers in Adam Smith’s pin factory. Similar to how deconstructing the process of manufacturing a pin into smaller tasks increased efficiency, breaking mathematical problems into discrete parts and assigning them to teams of human computers increased the complexity of the problems that could be solved. However issues did arise as a result of these abstractions, as errors could propagate across layers and many problems were impossible to solve locally.

Shifting this process to computers addressed many of these problems. The computation process is not longer subject to human error, but also no longer benefits from the intuition and context that humans have. This introduced a fundamental issue with programmable computers, which was the need to communicate logical instructions. This meant that programming served as a form of anticipatory reasoning, as it was the process of understanding the broader context of a task and leveraging human intuition to form a specific set of instructions. Since these instructions were adapted from the programmers mental model of the world, different languages emerged to represent different models. Object oriented programming, for example, represents the world as interacting entities that possess both state and behavior. Focutional programming, on the other hand, traits computation as the evaluation of mathematical functions and avoids changing states and predictability.

This is a reflection of the decoupling initiated by Babbage and formalized by Turing where a new Cartesian divide si created between the processor and the planner – in place of the body and soul. The mind is no longer embedded in the execution of the calculation, but its encoding. Rather than solve the problem piece by piece, the role of humans is now that of an architect designing logical systems that can solve problems. The challenges of communicating across layers, coordinating logical processes, and executing those processes systematically all still remain, but the execution is now mechanical rather than human-driven.

Discovery:
I had previously read about the creation of Charles Babbage’s universal machine, but did not realize that many principles were inspired by humans who were at the time called “computers”. That realization was really brought home by the comparison to Smith’s division of labor and labor specialization. Transforming a previously human process into an automated computer process is a longstanding trend of software engineering, but it’s interesting to note that it’s actually fundamental to the development of computers and software itself.