Hubbry Logo
Carl HewittCarl HewittMain
Open search
Carl Hewitt
Community hub
Carl Hewitt
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Carl Hewitt
Carl Hewitt
Carl Hewitt
View on Wikipedia
from Wikipedia

Carl Eddie Hewitt (/ˈhjuːɪt/; 1944 – 7 December 2022)[2] was an American computer scientist who designed the Planner programming language for automated planning[3] and the actor model of concurrent computation,[4] which have been influential in the development of logic, functional and object-oriented programming. Planner was the first programming language based on procedural plans invoked using pattern-directed invocation from assertions and goals. The actor model influenced the development of the Scheme programming language,[5] the π-calculus,[6] and served as an inspiration for several other programming languages.[7]

Key Information

Education and career

[edit]

Hewitt obtained his PhD in mathematics at MIT in 1971, under the supervision of Seymour Papert, Marvin Minsky, and Mike Paterson. He began his employment at MIT that year,[8] and retired from the faculty of the MIT Department of Electrical Engineering and Computer Science during the 1999–2000 school year.[9] He became emeritus in the department in 2000.[10] Among the doctoral students that Hewitt supervised during his time at MIT are Gul Agha, Henry Baker, William Clinger, Irene Greif, and Akinori Yonezawa.[11]

From September 1989 to August 1990, Hewitt was the IBM Chair Visiting professor in the Department of Computer Science at Keio University in Japan.[12] He has also been a visiting professor at Stanford University.

Research

[edit]

Hewitt was best known for his work on the actor model of computation. For the last decade, his work had been in "inconsistency robustness", which aims to provide practical rigorous foundations for systems dealing with pervasively inconsistent information.[13] This work grew out of his doctoral dissertation focused on the procedural (as opposed to logical) embedding of knowledge, which was embodied in the Planner programming language.

His publications also include contributions in the areas of open information systems,[14] organizational and multi-agent systems,[15] logic programming,[3] concurrent programming, paraconsistent logic[16] and cloud computing.[17]

Planner

[edit]
Main article: Planner (programming language)

The Planner language was developed during the late 1960s as part of Hewitt's doctoral research in MIT's Artificial Intelligence Laboratory. Hewitt's work on Planner introduced the notion of the "procedural embedding of knowledge",[18] which was an alternative to the logical approach to knowledge encoding for artificial intelligence pioneered by John McCarthy.[19] Planner has been described as "extremely ambitious".[20] A subset of Planner called Micro-Planner was implemented at MIT by Gerry Sussman, Drew McDermott, Eugene Charniak and Terry Winograd[21] and was used in Winograd's SHRDLU program,[22] Charniak's natural language story understanding work,[23] and L. Thorne McCarty's work on legal reasoning.[24] Planner was almost completely implemented in Popler[25] by Julian Davies at Edinburgh. Planner also influenced the later development of other AI research languages such as Muddle and Conniver,[20] as well as the Smalltalk object-oriented programming language.[26]

Hewitt's own work on Planner continued with Muddle (later called MDL), which was developed in the early 1970s by Sussman, Hewitt, Chris Reeve, and David Cressey as a stepping-stone towards a full implementation of Planner. Muddle was implemented as an extended version of Lisp, and introduced several features that were later adopted by Conniver, Lisp Machine Lisp, and Common Lisp.[20] However, in late 1972 Hewitt abruptly halted his development of the Planner design in his thesis, when he and his graduate students invented the actor model of computation.

Actor model

[edit]
Main article: Actor model

Hewitt's work on the actor model of computation spanned over 30 years, beginning with the introduction of the model in a 1973 paper authored by Hewitt, Peter Bishop, and Richard Steiger,[27] and including new results on actor model semantics published as recently as 2006.[28] Much of this work was carried out in collaboration with students in Hewitt's Message Passing Semantics Group at MIT's Artificial Intelligence Lab.[29]

Sussman and Steele developed the Scheme programming language in an effort to gain a better understanding of the actor model. They discovered that their operator to create an actor, ALPHA, and their operator to create a function, LAMBDA, were identical, so they only kept LAMBDA for both.[30][31] A number of other programming languages were developed to specifically implement the actor model, such as ACT-1,[32] SALSA,[33] Caltrop,[34] E[7] and ActorScript.[35] The actor model also influenced the development of the π-calculus.[36] (See actor model and process calculi history.)

Selected works

[edit]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Carl Hewitt

View on Grokipedia
from Grokipedia
Carl Hewitt (1944–2022) was an American computer scientist and professor emeritus at the Massachusetts Institute of Technology (MIT), best known for his foundational contributions to , concurrent and , and , including the invention of the Planner language and the of computation. Born in 1944, Hewitt earned his PhD in from MIT in 1971, where he began his academic career as an assistant professor in the Department of and from 1971 to 1976, advancing to from 1976 to 2000 before becoming professor emeritus. During his 37-year tenure at MIT, he spent much of his time in the Artificial Intelligence Laboratory, pioneering research on parallel and distributed systems. His early work on Planner, introduced in 1969 as a framework for theorem proving and automated planning in robots, emphasized procedural representation and goal-directed computation, influencing subsequent developments in AI planning languages. Hewitt's most enduring contribution is the actor model, formalized in his 1973 paper "Actor Induction and Meta-Evaluation," which provided a of concurrent computation based on autonomous agents (actors) communicating via asynchronous , independent of specific programming languages. This model addressed limitations in traditional von Neumann architectures by treating computation as communication, enabling scalable, robust systems for distributed environments, and it has profoundly impacted modern paradigms in , IoT, and multi-agent systems. Later in his career, Hewitt advanced concepts in inconsistency robustness, , and , arguing for systems that could handle imperfect information and evolve dynamically, as explored in works like his 2010 paper on the for adaptive concurrency. He also contributed to the analysis of offices and organizations as open systems, integrating actor-based semantics with real-world applications. Hewitt's research emphasized direct logic over for scalable reasoning and critiqued overly idealistic models in , advocating for practical, robust frameworks that accommodate human and system evolution. His visionary ideas, developed over decades with collaborators in MIT's Semantics Group, continue to underpin advancements in and AI resilience. Hewitt passed away on December 7, 2022, in , leaving a legacy as a key figure in shifting computing from sequential to concurrent paradigms.

Biography

Early Life and Education

Carl Hewitt was born in 1944 in , and moved to , at the age of two, where he spent much of his childhood. He attended , participating actively in the Math Club and Science Club, which fostered his early enthusiasm for mathematics and scientific inquiry. Hewitt pursued higher education at the Massachusetts Institute of Technology (MIT), earning a B.S. in Mathematics in 1966 and an M.S. in Mathematics in 1968. During his undergraduate and graduate studies, he gained significant exposure to artificial intelligence through the influential work and courses of at MIT's AI Group. In 1971, Hewitt completed his Ph.D. in at MIT, with a dissertation titled Description and Theoretical Analysis (Using Schemata) of PLANNER: A Language for Proving Theorems in Robots, which explored procedural representations of for in robotic systems. His committee included , , and Mike Paterson, who provided guidance on integrating logical and computational approaches. During his graduate years, Hewitt was deeply involved in the MIT Laboratory, contributing to foundational research in AI that shaped his later innovations.

Academic and Professional Career

Carl Hewitt joined the Massachusetts Institute of Technology (MIT) as an assistant professor in the Department of Electrical Engineering and Computer Science in 1971, shortly after completing his PhD, and became a key member of the MIT Artificial Intelligence Laboratory. He was promoted to in 1976, a tenured position he held until his retirement. During his tenure at MIT, Hewitt contributed significantly to the AI Lab's projects in the and , collaborating with prominent researchers such as Gerald Sussman on foundational work in programming languages and systems. He served as faculty until 2000, when he retired and was appointed Professor Emeritus of and . In addition to his primary role at MIT, Hewitt held visiting positions, including the IBM Chair Visiting Professor in the Department of at from September 1989 to August 1990. He also engaged as a visiting scholar and frequent lecturer at during various periods in the 1990s and beyond, contributing to discussions on logic and concurrent systems. Following his retirement from MIT, Hewitt maintained an active presence in academia and industry through advisory roles and consultations on concurrent systems, drawing on his expertise in the to influence practices into the .

Death and Posthumous Recognition

Carl Hewitt passed away on December 7, 2022, at his home in , at the age of 77, attended by his partner of 39 years, Fanya S. Montalvo. He was survived by Montalvo and his brother, Blake Hewitt. His death was announced through an obituary in the Santa Cruz Sentinel and by the artificial intelligence community, including a notice from Stanford University's Computer Systems Colloquium series, where Hewitt had been a frequent speaker. A private memorial gathering was held on January 14, 2023, at Benito & Azzaro Pacific Gardens Chapel in , followed by a Zoom reception for broader participation. Public tributes included the Stanford Seminar "Remembering Carl Hewitt" on January 18, 2023, which featured discussions by colleagues on his foundational contributions, such as the of computation. Hewitt's professional papers are preserved in the MIT ArchivesSpace collection, documenting his career at the institution.

Research Contributions

Planner Programming Language

The Planner programming language was developed by Carl Hewitt in the late 1960s at the MIT Artificial Intelligence Laboratory as part of his doctoral work. First presented at the First International Joint Conference on Artificial Intelligence (IJCAI) in 1969, it emerged from efforts to create systems capable of automated reasoning in robotic contexts. The foundational description appears in Hewitt's paper "PLANNER: A Language for Proving Theorems in Robots," which outlines its syntax and semantics for theorem proving and model manipulation. At its core, Planner employed procedural attachment to embed knowledge representation within executable procedures, allowing data-driven invocation of functions as "recommendations" during problem-solving. It featured pattern-directed invocation through a general-purpose matching mechanism, such as the MATCHLESS primitive, which enabled powerful against database assertions to generate deductions (e.g., the assign? form binds variables to data patterns). was integral for theorem proving, with failure responses like genfail triggering withdrawal of assumptions and retrying alternative paths, supporting dynamic assertion and erasure of statements as the world model evolved. Planner's key innovation was its goal-oriented paradigm, where a hierarchical control structure subordinated the deductive to prioritize in long chains, allowing to be established, pursued via subgoals, and dismissed upon satisfaction. This approach influenced subsequent rule-based s by demonstrating how procedural plans could be invoked based on pattern-matched assertions, paving the way for automated in AI. A representative example is proving for , such as deriving (subset a c) from premises like (subset a b) and (subset b c) through goal-directed subgoals: {goal (subset a c)} expands to matching relevant theorems and recursively proving intermediates. Despite these advances, Planner encountered limitations in handling non-monotonic reasoning, particularly challenges like proofs by contradiction or non-constructive proofs, stemming from the of its erase primitive for withdrawing conclusions amid changing knowledge. These issues, including difficulties with the in dynamic environments, highlighted the need for more robust mechanisms in knowledge representation. Such challenges spurred later evolutions toward formal non-monotonic logics and truth-maintenance systems in AI.

Actor Model of Computation

The Actor model of computation was introduced by Carl Hewitt, , and Richard Steiger in their 1973 paper presented at the International Joint Conference on (IJCAI), titled "A Universal Modular ACTOR Formalism for ." This work proposed actors as the universal primitives of concurrent digital computation, unifying concepts from data structures, functions, and processes into a single modular framework for . The model drew inspiration from physics, including and , to address limitations in previous computational paradigms that relied on shared state. At its core, the Actor model treats as autonomous computational entities that communicate exclusively through asynchronous , eliminating the need for and thereby avoiding race conditions inherent in traditional concurrency approaches. Each maintains its own local state and processes incoming messages sequentially from its mailbox, responding by either performing local computations, creating new , or sending messages to other . Behavior modification occurs not by altering an existing 's state in a mutable way but by the spawning successor that embody updated behaviors, ensuring immutability and enabling scalable parallelism. This design supports open systems where can dynamically discover and interact with others without prior knowledge of their internal structures. Formally, the model employs substitution semantics for evaluation, where messages are substituted into an actor's code and reduced according to definitional rules, providing a mathematical foundation for deduction and computation without global synchronization. A central concept is the actor address, which serves as a unique identifier functioning like a mailbox for receiving messages; for instance, the notation % A \, M \% denotes sending message MM to actor AA. This enables networks of actors to perform parallel computations, as illustrated by a simple account management example: an Account actor initialized with a starting balance processes concurrent deposit and withdraw messages independently, updating its local balance (e.g., concurrent withdrawals of €1 and €2 from €6 yield €3 regardless of processing order, demonstrating quasi-commutative operations in asynchronous environments). In the , the saw early implementations in Lisp-based systems, such as Act1 and Act2, which leveraged Lisp's procedural capabilities to realize concurrent actor networks and serializers for controlling access to shared resources. These developments influenced object-oriented concurrency by promoting asynchronous as a foundational mechanism, impacting languages like Smalltalk and later systems such as Erlang. Hewitt's earlier work on the Planner language provided procedural influences that shaped the actor's message-handling patterns, though the model extended these into fully distributed concurrency.

Inconsistency Robustness

In the 2000s, Carl Hewitt founded the field of Inconsistency Robustness, which addresses the challenges of designing scalable systems that must operate effectively amid partial and conflicting truths, marking a departure from traditional paradigms assuming consistent knowledge. This approach recognizes that large-scale systems, such as those in the era, inevitably encounter continual inconsistencies due to distributed data sources and asynchronous updates, requiring mechanisms to maintain performance without system failure. Central to Hewitt's framework is Direct Logic, a revision of classical that supports non-monotonic reasoning, allowing deductions to proceed robustly even with contradictory inputs by avoiding the explosion of inferences from inconsistencies. In Direct Logic, contradictions are made explicit to facilitate argumentative inference, enabling features like proof by contradiction and disjunctive case analysis while fixing issues such as the contrapositive inference bug in classical systems. Hewitt integrated this with the , where —autonomous computational entities—process inconsistent data without halting, managing indeterminate message orders through procedural embedding of knowledge rather than pure deduction. Key publications advancing these ideas include Hewitt's 2006 paper "What Is Commitment? Physical, Organizational, and Social," which explores commitments as physical relationships between and systems, using Direct Logic to handle inconsistencies in social and organizational contexts, such as policy disputes. Subsequent preprints from 2009 onward, including "Inconsistency Robustness in Logic Programs" and works on formalizing reasoning, further developed robust techniques for integrating conflicting in actor-based systems. Applications of Inconsistency Robustness span office automation, where actors resolve conflicting updates in collaborative workflows by prioritizing commitments based on meta-policies, and distributed databases, enabling scalable integration of heterogeneous data sources without requiring global consistency. For instance, in a distributed database scenario, actors can asynchronously handle update conflicts by propagating resolutions through explicit argumentation, ensuring system continuity despite pervasive discrepancies. Hewitt's principles emphasize that large systems must be engineered for "continual, unavoidable inconsistency," prioritizing operational robustness over idealized coherence.

Other Works in Logic and Systems

In addition to his foundational work in and concurrency, Hewitt contributed to the historical understanding of through his 2009 paper, which traces the evolution from resolution-based systems to and the Japanese project. He argued that early resolution methods, such as those in Planner, laid groundwork for but faced limitations in handling nondeterminism and efficiency, influencing the design of as a practical language. Hewitt highlighted how the Fifth Generation Project in aimed to integrate with knowledge representation for AI applications, though it encountered challenges in and . During the 1980s, Hewitt explored office information systems as open, concurrent environments, proposing actor-based models to support distributed workflows and document management. In his paper, he described offices as dynamic systems where "" activities—such as approval chains and information routing—require computer-mediated concurrency to handle ongoing organizational tasks. This approach emphasized actors as primitives for managing document lifecycles, enabling asynchronous communication and authority delegation in heterogeneous settings. Hewitt engaged in public debates on AI and concurrency, notably through a 2007 controversy where he was banned from editing for disruptive changes that promoted his research contributions. Administrators cited his alterations to articles on topics, including attempts to emphasize actor-based concurrency over rival paradigms, as violating neutrality policies and rendering entries unreliable. Hewitt defended his actions as countering perceived biases against innovative AI approaches, reflecting his broader critique of mainstream views on computational foundations. Hewitt's actor model also influenced collaborative projects, such as the development of the Scheme programming language, where its message-passing concepts inspired implementations of concurrency in a Lisp dialect. Similarly, parallels emerged between actors and the π-calculus in modeling process interactions, with Hewitt noting shared emphases on dynamic communication topologies without deep formal derivations.

Influence and Legacy

Impact on Concurrent and Distributed Systems

Hewitt's actor model has profoundly shaped the foundations of concurrent and distributed computing by promoting a message-passing paradigm that decouples computation from shared state, enabling scalable and fault-tolerant systems. This model directly influenced the development of programming languages and frameworks such as Erlang, which popularized actors for building highly available telecommunications systems at Ericsson, and Akka, a toolkit for Java and Scala that facilitates resilient distributed applications through actor-based concurrency. The actor model's emphasis on asynchronous communication and dynamic process creation provided a blueprint for cloud computing environments, where scalability arises from distributing workloads across independent units rather than centralized control. The model's theoretical impact extended to formal methods in concurrency, notably inspiring Robin Milner's , a process algebra that generalizes actor-like communication for modeling mobile processes and has become a cornerstone for verifying distributed systems. This influence rippled into subsequent calculi, including ambient calculus, which builds on principles to describe computational boundaries and mobility in a manner complementary to actor encapsulation. In industry adoption, the actor model underpins distributed AI and multi-agent systems, where autonomous entities collaborate via messages to solve complex problems, as seen in frameworks like ActressMAS for .NET-based simulations and agentic AI platforms that leverage parallelism for resilient orchestration. By the 2020s, the had evolved to support modern architectures, playing a key role in by treating services as independent actors that communicate asynchronously, reducing coupling and enhancing deployment flexibility in cloud-native environments. In , actor-based systems like Histrio enable stateful, scalable applications without traditional infrastructure management, allowing functions to behave as persistent actors that handle concurrency and distribution natively. This shift from the von Neumann model's shared-memory bottlenecks to actor-driven has facilitated the design of antifragile systems that thrive under failure and load. Quantitatively, Hewitt's seminal 1973 paper on the actor formalism has garnered over 1,100 citations, reflecting its enduring role in transitioning computing paradigms toward decentralized, robust concurrency. Collectively, publications by Hewitt exceed thousands of citations, underscoring their pivotal contribution to the field's move away from sequential, state-centric models toward inherently parallel ones.

Broader Contributions to Computer Science

Hewitt's development of the Planner programming language in 1969 marked a foundational advancement in AI planning, introducing primitives for goal-directed theorem proving and model manipulation that enabled automated reasoning in robotic and problem-solving contexts. This work emphasized procedural attachment and pattern-directed invocation, allowing systems to dynamically select methods based on current goals and data, which laid the groundwork for subsequent planning paradigms. Planner's legacy extended to expert systems, where its goal-subgoal hierarchy influenced rule-based inference engines, and it was cited in the development of the STRIPS planning framework at SRI International within the broader AI planning community. These innovations shifted AI planning from rigid theorem proving toward flexible, context-sensitive strategies, enabling applications in domains requiring adaptive decision-making. In the realm of logic and reasoning, Hewitt's early contributions through Planner pioneered elements of non-monotonic reasoning by incorporating mechanisms like the THNOT primitive, which supported provisional assumptions and over incomplete or changing information, challenging the monotonicity of . This approach highlighted the need for logics that could retract conclusions as new facts emerged, influencing the evolution of knowledge representation formalisms. Hewitt's later formulation of Direct Logic further advanced non-monotonic paradigms by integrating paraconsistent reasoning, allowing systems to derive useful inferences despite contradictions without non-termination. These ideas have shaped knowledge representation in the , where non-monotonic extensions to enable handling of defeasible rules and incomplete ontologies, facilitating more robust across distributed data sources. Hewitt's educational impact at MIT's Artificial Intelligence Laboratory profoundly influenced the advancement of and Scheme through his research and the inspiration provided by the , which motivated the creation of Scheme as a dialect of by Gerald Sussman and Guy Steele in the to explore concepts related to . Steele's work on compilers and Scheme implementations broadened their adoption in AI curricula. Hewitt contributed to training a generation of researchers through his guidance of projects on -based systems like , fostering expertise in dynamic, techniques. Philosophically, Hewitt advocated for viewing inconsistencies not as failures but as inherent opportunities in large-scale computation, arguing that pervasive contradictions in distributed systems could drive progressive reasoning if managed through robust, paraconsistent frameworks rather than eliminated via idealized monotonic logic. This perspective, encapsulated in his concept of inconsistency robustness, posits that explicit handling of contradictions enables scalable information integration and adaptive behavior in open environments, where classical logics falter due to indeterminate interactions. As a capstone to his logic work, inconsistency robustness underscores Hewitt's vision of computation as an inherently opportunistic process, resilient to real-world variability.

Selected Publications

Key Papers on Planning and Actors

Hewitt's seminal 1969 paper, "PLANNER: A Language for Proving Theorems in Robots," introduced as a framework for theorem proving and model manipulation in robotic systems, emphasizing a hierarchical control structure that subordinates deductive mechanisms to problem-solving primitives. The language supports dynamic assertion and withdrawal of statements, automatic conclusion drawing from state changes, and goal management through indirect function calls based on data-driven recommendations, distinguishing it from pure procedural languages like . Key innovations include procedural attachment, where statements like (implies a b) trigger both imperative procedures for assertion and declarative ones for subgoal generation, allowing efficient theorem recommendation and ordering. This approach enables sophisticated deductive systems for robots, utilizing pattern-directed retrieval via for enhanced efficiency over resolution-based methods, which rely on a single inference rule and lack such flexible control. The paper has been republished in MIT's archive as part of Memo 250. In 1973, Hewitt co-authored "Actor Induction and Meta-Evaluation," which formalized semantics within the PLANNER project, unifying knowledge embedding through the as an active agent responding to cues via scripted behaviors. serve as a universal primitive for computational entities, integrating control and data flow through , free of side effects, to represent diverse structures like data, functions, and processes. The introduces intentions as contracts specifying prerequisites and contexts for behavior, verified via meta-evaluation to ensure correctness. Examples of induction demonstrate how audience satisfy recipient intentions, with recursive satisfaction propagating downstream, enabling abstract evaluation and halting on inconsistencies. Presented at the ACM Symposium on Principles of Programming Languages, the work appears in the . Hewitt's 1977 paper, "Viewing Control Structures as Patterns of Passing Messages," expands on communication , modeling as a society of knowledge-based problem-solving experts decomposable into primitive . It frames control structures like and as emergent patterns from , addressing trade-offs in parallel versus serial processing and centralized versus decentralized control. Core include transmission as the universal event mechanism, where messengers carry envelopes containing requests, replies, or complaints, with continuations for handling responses akin to procedure calls. Packagers enable explicit message component naming, privacy enforcement, and optimization through in-line substitution, as illustrated in examples like operations and incremental sequences. Originally circulated as AI Memo 410 in 1976, the paper was published in the journal Artificial Intelligence.

Later Works on Robustness and Logic

In the mid-2000s, Hewitt explored the concept of commitment within computational systems, framing it through the lens of the to address coordination in multi-agent environments. In his 2006 , he defined physical commitments as information expressing configurations of physical systems at specific places and times, with fidelity measuring the strength of this relationship. Organizational commitments were characterized as physical commitments undertaken by organizations, often formalized through contracts that enable and . Social commitments, in turn, were analyzed as physical commitments with attributes such as debtor, creditor, and content, allowing for potential inconsistencies, as illustrated by conflicting interpretations in systems like Medicare claims processing. Hewitt critiqued Speech Act Theory for its limited expressiveness in handling concurrent commitments and proposed Participatory Semantics—a four-dimensional space-time framework—as a more robust alternative for explicating commitments in actor-based systems, where actors achieve "agenthood" by competently processing commitment expressions like plans and contracts. Building on these ideas, Hewitt's 2009 work provided a historical analysis of logic programming's evolution, emphasizing its implications for robust computational inference. The paper traced the development from J.A. Robinson's resolution proving (1965), which offered a uniform procedure for but suffered from inefficiency and lack of inconsistency robustness, as it could derive contradictions from inconsistent premises via the principle of explosion. Hewitt highlighted his own Planner language (1969–1971) as a pioneering hybrid of procedural and logical elements, incorporating pattern-directed invocation, forward and , and backtracking for efficient AI applications like SHRDLU, while supporting true negation and strong negation-as-failure. In contrast, (1972 onward), developed by R. and A. Colmerauer, adopted a Horn-clause subset with and unification, simplifying syntax but restricting expressiveness and , which contributed to challenges in projects like Japan's . This analysis underscored the shift from procedural embedding in Planner to procedural interpretation in , advocating for greater inconsistency robustness to handle real-world knowledge representation. Hewitt extended these themes in his 2010 publication, integrating the with logical foundations for scalable, robust systems. The work posited the as a mathematical theory treating actors as universal primitives for concurrent computation, enabling , dynamic actor creation, and secure communication via types, with applications to systems like , web services, and locked objects. To address pervasive inconsistencies in large-scale information integration, Hewitt introduced Direct Logic VI, a paraconsistent extension of that omits explosive rules to prevent deriving all propositions from a single contradiction. Key principles included persistence (information endures until explicitly superseded), concurrency (simultaneous processing without global ), quasi-commutativity (order-independent approximations for ), sponsorship (assertions backed by authoritative sources), pluralism (multiple viewpoints coexist), and (tracking information origins). This framework supported inconsistency-robust reasoning without requiring consistency enforcement, proving computationally universal under the while avoiding undecidability in consistency checks; updated versions through the 2010s refined these for practical implementations like Orleans actors in distributed systems. Hewitt's arXiv works on Direct Logic and inconsistency-robust reasoning, such as his 2008 paper on formalizing for scalable information integration and his 2009 analysis of history, advanced robust mechanisms by incorporating elements of non-monotonic rules to manage evolving, inconsistent bases. These works built on earlier Direct Logic formulations by formalizing , where conclusions can be retracted upon new evidence without exploding into triviality, exemplified by rules like "typically, birds fly" overridden by specifics such as penguins. For instance, Hewitt demonstrated how such rules enable scalable argumentation semantics, allowing s to sponsor and challenge assertions in concurrent environments, such as integrating diverse data without halting on conflicts. This emphasized pluralism and to ensure inferences remain grounded, with examples illustrating quasi-commutative approximations for efficient in actor networks, thereby enhancing the model's applicability to real-time, decentralized systems. In later publications, such as "Strong Types for Direct Logic" (2017) and "Inconsistency Robustness in Foundations" (2017), Hewitt further developed these concepts for intelligent applications and mathematical foundations.

References

  1. https://www.santacruzsentinel.com/obituaries/carl-e-hewitt/
  2. https://archivesspace.mit.edu/repositories/2/resources/871
  3. https://www.ijcai.org/Proceedings/69/Papers/030.pdf
  4. https://dblp.org/rec/conf/ijcai/Hewitt69
  5. https://dl.acm.org/doi/10.1145/512927.512942
  6. https://dspace.mit.edu/bitstream/handle/1721.1/41962/AI_WP_134A.pdf
  7. https://dspace.mit.edu/bitstream/handle/1721.1/6460/AIM-945.pdf
  8. https://dspace.mit.edu/bitstream/handle/1721.1/6196/AIM-250.pdf?sequence=2
  9. http://www.bitsavers.org/pdf/mit/ai/aim/AITR-258.pdf
  10. https://projects.csail.mit.edu/films/aifilms/AIFilms.html
  11. https://news.mit.edu/2000/retirees-0712
  12. https://dspace.mit.edu/bitstream/handle/1721.1/52392/Hewitt_Perfect-Disruption.pdf?sequence=2
  13. https://mediax.stanford.edu/event/science-storytelling-the-art-of-the-interview/
  14. https://www.youtube.com/watch?v=A69umiVS3ic
  15. https://web.stanford.edu/class/ee380/Carl-Hewitt.pdf
  16. https://web.stanford.edu/class/ee380/Abstracts/Ee380-carl.hewitt.pdf
  17. https://www.youtube.com/watch?v=-DdRQNibqKk
  18. https://www.ijcai.org/proceedings/1969
  19. https://dl.acm.org/doi/10.5555/1624562.1624592
  20. https://papers.cumincad.org/data/works/att/a162.content.pdf
  21. https://arxiv.org/pdf/0904.3036v10
  22. https://www.sciencedirect.com/science/article/pii/S0004370210000494
  23. https://www.ijcai.org/Proceedings/73/Papers/027B.pdf
  24. https://www.amazon.ca/Inconsistency-Robustness-Carl-Hewitt/dp/1848901593
  25. https://arxiv.org/abs/0904.3036
  26. https://arxiv.org/abs/0812.4852
  27. http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf
  28. https://dl.acm.org/doi/10.1145/214427.214432
  29. https://www.theguardian.com/technology/2007/dec/09/wikipedia.internet
  30. https://www.cs.tufts.edu/~nr/cs257/archive/guy-steele/scheme.pdf
  31. https://arxiv.org/pdf/1008.1459
  32. https://doc.akka.io/libraries/akka-core/current/typed/guide/actors-motivation.html
  33. https://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency
  34. https://adabeat.com/fp/introduction-to-actor-model/
  35. https://www.cis.upenn.edu/~stevez/cis670/pdfs/pi-calculus.pdf
  36. https://www.mdpi.com/2227-7390/10/3/382
  37. https://thenewstack.io/can-the-50-year-old-actor-model-rescue-agentic-ai/
  38. https://arxiv.org/abs/2410.21793
  39. https://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-197.pdf
  40. https://www.researchgate.net/publication/220812785_A_Universal_Modular_ACTOR_Formalism_for_Artificial_Intelligence
  41. https://www.semanticscholar.org/paper/Actor-Model-of-Computation%253A-Scalable-Robust-Systems-Hewitt/762693415b205b075639fad6670b16e9f72d14cb
  42. https://dspace.mit.edu/handle/1721.1/6171
  43. https://www.sri.com/wp-content/uploads/2021/12/635.pdf
  44. https://urresearch.rochester.edu/fileDownloadForInstitutionalItem.action?itemId=5342&itemFileId=8258
  45. https://hal.science/hal-01148496v1/file/2-2-Hewitt-LogicPrograms.pdf
  46. https://www.csail.mit.edu/sites/default/files/2022-10/moses_memoirs.pdf
  47. https://arxiv.org/pdf/0904.3036v28
  48. http://dspace.mit.edu/bitstream/handle/1721.1/6196/AIM-250.pdf?sequence=2
  49. https://apps.dtic.mil/sti/tr/pdf/ADA038246.pdf
  50. https://arxiv.org/pdf/0904.3036
  51. https://hal.science/hal-01566393
  52. https://hal.science/hal-01148293
Add your contribution
Related Hubs
User Avatar
No comments yet.