SHARE and the First Program Library: When Computer Users Began Sharing Software
SHARE organized IBM computer users into a cooperative community that exchanged programs, standards, and operating knowledge, helping turn software reuse into an institutional practice.
SHARE formed because early computer users needed one another as much as they needed IBM
In August 1955, representatives of organizations preparing to use IBM’s new 704 met at the RAND Corporation and formed SHARE. The Smithsonian’s archive of SHARE records describes forty-six people from seventeen installations at the first meeting and says the group aimed from the beginning to support joint research, standards, dialogue with IBM and the exchange of programs.[1] This was a major organizational innovation. Each computer installation faced similar problems—assemblers, input routines, mathematical libraries, operating procedures and debugging—but the cost of solving them independently was enormous. SHARE treated users at different companies and laboratories as a technical community whose software could be pooled rather than repeatedly reinvented.
A user group became part of the software infrastructure
SHARE did not manufacture the IBM 704. Its contribution was to organize the knowledge surrounding the machine so that customers could improve their collective ability to program and operate it.
The phrase “first program library” needs a careful qualification
The roadmap title captures SHARE’s pioneering role in organized software exchange, but it should not be read as a claim that no program library existed earlier. A National Bureau of Standards history notes that an IBM 650 program library was already established in 1954 and then describes SHARE, founded in 1955, as the first major computer users’ group and an early force for formal program exchange.[2] That distinction improves the history. Program libraries were emerging wherever expensive machines encouraged reuse. SHARE’s distinctive achievement was to make exchange a user-governed, inter-installation institution with meetings, committees, standards and a growing body of machine-checked contributions.
IBM 704 customers had strong economic incentives to avoid duplicate programming
Computers were expensive, programmers were scarce and many installations needed the same foundational routines. A mathematical subroutine for input conversion, matrix operations or special functions might consume weeks of expert effort even though another 704 site had already written something similar. MIT’s 1957 coding notes for the IBM 704 describe SHARE as a collection and distribution agency for pre-tested subroutines and stress that a library routine needed a detailed write-up and common conventions.[3] Reuse therefore had a direct economic logic: sharing one working routine could save multiple organizations from repeating the same low-level labor. The library also accelerated deployment because a new installation could begin with a base of existing software rather than an empty machine.
Software acquired value independent of the hardware purchase
The machine was still the dominant capital asset, but a library of proven programs made that machine more useful. Users were beginning to recognize software as an accumulated resource that could be transferred among compatible installations.
A shared program library required standards as well as generosity
Exchanging source or object code is useful only when recipients know what the program expects and can integrate it with their environment. SHARE therefore became involved in documentation conventions, common formats and operating standards. Its official history presents the organization as a continuing forum where enterprise computing users jointly addressed technical practices and requirements.[4] This link between reuse and standardization is fundamental. A program library becomes more valuable when routines use predictable calling conventions, data representations and documentation. The social agreement around the code can matter as much as the code itself, because every undocumented assumption becomes work for the next installation.
The library turned program quality into a community concern
A locally written routine might work only because its author remembered undocumented setup steps. A shared routine had to survive contact with strangers. MIT’s 704 programming notes make the same quality requirement explicit: shared subroutines were valued because they had already been written and debugged, and the library depended on detailed instructions and conventions.[3] That encouraged a stronger idea of software quality: a contribution should be identifiable, documented, testable and maintainable beyond the originating programmer’s desk. Distribution exposes hidden assumptions. If several sites report failures or request enhancements, the program begins to acquire something like a maintenance history. Long before public source-code forges, user groups were learning that reusable software needs governance and feedback channels.
Sharing changed the audience for a program
Code written for oneself can depend on private knowledge. Code written for a community must communicate enough about its behavior and requirements that other programmers can trust and adapt it.
SHARE also gave users collective influence over computer vendors
Program exchange was only one reason the group mattered. By meeting together, major IBM customers could compare experiences and present common technical needs. The Smithsonian archive says SHARE was created partly because prospective 704 users believed they collectively understood many practical issues better than the vendor’s seminar could address.[1] A user organization can therefore shape a platform from outside the manufacturer. Requirements for software, documentation and compatibility become harder to dismiss when they are expressed by a coordinated customer community. This relationship would recur throughout computing history in standards groups, open-source foundations, developer communities and enterprise user associations.
Program libraries anticipated later ecosystems without being open source in the modern sense
It is tempting to describe SHARE as an open-source community, but the analogy should be limited. Membership centered on institutions using particular IBM systems, software distribution mechanisms were physical and organizational, and modern open-source licenses did not yet exist. Still, the structural resemblance is revealing. Programmers contributed reusable artifacts, maintained shared conventions and learned collectively from one another. A surviving SHARE Program Library description preserved in U.S. government records emphasizes reducing duplicate effort and facilitating the exchange of useful programs among installations.[5] The community demonstrated that software’s value could increase when users cooperated across organizational boundaries.
The ecosystem preceded the licensing vocabulary
Modern software communities distinguish source availability, licensing, governance and distribution channels precisely. SHARE belongs to an earlier period, but it established the practical importance of cooperative software exchange before those categories were formalized.
Why SHARE belongs in the origins of programming culture
Programming did not mature through languages and compilers alone. It also required institutions that could preserve, circulate and improve the results of programming work. SHARE made that social layer explicit. The organization linked IBM installations that would otherwise have duplicated expensive routines, created mechanisms for program exchange, pushed toward shared conventions and gave users a collective voice. The National Bureau of Standards chronology prevents an exaggerated “first library” claim by documenting earlier IBM 650 library activity, while the Smithsonian records show why SHARE itself was still a landmark: it institutionalized cooperative software development among a large user community.[2][1] The modern package repository, user group and open-source foundation are not direct copies of SHARE, but they solve a recognizable version of the same problem. Once programs become reusable assets, programming history becomes partly the history of how communities decide to share them.
Works Cited
- 01
- 02
- 03MIT Computation Center — Coding for the MIT-IBM 704 Computer (1957) bitsavers.computerhistory.org
- 04SHARE Association — History share.org
- 05
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead