A review of Complexity and Verification: The History of Programming as Problem Solving, by Joline Zepcevski.
Despite a welcome flurry of activity over the past decade or so and a fast growing body of scholarship, the history of software remains largely under-explored. A reason for the reluctance of professional historians to venture into these territories lies no doubt in the versatile and multi-faceted nature of software, which makes it a category of artifacts that sits uneasily across an unusually large and diverse array of historical specialisms and their distinct historiographical traditions. Meanwhile, the field has been left open to actors of this history turned amateur historians, whose “memory work” tends to follow the linear model of progress template.
Joline Zepcevski’s dissertation, Complexity and Verification: The History of Programming as Problem Solving, tackles the history of programming from the 1950s to the 1980s, with the view to contest this dominant narrative. Her overarching argument is that in the development of programming methods, changes — rather than progress — respond to specific stimuli, rooted in causes endogenous as well as exogenous to the practice of software programming. The author focuses specifically on (management of) complexity and (problems of) verification as both recurring stimuli to change and fundamental computing problems – as much causes as consequences. Complexity, she defines as the proliferation of people and methods; verification, as the ability to ensure that a program functions as intended. She argues that from the 1950s onward, complexity and verification have both been catalysts for the development of automatic coding systems and have grown exponentially as a consequence.
In contrast to other historians of software and programming, the aim of Zepcevski’s account is not to embed the historical development of programming methods and languages into a social, cultural, intellectual or economic environment that would take her beyond the boundaries of the programming community. Rather, her story explores the complex process through which various programming methods, languages and theories co-developed over the period, by unpacking the often conflicting interests of different “factions” within the programming community, against the backdrop of the two themes of complexity and verification which are the analytical lenses she uses to highlight the recurring yet evolving issues that plague the programming industry. What she retains of the wider environment, conceptualized as “stimuli” that fall under the headings of complexity and verification, is indeed a “view from the inside” as it is largely filtered through the perception of the programmers.
Zepcevski devotes a significant part of Chapter 1 to defining terms in detail, such as “complexity” and “verification”, in order to develop her subsequent argumentation on solid grounds — a much-needed clarification as the terms are routinely used in both the primary and secondary literature on software, yet are fuzzy at best and have different meanings in different contexts. She also takes pains to delimit and characterize the human community whose practices she is going to study, which takes full significance later in her dissertation as we see tensions between different sub-groups develop. The rest of the chapter defends her methodological decisions, especially the original move of using programs as historical documents, before situating her dissertation within the historiography of software. The main authors she retains as complementing, paralleling and/or intersecting with her historical endeavor are Michael Mahoney, Stuart Shapiro, Peter Mark Priestley, Donald MacKenzie, Thomas Haigh and Nathan Ensmenger.
The following chapter is another foundation-laying exercise: Zepcevski outlines the history of programming up until the early 1950s, in order to give us a picture of the dominant programming languages and methods (i.e. machine and assembly languages) at the time her study starts. This sets the stage for Chapter 3, which explores a first major shift in the development of software — that towards automatic coding systems, i.e. higher level programming languages with a more English-like syntax. Zepcevski analyses the historical process which led to a wide acceptance, by 1960, of automatic coding systems by the programming community at large. As Zepcevski relates her findings to “complexity” and “verification”, the connecting threads of her work, she puts forward a hypothesis which she further develops in chapter 4. Beneath the well-identified chasm, in the broader software community, between programming theorists and vocational programmers (for a more detailed and contextualized exploration of which she refers her readers to Thomas Haigh and Nathan Ensmerger), there was another, more subtle divide already at work as automatic coding systems developed, showing early elements of a later controversy between theorists, which opposed partisans of the mathematization of programming theory to defenders of a more pragmatic approach.
In Chapters 4 and 5, Zepcevski deftly uses the overarching themes of “complexity” and “verification” to give us a fascinating and detailed analysis, centered on the different currents of thoughts that agitated the programming community and their negotiations with “the wider world”, of the historical circumstances which accompanied the concurrent birth, yet consecutive take off and dominance, of two more programming methodologies: respectively, the Structured Programming methodology in the 1960s-70s and the Object-Oriented methodology in the 1980s.
Besides a broad picture of “where things stand” as of 2010, about three decades after Object-Oriented programming came to dominate, the concluding chapter gives us an insightful discussion on how issues of complexity and verification have changed yet remained focal points of discussion, and tension, within the programming community. What ultimately stands out of Joline Zepcveski’s dissertation is a fascinating glimpse, over the decades running from the 1950s to the 1980s, into these tightly intertwined historical threads, and their shaping through a complex interplay of at times conflicting influences. In the process, Zepcveski reveals a number of rifts among the programming community, digging for the more obscure under the more visible ones.
Historiographically, Zepcevski’s practice of history is an original mix of intellectual history and material culture history, thanks to which she brings to light hitherto ignored connections between the development of programming methods, theories and languages. Her work will appeal to historians of software, both through the body of empirical historical material that it articulates and through her bold methodological choices. It will appeal to historians of computing of course, and more generally to historians of contemporary science, due to the ubiquitous presence of embedded software in knowledge producing practices.
Wellcome Library Research Fellow
Department of Science and Technology Studies
University College London
The primary sources used by Joline Zepcevski mirror the dual historiographical traditions of intellectual history and material culture history bridged by her dissertation:
On the one hand, original papers published by prominent actors of her study, individual archives, interviews, as well as the literature resulting from their own take on the history of their field. Two major sources are the Proceedings of the 1978 and 1993 ACM Conferences on the History of Programming Languages.
On the other hand, instances of programs as material objects.
University of Minnesota. 2012. 342pp. Primary Advisor: Arthur Norberg.
Image: Grace Murray Hopper at the UNIVAC keyboard, c. 1960. Grace Brewster Murray: American mathematician and Rear Admiral in the U.S. Navy. Credit: Unknown (Smithsonian Institution)