Sam S. Adams

Mapping the Landscape of Human-Level Artificial General Intelligence

We present the broad outlines of a roadmap toward human-level artificial general intelligence (henceforth, AGI). We begin by discussing AGI in general, adopting a pragmatic goal for its attainment and a necessary foundation of characteristics and requirements. An initial capability landscape will be presented, drawing on major themes from developmental psychology and illuminated by mathematical, physiological and information processing perspectives. The challenge of identifying appropriate tasks and environments for measuring AGI will be addressed, and seven scenarios will be presented as milestones suggesting a roadmap across the AGI landscape along with directions for future research and collaboration.

The economics of software reuse

In this note, we provide additional material to summarize and compliment the discussion of the position papers presented at OOPSLA 91 in Phoenix.

Hosting an object heap on manycore hardware: an exploration

In order to construct a test-bed for investigating new programming paradigms for future manycore systems (i.e. those with at least a thousand cores), we are building a Smalltalk virtual machine that attempts to efficiently use a collection of 56-on-chip caches of 64KB each to host a multi-megabyte object heap. In addition to the cost of inter-core communication, two hardware characteristics influenced our design: the absence of hardware-provided cache-coherence, and the inability to move a single object from one cores cache to anothers without changing its address. Our design relies on an object table, and the exploitation of a user-managed caching regime for read-mostly objects. At almost every stage of our process, we obtained measurements in order to guide the evolution of our system.n The architecture and performance characteristics of a manycore platform confound old intuitions by deviating from both traditional multicore systems and from distributed systems. The implementor confronts a wide variety of design choices, such as when to share address space, when to share memory as opposed to sending a message, and how to eke out the most performance from a memory system that is far more tightly integrated than a distributed system yet far less centralized than in a several-core system. Our system is far from complete, let alone optimal, but our experiences have helped us develop new intuitions needed to rise to the manycore software challenge.

Beyond the Turing test: performance metrics for evaluating a computer simulation of the human mind

Performance metrics for machine intelligence (e.g., the Turing test) have traditionally consisted of pass/fail tests. Because the tests devised by psychologists have been aimed at revealing unobservable processes of human cognition, they are similarly capable of revealing how a computer accomplishes a task, not simply its success or failure. Here we adapt a set of tests of abilities previously measured in humans to be used as a benchmark for simulation of human cognition. Our premise is that if a machine cannot pass these tests, it is unlikely to be able to engage in the more complex cognition routinely exhibited by animals and humans. If it cannot pass these tests, it will lack fundamental capabilities underlying such performance.

The future of end user programming

One of the Holy Grails of Computer Science for many decades has been to make the power of computer programming accessible to more and more people. The earliest high level languages, FORTRAN and COBOL, were intentionally designed to be written and understood by specific communities of users with problems to solve, namely the Scientific/Engineering and Business communities. As computing became more accessible to more people, the number of dedicated full time programmers mushroomed and formed a community unto itself, who largely created languages and tools by and for themselves to use. The end users, the people with the non-computing problems to solve, became isolated from the computer itself and were forced have their business problems encoded in the increasingly esoteric script of a powerful new programmer priesthood. But even throughout these dark ages, a small number of valiant dissenters survived and flourished in distant monasteries and hermitages, dedicating their lives and technical prowess to liberate computing from its raised floor temples. Resistance was stiff, but not futile, as every decade or so breakthroughs like spreadsheets, Hypercard, 4GLs and HTML empowered more and more non-programmers to create their own computing solutions. Now, well into the second era of the Web, consumer-oriented websites like Flickr and YouTube routinely offer end users snippets of JavaScript code to reuse in their own software creations, their Facebook and MySpace pages. Projects like IBMs CoScripter have achieved programming by demonstration for end users. Mashup tools abound, and the Web is filled with billions of customized applications, most created by end users themselves. Have we finally achieved the goals of those happy few who dreamed of a world where programming was as common as dialing a telephone? Have we finally arrived at the Long Tail of Programming? And if we have built it, did they come? This talk will assess the current state of end user programming and present a heretical perspective about the future of this endeavor from a confessed true believer.

Harnessing emergence for manycore programming: early experience integrating ensembles, adverbs, and object-based inheritance

We believe that embracing nondeterminism and harnessing emergence have great potential to simplify the task of programming manycore processors. To that end, we have designed and implemented Ly, pronounced Lee, a new parallel programming language built around two new concepts: (i) ensembles which provide for parallel execution and replace all collections and (ii) iterators, and adverbs, which modify the parallel behavior of messages sent to ensembles. The broad issues around programming in this fashion still need investigation, but, after our initial Ly programming experience, we have identified some specific issues that must be addressed in integrating these concepts into an object-based language, including empty ensembles, partial message understanding, non-local returns from ensemble members, and unintended ensembles.

I-athlon: Towards A Multidimensional Turing Test

While the Turing test is a well-known method for evaluating machine intelligence, it has a number of drawbacks that make it problematic as a rigorous and practical test for assessing progress in general-purpose AI. For example, the Turing test is deception based, subjectively evaluated, and narrowly focused on language use. We suggest that a test would benefit from including the following requirements: focus on rational behavior, test several dimensions of intelligence, automate as much as possible, score as objectively as possible, and allow incremental progress to be measured. In this article we propose a methodology for designing a test that consists of a series of events, analogous to the Olympic Decathlon, which complies with these requirements. The approach, which we call the I-athlon, is intended to ultimately enable the community to evaluate progress towards machine intelligence in a practical and repeatable way.

Neural agents - a frame of mind

Several recent theories have been advanced to model complex heuristic behavior. From Minskys Society of Mind to neural networks, these theories all share a common architecture consisting of many highly connected elements that together exhibit sophisticated macro behavior. This paper describes NeuralAgents, a framework developed in Smalltalk-80 that combines the high level interaction and collaboration of rule-based agents with the topological connectivity of neural nets. The Client-Facilitator-Consultant model for agencies will be presented, along with the object oriented design and implementation of the NeuralAgents system. PetWorld, an animated environment for the simulation of animal behavior is presented as an example application.

Enterprise context: a rich source of requirements for context-oriented programming

We introduce the domain of enterprise context, as opposed to personal or execution context, and we present requirements for context-oriented programming technology arising out of this broader notion of context. We illustrate enterprise context with scenarios in which data from across an enterprise, as well as data from outside an enterprise, are all brought to bear as context in any situation where they are relevant and can factor into making better decisions and achieving better outcomes. We suggest enterprise context as a rich source of requirements for context-oriented programming models, languages, and virtual machines. In particular, we raise issues such as scale, integration, relevance, temporality, protection, privacy, provenance, policy in general, and valuation. And, for this workshop, we propose enterprise context as one perspective for discussion of new language and VM features: How do proposed features support such a domain?

Developing software for large-scale reuse (panel)

Software reuse is a simple idea: reduce the cost of software development by developing less new software. In practice, however, achieving software reuse on a large scale has been frustratingly difficult. Nevertheless, as the complexity and cost of software systems continues to rise, there has been growing interest in really trying to make large-scale reuse a reality. Interest in reuse has been particularly. strong in both the Ada and objectoriented programming communities. This panel brings together key experts from these communities to discuss the issues, problems and potentials of reuse. This discussion is continued from the first meeting of this panel at the Tenth Washington Ada Symposium last June.