Modelul Actor

De la Wikipedia, enciclopedia liberă
Salt la: Navigare, căutare

În știința calculatoarelor, modelul Actor este un model matematic de calcul concurent care tratează "actorii" ca primitivele universale de calcul digital concurent: un actor poate lua decizii locale, crea mai mulți actori, trimite mai multe mesaje, și determina cum să răspundă la următorul mesaj primit. Modelul Actor a fost creat în 1973. A fost folosit și ca framework pentru o înțelegere teoretică a calculului, și ca bază teoretică pentru mai multe aplicații practice a sistemelor concurente.

Istoric[modificare | modificare sursă]

Spre deosebire de modelele de calcul anterioare, modelul Actor a fost inspirat din fizică incluzând relativitatea generală și mecanica cuantică. A fost deasemenea influențat de limbaje de programare ca Lisp, Simula și versiunile de început ale Smalltalk, dar și de sisteme bazate pe capabilitate și comutație de pachete. Dezvoltarea sa a fost "motivată de un prospect de mașini de calcul înalt paralelizate conținând zeci, sute și chiar mii de microprocesoare independente, fiecare cu propria memorie locală și procesoare de comunicație, comunicând printr-o rețea de înaltă performanță." [1] De atunci, evoluția concurenței masive prin arhitecturi de calculatoare multi-core a retrezit interesul în modelul Actor.

Urmând publicația din 1973 a lui Hewitt, Bishop, și Steiger, Irene Greif a dezvoltat o semantică operațională pentru modelul Actor ca parte a cercetării sale doctorale.[2] Doi ani mai târziu, Henry Baker și Hewitt au publicat un set de legi axiomatice pentru sistemele Actor.[3] Alte momente majore în istorie includ dizertația lui William Clinger's, în 1981, introducând o semantică denotațională bazată pe domenii de putere[1] și dizertația lui Gul Agha din 1985 care a dezvoltat mai departe modelul semantic complementar modelui lui Clinger. Gul Agha (1986). Actors: A Model of Concurrent Computation in Distributed Systems. Doctoral Dissertation. MIT Press. https://dspace.mit.edu/handle/1721.1/6952. </ref> Aceasta a rezultat în dezvoltarea completă a teoriei modelului Actor.

Însă cea mai importantă implementare în software a fost facută de Russ Atkinson, Beppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Peter de Jong, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Richard Steiger, și Dan Theriault, în Message Passing Semantics Group la Massachusetts Institute of Technology (MIT). Grupurile de cercetare conduse de Chuck Seitz la California Institute of Technology (Caltech) și Bill Dally la MIT au construit arhitecturi ce au dezvoltat mai departe transferul mesajelor în model. Vedeți Implementarea modelului Actor.

Cercetări asupra modelului Actor au fost întreprinse la Caltech Computer Science, Kyoto University Tokoro Laboratory, MCC, MIT Artificial Intelligence Laboratory, SRI, Stanford University, University of Illinois at Urbana-Champaign Open Systems Laboratory, Pierre and Marie Curie University (University of Paris 6), University of Pisa, University of Tokyo Yonezawa Laboratory and elsewhere.

Concepte Fundamentale[modificare | modificare sursă]

Modelul Actor adoptă filosofia ca totul este un actor. Acesta este similar cu filosofia totul este un obiect folosită de unele dintre limbajele de programare, dar diferă prin faptul că software-ul orientat pe obiect este de obicei executat secvențial, în timp ce modelul Actor este prin esență concurent.

Un actor este o entitate computațională care, în răspuns la un mesaj recepționat, poate în mod concurent să:

  • trimită un număr finit de mesaje la alți actori;
  • creeze un număr finit de actori noi;
  • stabilească comportamentul folosit la următorul mesaj pe care îl recepționează;

Nu există o ordine precisă pentru acțiunile de mai sus și pot fi efectuate în paralel.

Decuplarea emițătorul de la comunicațiile trimise a fost o evoluție fundamentală către modelul Actor asigurând comunicația asincronă și structurile de control ca modele de mesaje transferate.[4]

Receptorii acestor mesaje sunt identificați după adresă, câteodată numită "mailing address". Deci un actor poate doar comunica cu actori ale căror adrese le cunoaște. Poate obține acestea dintr-un mesaj recepționat sau dacă adresa este pentru un actor care s-a creat singur.

Modelul Actor este caracterizat de concurența calculelor prin esența între și printre actori, crearea dinamică de actori, includerea adreselor de actori în mesaje și interacțiunea numai prin direct asynchronous message passing (comunicare asincronă) fără restricție asupra ordinii sosirii mesajelor.

Systeme Formale[modificare | modificare sursă]

De-a lungul anilor, mai multe sisteme formale diferite s-au dezvoltat și au început să permită gândiri despre sistemele în modelul Actor. Acestea includ:

Există de asemenea și formalisme care nu sunt compatibile total cu modelul Actor prin faptul că nu formalizează expedierea garantată a mesajelor incluzând următoarele ( Vedeți Attempts to relate Actor semantics to algebra and linear logic) (Încercări de a relaționa semantica modelului Actor cu algebra și logica liniară):

Aplicații[modificare | modificare sursă]

Modelul actor poate fi folosit ca un framework pentru modelare, înțelegerea și gândire despre o mare arie de sisteme concurente. De exemplu:

  • Poșta Electronică (e-mail) poate fi modelat ca un sistem Actor. Conturile sunt modelate ca Actori și email addresses ca adrese Actor.
  • Servicii Web pot fi modelate cu noduri SOAP ca adrese Actor.
  • Obiecte cu locks (de exemplu Java și C#) pot fi modelate ca Serializatoare, cu condiția ca implementarea lor să fie ca mesajele să sosească continuu ( de exemplu prin stocarea într-o coadă internă). Un serializator (serializer) este un tip important de Actor definit de proprietatea că e disponibil în mod continuu pentru sosirea noilor mesaje. Orice mesaj trimis către un serializator este garantat să ajungă.
  • Notarea Test și Controlul Testului (Testing and Test Control Notation (TTCN) ), ambele TTCN-2 și TTCN-3, urmează un model Actor de aproape. În TTCN, un Actor este o componența de test: ori un component de test în paralel (PTC - parallel test component) ori un component de test în principal ( MTC - main test component). Componentele de test pot trimite și recepționa mesaje către și dinspre parteneri de la distanță (componente test la peer sau interfețe de sisteme de test), ultimul fiind indentificat de adresa sa. Fiecare component de test are o diagramă de comportament legată de el. Componentele de test rulează în paralel și pot fi create dinamic de componentele de test părinte. Constructorii de limbă conținuți de ei asigură definirea acțiunilor ce trebuie întreprinse când un mesaj este recepționat de la o coadă de mesaje internă,

Modele precedente modelului Actor[modificare | modificare sursă]

Modelul actor se bazează pe modele anterioare de calcul.

Calculul Lambda[modificare | modificare sursă]

Calculul Lambda al lui Alonzo Church poate fi văzut ca cel dintâi limbaj de programare bazat pe transmiterea mesajelor ( message passing ). (vezi Hewitt, Bishop, and Steiger 1973; Abelson and Sussman 1985). De exemplu, expresia lambda de mai jos implementează o structură de arbore de date când îi sunt furnizați parametrii pentru un <țț>leftSubTree</țț> și un <țț>rightSubTree</țț>. Când acestui arbore îi este dat un mesaj parametru <țț>"getLeft"</țț>, el returnează <țț>leftSubTree</țț> și invers, dacă primește <țț>"getRight"</țț>, returnează <țț>rightSubTree</țț>.

 λ(leftSubTree,rightSubTree)
   λ(message)
     if (message == "getLeft") then leftSubTree
     else if (message == "getRight") then rightSubTree

Oricum, semantică calcului lambda este exprimată folosind substitutia de variabile în care valorile parametrilor sunt substituite în cod prin invocarea expresiilor lambda. Modelul de substituție este nepotrivit pentru concurență deoarece nu îngăduie capacitatea partajarii resurselor de schimbat. Inspirat de calculul lambda, interpreter pentru limbajul de programare Lisp face uz de o structură de date numită mediu în felul că valoarea parametrilor nu trebuie să fie substituită în corpul expresiilor lambda invocate. Această a dat voie la partajarea efectelor secundare cum ar fi updatarea structurilor de date partajate dar nu a îngăduit și concurența.

Simula[modificare | modificare sursă]

Simula 67 a fost un pioner în transmiterea mesajelor pentru calcule, motivat de aplicațiile de simulare a evenimentelor discrete. Aceste aplicații erau mari și nemodulare în limbile de simulare de dinainte. La fiecare pas, un larg și central program trebuia să fie rulat și să actualizeze fiecare obiect de simulare care se schimbau în funcție de stare obiectele care interacționau la fiecare pas. Kristen Nygaard și Ole-Johan Dahl au dezvoltat idea (prima dată descrisă în IFIP workshop în 1967) ca având metode pe fiecare obiect care își updateaza propria stare locală bazându-se pe mesaje de la alte obiecte. În adiție, au introdus o structură de clare pentru obiecte cu mostenire. Inovația lor a îmbunătățit în mod considerabil modularitatea programelor.

Totuși, Simula folosea o structură de control coroutine (corutină) în loc de concurență adevărată.

Smalltalk[modificare | modificare sursă]

Alan Kay a fost influențat de transmiterea mesajelor în invocarea direcției modelelor prin Planificator în dezvoltarea Smalltalk-71. Hewitt a fost interesat de Smalltalk-71 dar a renunțat datorită complexității comunicării care includerea invocări cu mai multe câmpuri incluzând global, sender, receiver, reply-style, status, reply, operator selector, etc.

În 1972 Kay a visitat MIT și discutat ideile sale despre Smalltalk-72 construind limbajul de programare Logo ajutat de Seymour Papert și modelul "little person" (persoană mică), model de calcul utilizat în predarea programării copiilor mici. Totuși, transmiterea mesajelor în Smalltalk-72 era destul de complex. Codul în acest limbaj era vizionat de interpretor ca simple stream-uri de tokene. După cum Dan Ingalls a descris mai târziu:

Primul (token) întâlnit (într-un program) era folosit într-un context dinamic, pentru a determina receptorul mesajelor următoare. Căutarea numelui începe cu dicționarul claselor a activării prezente. De acolo se mișcă către expeditorul acelei activări și continuă pe lanțul expeditorului. Când o legătură este găsită potrivită pentru token, valoarea lui devine receptorul noului mesaj, și interpretorul activează codul pentru clasă al acelui obiect.

De aici și modelul de transmitere a mesajelor din Smalltalk-72 este legat la un model mașina particulară și o sintaxă de limbaj de programare care nu se dedică concurenței.

Versiuni anterioare de Smalltalk au urmat calea folosirii metodelor virtuale din Simula în structura message-passing programelor. Totusi, Smalltalk-72 a folosit primitivele ca integrii, numere în format virgulă mobilă, iar etc ca obiecte. Autorii Simula au considerat transformarea astfel a primitelor dar s-au abținut să le folosească pe scară largă din motive de eficiență. Java la început a folosit un expedient având ambele primitive și versiuni de obiect ca integrii, numere format virgula mobilă, etc. Iar limbajul de programare C# (și verisiuni mai recente de java, începând cu Java 1.5) au adoptat soluția mai puțin elegantă de a folosi boxing și unboxing, o variantă folosită mai devreme în implementările Lisp.

Sistemul Smalltalk a devenit foarte influent, inovând în afișările bitmap, calcul personal (PC), interfețe de browser de clase și multe alte căi. Pentru detalii vizitați Kay's The Early History of Smalltalk.[12] Între timp, eforturile pentru modelul Actor la MIT au rămas concentrate pe dezvoltarea științei și ingineriei la nivel înalt de concurență. (Vedeți cartea lui Jean-Pierre Briot pentru idei care au fost dezvoltate mai tărziu despre încorporarea anumitor tipuri de concurență Actor în ultimele versiuni de Smalltalk)

Rețele Petri[modificare | modificare sursă]

Înainte de apariția modelului Actor, Rețelele Petri erau larg folosite în modelul de calcul nondeterministic. Oricum, ele erau larg cunoscute ca având limitări importante:

  • ele modelau flowul de control dar nu și cel de date
  • în consecință, ele nu erau composabile, deci erau limitate în modularitate.

Hewit a accentuat o altă dificultate a rețelelor Petri: Acțiunea simultană. De exemplu pasul atomic de calcul în rețele Petri este o tranziție în care tokenurile dispar simultan din locurile de input ale tranzițiilor și apar în locurile de output. Baza fizică de a folosi primitive pentru acest tip de simultaneitate îi părea conflictuala. În ciuda aparentelor dificultăți, rețelele Petri continuă să fie o abordare populară în modelarea concurenței, și sunt încă un subiect de studiu activ.

Threads, locks și buffers (channels)[modificare | modificare sursă]

Înainte de modelul Actor, concurența era definită în termeni de low-level machine ca threads, locks și buffers(channels). Cu siguranță este cazul ca implementarea modelului Actor să facă uz de aceste capacități hardware. Totuși, nu există motiv ca modelul să nu poată fi implementat direct în hardware fără a expune threaduri hardware și locks. DE asemenea, nu există o relație obligatorie între numărul de Actori, threaduri, lockuri, relație care ar putea fi implicată în calcul. Implementările modelului Actor sunt libere să folosească threaduri și lockuri în orice fel este dorit și este compatibil cu legile pentru Actori.

Semantica Transmiterii mesajelor (Message-passing)[modificare | modificare sursă]

Modelul Actor este despre semantica transmiterii mesajelor.

Controversa nondeterministă[modificare | modificare sursă]

Primele programe concurente au fost interrupt handlers. În timpul operării normale, un calculator trebuie să primească informație din exterior (caractere de la tastatură, pachete din rețea, etc.). Și când informația ajunge, execuția calculatorului este "întreruptă" și codul special chemat handler de întrerupere este rulat pentru a așeza informația într-un buffer de unde poate fi retrasă mai târziu.

În anii 1960, întreruperile au început să fie folosite să simuleze execuția concurentă a mai multor programe pe un singur procesor.[13]

Având concurență cu memorie partajată, s-a născut problema controlului de concurență. Original, această problemă era privită ca fiind una dintre excusiunile mutuale pe un singur calculator. Edsger Dijkstra a dezvoltat semafoarele și mai târziu, între 1971 și 1973,[14] Tony Hoare[15] si Per Brinch Hansen[16] developed monitors, pentru a rezolva problema excluziunii mutuale. Totuși, nici una dintre soluțiile aduse nu a dat o structură pentru un limbaj de programare care încapsulează accesul la resursele partajate. Această încapsulare a venit mai târziu printr-un serializer construct ([Hewitt and Atkinson 1977, 1979] and [Atkinson 1980]).

Primele modele de calcul (e.g. Turing machines, Post productions, the lambda calculus, etc.) au fost bazate pe matematică și folosesc o stare globală să reprezinte un pas computațional (mai târziu generalizat în [McCarthy and Hayes 1969] și [Dijkstra 1976]. Starea globală a fost continuată în teoria automatelor pentru mașinile cu stări finite și mașinile cu stive push down. Astfel de automate nondeterministice au proprietatea ca nondeterminism nelegat. Adică, dacă o mașină întotdeauna se oprește când este pornită în starea sa inițială, atunci este o limită asupră numărului de stări pe care le poate avea.

Edsger Dijkstra a dezvoltat mai departe conceptul de abordare de stare globală nondeterministică și a generat o controversă numită nedeterminism nelegat (sau nedeterminare nelegată, și este o proprietate prin care cantitatea de întârziere pentru o cerere poate deveni fără limită ca un rezultat al arbitrării pentru partajarea resurselor încă garantând că cererea va fi îndeplinită cândva.

Modelul Actor conferă nondeterminism nelegat care a fost capturat în modelul matematic de Will Clinger folosit teoria domeniilor.[1] Deci nu este o stare globală în modelul Actor.

Comunicarea directă și asincronismul[modificare | modificare sursă]

Mesajele în modelul Actor nu sunt trecute prin buffer în mod obligatoriu. Deasemenea, mesajele sunt transmise direct și simplu (de exemplu prin pachete prin protoculul IP. Nu există nici o cerință pentru un handshake obligatoriu cu receptorul.

Crearea Actorilor și a adreselor în mesaje înseamnă topologie variabilă[modificare | modificare sursă]

O dezvoltare naturală a modelului Actor este să permită adrese în mesaje. Totuși Hewitt a dorit să poate fi trimise și mesaje goale (fără adresă).

Concurență înnăscută[modificare | modificare sursă]

Modelul Actor a fost construit ca un model cu concurență înnascută. În acest model, secvențialitatea e un caz special derivat din calculul concurent.

Nici o restricționare asupra ordinii primirii mesajelor[modificare | modificare sursă]

Hewitt a fost de părere că mesajele nu trebuie să ajungă în ordinea trimiterii lor. Dacă se dorește o restricționare de tip FIFO de exemplu, se poate modela un Actor Coada (Queue) care aranjează mesajele în ordinea sosirii lor. Dacă un actor X trimite un mesaj M1 la un actor Y, și mai târziu trimite alt mesaj M2, nu este nici o cerință ca M1 să ajungă la Y înaintea lui M2

Localitatea[modificare | modificare sursă]

Localitatea înseamnă că în procesarea unui mesaj, Actorul receptor poate trimite mesaje numai adreselor conținute în mesaj, adreselor pe care le avea înainte de a sosi mesajul sau adreselor pentru Actorii pe care îi creează în timpul procesării mesajului. Synthesizing Addresses of Actors.

Compunând Sisteme Actor[modificare | modificare sursă]

Ideea de a compune sisteme Actor în altele mai mari este un important aspect din modularitate. (tratat în dizertația lui Gul Agha [7] și cercetată mai târziu de Gul Agha, Ian Mason, Scott Smith, and Carolyn Talcott.[5]

Comportamente[modificare | modificare sursă]

O inovație cheie a fost introducerea comportamentelor specificate ca funcții matematice să exprime ce face un Actor când procesează un mesaj incluzând un nou comportament de procesat în următorul mesaj care sosește. Comportamentele aduc mecanisme pentru a modela matematic partajarea în concurență.

Comportamentele deasemenea au eliberat modelul Actor de detaliile implementării, cum sunt interpretoarele de la Smalltalk. Oricum, este critic de înțeles că implementarea eficientă a sistemelor descrise de modelul Actor să ceară optimizări extensive.

Teorema de reprezentare computațională[modificare | modificare sursă]

În modelul Actor există o teoremă de reprezentare a calculelor pentru sisteme închise (care nu primesc comunicații din exterior). Denotarea matematică pentru un sistem închis S este construită pentru un comportament inițial S și o funcție comportamentală de aproximare progressionS. Acestea obțin aproximări mult mai bune și construiesc o denotare ( inteles) pentru S după cum urmează:

DenotaS ≡ ⊔i∈ω progressionSi(⊥S)

Astfel, S poate fi matematic caracterizat în termeni de toate comportamentele posibile. Deși DenoteS nu este o implementare a S, poate fi folosit să demonstreze generalizarea tezei Church-Turing-Rosser-Kleene [Kleene 1943]:

Teorema Enumerării: Dacă Actorii primitivi ai unui sistem Actor închis sunt eficienți, atunci ieșirile posibile sunt enumerabile.
Demonstrație: Din teorema reprezentării.

Migrație[modificare | modificare sursă]

Migrarea în modelul Actor este abilitatea Actorilor de a-și schimba locația.

Securitatea[modificare | modificare sursă]

Securitatea modelului înseamnă:

Sintetizând adresele actorilor[modificare | modificare sursă]

O problemă delicată este sintetizarea adreselor actorilor. Din motive de securitate se dorește ascunderea acestora dar fiind doar simple stringuri de biți, acestea pot fi ghicite, dacă sunt suficient de mici. SOAP folosește URL (Uniform Resourse Locator) pentru adresa actorilor. Cum acesta este un string de caractere, este evident că poate fi sintetizat. Dar criptarea face acest lucru virtual imposibil.

Sintetizarea adreselor actorilor se modelează de obicei folosind maparea. Ideea e să folosești sisteme Actor pentru a face maparea adreselor Actor. De exemplu, modelarea memoriei unui calculator poate fi considerată ca făcută de un sistem Actor care face maparea.

Savanți în modelul Actor[modificare | modificare sursă]

Contributori importanți sunt: Gul Agha, Beppe Attardi, Henry Baker, Will Clinger, Irene Greif, Carl Hewitt, Carl Manning, Ian Mason, Ugo Montanari, Maria Simi, Scott Smith, Carolyn Talcott, Prasanna Thati, and Aki Yonezawa, Bill Athas, Russ Atkinson, Beppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Nanette Boden, Jean-Pierre Briot, Bill Dally, Peter de Jong, Jessie Dedecker, Travis Desell, Ken Kahn, Carl Hewitt, Henry Lieberman, Carl Manning, Tom Reinhardt, Chuck Seitz, Richard Steiger, Dan Theriault, Mario Tokoro, Carlos Varela, Darrell Woelk.

Programând cu Actori[modificare | modificare sursă]

Un număr de limbaje de programare includ model Actor sau diverse variațiuni. Unele dintre acestea sunt:

Limbaje de programare timpurii[modificare | modificare sursă]

Limbaje de programare târzii[modificare | modificare sursă]

Librării Actor și Frameworks[modificare | modificare sursă]

Librăriile Actor și frameworks au fost de altfel implementate să permită programarea în stil actor în limbi care nu au actori integrați. Unele sunt:

  • Akka - A Java and Scala framework with Actors, STM & Transactors
  • Ateji PX - Ateji PX provides an Actor Model for Java
  • Korus - A Java parallel and distributed programming framework based on Actor Model
  • Kilim - a message-passing framework for Java[29]
  • ActorFoundry - a Java library for Actor programming
  • Retlang for .NET
  • Jetlang for Java
  • Haskell-Actor for Haskell
  • GPars - the concurrency and actor library for Groovy (was GParallelizer)
  • PARLEY - The Python Actor Runtime Library
  • PYKKA - The Python Actor Library inspired by Akka
  • Termite Scheme - provides Erlang-like concurency for the Gambit implementation of Scheme
  • Theron - provides an Actor Model for C++.
  • S4 , a distributed, scalable platform featuring many aspects of the Actors Model.

Vezi și[modificare | modificare sursă]

Referințe[modificare | modificare sursă]

  1. ^ a b c d William Clinger (1 iunie 1981). Foundations of Actor Semantics. Mathematics Doctoral Dissertation. MIT. https://dspace.mit.edu/handle/1721.1/6935. 
  2. ^ a b Irene Greif (1 august 1975). Semantics of Communicating Parallel Processes. EECS Doctoral Dissertation. MIT. 
  3. ^ a b Henry Baker (1 august 1977). Laws for Communicating Parallel Processes. IFIP. 
  4. ^ Carl Hewitt. Viewing Control Structures as Patterns of Passing Messages Journal of Artificial Intelligence. June 1977.
  5. ^ a b Gul Agha (1 ianuarie 1993). „A Foundation for Actor Computation”. Journal of Functional Programming. 
  6. ^ Carl Hewitt (27 aprilie 2006) (PDF). What is Commitment? Physical, Organizational, and Social. COIN@AAMAS. http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf. 
  7. ^ Eroare la citare: Etichetă <ref> invalidă; niciun text nu a fost furnizat pentru ref-urile numite agha1986
  8. ^ Mauro Gaspari (1 mai 1997). An Algebra of Actors. Technical Report UBLCS-97-4. University of Bologna. 
  9. ^ M. Gaspari (1999). An Algebra of Actors. Formal Methods for Open Object Based Systems. 
  10. ^ Gul Agha (2004) (PDF). An Algebraic Theory of Actors and Its Application to a Simple Object-Based Language. From OO to FM (Dahl Festschrift) LNCS 2635. http://formal.cs.uiuc.edu/papers/ATactors_festschrift.pdf. 
  11. ^ John Darlington (1994). Formalizing Actors in Linear Logic. International Conference on Object-Oriented Information Systems. 
  12. ^ Kay, Alan (1 martie 1993). „The Early History of Smalltalk” (PDF). ACM SIGPLAN 28 (3): 69–75. doi:10.1145/155360.155364. http://www.smalltalk.org/downloads/papers/SmalltalkHistoryHOPL.pdf. 
  13. ^ Brinch-Hansen, Per (2002). The Origins of Concurrent Programming: From Semaphores to Remote Procedure Calls. Springer. ISBN 978-0-387-95401-1 
  14. ^ Per Brinch Hansen, Monitors and Concurrent Pascal: A Personal History, Comm. ACM 1996, pp 121-172
  15. ^ C.A.R. Hoare, Monitors: An Operating System Structuring Concept, Comm. ACM Vol. 17, No. 10. October 1974, pp. 549-557
  16. ^ Brinch Hansen, P., Operating System Principles, Prentice-Hall, July 1973.
  17. ^ Henry Lieberman (1 iunie 1981). A Preview of Act 1. MIT AI memo 625. ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-625.pdf. 
  18. ^ Henry Lieberman (1 iunie 1981). Thinking About Lots of Things at Once without Getting Confused: Parallelism in Act 1. MIT AI memo 626. ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-626.pdf. 
  19. ^ Jean-Pierre Briot. Acttalk: A framework for object-oriented concurrent programming-design and experience 2nd France-Japan workshop. 1999.
  20. ^ Ken Kahn. A Computational Theory of Animation MIT EECS Doctoral Dissertation. August 1979.
  21. ^ William Athas and Nanette Boden Cantor: An Actor Programming System for Scientific Computing in Proceedings of the NSF Workshop on Object-Based Concurrent Programming. 1988. Special Issue of SIGPLAN Notices.
  22. ^ Darrell Woelk. Developing InfoSleuth Agents Using Rosette: An Actor Based Language Proceedings of the CIKM '95 Workshop on Intelligent Information Agents. 1995.
  23. ^ Dedecker J., Van Cutsem T., Mostinckx S., D'Hondt T., De Meuter W. Ambient-oriented Programming in AmbientTalk. In “Proceedings of the 20th European Conference on Object-Oriented Programming (ECOOP), Dave Thomas (Ed.), Lecture Notes in Computer Science Vol. 4067, pp. 230-254, Springer-Verlag.”, 2006
  24. ^ http://www.eweek.com/c/a/Application-Development/Microsoft-Cooking-Up-New-Parallel-Programming-Language-Axum-868670/
  25. ^ http://www.dalnefre.com/wp/humus/
  26. ^ Carlos Varela and Gul Agha (2001). „Programming Dynamically Reconfigurable Open Systems with SALSA”. ACM SIGPLAN Notices. OOPSLA’2001 Intriguing Technology Track Proceedings 36. 
  27. ^ Philipp Haller and Martin Odersky (1 septembrie 2006) (PDF). Event-Based Programming without Inversion of Control. Proc. JMLC 2006. http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf. 
  28. ^ Philipp Haller and Martin Odersky (1 ianuarie 2007) (PDF). Actors that Unify Threads and Events. Technical report LAMP 2007. http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf. 
  29. ^ Srinivasan, Sriram; Alan Mycroft (2008). „Kilim: Isolation-Typed Actors for Java” (PDF). European Conference on Object Oriented Programming ECOOP 2008. Cyprus. http://www.malhar.net/sriram/kilim/kilim_ecoop08.pdf. Accesat la 24 iulie 2008. .

Lecturi Adiacente[modificare | modificare sursă]

  • Stephen Kleene Recursive Predicates and Quantifiers American Mathematical Society Transactions. 1943.
  • Paul Baran. On Distributed Communications Networks IEEE Transactions on Communications Systems. March 1964.
  • Peter Landin. A Generalization of Jumps and Labels Report. UNIVAC Systems Programming Research. August 1965. Reprinted in Higher Order and Symbolic Computation. 1998.
  • Edsger Dijkstra Solution of a Problem in Concurrent Programming Control CACM. 1965.
  • Jack Dennis and Earl Van Horn. Programming Semantics for Multiprogrammed Computations CACM. March 1966.
  • Ole-Johan Dahl and Kristen Nygaard. Class and subclass declarations IFIP TC2 Conference on Simulation Programming Languages. May 1967.
  • Carl Hewitt. PLANNER: A Language for Proving Theorems in Robots IJCAI 1969
  • William A. Woods. Transition network grammars for natural language analysis CACM. 1970.
  • Terry Winograd. Procedures as a Representation for Data in a Computer Program for Understanding Natural Language MIT AI TR-235. January 1971.
  • Carl Hewitt. Procedural Embedding of Knowledge In Planner IJCAI 1971.
  • G.M. Birtwistle, Ole-Johan Dahl, B. Myhrhaug and Kristen Nygaard. SIMULA Begin Auerbach Publishers Inc, 1973.
  • Daniel Bobrow: A Model for Control Structures for Artificial Intelligence Programming Languages IJCAI 1973.
  • Carl Hewitt, et al. Actor Induction and Meta-evaluation Conference Record of ACM Symposium on Principles of Programming Languages, January 1974.
  • Carl Hewitt, et al. Behavioral Semantics of Nonrecursive Control Structure Proceedings of Colloque sur la Programmation, April 1974.
  • Irene Greif and Carl Hewitt. Actor Semantics of PLANNER-73 Conference Record of ACM Symposium on Principles of Programming Languages. January 1975.
  • Carl Hewitt. How to Use What You Know IJCAI. September, 1975.
  • Alan Kay and Adele Goldberg. Smalltalk-72 Instruction Manual Xerox PARC Memo SSL-76-6. May 1976.
  • Edsger Dijkstra. A discipline of programming Prentice Hall. 1976.
  • Carl Hewitt and Henry Baker Actors and Continuous Functionals Proceeding of IFIP Working Conference on Formal Description of Programming Concepts. August 1–5, 1977.
  • Henry Baker and Carl Hewitt The Incremental Garbage Collection of Processes Proceeding of the Symposium on Artificial Intelligence Programming Languages. SIGPLAN Notices 12, August 1977.
  • Gilles Kahn and David MacQueen. Coroutines and networks of parallel processes IFIP. 1977
  • Aki Yonezawa Specification and Verification Techniques for Parallel Programs Based on Message Passing Semantics MIT EECS Doctoral Dissertation. December 1977.
  • Henry Baker. Actor Systems for Real-Time Computation MIT EECS Doctoral Dissertation. January 1978.
  • Carl Hewitt and Russ Atkinson. Synchronization in Actor Systems Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. 1977
  • Carl Hewitt and Russ Atkinson. Specification and Proof Techniques for Serializers IEEE Journal on Software Engineering. January 1979.
  • Ken Kahn. A Computational Theory of Animation MIT EECS Doctoral Dissertation. August 1979.
  • Carl Hewitt, Beppe Attardi, and Henry Lieberman. Delegation in Message Passing Proceedings of First International Conference on Distributed Systems Huntsville, AL. October 1979.
  • Nissim Francez, C.A.R. Hoare, Daniel Lehmann, and Willem-Paul de Roever. Semantics of nondetermiism, concurrency, and communication Journal of Computer and System Sciences. December 1979.
  • George Milne and Robin Milner. Concurrent processes and their syntax JACM. April 1979.
  • Russ Atkinson. Automatic Verification of Serializers MIT Doctoral Dissertation. June, 1980.
  • Bill Kornfeld and Carl Hewitt. The Scientific Community Metaphor IEEE Transactions on Systems, Man, and Cybernetics. January 1981.
  • Bill Kornfeld. Parallelism in Problem Solving MIT EECS Doctoral Dissertation. August 1981.
  • Daniel Theriault. A Primer for the Act-1 Language MIT AI memo 672. April 1982.
  • Daniel Theriault. Issues in the Design and Implementation of Act 2 MIT AI technical report 728. June 1983.
  • Henry Lieberman. An Object-Oriented Simulator for the Apiary Conference of the American Association for Artificial Intelligence, Washington, D. C., August 1983
  • Carl Hewitt and Peter de Jong. Analyzing the Roles of Descriptions and Actions in Open Systems Proceedings of the National Conference on Artificial Intelligence. August 1983.
  • Carl Hewitt and Henry Lieberman. Design Issues in Parallel Architecture for Artificial Intelligence MIT AI memo 750. Nov. 1983.
  • Daniel Ingalls. The Evolution of the Smalltalk Virtual Machine in Smalltalk-80: Bits of History, Words of Advice. Addison Wesley. 1983.
  • Hal Abelson, Gerald Jay Sussman and Julie Sussman, Structure and Interpretation of Computer Programs MIT Press and McGraw-Hill, 1985.
  • C.A.R. Hoare. Communicating Sequential Processes Prentice Hall. 1985.
  • Carl Hewitt. The Challenge of Open Systems Byte Magazine. April 1985. Reprinted in The foundation of artificial intelligence---a sourcebook Cambridge University Press. 1990.
  • Carl Manning. Traveler: the actor observatory ECOOP 1987. Also appears in Lecture Notes in Computer Science, vol. 276.
  • William Athas and Charles Seitz Multicomputers: message-passing concurrent computers IEEE Computer August 1988.
  • William Athas and Nanette Boden Cantor: An Actor Programming System for Scientific Computing in Proceedings of the NSF Workshop on Object-Based Concurrent Programming. 1988. Special Issue of SIGPLAN Notices.
  • 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
  • William Dally and Wills, D. Universal mechanisms for concurrency PARLE 1989.
  • W. Horwat, A. Chien, and W. Dally. Experience with CST: Programming and Implementation PLDI. 1989.
  • Carl Hewitt. Towards Open Information Systems Semantics Proceedings of 10th International Workshop on Distributed Artificial Intelligence. October 23–27, 1990. Bandera, Texas.
  • Akinori Yonezawa, Ed. ABCL: An Object-Oriented Concurrent System MIT Press. 1990.
  • K. Kahn and Vijay A. Saraswat, "Actors as a special case of concurrent constraint (logic) programming", in SIGPLAN Notices, October 1990. Describes Janus.
  • Carl Hewitt. Open Information Systems Semantics Journal of Artificial Intelligence. January 1991.
  • 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 and Gul Agha. Guarded Horn clause languages: are they deductive and Logical? International Conference on Fifth Generation Computer Systems, Ohmsha 1988. Tokyo. Also in Artificial Intelligence at MIT, Vol. 2. MIT Press 1991.
  • William Dally, et al. The Message-Driven Processor: A Multicomputer Processing Node with Efficient Mechanisms IEEE Micro. April 1992.
  • S. Miriyala, G. Agha, and Y.Sami. Visulatizing actor programs using predicate transition nets Journal of Visual Programming. 1992.
  • Alan Kay. The Early History of Smalltalk The second ACM conference on history of programming languages. 1993.
  • Carl Hewitt and Carl Manning. Negotiation Architecture for Large-Scale Crisis Management AAAI-94 Workshop on Models of Conflict Management in Cooperative Problem Solving. Seattle, WA. Aug. 4, 1994.
  • Darrell Woelk. Developing InfoSleuth Agents Using Rosette: An Actor Based Language Proceedings of the CIKM '95 Workshop on Intelligent Information Agents. 1995.
  • Carl Hewitt and Carl Manning. Synthetic Infrastructures for Multi-Agency Systems Proceedings of ICMAS '96. Kyoto, Japan. December 8–13, 1996.
  • S. Frolund. Coordinating Distributed Objects: An Actor-Based Approach for Synchronization MIT Press. November 1996.
  • W. Kim. ThAL: An Actor System for Efficient and Scalable Concurrent Computing PhD thesis. University of Illinois at Urbana Champaign. 1997.
  • Jean-Pierre Briot. Acttalk: A framework for object-oriented concurrent programming-design and experience 2nd France-Japan workshop. 1999.
  • N. Jamali, P. Thati, and G. Agha. An actor based architecture for customizing and controlling agent ensembles IEEE Intelligent Systems. 14(2). 1999.
  • Don Box, David Ehnebuske, Gopal Kakivaya, Andrew Layman, Noah Mendelsohn, Henrik Nielsen, Satish Thatte, Dave Winer. Simple Object Access Protocol (SOAP) 1.1 W3C Note. May 2000.
  • M. Astley, D. Sturman, and G. Agha. Customizable middleware for modular distributed software CACM. 44(5) 2001.
  • Carlos Varela. Worldwide Computing with Universal Actors: Linguistic Abstractions for Naming, Migration, and Coordination PhD thesis. U. of Illinois at Urbana-Champaign. 2001.
  • N. Venkatasubramanian, C. Talcott, and G. Agha. A formal model for reasoning about adaptive QoS-enabled middleware Formal Methods Europe (FME). 2001.
  • Edward Lee, S. Neuendorffer, and M. Wirthlin. Actor-oriented design of embedded hardware and software systems Journal of circuits, systems, and computers. 2002.
  • P. Thati, R. Ziaei, and G. Agha. A Theory of May Testing for Actors Formal Methods for Open Object-based Distributed Systems. March 2002.
  • P. Thati, R. Ziaei, and G. Agha. A theory of may testing for asynchronous calculi with locality and no name matching Algebraic Methodology and Software Technology. Springer Verlag. September 2002. LNCS 2422.
  • Gul Agha and Carlos Varela. Worldwide Computing Middleware Practical Handbook on Internet Computing. CRC Press, 2004.
  • Stephen Neuendorffer. Actor-Oriented Metaprogramming PhD Thesis. University of California, Berkeley. December, 2004
  • Carl Hewitt (2006a) The repeated demise of logic programming and why it will be reincarnated What Went Wrong and Why: Lessons from AI Research and Applications. Technical Report SS-06-08. AAAI Press. March 2006.
  • Carl Hewitt (2006b) What is Commitment? Physical, Organizational, and Social COIN@AAMAS. April 27, 2006b.
  • Carl Hewitt (2007a) What is Commitment? Physical, Organizational, and Social (Revised) Pablo Noriega .et al. editors. LNAI 4386. Springer-Verlag. 2007.
  • Carl Hewitt (2007b) Large-scale Organizational Computing requires Unstratified Paraconsistency and Reflection COIN@AAMAS'07.

Legături externe[modificare | modificare sursă]

  • Actors on the JVM Dr. Dobb's, April 2011
  • A now dated set of speculations by Paul Mackay can be found at Why has the actor model not succeeded?
  • JavAct - a Java library for programming concurrent, distributed, and mobile applications using the actor model (and open implementation principles).
  • Functional Java - a Java library of that includes an implementation of concurrent actors with code examples in standard Java and Java 7 BGGA style.
  • ActorFoundry - a Java-based library for Actor programming. The familiar Java syntax, an ant build file and a bunch of example make the entry barrier very low.
  • ActiveJava - a prototype Java language extension for Actor programming.