Blog · Review Essay · Last reviewed June 15, 2026

The Software Arts and the Humanities Inside the Machine

Warren Sack's The Software Arts is a useful AI-era book because it refuses the clean story that software descends only from mathematics, engineering, and machine logic. It treats programming as a historical language art: grammar, rhetoric, logic, translation, demonstration, and cultural meaning hardened into executable form.

The Book

The Software Arts was published by the MIT Press in 2019 as part of its Software Studies series. MIT Press lists the ebook publication date as March 15, 2019, and the hardcover as April 9, 2019, with ISBN 9780262039703 and 38 black-and-white illustrations. Google Books lists the April 9, 2019 MIT Press edition at 400 pages, with ISBN 0262039702 / 9780262039703.

Sack is a media theorist, software designer, and artist at the University of California, Santa Cruz. His UCSC profile lists research interests including media theory, software studies, software design, digital studies, history and philosophy of science and technology, and the history of the humanities and liberal arts. That matters because the book is not written as a programmer's memoir or an abstract philosophy of computation. It is a close reading of the cultural materials through which software learned to describe itself.

The central claim is simple enough to state and hard enough to absorb: software belongs to the arts as much as to engineering. MIT Press summarizes the argument as an alternative history of computing that puts the liberal arts at the center of software's evolution. Sack traces software back through the eighteenth-century French encyclopedists' descriptions of artisan practice, then forward through computer science, programming languages, algorithms, grammar, logic, rhetoric, learning, and simulation.

That makes the book a strong companion to Software Takes Command, Programmed Visions, Interface Culture, and The Cultural Logic of Computation. It is less about what software does than about what kinds of language, schooling, proof, performance, and imagination made software thinkable in the first place.

Software as Translation

The best way to read The Software Arts is as a book about translation. Sack is interested in what happens when practices move between domains: workshop procedure into written instruction, liberal arts vocabulary into computer science, mathematical proof into software demonstration, grammar into machine parsing, and code into popular culture.

Translation is never neutral. It carries meaning across a boundary, but it also drops things, compresses things, and changes which parts of a practice can be recognized. A craftsperson's situated judgment becomes an instruction. A social process becomes a flowchart. A disputed category becomes a data type. A user action becomes a click event. A public service becomes a form and a status code.

This is where the book becomes more than media history. AI systems now perform translation as infrastructure. They translate people into embeddings, documents into summaries, tasks into tool calls, intentions into prompts, images into labels, policy into workflow, and human speech into operational records. Each translation creates a world the machine can handle. Each also leaves residue outside the machine's grammar.

That residue is politically important. A system that cannot represent a kind of need, ambiguity, exception, expertise, grief, humor, danger, or local knowledge may still act as if the translation is complete. Software does not only execute commands. It decides what can count as an intelligible command.

Grammar, Logic, Rhetoric

Sack's recovery of the trivium - grammar, logic, and rhetoric - is the book's most useful provocation for the present moment. Modern computing culture likes to imagine itself as logic made operational. Sack keeps asking what happened to the other language arts.

Grammar appears wherever systems decide what forms are valid. A programming language has syntax. A database has schema. A platform has acceptable formats. A chatbot has system instructions, guardrails, and prompt patterns. A government service has fields and required attachments. The grammar is not merely technical. It tells users what the institution can hear.

Logic appears wherever a system defines implication, consistency, equivalence, or proof. But software rarely lives in pure formal logic. It lives inside business rules, ranking formulas, eligibility thresholds, moderation policies, recommender objectives, benchmarks, and model evaluations. These are logics in the plural: partial, situated, contested, and often hidden behind a smooth interface.

Rhetoric appears wherever software persuades. A demo persuades investors that a capability exists. A benchmark persuades buyers that a model is superior. An interface persuades users that an action is safe, normal, or expected. A conversational agent persuades through patience, fluency, apology, citation, and tone. The AI era did not add rhetoric to computation. It made the rhetoric harder to ignore.

The AI Interface

The Software Arts now reads like a prehistory of prompt culture. Large language models make visible what older software often hid: computation is saturated with language, genre, address, expectation, and interpretation. A prompt is not just an input string. It is a request, role assignment, context frame, example, constraint, and social performance.

That does not mean language models understand like humans. It means the interface has moved closer to the surface where humanistic disciplines have always worked: ambiguity, rhetoric, genre, narrative, style, audience, authority, interpretation, and the social life of texts. AI tools are marketed as engines of intelligence, but users encounter them as writing environments that act back.

This changes how software labor is perceived. When a model writes code, the easy story is automation: the machine replaces the programmer. Sack's frame makes the event stranger. The model is drawing from human-written code, documentation, examples, bug reports, tutorials, naming conventions, and programming idioms. It generates new software by recombining a textual culture. The output may compile, but it remains inside a history of reading, writing, convention, and maintenance.

That is why code generation creates governance problems beyond correctness. Who owns the source traditions being recombined? Which conventions become defaults? Which programming styles are overrepresented? Which security habits are copied? Which comments, examples, and naming practices become the model's common sense? The machine writes, but the culture supplies the grammar.

Recursive Reality

The recursive loop in The Software Arts is concrete. People describe practices so machines can process them. Machines process those descriptions. The outputs return as new practices, new training material, new institutional categories, and new expectations about what work should look like.

A software tool begins as a translation of an activity. Then the activity changes to fit the tool. Writers learn the content management system. Drivers learn the routing app. Teachers learn the learning-management dashboard. Doctors learn the electronic record. Programmers learn the autocomplete model. Citizens learn the government portal. The description becomes an environment.

Generative AI intensifies that loop. Documentation trains models; models write documentation. Code trains models; models write code. Online arguments train models; models produce new arguments. Policy memos train models; models draft policy memos. The archive no longer sits behind the interface. It is increasingly folded into a machine that writes back into the archive.

Sack helps clarify why this is not simply "automation." It is a cultural feedback loop. The machine-readable version of a practice becomes easier to repeat, cheaper to scale, and more likely to be treated as the real practice. What resists translation becomes friction, edge case, exception, or user error.

Institutions and Training

The book also has implications for education and institutions. Berkeley Center for New Media's account of Sack's lecture emphasizes his challenge to the division between computer science and the arts, and his claim that software studies must attend to code as text and media. The UCSC news interview similarly frames the book as an invitation for artists, humanists, and computer scientists to see software as shared terrain.

That matters for AI literacy. Most organizations still split the problem badly. Technical staff are asked to understand models, APIs, evaluation, and security. Nontechnical staff are asked to understand policy, communication, care, law, culture, and public consequences. The deployment itself crosses that boundary every day.

A useful AI education would therefore teach grammar, logic, and rhetoric together. Users need to know how prompts structure attention, how schemas exclude, how benchmarks persuade, how generated citations can mislead, how model outputs become records, how interface defaults shape conduct, and how workflows turn language into institutional action.

The point is not to make everyone a programmer. It is to stop pretending that programming is the only serious literacy around software. A person governed by a model, managed through a dashboard, treated by a triage system, scored by a risk tool, or counseled by a chatbot needs interpretive power too. Software is now a public language.

Where the Book Needs Friction

The Software Arts is dense. Ragnhild Solberg's 2020 review in the Nordic Journal of Science and Technology Studies is helpful here: it recognizes the richness of Sack's historical and semiotic approach while noting that the book can become hard to follow and that some of its most broadly useful ideas may be buried inside an ambitious scholarly apparatus.

That difficulty is not fatal, but it does shape the audience. The book is strongest for readers already willing to move among software studies, media theory, history of science, digital humanities, computer science, and philosophy. Readers looking for a direct account of today's AI companies, surveillance platforms, labor markets, or policy fights will need to make those connections themselves.

The book also needs more material pressure. A history of software as language can underplay the institutions that make some languages enforceable: cloud platforms, procurement systems, app stores, proprietary APIs, compute markets, military funding, intellectual property, data labor, and workplace management. Rhetoric and grammar matter, but so do contracts, capital, infrastructure, and coercion.

Finally, the humanities frame can be too generous if it becomes a prestige transfer: software is important because it belongs to the liberal arts. The better claim is harsher and more democratic. Software needs humanistic interpretation because it governs people through signs, categories, narratives, and procedures. The humanities are not ornament. They are part of how power becomes legible and contestable.

What This Changes

The practical value of The Software Arts is that it changes what readers inspect. Do not look only at the model, the codebase, the benchmark, or the interface. Look at the language arts underneath them.

Ask what grammar the system imposes. What fields, roles, formats, prompts, labels, and schemas must the world fit before the system can act? Ask what logic the system uses. What equivalences, thresholds, rankings, objectives, and proofs are being treated as operational truth? Ask what rhetoric the system performs. How does it make itself appear neutral, intelligent, safe, inevitable, objective, friendly, or authoritative?

Those questions are especially useful for AI agents. An agent is not only a model plus tools. It is a little theater of command: role, prompt, memory, permissions, interface cues, logs, failure modes, and institutional context. It acts through language before it acts through APIs. It persuades the user to delegate before it executes the delegation.

Sack's book helps restore responsibility to that scene. Software is not an alien logic that arrived from outside culture. It was made through human arts of description, proof, persuasion, classification, and simulation. The machines now speaking through our institutions inherit those arts. The question is whether we still know how to read them.

Sources

Book links are paid affiliate links. As an Amazon Associate I earn from qualifying purchases.

Buy on Amazon Browse Books

Return to Blog · Return to Books