Church’s Foundation of Logic
Arguably, Church’s Foundation of Logic was the first Logic Programming language [Church 1932, 1933].[i] It attempted to avoid the known logical paradoxes by using partial functions and restricting the law of the excluded middle.
The system was very powerful and flexible. Unfortunately, it was so powerful that it was inconsistent [Kleene and Rosser 1935] and consequently the propositional logic was removed, leaving only the functional lambda calculus [Church 1941].
| What went wrong:[ii] A logical system that was developed by Church to be a new foundation for logic turned out to have inconsistencies that could not be removed. |
| What was done about it:
|
McCarthy’s Advice Taker
McCarthy [1958] proposed the Logicist Programme for Artificial Intelligence that included the Advice Taker with the following main features:
1. There is a method of representing expressions in the computer. These expressions are defined recursively as follows: A class of entities called terms is defined and a term is an expression. A sequence of expressions is an expression. These expressions are represented in the machine by list structures [Newell and Simon 1957].
2. Certain of these expressions may be regarded as declarative sentences in a certain logical system which will be analogous to a universal Post canonical system. The particular system chosen will depend on programming considerations but will probably have a single rule of inference which will combine substitution for variables with modus ponens. The purpose of the combination is to avoid choking the machine with special cases of general propositions already deduced.
3. There is an immediate deduction routine which when given a set of premises will deduce a set of immediate conclusions. Initially, the immediate deduction routine will simply write down all one-step consequences of the premises. Later, this may be elaborated so that the routine will produce some other conclusions which may be of interest. However, this routine will not use semantic heuristics; i.e., heuristics which depend on the subject matter under discussion.
4. The intelligence, if any, of the advice taker will not be embodied in the immediate deduction routine. This intelligence will be embodied in the procedures which choose the lists of premises to which the immediate deduction routine is to be applied.
5. The program is intended to operate cyclically as follows. The immediate deduction routine is applied to a list of premises and a list of individuals. Some of the conclusions have the form of imperative sentences. These are obeyed. Included in the set of imperatives which may be obeyed is the routine which deduces and obeys.
| What went wrong: · The imperative sentences deduced by the Advice Taker could have impasses in the following forms: o lapses in which no imperative sentences were deduced o conflicts in which inconsistent sentences were deduced. · The immediate deduction routine of the Advice Taker was extremely inefficient |
What was done about it:
|
Uniform Proof Procedures based on Resolution
John Alan Robinson [1965] developed a deduction method called resolution that was proposed as a uniform proof procedure. Resolution required converting everything to clausal form and then used a method analogous to modus ponens to attempt to obtain a proof by contradiction by adding the clausal form of the negation of the theorem to be proved.
The first use of Resolution was in computer programs to prove mathematical theorems and in the synthesis of simple sequential programs from logical specifications [Wos 1965; Green 1969; Waldinger and Lee 1969; Anderson and 1970; 1971, etc.]. In the resolution uniform proof procedure theorem proving paradigm, the use of procedural knowledge was considered to be “cheating” [Green 1969].
What went wrong:
|
| What was done about it:
|
Planner
The two major paradigms for constructing semantic software systems were procedural and logical. The procedural paradigm was epitomized by using Lisp [McCarthy et al. 1962; Minsky, et al. 1968] recursive procedures operating on list structures. The logical paradigm was epitomized by uniform resolution theorem provers [Robinson 1965].
Planner [Hewitt 1969] was a kind of hybrid between the procedural and logical paradigms. An implication of the form (P implies Q) was procedurally interpreted as follows:[iv]
- when assert P, assert Q
- when goal Q, goal P
- when assert (not Q), assert (not P)
- when goal (not P), goal (not Q)
Planner was the first programming language based on the pattern-directed invocation of procedural plans from assertions and goals. The development of Planner was inspired by the work of Karl Popper [1935, 1963], Frederic Fitch [1952], George Polya [1954], Allen Newell and Herbert Simon [1956], John McCarthy [1958, et. al. 1962], and Marvin Minsky [1968]. Planner represented a rejection of the resolution uniform proof procedure paradigm.
Computers were expensive. They had only a single slow processor and their memories were very small by comparison with today. So Planner adopted some efficiency expedients including the following:
- Backtracking [Golomb and Baumert 1965] was adopted to economize on the use of time and storage by working on and storing only one possibility at a time in exploring alternatives.
- A unique name assumption was adopted to save space and time by assuming that different names referred to different objects. For example names like Peking and Beijing were assumed to refer to different objects.
- A closed world assumption could be implemented by conditionally testing whether an attempt to prove a goal exhaustively failed. Later this capability was given the misleading name "negation as failure" because for a goal G it was possible to say: "if attempting to achieve G exhaustively fails then assert (Not G).
A subset called Micro-Planner was implemented by Gerry Sussman, Eugene Charniak and Terry Winograd. Micro-Planner was used in Winograd's natural-language understanding program SHRDLU [Winograd 1971], Eugene Charniak's story understanding work, work on legal reasoning [McCarty 1977], etc. This generated a great deal of excitement in the field of AI. Since Micro-Planner was embedded in Lisp, applications used two different syntaxes and so lacked a certain degree of elegance. In fact, after Hewitt's lecture at IJCAI'71, Allen Newell rose from the audience to remark on the “Baroque” syntax! However, variants of this syntax persist to this day.
What went wrong: 1. Although pragmatically useful at the time Planner was developed, the efficiency expedients (backtracking, unique name assumption, and closed world assumption) proved to be rigid and inexpressive. 2. Planner had a single global data base that was not modular or scalable. 3. Although pragmatically useful for interfacing with the underlying Lisp system, the syntax used in micro-Planner applications was not a pretty sight. |
| What was done about it: 1. Concurrency based on message passing was developed as an alternative to backtracking. [Hewitt, Bishop, and Steiger 1973] 2. QA4 [Rulifson, Derksen, and Waldinger 1973] developed a hierarchical context system to modularize the data base. Contexts were later generalized into strongly paraconsistent theories [Hewitt 2008e] (see below). 3. Prolog [Kowalski 1974, Colmerauer and Roussel 1996] was basically a subset of Planner that restricted programs to clausal form using backward chaining (i.e. no forward chaining) and no ability to define functions. Consequently Prolog had a simpler syntax than Planner. However, the simpler syntax came at the cost of expressive power including not being able to make assertions and the inability to directly say that an assertion is false. (See [Hewitt 2008c] for further information.) |
Concurrency cannot be implemented using logical inference
Several models of nondeterministic computation were developed including the following:
- Lambda calculus The lambda calculus of Alonzo Church can be viewed as the earliest message passing programming language (see Hewitt, Bishop, and Steiger 1973; Abelson and Sussman 1985). For example the lambda expression below implements a tree data structure when supplied with parameters for a leftSubTree and rightSubTree. When such a tree is given a parameter message "getLeft", it returns leftSubTree and likewise when given the message "getRight" it returns rightSubTree.
λ(leftSubTree, rightSubTree)
λ(message)
if (message == "getLeft")
then leftSubTree
else if (message == "getRight") then rightSubTree
However, the semantics of the lambda calculus were expressed using variable substitution in which the values of parameters were substituted into the body of an invoked lambda expression. The substitution model is unsuitable for concurrency because it does not allow the capability of sharing of changing resources. Inspired by the lambda calculus, the interpreter for the programming language Lisp made use of a data structure called an environment so that the values of parameters did not have to be substituted into the body of an invoked lambda expression.[v]
- Petri nets. Prior to the development of the Actor model, Petri nets were widely used to model nondeterminism. However, they were widely acknowledged to have an important limitation: they modeled control flow but not data flow. Consequently they were not readily composable. Another difficulty with Petri nets is simultaneous action. I.e., the atomic step of computation in Petri nets is a transition in which tokens simultaneously disappear from the input places of a transition and appear in the output places. The physical basis of using a primitive with this kind of simultaneity seems questionable. Despite these apparent difficulties, Petri nets continue to be a popular approach to modeling nondeterminism, and are still the subject of active research.
- Simula pioneered using message passing for computation, motivated by discrete event simulation applications. These applications had become large and unmodular in previous simulation languages. At each time step, a large central program would have to go through and update the state of each simulation object that changed depending on the state of simulation objects it interacted with on that step. Kristen Nygaard and Ole-Johan Dahl developed the idea (first described in an IFIP workshop in 1967) of having methods on each object that would update its own local state based on messages from other objects. In addition they introduced a class structure for objects with inheritance. Their innovations considerably improved the modularity of programs. Simula used nondeterministic coroutine control structure in its simulations.
- Smalltalk-72 Planner, Simula, Smalltalk-72 [Kay 1975; Ingalls 1983] and computer networks had previously used message passing. However, they were too complicated to use as the foundation for a mathematical theory of concurrency. Also they did not address fundamental issues of concurrency.
Alan Kay was influenced by message passing in the pattern-directed invocation of Planner in developing Smalltalk-71.[2] Hewitt was intrigued by Smalltalk-71 but was put off by the complexity of communication that included invocations with many fields including global, sender, receiver, reply-style, status, reply, operator selector, etc.
In November 1972 Kay visited MIT and discussed some of his ideas for Smalltalk-72 building on the Logo work of Seymour Papert and the "little person" model of computation used for teaching children to program. However, the message passing of Smalltalk-72 was quite complex [Kay 1975]. Code in the language was viewed by the interpreter as simply a stream of tokens.[vi] As Dan Ingalls [1983] later described it:[vii]
The first (token) encountered (in a program) was looked up in the dynamic context, to determine the receiver of the subsequent message. The name lookup began with the class dictionary of the current activation. Failing there, it moved to the sender of that activation and so on up the sender chain. When a binding was finally found for the token, its value became the receiver of a new message, and the interpreter activated the code for that object's class.[viii]
Thus the message passing model in Smalltalk-72 was closely tied to a particular machine model and programming language syntax that did not lend itself to concurrency. Also, although the system was bootstrapped on itself, the language constructs were not formally defined as objects that respond to Eval messages (see discussion below).
The notion of computation has been evolving for a long time. One of the earliest examples was Euclid’s GCD algorithm. Next came mechanical calculators of various kinds. These notions were formalized in the Turing Machines, the lambda calculus, etc. paradigm that focused on the “state” of a computation that could be logically inferred from the “previous” state.
Threads, locks, and queues
The invention of digital computers caused a decisive paradigm shift when the notion of an interrupt was invented so that input that arrived asynchronously from outside could be incorporated in an ongoing computation. At first concurrency was conceived using low level machine implementation concepts like threads, locks, and queues.
Message Passing
Actors [Hewitt, Bishop, and Steiger 1973] was a new model of computation based on message passing[xiv] in which there is no global state. The Actor model has laws that govern privacy and security [Baker and Hewitt 1977].[xvi]
The break was decisive because asynchronous communication cannot be implemented by Turing machines etc. because the order of arrival of messages cannot be logically inferred. Message passing is the foundation of many-core and client-cloud computing.
In constract, Robert Kowalski developed the thesis that “computation could be subsumed by deduction” [Kowalski 1988a] that he states was first proposed by Hayes [1973] in the form “Computation = controlled deduction.” [Kowalski 1979] This thesis was also implicit in one interpretation of Cordell Green’s earlier work [Green 1969]. He forcefully stated:
There is only one language suitable for representing information -- whether declarative or procedural -- and that is first-order predicate logic. There is only one intelligent way to process information -- and that is by applying deductive inference methods. [Kowalski 1980][xiii]
The gauntlet was officially thrown in The Challenge of Open Systems [Hewitt 1985] to which [Kowalski 1988b] replied in Logic-Based Open Systems (also see [Davison 2000]). This was followed up with Guarded Horn clause languages: are they deductive and logical? [Hewitt and Agha 1988] in the context of the Japanese Fifth Generation Project (see section below). All of this was against Kowalski who stated “Looking back on our early discoveries, I value most the discovery that computation could be subsumed by deduction.” [Kowalski 1988a] Kowalski also stated that “computation could be subsumed by deduction” [Kowalski 1988a]
According to Hewitt et. al. and contrary to Kowalski and Hayes, computation in general cannot be subsumed by deduction and contrary to the quotation (above) attributed to Hayes computation in general is not controlled deduction. Hewitt and Agha [1991] and other published work argued that mathematical models of concurrency did not determine particular concurrent computations because they make use of arbitration for determining which message is next in the arrival order when multiple messages concurrently. For example Arbiters can be used in the implementation of the arrival order. Since arrival orders are in general indeterminate, they cannot be deduced from prior information by mathematical logic alone. Therefore mathematical logic cannot implement concurrent computation in open systems.
In concrete terms, typically we cannot observe the details by which the arrival order of messages determined. Attempting to do so affects the results and can even push the indeterminacy elsewhere. Instead of observing the internals of arbitration processes, we await outcomes. The reason that we await outcomes is that we have no alternative because of indeterminacy.
According to Hewitt [2007]:
DenoteS = ⊔i∈ω ProgressionSi(⊥S)
In this way, the behavior of S can be mathematically characterized in terms of all its possible behaviors (including those involving unbounded nondeterminism). Although DenoteS is not an implementation of S, it can be used to prove a generalization of the Church-Turing-Rosser-Kleene thesis [Kleene 1943]:
Enumeration Theorem: If the primitive Actors of a closed Actor System are effective, then its possible outputs are recursively enumerable.
Proof: Follows immediately from the Representation Theorem.
The upshot is that Actor systems can be represented and characterized by logical deduction but cannot be implemented. Thus, the following practical problem arose:
How can practical programming languages be rigorously defined since the proposal by Scott and Strachey [1971] to define them in terms lambda calculus failed because the lambda calculus cannot implement concurrency?
One solution was to develop a concurrent variant of the Lisp meta-circular definition [McCarthy, Abrahams, Edwards, Hart, and Levin 1962] that was inspired by Turing's Universal Machine [Turing 1936]. If exp is a Lisp expression and env is an environment that assigns values to identifiers, then the procedure EVAL with arguments exp and env evaluates exp using env. In the concurrent variant, EVAL<env> is a message that can be sent to exp to cause exp to be evaluated. Using such messages, modular meta-circular definitions can be concisely expressed in the Actor model for universal concurrent programming languages (e.g. ActorScriptTM [Hewitt 2008e]).
What went wrong: 1. Nondeterministic global state machines [Dijkstra 1976] failed as a model of concurrent computation. 2. The thesis that computation is subsumed by logical inference failed because concurrent computation could not be implemented. 3. The proposal to define the semantics of programming languages in terms of the lambda calculus (a branch of mathematical logic) failed because concurrency cannot be implemented in the lambda calculus. 4. Concurrent computation was initially conceived in terms of low level machine implementation concepts of threads, locks, and queues. |
| What was done about it: 1. The Actor model of concurrent computation was developed based on message passing instead of nondeterministic global states. 2. A mathematical foundation for concurrent computation was developed based on domain theory [Scott and Strachey 1971, Clinger 1981, Hewitt 2007]. 3. Universal concurrent programming languages can be modularly defined in terms of themselves using the Actor model. 4. The Actor model was developed founding concurrent computation on message passing. |
Beginning in the 1970’s, Japan became dominant in the DRAM market (and consequently most of the integrated circuit industry). This was accomplished with the help of the Japanese VLSI project that was funded and coordinated mostly by the Japanese government Ministry of International Trade and Industry (MITI) [Sigurdson 1986]. MITI hoped to enlarge this victory by taking over the computer industry with a new Fifth Generation Computing System (FGCS) project (officially named ICOT). However, Japan had come under criticism for “copying” the US. One of the MITI goals for ICOT was to show that Japan could innovate new computer technology and not just copy the United States.
ICOT, strongly influenced by Logic Programming enthusiasts, tried to go all the way with Logic Programming. Kowalski later recalled “Having advocated LP [Logic Programming] as a unifying foundation for computing, I was delighted with the LP focus of the FGCS [Fifth Generation Computer Systems] project.” [Fuchi, Kowalski, Ueda, Kahn, Chikayama, and Tick 1993] By making Logic Programming (which was mainly being developed outside the US) the foundation, MITI hoped that the Japanese computer industry could leapfrog the US. “The [ICOT] project aimed to leapfrog over IBM, and to a new era of advanced knowledge processing applications” [Sergot 2004] But the MITI strategy backfired because the software wasn’t good enough and so the Japanese companies refused to productize the ICOT hardware.
| What went wrong: The way that it used Logic Programming was a principal contributing cause to the failure of ICOT because Logic Programming proved not to be competitive with object-oriented programming. |
| What was done about it:
|
Strongly Paraconsistent inference
The development of large software systems and the extreme dependence of our society on these systems have introduced new phenomena. These systems have pervasive inconsistencies among and within the following:
- Use cases that express how systems can be used and tested in practice
- Documentation that expresses over-arching justification for systems and their technologies
- Code that expresses implementations of systems
Different communities are responsible for constructing, evolving, justifying and maintaining documentation, use cases, and code for large, human-interaction, software systems. In specific cases any one consideration can trump the others. Sometimes debates over inconsistencies among the parts can become quite heated, e.g., between vendors. In the long run, after difficult negotiations, in large software systems, use cases, documentation, and code all change to produce systems with new inconsistencies. However, no one knows what they are or where they are located!
Furthermore there is no evident way to divide up the code, documentation, and use cases into meaningful, consistent microtheories for human-computer interaction. Organizations such as Microsoft, the US government, and IBM have tens of thousands of employees pouring over hundreds of millions of lines of documentation, code, and use cases attempting to cope. In the course of time almost all of this code will interoperate using Web Services. A large software system is never done [Rosenberg 2007].
The thinking in almost all scientific and engineering work has been that models (also called theories or microtheories) should be internally consistent, although they could be inconsistent with each other.
Logic Programming can proceed even in the face of inconsistency, which is fortunate because consistency testing is recursively undecidable even in first order logic. Because of this difficulty, it is usually not known whether or not large theories of practical domains are consistent. In practice, the information in large software projects and information on the Internet is invariably inconsistent.
Platonic Ideals were to be perfect, unchanging, and eternal. Beginning with the Hellenistic mathematician Euclid [circa 300BC] in Alexandria, theories were intuitively supposed to be both consistent and complete. However, using a kind of reflection, Gödel [1931] (later generalized by Rosser [1936]) proved that mathematical theories are incomplete, i.e., there are propositions that can neither be proved nor disproved. This was accomplished using a kind of reflection by showing that in each sufficiently strong theory T, there is a paradoxical proposition ParadoxT that is logically equivalent to its own unprovability, i.e., ¬ ├T ParadoxT.
Some restrictions are needed around reflection to avoid inconsistencies in mathematics (e.g., Liar Paradox, Russell’s Paradox, Curry’s Paradox, etc.). Various authors, (e.g., [Feferman 1984a, Restall 2006]) have raised questions about how to do it.
The Tarskian framework of assuming a hierarchy of metatheories in which the semantics of each theory is formalized in its metatheory [Tarski and Vaught 1957] is currently standard. However, according to Feferman [1984a]:
“…natural language abounds with directly or indirectly self-referential yet apparently harmless expressions—all of which are excluded from the Tarskian framework.”
Self-referential propositions about cases, documentation, and code are common in large software systems. These propositions are excluded by the Tarskian framework substantially limiting its applicability to Software Engineering. To overcome such limitations, Direct Logic[xvii] was developed as an unstratified strongly paraconsistent reflective inference systems with the following goals [Hewitt 2008e]:
- Provide a foundation for strongly paraconsistent theories in Software Engineering.
- Formalize a notion of “direct” inference for strongly paraconsistent theories.[xviii]
- Support all “natural” deductive inference [Fitch 1952; Gentzen 1935] in strongly paraconsistent theories with the exception of general Proof by Contradiction and Disjunction Introduction.
- Support mutual reflection among code, documentation, and use cases of large software systems.
- Provide increased safety in reasoning about large software systems using strongly paraconsistent theories.
In the new system, reflection was restricted to propositions that are Admissible.[xix] In this way the classical paradoxes of reflection were blocked, i.e., the Liar, Russell, Curry, Kleene-Rosser, etc.
To demonstrate the power of Direct Logic, a generalization of the incompleteness theorem was proved paraconsistently without using the assumption of consistency on which Godel/Rosser had relied for their proofs. Then there was a surprising development: since it turns out that the Gödelian paradoxical proposition ParadoxT is self-provable (i.e. ├T ParadoxT), it follows that every reflective strongly paraconsistent theory in Direct Logic is inconsistent! However, in the context of large software systems, it is not especially bothersome that theories of Direct Logic are inconsistent about
├T ParadoxT.
According to Hewitt [2008e]:
“This means that the formal concept of TRUTH as developed by Tarski, et al. is out the window. At first, TRUTH may seem like a desirable property for propositions in theories for large software systems. However, because a paraconsistent reflective theory T is necessarily inconsistent about ├T ParadoxT, it is impossible to consistently assign truth values to propositions of T. In particular it is impossible to consistently assign a truth value to the proposition ├T ParadoxT. If the proposition is assigned the value TRUE, then (by the rules for truth values) it must also be assigned FALSE and vice versa. It is not obvious what (if anything) is wrong or how to fix it.”
We are investigating strongly paraconsistent Logic Programming using Direct Logic [Hewitt 2008e] to deal with theories of practical domains that are chock full of inconsistencies, e.g., domains associated with large software systems.
In this respect, the Deduction Theorem of logic plays a crucial role in relating logical implication to computation. The Classical Deduction Theorem can be stated as follows: (├ (P ⇒ Q)) ⇔ (P├ Q) stating that (P implies Q) can be proved if and only if Q can be inferred from P. Thus procedures can search for a proof of the implication (P → Q) by simply searching for a proof of Q from P. However, the Classical Deduction Theorem is not valid for the strongly paraconsistent theories of Direct Logic.
Consequently for Direct Logic, the Two-Way Deduction Theorem [Hewitt 2008e] was developed taking the following form:
PrediCalc [Kassoff, Zen, Garg, and Genesereth 2005] uses paraconsistent constraint logic for spreadsheets by allowing inconsistency between cell values and constraints. This approach differs from the traditional consistency-maintaining techniques. In addition, PrediCalc shows the consequences of the value assignments, even when the assignments are inconsistent with the constraints. PrediCalc’s notion of consequence differs from current notions based on minimal repairs.
| What went wrong: 1. [Turing 1949, McCarthy 1963, Floyd 1967, Hoare 2003] proposed ususing classical mathematical logic to prove that programs were consistent with their specifications. However, as systems grew larger this became infeasible [Cusumano and Selby 1995, Rosenberg 2007]. 2. When formalizing reasoning using reflection for large software systems, the reasoning process itself produced inconsistencies about certain specialized propositions that make assertions about their own provability. 3. The Classical Deduction Theorem (a mainstay principle of Logic Programming) was found not to be valid for the strongly paraconsistent theories of Direct Logic. |
| What was done about it: 1. A strongly paraconsistent logic (Direct Logic [Hewitt 2008]) was developed to reason about the mutually inconsistent code, specifications, and test cases of large software systems. 2. It was decided to ignore these inconsistencies because:
3. A replacement for the classical Deduction Theorem (the Two-way Deduction Theorem) was developed thereby facilitating Logic Programming for strongly paraconsistent theories in Direct Logic |
Privacy-friendly, client cloud computing
In Client Cloud Computing, information is permanently stored in servers on the Internet and cached temporarily on clients that range from single chip sensors, handhelds, notebooks, desktops, and entertainment centers to huge data centers. (Even data centers often cache their information to guard against geographical disaster.) Client cloud computing will provide new capabilities including the following:
- maintaining the privacy of client information by storing it on servers encrypted so that it can be decrypted only by using the client’s private key. (The information is unencrypted only when cached on a client.)[xx]
- allowing greater integration of user information obtained from the servers of competing vendors without requiring them to interact with each other. A consequence is the client becomes the monetization platform providing better advertising relevance and targeting without exposing client privacy
- strongly paraconsistent logic using Direct LogicTM [Hewitt 2008e] to more safely reason about pervasively inconsistent information
- concurrent reasoning using ActorScriptTM [Hewitt 2008e] for many-core processors (e.g. Larrabee) that cannot be implemented using logical deduction.[1] (Although strongly paraconsistent and Bayesian inference are used together locally, they are inadequate to accomplish the overall results of concurrent reasoning.)
To address the above, ORGs (Organizations of Restricted GeneralityTM) have been developed as a paradigm in which organizations have people that are tightly integrated with information technology that enables them to function organizationally [Hewitt and Inman 1991; Hewitt 2008b, 2008d, 2008g].[4] ORGs formalize existing practices to provide a framework for addressing issues of authority, accountability, scalability, and robustness using methods that are analogous to human organizations.[xxi]
ORGs are structured around organizational commitment defined as information pledged [Hewitt 2007]. For example, ORGs can use contracts to formalize their mutual commitments to fulfill specified obligations to each other. Yet, manifestations of information pledged will often be inconsistent. Any given contract might be internally inconsistent, or two contracts in force at one time could contradict each other. Issues that arise from such inconsistencies can be negotiated among ORGs.
ORGs can make use of the following information system principles [Hewitt 2008g]:
- Monotonicity: Once something is published it cannot be undone. Published work is collected and indexed.
- Concurrency: Works proceeds interactively and concurrently, overlapping in time.
- Commutativity: Publications can be read regardless of whether they initiate new work or become relevant to ongoing work.
- Sponsorship: Sponsors provide resources for computation, i.e., processing, storage, and communications. Publication and subscription require sponsorship although sometimes costs can be offset by advertising.
- Pluralism: Publications include heterogeneous, overlapping and possibly conflicting information. There is no central arbiter of truth
- Skepticism: Great effort is expended to test and validate current information and replace it with better information.
- Provenance: The provenance of information is carefully tracked and recorded.
| What went wrong:
|
| What is being done about it:
|
Rapid Recovery
Rapid Recovery is a computing paradigm being developed in contrast with the traditional Inconsistency Denial paradigm.
Digital data is fragile. It often doesn't take much disruption to make it unrecoverable. Consequently, we adopt the following principle:
All data is cached data; however, sometimes there is only one copy.
For example, consider a cloud blob storage service that stores and retrieves digital artifacts (called blobs). Amazon Dynamo [DeCandia, et al. 2007] and Tahoe [Wilcox-O'Hearn and Warner 2008] developed highly available blob storage services that could be improved in the following ways:
- Making storage receipt-based instead of key-based. In receipt-based storage a receipt is provided for each instance of the deposit of a blob, a familiar business model to customers. Receipt-based storage can be more efficiently implemented than key-based because it does not require global co-ordination of keys.
- Making each deposit of a blob under a Service Level Agreement (SLA) that can be of various kinds including the following:
- rent per time period
- incremental charge for retrieving the blob
- drop-off changes for retrieving the blob at a place that is geographically distant from where it was stored
- incremental charge for replacing the blob with a new version and issuing a replacement receipt. The replacement can optionally be specified as an incremental difference of the blob being replaced in order to save on storage and communications.
- variable charging for availability and reliability
- requiring that blob retrieval in addition to requiring a receipt must also be performed by a specified ORG.[xxv]
- Providing a clean abstraction for high availability in retrieving blobs. A request to retrieve the blob for a receipt should either return the blob or throw an exception if the SLA specified when depositing the blob cannot be met. However, the exception can provide a list, each element of which is an alternative previous version of the blob together with the receipt that was provided when it was stored.
In contrast, Rapid Recovery can be compared with Eventual Consistency [Vogels 2007]:
The storage system guarantees that if no new updates are made to the object eventually (after the inconsistency window closes) all accesses will return the last updated value.
Rapid Recovery differs from Eventual Consistency as follows:
- In response to a request to retrieve a blob for a receipt, the blob storage system may respond that, unfortunately, all versions of the blob have been irretrievably lost. In which case, (monetary) compensation may be owed in accordance with the SLA of the receipt.
- It may not be possible to retrieve the latest version of a blob using the receipt that was provived when the version was stored. Only older versions of the blob might be available.
- Recovery information can be provided in the exception thrown by a request that does not meet its SLA. For example, the exception can include an estimate as to when a better response to the request might be available.
- A request can be made that better responses be sent as they become available.
| What went wrong: Dynamo and Tahoe developed highly available cloud storage services that although practically useful for what they were designed did not implement Rapid Recovery (i.e. functionality to return improved reponses as they became available). |
| What is being done about it: An improved abstraction is being developed for Rapid Recovery cloud storage services.[5] |
Practical Semantic IntegrationTM
Computer information is currently stored separately:
- calendars and to do lists
- email, SMS and Twitter archives
- presence information (including physical, psychological and social)
- maps (including firms, points of interest, traffic, parking, and weather)
- events (including alerts and status)
- documents (including presentations, spread sheets, proposals, job applications, health records, photos, videos, gift lists, memos, purchasing, contracts, and articles)
- contacts (including social graphs and reputation)
- data bases (including relational and geospatial)
- search results (including rankings and ratings)
- user interface
- privacy and security of the above
- marketing and advertising relevance (influenced by all of the above)
Practical Semantic Integration is the combination of diverse sources of information for use in making semantic connections Lightly Structured Natural LanguageTM and Many-core Semantic Engines):
 |
| Practical Semantic IntegrationTM |
The Practical Semantic Integration paradigm shift is analogous to the previous Personal Computer paradigm shift in terms of user interfaces, processing, and network security as follows (see Perfect Disruption: The Paradigm Shift from Mental Agents to ORGs IEEE Internet Computing, Jan/Feb 2009):
Personal Computer Practical Semantic IntegrationTM
User Interface Keyboard and Pointer Lightly Structured Natural Language
Processing Microprocessor Many-core Semantic Engine
Network Security Firewall Client-cloud encryption
There is tremendous value in semantically integrating the above kinds of intimate personal information. However,
“We want consumers to be able to take advantage of all of the new technologies without the technologies taking advantage of the consumers. Right now, that balance is not there,” Pam Dixon, executive director of the World Privacy Forum, said. “We like the digital world that we’ve moved into, but people shouldn’t have to have their rights abridged in order to take advantage of it.” [Privacy Groups Urge Congress to Toughen Up on Online Ads Wall Street Journal. Sept. 1. 2009]
Doing semantic integration on clients’ clouds can provide the right kind of balance between consumers, merchants, and aggregators (see Is intimate personal information a toxic asset in cloud datacenters? O’Reilly Radar. Aug. 17, 2009).
As an example, Semantic Engines can be provided with event streams of what occurs in the Google Waves like the following:
 |
| A Google Wave |
Then Semantic Integration users might express themselves as follows:
- “Make a table of when each user from Microsoft Research joined this wave.”
- “Drop a pin on the map where Tony’s mom lives.”
- “When is Rosie returning from Leeds after she sees Tony?”
Many-core Semantic Engines work by making semantic connections including examples like the following:
· A statistical connection between “being in a traffic jam” and “driving in downtown Trenton between 5PM and 6PM on a weekday.”
· A terminological connection between “MSR” and “Microsoft Research.”
· A causal connection between “joining a Google Wave” and “being a member of the Wave.”
· A syntactic connection between “a pin dropped” and “a dropped pin.”
· A biological connection between “a dolphin” and “a mamal”.
If a Semantic Engine cannot make a connection, then as far as it is concerned, it does not know of any semantic relationship.
As another example, consider the following task for practical semantic integration [Hewitt 2007f]:
· Working for ABC Corp, your task is to organize a joint sales conference with your partner XYZ Corp.
· It will include approximately 60 regional sales managers from both companies including international (visas will be required). The conference will be for 2 days in the summer of 2009 in the Western US at a scenic location near golf links.
· There will be an awards banquet (with individually engraved plaques for awardees). The sales VPs of both companies must attend. The air and car rental travel of participants should be coordinated to maximize interaction.
· The conference budget for ABC Corp is $60K.
· You need to prepare a detailed proposal for the sales VPs of both companies in 1 week’s time!
Consider another example [Ballmer 2009]:
Instead of telling my secretary to get me ready for my trip to the House Democratic Caucus, I’ll just type it in or speak it to my computer. It can look up, it turns out, who you all are, and where you’re all from, and it’s got all–it’s all out there. We just need to automate it in ways that real people can get access to information. (emphasis added)
Today's computer systems offer little more than "copy and paste" to aid integration for the above tasks.
However, it is not possible to guarantee the consistency of information within a Semantic Engine because consistency testing is recursively undecidable even in logics much weaker than first order logic. Because of this difficulty, it is usually not known whether the information in a Semantic Engine is consistent. In practice, the information in large software projects and information on the Internet is invariably inconsistent. Therefore Semantic Engines must be able to make semantic connections even in the face of inconsistency. Unfortunately, classical logic has the property that from a single inconsistency anything and everything can be inferred. Direct Logic™ (ArXiv 0812.4852) is a logical system that can be used to reason more safely about inconsistent information that results when Full Indirect Inference and Disjunction Introduction are removed from classical reasoning. In order to more safely reason about inconsistent information, Semantic Integration should use Direct Logic.
Semantic Integration enjoys important positive feedback effects. Value grows with use. Also the value of Semantic Integration to users increases by selectively sharing information with others including the following:
- Individuals
- Extended families
- Groups
- Organizations
- Advertisers
- Merchants
- Aggregators (e.g. Google, Microsoft, Yahoo, Facebook, etc.)
- Game and sporting partners
- Media
Semantic Integration can be implemented using ORGs (Organizations of Restricted Generality™) consisting of people and information technology, tightly integrated by authority and accountability. ORGs are a new foundation for implementing applications that formalize existing practices by addressing issues of scalability and robustness using methods that are analogous to human organizations. In this way application programming can become a kind of organizational design and implementation. Semantic Engines will become a primary technological foundation for sharing information among applications. These applications can be implemented as ORGs using programming languages such as ActorScript™ (ArXiv 0907.3330) that are well suited for implementing eventing, co-routining, sponsors, serializing, etc.
| What went wrong: 1. Information in computer systems was stored in isolated silos. 2. Strongly paraconsistent inference in Direct Logic [Hewitt 2008a, 2008e] is a useful advance over classical logic for reasoning in Semantic Integration systems. (It includes statistical and probabilistic inference as special cases.) However, like all inference systems, it is incapable of doing the whole job.[7] |
| What is being done about it: 1. Semantic integration systems are being developed to integrate information from diverse sources. 2. Practical Semantic Integration is being developed for reasoning using strong paraconsistency for the following:
|
Acknowledgements
Alonzo Church, Alain Colmerauer, Ted Elcock, Scott Fahlman, Solomon Feferman, Frederic Fitch, Cordell Green, Pat Hayes, Stephen Kleene, Bill Kornfeld, Robert Kowalski, John McCarthy, Drew McDermott, Marvin Minsky, Alan Robinson, Philippe Roussel, John Barkley Rosser, Jeff Rulifson, Erik Sandewall, Dana Scott, Christopher Strachey, Gerry Sussman, Alan Turing, Richard Waldinger, etc. deserve a lot of credit for contributing to the development of Logic Programming. At the same time, the term “logic programming” (like "functional programming") is highly descriptive and should mean something. Over the course of history, the term “functional programming” has grown more precise and technical as the field has matured. Logic Programming should be on a similar trajectory. Accordingly, “Logic Programming” should have a more precise characterization, e.g., “the logical inference of computational steps”.
Today we know much more about the strengths and limitations of Logic Programming than in the late 1960’s. For example, Logic Programming is not computationally universal and is strictly less general than the Procedural Embedding of Knowledge paradigm [Minsky et al. 1968; Hewitt 1971]. Logic Programming and Functional Programming will both be very important for concurrent computation. Although neither one by itself (or even both together) can do the whole job, what can be done is extremely well suited to massive concurrency.
At AAAI’08, conversations with Bruce Buchanan, Mehmet Göker, Ben Kuipers, Erik Sandewall, Dan Shapiro, Reid Smith, and others were very helpful. The Stanford Logic group led by Michael Genesereth has provided a supportive environment for the further development of some of the ideas. Elihu M. Gerson, Erik Sandewall, and Dan Shapiro made extensive suggestions for improving this paper. Richard Waldinger provided a suggestion on how to better characterize Logic Programming. Conversations with Pat Helland were very helpful in developing the blob storage service described in this paper. Jeremy Forth made helpful comments and suggested including the section on the future of Logic Programming. Peter Neumann proposed that I develop a better ending for the paper. An anonymous referee of CACM corrected some typos. Peter de Jong and Fanya S. Montalvo provided extensive comments and suggestions. Participant interaction at my Stanford Computer Systems Laboratory Colloquium [Hewitt 2008f] organized by Dennis Allison helped improve the presentation. A delightful conversation with Pat Helland at PDC'08 helped improve the section on Rapid Recovery. Burton Smith and Dean Jacobs made helpful comments.
We are in the midst of a paradigm shift from “inconsistency denial” to “semantic integration.”
References
Michael Armbrust, Armando Fox, David Patterson, Nick Lanham, Beth Trushkowsky, Jesse Trutna, and Haruki Oh. SCADS: Scale-Independent Storage for Social Computing Applications CIDR'09.
Henry Baker and Carl Hewitt. Laws for Communicating Parallel Processes IFIP’77.
Steve Ballmer. “Steve Ballmer's Comments at Democratic Caucus Retreat” U.S. House of Representatives Democratic Caucus Retreat. February 6, 2009.
Andreas Blass, Yuri Gurevich, Dean Rosenzweig, and Benjamin Rossman (2007a) Interactive small-step algorithms I: Axiomatization Logical Methods in Computer Science. 2007.
Andreas Blass, Yuri Gurevich, Dean Rosenzweig, and Benjamin Rossman (2007b) Interactive small-step algorithms II: Abstract state machines and the characterization theorem. Logical Methods in Computer Science. 2007.
Kellogg Booth, Jonathan Schaeffer. and W. Morven Gentleman. Anthropomorphic Programming University of Waterloo Computer Science Dept. Memo CS-82-47. February 1984.
Geof Bowker, Susan L. Star, W. Turner, and Les Gasser, (Eds.) Social Science Research, Technical Systems and Cooperative Work Lawrence Earlbaum. 1997.
Jean-Pierre Briot. From objects to actors: Study of a limited symbiosis in Smalltalk-80 Rapport de Recherche 88-58, RXF-LITP, Paris, France, September 1988.
Luca Cardelli and Andrew Gordon. Mobile Ambients Foundations of Software Science and Computational Structures, Maurice Nivat (Ed.), Lecture Notes in Computer Science, Vol. 1378, Springer, 1998.
Alonzo Church A Set of postulates for the foundation of logic Annals of Mathematics. Vol. 33, 1932. Vol. 34, 1933.
Alonzo Church The Calculi of Lambda-Conversion Princeton University Press. 1941
James Crawford and Benjamin. Kuipers Negation and proof by contradiction in access-limited logic. AAAI-91
Will Clinger. Foundations of Actor Semantics MIT Mathematics Doctoral Dissertation. June 1981.
Michael Cusumano and Richard Selby, R. Microsoft Secrets: How the World’s Most Powerful Software Company Creates Technology, Shapes Markets, and Manages People. Free Press. 1995
Ole-Johan Dahl and Kristen Nygaard. Class and subclass declarations IFIP TC2 Conference on Simulation Programming Languages. May 1967.
Edsger Dijkstra. A Discipline of Programming Prentice Hall. 1976.
Solomon Feferman (1984a) Toward Useful Type-Free Theories, I in Recent Essays on Truth and the Liar Paradox. Ed. Robert Martin (1991) Claraendon Press.
Solomon Feferman (1984b) Kurt Gödel: Conviction and Caution Philosophia Naturalis Vol. 21.
Shel Finkelstein, Rainer Brendle, and Dean Jacobs. Principles for Inconsistency CIDR'09.
Frederic Fitch. Symbolic Logic: an Introduction. Ronald Press. 1952.
Robert Floyd Assigning meanings to programs Proceedings of Symposium on applied Mathematics. 1967.
Kazuhiro Fuchi, Robert Kowalski, Kazunori Ueda, Ken Kahn, Takashi Chikayama, and Evan Tick. Launching the new era CACM. 1993.
Herbert Gelernter. Realization of a geometry theorem-proving machine International Conference on Information Processing. UNESCO. Paris. 1959
Andreas Glausch and Wolfgang Reisig. Distributed Abstract State Machines and Their Expressive Power Informatik-Berichete 196. Humboldt University of Berlin. January 2006.
Adele Goldberg and Alan Kay (ed.) Smalltalk-72 Instruction Manual SSL 76-6. Xerox PARC. March 1976.
C. Cordell Green: “Application of Theorem Proving to Problem Solving” IJCAI 1969.
Kurt Gödel (1931) “On formally undecidable propositions of Principia Mathematica” in A Source Book in Mathematical Logic, 1879-1931. Translated by Jean van Heijenoort. Harvard Univ. Press. 1967.
Pat Hayes Computation and Deduction Mathematical Foundations of Computer Science: Proceedings of Symposium and Summer School, Štrbské Pleso, High Tatras, Czechoslovakia, September 3-8, 1973.
Pat Helland. The Irresistible Forces Meet the Moveable Objects Microsoft TechEd Developers Conference. Nov. 9, 2007. http://blogs.msdn.com/pathelland/
Pat Helland and Dave Campbell. Building on Quicksand CIDR'09.
Carl Hewitt Procedural Embedding of Knowledge in Planner IJCAI 1971.
Carl Hewitt, Peter Bishop and Richard Steiger. A Universal Modular Actor Formalism for Artificial Intelligence IJCAI 1973.
Carl Hewitt and Jeff Inman. DAI Betwixt and Between: From "Intelligent Agents" to Open Systems Science IEEE Transactions on Systems, Man, and Cybernetics. Nov./Dec. 1991.
Carl Hewitt. What is Commitment? Physical, Organizational, and Social Lecture Notes in Artificial Intelligence. Edited by Javier Vázquez-Salceda and Pablo Noriega. Springer Verlag. 2007.
Carl Hewitt (2008a) Large-scale Organizational Computing requires Unstratified Reflection and Strong Paraconsistency Coordination, Organizations, Institutions, and Norms in Agent Systems III. Jaime Sichman, Pablo Noriega, Julian Padget and Sascha Ossowski (Ed.). Springer-Verlag. 2008. http://organizational.carlhewitt.info/
Carl Hewitt (2008b). ORGs for Scalable, Robust, Privacy-Friendly Client Cloud Computing IEEE Internet Computing September/October 2008.
Carl Hewitt (2008c) Middle History of Logic Programming: From Planner to Prolog and the Japanese Fifth Generation
Google Knol. http://middlehistory.carlhewitt.info/
Carl Hewitt (2008d). ORGs (Organizations of Restricted Generality): Strong Paraconsistency and Participatory Behavioral Model Checking
http://normsandcommitmentfororgs.carlhewitt.info/
Carl Hewitt (2008e) Common sense for concurrency and strong paraconsistency using unstratified inference and reflection ArXiv December 30, 2008.
Cark Hewitt (2008f) Scalable Privacy-Friendly Client Cloud Computing: a gathering Perfect Disruption Stanford Computer Systems Laboratory Colloquium Oct. 22, 2008. Video recording.
http://stanford-online.stanford.edu/courses/ee380/
081022-ee380-300.asx
Carl Hewitt (2008g) Perfect Disruption: Causing the Paradigm Shift from Mental Agents to ORGS IEEE Internet Computing. Jan/Feb 2009.
Tony Hoare. The Verfying Compiler: a Grand Challenge for Computing Research JACM. January 2003.
Ian Horrocks. Ontologies and the Semantic Web CACM. December 2008.
Zhisheng Huang, Frank van Harmelen, and Annette ten Teije. Reasoning with inconsistent ontologies IJCAI'05.
Michael Kassoff, Lee-Ming Zen, Ankit Garg, and Michael Genesereth. PrediCalc: A Logical Spreadsheet Management System 31st International Conference on Very Large Databases (VLDB). 2005.
Alan Kay. The Meaning of “Object-Oriented Programming” http://www.purl.org/stefan_ram/pub/doc_kay_oop_en July 2003.
Alan Kay. Personal Computing in "Meeting on 20 Years of Computing Science" Instituto di Elaborazione della Informazione, Pisa, Italy. 1975.
http://www.mprove.de/diplom/gui/Kay75.pdf
Jussi Ketonen and Richard Weyhrauch. A decidable fragment of Predicate Calculus Theoretical Computer Science. 1984.
Stephen Kleene Recursive Predicates and Quantifiers American Mathematical Society Transactions. 1943.
William Kornfeld and Carl Hewitt The Scientific Community Metaphor IEEE Transactions on Systems, Man, and Cybernetics. January 1981.
Frederick Knabe. A Distributed Protocol for Channel-Based Communication with Choice PARLE 1992.
Robert Kowalski Algorithm = logic + control CACM. July, 1979.
Robert Kowalski. Response to questionnaire Special Issue on Knowledge Representation. SIGART Newsletter. February 1980.
Robert Kowalski (1988a) The Early Years of Logic Programming CACM. January 1988.
John Laird, Allen Newell, and Paul Rosenbloom SOAR: an architecture for general intelligence Artificial Intelligence. Vol. 33. No 1. 1987.
Philip Leith. “Involvement, Detachment and Programming: The Belief in Prolog” In The Question of Artificial Intelligence Routledge. 1985.
Yue Ma, Pascal Hitzler and Zuoquan Lin. Paraconsistent Reasoning with OWL -- Algorithms and the ParOWL Reasoner. Technical Report, AIFB, University of Karlsruhe. December 2006.
James Masters and Zelal Gűngőrdű Semantic knowledge source integration: a progress report Integration of Knowledge Intensive Multi-Agent Systems. 2003.
John McCarthy Programs with common sense Symposium on Mechanization of Thought Processes. National Physical Laboratory, UK. Teddington, England. 1958.
John McCarthy Towards a mathematical theory of computation IFIP 1962.
L. Thorne McCarty. Reflections on TAXMAN: An Experiment on Artificial Intelligence and Legal Reasoning Harvard Law Review. Vol. 90, No. 5, March 1977.
Robin Milner Elements of interaction: Turing award lecture CACM. January 1993.
Marvin Minsky (ed.) Semantic Information Processing MIT Press. 1968.
Boris Motik, Peter Patel-Schneider and Bernardo Grau (editors). OWL 2 Web Ontology Language: Direct Semantics. W3C. October 8, 2008.
Richard Neapolitan. Learning Bayesian Networks Prentice Hall 2004.
Peter Neumann. Holistic Approaches to Trustworthiness, Security, & Privacy Cybersecurity Summit 2008 for NSF Large Research Facilities. 7 May 2008.
http://www.csl.sri.com/users/neumann/nsf08sum.pdf
Allen Newell and Herbert Simon. The Logic Theory Machine: A Complex Information Processing System. Rand Technical Report P-868. June 15, 1956
Gordon Plotkin. A powerdomain construction SIAM Journal of Computing. September 1976.
George Polya (1957) Mathematical Discovery: On Understanding, Learning and Teaching Problem Solving Combined Edition Wiley. 1981.
Karl Popper (1935, 1963) Conjectures and Refutations: The Growth of Scientific Knowledge Routledge. 2002.
Chris Preimsberger. Get Off My Cloud: Private Cloud Computing Takes Shape eWeek. November 4, 2008.
Greg Restall (2006). “Curry’s Revenge: the costs of non-classical solutions to the paradoxes of self-reference” (to appear in The Revenge of the Liar ed. J.C. Beall. Oxford University Press. 2007) July 12, 2006.
http://consequently.org/papers/costing.pdf
Scott Rosenberg. Dreaming in Code. Crown Publishers. 2007.
John Barkley Rosser. “Extensions of Some Theorems of Gödel and Church” Journal of Symbolic. Logic. 1(3) 1936.
Jeff Rulifson, Jan Derksen, and Richard Waldinger. “QA4, A Procedural Calculus for Intuitive Reasoning” SRI AI Center Technical Note 73. November 1973.
Erik Sandewall. From Systems to Logic in the Early Development of Nonmonotonic Reasoning CAISOR. July, 2006.
Larry Seiler, et. al. Larrabee: A Many-Core x86 Architecture for Visual Computing ACM Transactions on Graphics. August 2008.
Marek Sergot. Bob Kowalski: A Portrait Computational Logic: Logic Programming and Beyond: Essays in Honour of Robert A. Kowalski, Part I Springer. 2004.
Munindar Singh and Michael Huhns. Service-Oriented Computing: Semantics, Processes, Agents. John Wiley & Sons. 2005.
Dana Scott and Christopher Strachey. Toward a mathematical semantics for computer languages Oxford Programming Research Group Technical Monograph. PRG-6. 1971.
Alfred Tarski and Robert Vaught (1957). “Arithmetical extensions of relational systems” Compositio Mathematica 13.
Dave Thomas and Brian Barry. Using Active Objects for Structuring Service Oriented Architectures: Anthropomorphic Programming with Actors Journal of Object Technology. July-August 2004.
Alan Turing On computable numbers, with an application to the Entscheidungsproblem Proceedings London Math Society. 1936.
Alan Turing Checking a large routine Report on a Conference on High Speed Automatic Calculating Machines Cambridge University Mathematics Laboratory. 1949.
Werner Vogels. Eventually Consistent All things Distributed: Werner Vogel's weblog on building scalable and robust distributed systems. December 19, 2007.
Werner Vogels. Eventually Consistent - Revisited All things Distributed: Werner Vogel's weblog on building scalable and robust distributed systems. December 23, 2008.
H. Wache, et. al. Ontology-based integration of information - a survey of existing approaches Intelligent Systems Group. University of Bremen. 2001.
Zooko Wilcox-O'Hearn and Brian Warner. Tahoe -- The Least-Authority File System. StorageSS'08. October 31, 2008.
References
- This article is a revised version of the publication "Development of Logic Programming: What went wrong, What was done about it, and What it might mean for the future" in Proceedings of What Went Wrong and Why edited by Mehmet Gőker and Daniel Shapiro, AAAI Press. 2008.
- Alan Kay. The Meaning of “Object-Oriented Programming” http://www.purl.org/
stefan_ram/pub/doc_k ay_oop_en July 2003. - Other models of concurrency (e.g. process calculi) can be modeled using a two-phase committ protocol [Knabe 1992].
- ORGs are a further development of “Anthropomorphic Programming” [Booth and Gentleman 1984; Thomas and Barry 2004]: "Alan Karp has pointed out that experience with MIMD architectures invites an analogy with human organizations. For a very small number of processors (people) detailed interactions can be maintained without a manager; with a modest number of processors (people) the interaction patterns can be handled by simple structuring techniques that decompose the problem into distinct tasks with well-defined areas of responsibility; with a very large number of processors (people) the interaction becomes so complicated that more rigid organizations imposing a high degree of regularity seems to be required. We suggest that these three levels may be understood best through the metaphors of anthropomorphic programming.”
- Similar sentiments can be found in independent work by [Finkelstein, Brendle, and Jacobs 2009], [Helland and Campbell 2009], and [Armbrust, et. al. 2009].
- Future generations will be astounded to learn that there was once a time when people could not just tell the computer what they wanted it to do.
- See section above on “Concurrency cannot be implemented using deduction”
Comments
Write New Comment ▼
Write New Comment
Sorry! This knol's owner(s) have blocked you from editing, making suggestions, or commenting here.