The LISP 2 Project

The 2011 opening at the Computer History Museum of the world's largest and most complete physical and cyber exhibit of computing history marks the sixth stage of a public museum's evolution, which began in 1975 with a closet-sized exhibit in a Digital Equipment Corporation building, migrating to The Computer Museum, Boston. It now lives in an 119,000 square foot public home in Silicon Valley. This chance/luck driven evolution of an institution is due to the dedication and leadership of a few people who persuaded hundreds of others that the endeavor was worthwhile and needed their support. Gwen Bell, The Computer Museum's founding director, and Len Shustek, the founding chairman of the Computer History Museum were committed to its success! Behind nearly every artifact, exhibit, and pioneering effort is a story that the museum is dedicated to understand and tell. This is the story leading to the Computer History Museum.

The ScalaDyno compiler plugin allows fast prototyping with the Scala programming language, in a way that combines the benefits of both statically and dynamically typed languages. Static name resolution and type checking prevent partially-correct code from being compiled and executed. Yet, allowing programmers to test critical paths in a program without worrying about the consistency of the entire code base is crucial to fast prototyping and agile development. This is where ScalaDyno comes in: it allows partially-correct programs to be compiled and executed, while shifting compile-time errors to program runtime.The key insight in ScalaDyno is that name and type errors affect limited areas of the code, which can be replaced by instructions to output the respective errors at runtime. This allows byte code generation and execution for partially correct programs, thus allowing Python or JavaScript-like fast prototyping in Scala. This is all done without sacrificing name resolution, full type checking and optimizations for the correct parts of the code -- they are still performed, but without getting in the way of agile development. Finally, for release code or sensitive refactoring, runtime errors can be disabled, thus allowing full static name resolution and type checking typical of the Scala compiler.

Typestate reflects how the legal operations on imperative objects can change at runtime as their internal state changes. A typestate checker can statically ensure, for instance, that an object method is only called when the object is in a state for which the operation is well-defined. Prior work has shown how modular typestate checking can be achieved thanks to access permissions and state guarantees. However, static typestate checking is still too rigid for some applications. This paper formalizes a nominal object-oriented language with mutable state that integrates typestate change and typestate checking as primitive concepts. In addition to augmenting the types of object references with access permissions and state guarantees, the language extends the notion of gradual typing to account for typestate: gradual typestate checking seamlessly combines static and dynamic checking by automatically inserting runtime checks into programs. A novel flow-sensitive permission-based type system allows programmers to write safe code even when the static type checker can only partly verify it.

In May, 1965, System Development Corporation (SDC) proposed to do some research to study program organization with respect to dynamic program behavior. Further, the proposal suggested that simulation techniques might be used to study the problem of resource allocation in a multiprocessor time-sharing system. Some of the reasons for the proposal related to the prospective utilization of the time-sharing hardware features of the GE and IBM time-sharing computers. At the time, there was considerable interest in investigating the concepts of program segmentation and page turning, both at SDC and in the time-sharing community at large. The concept of fixed-size paging on demand particularly, raised some questions of practicality. One of the early papers on the subject by Dennis and Glaser1 states that the concept of page-turning can be either useful or disastrous, depending on the class of information to which it is applied. However, the theory appeared to be both advantageous and elegant, so that the future of time-sharing seemed to be committed to the concept.

System Development Corporation (SDC) has developed an informal approach for establishing correspondence (or lack thereof) between the formal specifications of a system and lower levels of specification, including implementation code. Establishing correspondence means showing that one level meets the intent of a higher lever. This paper presents the motivation, technique, and current SDC experience with the method, contains an example of the hypothetical correlation analysis, and evaluates the limits and the usefulness of this approach. This paper results from recent applications of the method.

The language Plop! is an experimental object oriented language, with a functional flavor. It combines in one language the following features: prototyping, multiple delegation, multi-methods and static type checking.

Common record systems only provide access to individual record fields. However, it is often useful to have generic record combinators, that is, functions that work with complete records of varying structure. Traditionally, generic record combinators can only be implemented in dynamically typed languages.

Now you’re ready to look at how the FOO compiler works. The main difference between a compiler and an interpreter is that an interpreter processes a program and directly generates some behavior—generating HTML in the case of a FOO interpreter—but a compiler processes the same program and generates code in some other language that will exhibit the same behavior. In FOO, the compiler is a Common Lisp macro that translates FOO into Common Lisp so it can be embedded in a Common Lisp program. Compilers, in general, have the advantage over interpreters that, because compilation happens in advance, they can spend a bit of time optimizing the code they generate to make it more efficient. The FOO compiler does that, merging literal text as much as possible in order to emit the same HTML with a smaller number of writes than the interpreter uses. When the compiler is a Common Lisp macro, you also have the advantage that it’s easy for the language understood by the compiler to contain embedded Common Lisp—the compiler just has to recognize it and embed it in the right place in the generated code. The FOO compiler will take advantage of this capability.KeywordsSpecial OperatorHelper FunctionParameter ListProperty ListPredicate FunctionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Computer History Museum Update; Pioneers of Soviet Computing; Obituary: Hiroshi Wada; Obituary: Zen-iti Kiyasu; Computer History Museum Bits; History of Programming Languages (HOPL-III)

A meta-circular language for active libraries

Using Office Central, remote workers can advertise their presence in public spaces within offices, such as break areas, lounges or cafeterias. The design concept is to encourage informal, unplanned interactions between remote workers and those who pass through the public spaces. In this prototype installation at the Computer History Museum in Mountain View, CA, we set up a lounge area with an Office Central picture window display (Figure 1). The local people in the lounge, wearing RFID tags for identification, could chat informally with remote people using a high-fidelity, CD-quality audio channel. The virtual meeting places included audio and video content, designed to be experienced jointly by the local and remote people. Some content was also tailored to the local people, updating as they approached the picture window display.

Annual Review of Information Science and Technology

Everyone talks about the computer user, but virtually no one has studied him in a systematic, scientific manner. There is a growing experimental lag between verified knowledge about users and rapidly expanding applications for them. This experimental lag has always existed in computer technology. Technological innovation and aggressive marketing of computer wares have consistently outpaced established knowledge of user performance—a bias in computer technology largely attributable to current management outlook and practice. With the advent of time-sharing systems, and with the imminence of the much-heralded information utility, the magnitude of this scientific lag may have reached a critical point. If unchecked, particularly in the crucial area of software management, it may become a crippling humanistic lag—a situation in which both the private and the public use of computers would be characterized by overriding concern for immediate machine efficiency and economy, and by an entrenched neglect of human needs, individual capabilities, and long-range social responsibilities.

Although online searching has been available to libraries since the late 1960s, it is only in very recent years that a significant number of academic institutions have begun offering information retrieval through commercial vendors such as Dialog, BRS (Bibliographic Retrieval Service), and SDC's (System Development Corporation's) Orbit. Because online searching is so new compared with traditional library services, it is still developing as a standard offering in most academic libraries.

This paper reviews the introduction of factory concepts and practices, based on tools and methods from the evolving field of software engineering, at major software producers, in particular those that explicitly adopted the factory label to describe their software facilities or approach to software development: Hitachi, Toshiba, NEC, and Fujitsu in Japan, as well as System Development Corporation in the United States. The other United States firm discussed in detail is International Business Machines, which, without adopting the factory label, introduced numerous measures to organize and control software development, especially basic software. The paper emphasizes that the difficulty of the technology, shortages of skilled engineers, and large-scale projects have encouraged producers to become more systematic or factory-like in managing a series of projects, even though some characteristics of the technology and the industry have made software seem difficult to control and more suitable to a loosely structured project-centered or craft approach to development.