Bibliography C# .NET DevOps Software Engineering

C# in Depth, Fourth Edition  – ISBN-13: 978-1617294532

See: C# in Depth, Fourth Edition 

Fair Use Source:

Effective techniques and experienced insights to maximize your C# 6 and 7 programming skills

Key Features

Written by C# legend and top StackOverflow contributor Jon Skeet
Unlock the new features of C# 6 and 7
Insights on the future of the C# language
Master asynchronous functions, interpolated strings, tuples, and more

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

”An excellent overview of C# with helpful and realistic examples that make learning the newest features of C# easy.” —Meredith Godar

About The Book
C# is the foundation of .NET development. New features added in C# 6 and 7 make it easier to take on big data applications, cloud-centric web development, and cross-platform software using .NET Core. Packed with deep insight from C# guru Jon Skeet, this book takes you deep into concepts and features other C# books ignore.

C# in Depth, Fourth Edition is an authoritative and engaging guide that reveals the full potential of the language, including the new features of C# 6 and 7. It combines deep dives into the C# language with practical techniques for enterprise development, web applications, and systems programming. As you absorb the wisdom and techniques in this book, you’ll write better code, and become an exceptional troubleshooter and problem solver.

What You Will Learn

Comprehensive guidance on the new features of C# 6 and 7
Important legacies and greatest hits of C# 2–5
Expression-bodied members
Extended pass-by-reference functionality
Writing asynchronous C# code
String interpolation
Composition with tuples
Decomposition and pattern matching

This Book Is Written For
For intermediate C# developers. 

About The Author
Jon Skeet is a senior software engineer at Google. He studied mathematics and computer science at Cambridge, is a recognized authority in Java and C#, and maintains the position of top contributor to Stack Overflow.

Table of Contents

1. Survival of the sharpest
2. C# 2
3. C# 3: LINQ and everything that comes with it
4. C# 4: Improving interoperability
5. Writing asynchronous code
6. Async implementation
7. C# 5 bonus features
8. Super-sleek properties and expression-bodied members
9. Stringy features
10. A smörgåsbord of features for concise code
11. Composition using tuples
12. Deconstruction and pattern matching
13. Improving efficiency with more pass by reference
14. Concise code in C# 7
15. C# 8 and beyond


PART 2 C# 2–5

PART 3 C# 6


Bibliography C# .NET Software Engineering

B08S42DWN9 – 978-1484261798

See: Design Patterns in .NET Core 3: Reusable Approaches in C# and F# for Object-Oriented Software Design 2nd ed. Edition

Fair Use Source:

Bibliography C# .NET DevOps JavaScript Software Engineering

B01N3C5ECP ISBN-13: 978-1787286610

See: Continuous Integration, Delivery, and Deployment: Reliable and faster software releases with automating builds, tests, and deployment, Publisher ‏ : ‎ Packt Publishing (October 30, 2017)

Fair Use Source:

Bibliography C# .NET DevOps DevSecOps-Security-Privacy Java Software Engineering


See: Complete Guide to Test Automation: Techniques, Practices, and Patterns for Building and Maintaining Effective Software Projects 1st ed. Edition, Kindle Edition

Fair Use Source:

Bibliography C# .NET C++ DevOps DevSecOps-Security-Privacy PowerShell Software Engineering Windows Desktop Windows Server


See: How We Test Software at Microsoft 1st Edition

Fair Use Source:

Bibliography C# .NET Software Engineering


See: Code Complete (Developer Best Practices) 2nd Edition

Fair Use Source:

C# .NET Java Software Engineering

Actor model – Actor-based concurrency

” (WP)

The actor model in computer science is a mathematical model of concurrent computation that treats actor as the universal primitive of concurrent computation. In response to a message it receives, an actor can: make local decisions, create more actors, send more messages, and determine how to respond to the next message received. Actors may modify their own private state, but can only affect each other indirectly through messaging (removing the need for lock-based synchronization).

The actor model originated in 1973.[1] It has been used both as a framework for a theoretical understanding of computation and as the theoretical basis for several practical implementations of concurrent systems. The relationship of the model to other work is discussed in actor model and process calculi.


Main article: History of the Actor model

According to Carl Hewitt, unlike previous models of computation, the actor model was inspired by physics, including general relativity and quantum mechanics.[citation needed] It was also influenced by the programming languages LispSimula, early versions of Smalltalkcapability-based systems, and packet switching. Its development was “motivated by the prospect of highly parallel computing machines consisting of dozens, hundreds, or even thousands of independent microprocessors, each with its own local memory and communications processor, communicating via a high-performance communications network.”[2] Since that time, the advent of massive concurrency through multi-core and manycore computer architectures has revived interest in the actor model.

Following Hewitt, Bishop, and Steiger’s 1973 publication, Irene Greif developed an operational semantics for the actor model as part of her doctoral research.[3] Two years later, Henry Baker and Hewitt published a set of axiomatic laws for actor systems.[4][5] Other major milestones include William Clinger’s 1981 dissertation introducing a denotational semantics based on power domains[2] and Gul Agha‘s 1985 dissertation which further developed a transition-based semantic model complementary to Clinger’s.[6] This resulted in the full development of actor model theory.

Major software implementation work was done by Russ Atkinson, Giuseppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Peter de Jong, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Richard Steiger and Dan Theriault in the Message Passing Semantics Group at Massachusetts Institute of Technology (MIT). Research groups led by Chuck Seitz at California Institute of Technology (Caltech) and Bill Dally at MIT constructed computer architectures that further developed the message passing in the model. See Actor model implementation.

Research on the actor model has been carried out at California Institute of TechnologyKyoto University Tokoro Laboratory, Microelectronics and Computer Technology Corporation (MCC), MIT Artificial Intelligence LaboratorySRIStanford UniversityUniversity of Illinois at Urbana–Champaign,[7] Pierre and Marie Curie University (University of Paris 6), University of PisaUniversity of Tokyo Yonezawa Laboratory, Centrum Wiskunde & Informatica (CWI) and elsewhere.

Fundamental concepts

The actor model adopts the philosophy that everything is an actor. This is similar to the everything is an object philosophy used by some object-oriented programming languages.

An actor is a computational entity that, in response to a message it receives, can concurrently:

  • send a finite number of messages to other actors;
  • create a finite number of new actors;
  • designate the behavior to be used for the next message it receives.

There is no assumed sequence to the above actions and they could be carried out in parallel.

Decoupling the sender from communications sent was a fundamental advance of the actor model enabling asynchronous communication and control structures as patterns of passing messages.[8]

Recipients of messages are identified by address, sometimes called “mailing address”. Thus an actor can only communicate with actors whose addresses it has. It can obtain those from a message it receives, or if the address is for an actor it has itself created.

The actor model is characterized by inherent concurrency of computation within and among actors, dynamic creation of actors, inclusion of actor addresses in messages, and interaction only through direct asynchronous message passing with no restriction on message arrival order.

Formal systems

Over the years, several different formal systems have been developed which permit reasoning about systems in the actor model. These include:

There are also formalisms that are not fully faithful to the actor model in that they do not formalize the guaranteed delivery of messages including the following (See Attempts to relate actor semantics to algebra and linear logic):


This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: “Actor model” – news · newspapers · books · scholar · JSTOR (December 2006) (Learn how and when to remove this template message)

The actor model can be used as a framework for modeling, understanding, and reasoning about a wide range of concurrent systems. For example:

  • Electronic mail (email) can be modeled as an actor system. Accounts are modeled as actors and email addresses as actor addresses.
  • Web services can be modeled with Simple Object Access Protocol (SOAP) endpoints modeled as actor addresses.
  • Objects with locks (e.g., as in Java and C#) can be modeled as a serializer, provided that their implementations are such that messages can continually arrive (perhaps by being stored in an internal queue). A serializer is an important kind of actor defined by the property that it is continually available to the arrival of new messages; every message sent to a serializer is guaranteed to arrive.
  • Testing and Test Control Notation (TTCN), both TTCN-2 and TTCN-3, follows actor model rather closely. In TTCN actor is a test component: either parallel test component (PTC) or main test component (MTC). Test components can send and receive messages to and from remote partners (peer test components or test system interface), the latter being identified by its address. Each test component has a behaviour tree bound to it; test components run in parallel and can be dynamically created by parent test components. Built-in language constructs allow the definition of actions to be taken when an expected message is received from the internal message queue, like sending a message to another peer entity or creating new test components.

Message-passing semantics

The actor model is about the semantics of message passing.

Unbounded nondeterminism controversy

Arguably, the first concurrent programs were interrupt handlers. During the course of its normal operation a computer needed to be able to receive information from outside (characters from a keyboard, packets from a network, etc). So when the information arrived the execution of the computer was interrupted and special code (called an interrupt handler) was called to put the information in a data buffer where it could be subsequently retrieved.

In the early 1960s, interrupts began to be used to simulate the concurrent execution of several programs on one processor.[15] Having concurrency with shared memory gave rise to the problem of concurrency control. Originally, this problem was conceived as being one of mutual exclusion on a single computer. Edsger Dijkstra developed semaphores and later, between 1971 and 1973,[16] Tony Hoare[17] and Per Brinch Hansen[18] developed monitors to solve the mutual exclusion problem. However, neither of these solutions provided a programming language construct that encapsulated access to shared resources. This encapsulation was later accomplished by the serializer construct ([Hewitt and Atkinson 1977, 1979] and [Atkinson 1980]).

The first models of computation (e.g.Turing machines, Post productions, the lambda calculusetc.) were based on mathematics and made use of a global state to represent a computational step (later generalized in [McCarthy and Hayes 1969] and [Dijkstra 1976] see Event orderings versus global state). Each computational step was from one global state of the computation to the next global state. The global state approach was continued in automata theory for finite-state machines and push down stack machines, including their nondeterministic versions. Such nondeterministic automata have the property of bounded nondeterminism; that is, if a machine always halts when started in its initial state, then there is a bound on the number of states in which it halts.

Edsger Dijkstra further developed the nondeterministic global state approach. Dijkstra’s model gave rise to a controversy concerning unbounded nondeterminism (also called unbounded indeterminacy), a property of concurrency by which the amount of delay in servicing a request can become unbounded as a result of arbitration of contention for shared resources while still guaranteeing that the request will eventually be serviced. Hewitt argued that the actor model should provide the guarantee of service. In Dijkstra’s model, although there could be an unbounded amount of time between the execution of sequential instructions on a computer, a (parallel) program that started out in a well defined state could terminate in only a bounded number of states [Dijkstra 1976]. Consequently, his model could not provide the guarantee of service. Dijkstra argued that it was impossible to implement unbounded nondeterminism.

Hewitt argued otherwise: there is no bound that can be placed on how long it takes a computational circuit called an arbiter to settle (see metastability (electronics)).[19] Arbiters are used in computers to deal with the circumstance that computer clocks operate asynchronously with respect to input from outside, e.g., keyboard input, disk access, network input, etc. So it could take an unbounded time for a message sent to a computer to be received and in the meantime the computer could traverse an unbounded number of states.

The actor model features unbounded nondeterminism which was captured in a mathematical model by Will Clinger using domain theory.[2] In the actor model, there is no global state.[dubious – discuss]

Direct communication and asynchrony

Messages in the actor model are not necessarily buffered. This was a sharp break with previous approaches to models of concurrent computation. The lack of buffering caused a great deal of misunderstanding at the time of the development of the actor model and is still a controversial issue. Some researchers argued that the messages are buffered in the “ether” or the “environment”. Also, messages in the actor model are simply sent (like packets in IP); there is no requirement for a synchronous handshake with the recipient.

Actor creation plus addresses in messages means variable topology

A natural development of the actor model was to allow addresses in messages. Influenced by packet switched networks [1961 and 1964], Hewitt proposed the development of a new model of concurrent computation in which communications would not have any required fields at all: they could be empty. Of course, if the sender of a communication desired a recipient to have access to addresses which the recipient did not already have, the address would have to be sent in the communication.

For example, an actor might need to send a message to a recipient actor from which it later expects to receive a response, but the response will actually be handled by a third actor component that has been configured to receive and handle the response (for example, a different actor implementing the observer pattern). The original actor could accomplish this by sending a communication that includes the message it wishes to send, along with the address of the third actor that will handle the response. This third actor that will handle the response is called the resumption (sometimes also called a continuation or stack frame). When the recipient actor is ready to send a response, it sends the response message to the resumption actor address that was included in the original communication.

So, the ability of actors to create new actors with which they can exchange communications, along with the ability to include the addresses of other actors in messages, gives actors the ability to create and participate in arbitrarily variable topological relationships with one another, much as the objects in Simula and other object-oriented languages may also be relationally composed into variable topologies of message-exchanging objects.

Inherently concurrent

As opposed to the previous approach based on composing sequential processes, the actor model was developed as an inherently concurrent model. In the actor model sequentiality was a special case that derived from concurrent computation as explained in actor model theory.

No requirement on order of message arrival

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this template message)

Hewitt argued against adding the requirement that messages must arrive in the order in which they are sent to the actor. If output message ordering is desired, then it can be modeled by a queue actor that provides this functionality. Such a queue actor would queue the messages that arrived so that they could be retrieved in FIFO order. So if an actor X sent a message M1 to an actor Y, and later X sent another message M2 to Y, there is no requirement that M1 arrives at Y before M2.

In this respect the actor model mirrors packet switching systems which do not guarantee that packets must be received in the order sent. Not providing the order of delivery guarantee allows packet switching to buffer packets, use multiple paths to send packets, resend damaged packets, and to provide other optimizations.

For example, actors are allowed to pipeline the processing of messages. What this means is that in the course of processing a message M1, an actor can designate the behavior to be used to process the next message, and then in fact begin processing another message M2 before it has finished processing M1. Just because an actor is allowed to pipeline the processing of messages does not mean that it must pipeline the processing. Whether a message is pipelined is an engineering tradeoff. How would an external observer know whether the processing of a message by an actor has been pipelined? There is no ambiguity in the definition of an actor created by the possibility of pipelining. Of course, it is possible to perform the pipeline optimization incorrectly in some implementations, in which case unexpected behavior may occur.


Another important characteristic of the actor model is locality.

Locality means that in processing a message, an actor can send messages only to addresses that it receives in the message, addresses that it already had before it received the message, and addresses for actors that it creates while processing the message. (But see Synthesizing addresses of actors.)

Also locality means that there is no simultaneous change in multiple locations. In this way it differs from some other models of concurrency, e.g., the Petri net model in which tokens are simultaneously removed from multiple locations and placed in other locations.

Composing actor systems

The idea of composing actor systems into larger ones is an important aspect of modularity that was developed in Gul Agha’s doctoral dissertation,[6] developed later by Gul Agha, Ian Mason, Scott Smith, and Carolyn Talcott.[9]


A key innovation was the introduction of behavior specified as a mathematical function to express what an actor does when it processes a message, including specifying a new behavior to process the next message that arrives. Behaviors provided a mechanism to mathematically model the sharing in concurrency.

Behaviors also freed the actor model from implementation details, e.g., the Smalltalk-72 token stream interpreter. However, it is critical to understand that the efficient implementation of systems described by the actor model require extensive optimization. See Actor model implementation for details.

Modeling other concurrency systems

Other concurrency systems (e.g.process calculi) can be modeled in the actor model using a two-phase commit protocol.[20]

Computational Representation Theorem

See also: Denotational semantics of the Actor model

There is a Computational Representation Theorem in the actor model for systems which are closed in the sense that they do not receive communications from outside. The mathematical denotation denoted by a closed system {\displaystyle {\mathtt {S}}}{\displaystyle {\mathtt {S}}} is constructed from an initial behavior S and a behavior-approximating function progressionS. These obtain increasingly better approximations and construct a denotation (meaning) for {\displaystyle {\mathtt {S}}}{\displaystyle {\mathtt {S}}} as follows [Hewitt 2008; Clinger 1981]:{\displaystyle \mathbf {Denote} _{\mathtt {S}}\equiv \lim _{i\to \infty }\mathbf {progression} _{{\mathtt {S}}^{i}}(\bot _{\mathtt {S}})}{\displaystyle \mathbf {Denote} _{\mathtt {S}}\equiv \lim _{i\to \infty }\mathbf {progression} _{{\mathtt {S}}^{i}}(\bot _{\mathtt {S}})}

In this way, S can be mathematically characterized in terms of all its possible behaviors (including those involving unbounded nondeterminism). Although {\displaystyle \mathbf {Denote} _{\mathtt {S}}}{\displaystyle \mathbf {Denote} _{\mathtt {S}}} is not an implementation of {\displaystyle {\mathtt {S}}}{\displaystyle {\mathtt {S}}}, it can be used to prove a generalization of the Church-Turing-Rosser-Kleene thesis [Kleene 1943]:

A consequence of the above theorem is that a finite actor can nondeterministically respond with an uncountable[clarify] number of different outputs.

Relationship to logic programming

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this template message)

One of the key motivations for the development of the actor model was to understand and deal with the control structure issues that arose in development of the Planner programming language.[citation needed] Once the actor model was initially defined, an important challenge was to understand the power of the model relative to Robert Kowalski‘s thesis that “computation can be subsumed by deduction”. Hewitt argued that Kowalski’s thesis turned out to be false for the concurrent computation in the actor model (see Indeterminacy in concurrent computation).

Nevertheless, attempts were made to extend logic programming to concurrent computation. However, Hewitt and Agha [1991] claimed that the resulting systems were not deductive in the following sense: computational steps of the concurrent logic programming systems do not follow deductively from previous steps (see Indeterminacy in concurrent computation). Recently, logic programming has been integrated into the actor model in a way that maintains logical semantics.[19]


Migration in the actor model is the ability of actors to change locations. E.g., in his dissertation, Aki Yonezawa modeled a post office that customer actors could enter, change locations within while operating, and exit. An actor that can migrate can be modeled by having a location actor that changes when the actor migrates. However the faithfulness of this modeling is controversial and the subject of research.[citation needed]


The security of actors can be protected in the following ways:

Synthesizing addresses of actors

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this template message)

A delicate point in the actor model is the ability to synthesize the address of an actor. In some cases security can be used to prevent the synthesis of addresses (see Security). However, if an actor address is simply a bit string then clearly it can be synthesized although it may be difficult or even infeasible to guess the address of an actor if the bit strings are long enough. SOAP uses a URL for the address of an endpoint where an actor can be reached. Since a URL is a character string, it can clearly be synthesized although encryption can make it virtually impossible to guess.

Synthesizing the addresses of actors is usually modeled using mapping. The idea is to use an actor system to perform the mapping to the actual actor addresses. For example, on a computer the memory structure of the computer can be modeled as an actor system that does the mapping. In the case of SOAP addresses, it’s modeling the DNS and the rest of the URL mapping.

Contrast with other models of message-passing concurrency

Robin Milner‘s initial published work on concurrency[21] was also notable in that it was not based on composing sequential processes. His work differed from the actor model because it was based on a fixed number of processes of fixed topology communicating numbers and strings using synchronous communication. The original communicating sequential processes (CSP) model[22] published by Tony Hoare differed from the actor model because it was based on the parallel composition of a fixed number of sequential processes connected in a fixed topology, and communicating using synchronous message-passing based on process names (see Actor model and process calculi history). Later versions of CSP abandoned communication based on process names in favor of anonymous communication via channels, an approach also used in Milner’s work on the calculus of communicating systems and the π-calculus.

These early models by Milner and Hoare both had the property of bounded nondeterminism. Modern, theoretical CSP ([Hoare 1985] and [Roscoe 2005]) explicitly provides unbounded nondeterminism.

Petri nets and their extensions (e.g., coloured Petri nets) are like actors in that they are based on asynchronous message passing and unbounded nondeterminism, while they are like early CSP in that they define fixed topologies of elementary processing steps (transitions) and message repositories (places).


The actor model has been influential on both theory development and practical software development.


The actor model has influenced the development of the π-calculus and subsequent process calculi. In his Turing lecture, Robin Milner wrote:[23]

Now, the pure lambda-calculus is built with just two kinds of thing: terms and variables. Can we achieve the same economy for a process calculus? Carl Hewitt, with his actors model, responded to this challenge long ago; he declared that a value, an operator on values, and a process should all be the same kind of thing: an actor.

This goal impressed me, because it implies the homogeneity and completeness of expression … But it was long before I could see how to attain the goal in terms of an algebraic calculus…

So, in the spirit of Hewitt, our first step is to demand that all things denoted by terms or accessed by names—values, registers, operators, processes, objects—are all of the same kind of thing; they should all be processes.


The actor model has had extensive influence on commercial practice. For example, Twitter has used actors for scalability.[24] Also, Microsoft has used the actor model in the development of its Asynchronous Agents Library.[25] There are many other actor libraries listed in the actor libraries and frameworks section below.

Addressed issues

According to Hewitt [2006], the actor model addresses issues in computer and communications architecture, concurrent programming languages, and Web services including the following:

  • Scalability: the challenge of scaling up concurrency both locally and nonlocally.
  • Transparency: bridging the chasm between local and nonlocal concurrency. Transparency is currently a controversial issue. Some researchers[who?] have advocated a strict separation between local concurrency using concurrent programming languages (e.g., Java and C#) from nonlocal concurrency using SOAP for Web services. Strict separation produces a lack of transparency that causes problems when it is desirable/necessary to change between local and nonlocal access to Web services (see Distributed computing).
  • Inconsistency: inconsistency is the norm because all very large knowledge systems about human information system interactions are inconsistent. This inconsistency extends to the documentation and specifications of very large systems (e.g., Microsoft Windows software, etc.), which are internally inconsistent.

Many of the ideas introduced in the actor model are now also finding application in multi-agent systems for these same reasons [Hewitt 2006b 2007b]. The key difference is that agent systems (in most definitions) impose extra constraints upon the actors, typically requiring that they make use of commitments and goals.

Programming with actors

A number of different programming languages employ the actor model or some variation of it. These languages include:

Early actor programming languages

Later actor programming languages

Actor libraries and frameworks

Actor libraries or frameworks have also been implemented to permit actor-style programming in languages that don’t have actors built-in. Some of these frameworks are:

NameStatusLatest releaseLicenseLanguages
ReActedActive2021-03-07Apache 2.0Java
ActeurActive2020-04-16[43]Apache-2.0 / MITRust
BastionActive2020-08-12[44]Apache-2.0 / MITRust
Actor4jActive2020-01-31Apache 2.0Java
ActrActive2019-04-09[46]Apache 2.0Java
Vert.xActive2018-02-13Apache 2.0Java, Groovy, Javascript, Ruby, Scala, Kotlin, Ceylon
ActorFxInactive2013-11-13Apache 2.0.NET
Akka (toolkit)Active2019-05-21[47]Apache 2.0Java and Scala
Akka.NETActive2020-08-20[48]Apache 2.0.NET
Remact.NetInactive2016-06-26MIT.NET, Javascript
Ateji PXInactive??Java
F# MailboxProcessorActivesame as F# (built-in core library)Apache LicenseF#
KorusActive2010-02-04GPL 3Java
ActorFoundry (based on Kilim)Inactive2008-12-28?Java
Cloud HaskellActive2015-06-17[52]BSDHaskell
CloudIActive2021-05-27[53]MITATS, C/C++, Elixir/Erlang/LFE, Go, Haskell, Java, Javascript, OCaml, Perl, PHP, Python, Ruby
ClutterActive2017-05-12[54]LGPL 2.1C, C++ (cluttermm), Python (pyclutter), Perl (perl-Clutter)
NActInactive2012-02-28LGPL 3.0.NET
NactActive2018-06-06[55]Apache 2.0JavaScript/ReasonML
RetlangInactive2011-05-18[56]New BSD.NET
JetlangActive2013-05-30[57]New BSDJava
Haskell-ActorActive?2008New BSDHaskell
GParsActive2014-05-09[58]Apache 2.0Groovy
OOSMOSActive2019-05-09[59]GPL 2.0 and commercial (dual licensing)C. C++ friendly
PaniniActive2014-05-22MPL 1.1Programming Language by itself
PARLEYActive?2007-22-07GPL 2.1Python
PeerneticActive2007-06-29LGPL 3.0Java
PostSharpActive2014-09-24Commercial / Freemium.NET
PulsarActive2016-07-09[60]New BSDPython
PykkaActive2019-05-07[62]Apache 2.0Python
Termite SchemeActive?2009-05-21LGPLScheme (Gambit implementation)
LibactorActive?2009GPL 2.0C
Actor-CPPActive2012-03-10[67]GPL 2.0C++
S4Inactive2012-07-31[68]Apache 2.0Java
C++ Actor Framework (CAF)Active2020-02-08[69]Boost Software License 1.0 and BSD 3-ClauseC++11
LabVIEW Actor FrameworkActive2012-03-01[71]National Instruments SLALabVIEW
LabVIEW Messenger LibraryActive2016-06-01BSDLabVIEW
OrbitActive2019-05-28[72]New BSDJava
QP frameworks for real-time embedded systemsActive2019-05-25[73]GPL 2.0 and commercial (dual licensing)C and C++
libprocessActive2013-06-19Apache 2.0C++
SObjectizerActive2020-05-09[74]New BSDC++11
rotorActive2020-10-23[75]MIT LicenseC++17
OrleansActive2019-06-02[76]MIT LicenseC#/.NET
SkynetActive2020-12-10MIT LicenseC/Lua
Reactors.IOActive2016-06-14BSD LicenseJava/Scala
libagentsActive2020-03-08Free software licenseC++11
Proto.ActorActive2021-01-05Free software licenseGo, C#, Python, JavaScript, Java, Kotlin
FunctionalJavaActive2018-08-18[77]BSD 3-ClauseJava
RikerActive2019-01-04MIT LicenseRust
ComedyActive2019-03-09EPL 1.0JavaScript
vlingoActive2020-07-26Mozilla Public License 2.0Java, Kotlin, soon .NET
wasmCloudActive2021-03-23Apache 2.0WebAssembly (Rust, TinyGo, Zig, AssemblyScript)
rayActive2020-08-27Apache 2.0Python

See also


  1. ^ Hewitt, Carl; Bishop, Peter; Steiger, Richard (1973). “A Universal Modular Actor Formalism for Artificial Intelligence”. IJCAI.
  2. a b c d William Clinger (June 1981). “Foundations of Actor Semantics”. Mathematics Doctoral Dissertation. MIT. hdl:1721.1/6935.
  3. a b Irene Greif (August 1975). “Semantics of Communicating Parallel Processes”. EECS Doctoral Dissertation. MIT.
  4. a b Henry BakerCarl Hewitt (August 1977). “Laws for Communicating Parallel Processes”. IFIP.
  5. ^ “Laws for Communicating Parallel Processes” (PDF). 10 May 1977.
  6. a b c Gul Agha (1986). “Actors: A Model of Concurrent Computation in Distributed Systems”. Doctoral Dissertation. MIT Press. hdl:1721.1/6952.
  7. ^ “Home”. Archived from the original on 2013-02-22. Retrieved 2012-12-02.
  8. ^ Carl Hewitt. Viewing Control Structures as Patterns of Passing Messages Journal of Artificial Intelligence. June 1977.
  9. a b Gul Agha; Ian Mason; Scott Smith; Carolyn Talcott (January 1993). “A Foundation for Actor Computation”. Journal of Functional Programming.
  10. ^ Carl Hewitt (2006-04-27). “What is Commitment? Physical, Organizational, and Social” (PDF). COIN@AAMAS.
  11. ^ Mauro Gaspari; Gianluigi Zavattaro (May 1997). “An Algebra of Actors” (PDF). Formal Methods for Open Object-Based Distributed Systems. Technical Report UBLCS-97-4. University of Bologna. pp. 3–18. doi:10.1007/978-0-387-35562-7_2ISBN 978-1-4757-5266-3.
  12. ^ M. Gaspari; G. Zavattaro (1999). “An Algebra of Actors”. Formal Methods for Open Object Based Systems.
  13. ^ Gul Agha; Prasanna Thati (2004). “An Algebraic Theory of Actors and Its Application to a Simple Object-Based Language” (PDF). From OO to FM (Dahl Festschrift) LNCS 2635. Archived from the original (PDF) on 2004-04-20.
  14. ^ John Darlington; Y. K. Guo (1994). “Formalizing Actors in Linear Logic”. International Conference on Object-Oriented Information Systems.
  15. ^ Hansen, Per Brinch (2002). The Origins of Concurrent Programming: From Semaphores to Remote Procedure Calls. Springer. ISBN 978-0-387-95401-1.
  16. ^ Hansen, Per Brinch (1996). “Monitors and Concurrent Pascal: A Personal History”. Communications of the ACM: 121–172.
  17. ^ Hoare, Tony (October 1974). “Monitors: An Operating System Structuring Concept”. Communications of the ACM17(10): 549–557. doi:10.1145/355620.361161S2CID 1005769.
  18. ^ Hansen, Per Brinch (July 1973). Operating System Principles. Prentice-Hall.
  19. a b Hewitt, Carl (2012). “What is computation? Actor Model versus Turing’s Model”. In Zenil, Hector (ed.). A Computable Universe: Understanding Computation & Exploring Nature as Computation. Dedicated to the memory of Alan M. Turing on the 100th anniversary of his birth. World Scientific Publishing Company.
  20. ^ Frederick Knabe. A Distributed Protocol for Channel-Based Communication with Choice PARLE 1992.
  21. ^ Robin Milner. Processes: A Mathematical Model of Computing Agents in Logic Colloquium 1973.
  22. ^ C.A.R. Hoare. Communicating sequential processesCACM. August 1978.
  23. ^ Milner, Robin (1993). “Elements of interaction”Communications of the ACM36: 78–89. doi:10.1145/151233.151240.
  24. ^ “How Twitter Is Scaling « Waiming Mok’s Blog”. 2009-06-27. Retrieved 2012-12-02.
  25. ^ “Actor-Based Programming with the Asynchronous Agents Library” MSDN September 2010.
  26. ^ Henry Lieberman (June 1981). “A Preview of Act 1”. MIT AI memo 625. hdl:1721.1/6350.
  27. ^ Henry Lieberman (June 1981). “Thinking About Lots of Things at Once without Getting Confused: Parallelism in Act 1”. MIT AI memo 626. hdl:1721.1/6351.
  28. ^ Jean-Pierre Briot. Acttalk: A framework for object-oriented concurrent programming-design and experience 2nd France-Japan workshop. 1999.
  29. ^ Ken Kahn. A Computational Theory of Animation MIT EECS Doctoral Dissertation. August 1979.
  30. ^ 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.
  31. ^ Darrell Woelk. Developing InfoSleuth Agents Using Rosette: An Actor Based Language Proceedings of the CIKM ’95 Workshop on Intelligent Information Agents. 1995.
  32. ^ 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
  33. ^ Darryl K. Taft (2009-04-17). “Microsoft Cooking Up New Parallel Programming Language”. Retrieved 2012-12-02.
  34. ^ “Humus”. Retrieved 2012-12-02.
  35. ^ Brandauer, Stephan; et al. (2015). “Parallel objects for multicores: A glimpse at the parallel language encore”. Formal Methods for Multicore Programming. Springer International Publishing: 1–56.
  36. ^ “The Pony Language”.
  37. ^ Clebsch, Sylvan; Drossopoulou, Sophia; Blessing, Sebastian; McNeil, Andy (2015). “Deny capabilities for safe, fast actors”. Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control – AGERE! 2015. pp. 1–12. doi:10.1145/2824815.2824816ISBN 9781450339018S2CID 415745. by Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, Andy McNeil
  38. ^ “The P Language”. 2019-03-08.
  39. ^ “The P# Language”. 2019-03-12.
  40. ^ Carlos Varela and Gul Agha (2001). “Programming Dynamically Reconfigurable Open Systems with SALSA”. ACM SIGPLAN Notices. OOPSLA’2001 Intriguing Technology Track Proceedings36.
  41. ^ Philipp Haller and Martin Odersky (September 2006). “Event-Based Programming without Inversion of Control”(PDF). Proc. JMLC 2006.
  42. ^ Philipp Haller and Martin Odersky (January 2007). “Actors that Unify Threads and Events” (PDF). Technical report LAMP 2007. Archived from the original (PDF) on 2011-06-07. Retrieved 2007-12-10.
  43. ^ “acteur – 0.9.1· David Bonet ·”. Retrieved 2020-04-16.
  44. ^ Bulut, Mahmut (2019-12-15). “Bastion on” Retrieved 2019-12-15.
  45. ^ “actix – 0.10.0· Rob Ede ·”. Retrieved 2021-02-28.
  46. ^ “Releases · zakgof/actr · GitHub”. Retrieved 2019-04-16.
  47. ^ “Akka 2.5.23 Released · Akka”. Akka. 2019-05-21. Retrieved 2019-06-03.
  48. ^ Akka.NET v1.4.10 Stable Release GitHub – akkadotnet/ Port of Akka actors for .NET., Akka.NET, 2020-10-01, retrieved 2020-10-01
  49. ^ Srinivasan, Sriram; Alan Mycroft (2008). “Kilim: Isolation-Typed Actors for Java” (PDF). European Conference on Object Oriented Programming ECOOP 2008. Cyprus. Retrieved 2016-02-25.
  50. ^ “Releases · kilim/kilim · GitHub”. Retrieved 2019-06-03.
  51. ^ “Commit History · stevedekorte/ActorKit · GitHub”. Retrieved 2016-02-25.
  52. ^ “Commit History · haskell-distributed/distributed-process · GitHub”. Retrieved 2012-12-02.
  53. ^ “Releases · CloudI/CloudI · GitHub”. Retrieved 2021-06-21.
  54. ^ “Tags · GNOME/clutter · GitLab”. Retrieved 2019-06-03.
  55. ^ “Releases · ncthbrt/nact · GitHub”. Retrieved 2019-06-03.
  56. ^ “Changes – retlang – Message based concurrency in .NET – Google Project Hosting”. Retrieved 2016-02-25.
  57. ^ “ – jetlang – – Message based concurrency for Java – Google Project Hosting”. 2012-02-14. Retrieved 2016-02-25.
  58. ^ “GPars Releases”. GitHub. Retrieved 2016-02-25.
  59. ^ “Releases · oosmos/oosmos · GitHub”. GitHub. Retrieved 2019-06-03.
  60. ^ “Pulsar Design and Actors”. Archived from the originalon 2015-07-04.
  61. ^ “Pulsar documentation”. Archived from the original on 2013-07-26.
  62. ^ “Changes – Pykka 2.0.0 documentation”. Retrieved 2019-06-03.
  63. ^ “Theron – Ashton Mason”. Retrieved 2018-08-29.
  64. ^ “Theron – Version 6.00.02 released”. Archived from the original on 2016-03-16. Retrieved 2016-02-25.
  65. ^ “Theron”. Archived from the originalon 2016-03-04. Retrieved 2016-02-25.
  66. ^ “Releases · puniverse/quasar · GitHub”. Retrieved 2019-06-03.
  67. ^ “Changes – actor-cpp – An implementation of the actor model for C++ – Google Project Hosting”. Retrieved 2012-12-02.
  68. ^ “Commit History · s4/s4 · Apache”. Archived from the original on 2016-03-06. Retrieved 2016-01-16.
  69. ^ “Releases · actor-framework/actor-framework · GitHub”. Retrieved 2020-03-07.
  70. ^ “celluloid | | your community gem host”. Retrieved 2019-06-03.
  71. ^ “Community: Actor Framework, LV 2011 revision (version 3.0.7)”. 2011-09-23. Retrieved 2016-02-25.
  72. ^ “Releases · orbit/orbit · GitHub”. GitHub. Retrieved 2019-06-03.
  73. ^ “QP Real-Time Embedded Frameworks & Tools – Browse Files at”. Retrieved 2019-06-03.
  74. ^ “Releases · Stiffstream/sobjectizer · GitHub”. GitHub. Retrieved 2019-06-19.
  75. ^ “Releases · basiliscos/cpp-rotor· GitHub”. GitHub. Retrieved 2020-10-10.
  76. ^ “Releases · dotnet/orleans · GitHub”. GitHub. Retrieved 2019-06-03.
  77. ^ “FunctionalJava releases”. GitHub. Retrieved 2018-08-23.

Further reading

External links


” (WP)


Fair Use Sources:

Android OS Apple iOS Artificial Intelligence AWS Azure Bibliography C Language C# .NET C++ Cloud Data Science - Big Data DevOps DevSecOps-Security-Privacy GCP Go Programming Language Java JavaScript Kotlin Kubernetes Linux Networking Operating Systems PowerShell Python React Software Engineering Spring Framework SRE - Reliability engineering - Chaos engineer Swift TypeScript Vue.js Framework Windows Server

Manning Publications

See also Java Bibliography, JavaScript Bibliography, Python Bibliography

Manning publishes the best quality IT books in the industry.

Manning is an independent publisher, providing computer books for software developers, engineers, architects, system administrators, and managers. Our books also cover topics for young programmers, students, and occasionally children.


Manning is an independent publisher of computer books and video courses for software developers, engineers, architects, system administrators, managers and all who are professionally involved with the computer business. We also publish for students and young programmers, including occasionally for children. We are an entirely virtual organization based on Shelter Island, New York, with many staff working from far-flung places like Manila and Zagreb.

company character

“Independent” means we are not owned by a large corporate entity and are free to make decisions without bureaucratic overhead. That has allowed us to innovate and be flexible and to quickly adjust what we do as we go. We were the first by several years to sell our books as unprotected PDFs, something that later became commonplace. We were the first to start selling books before they were finished, in the Manning Early Access Program. This gave our readers access to our content as soon as it was readable, and this too has become common in the industry. And it means we are thinking every day about new ways to satisfy our customers, some of which we hope you will be pleased to discover in the not-too-distant future.

how we improve

We published our first book in 1993 and have been learning from our successes, and even more from our mistakes, ever since. Every new book teaches us something that helps us improve:

  • How to choose the topics we publish on
  • How to find the right authors for each book
  • How to help authors write the best books they can
  • How to ensure the content is valuable and easy to learn
  • How to let readers know about our content

book series

We publish standalone titles as well as the following book series:

  • Hello!
  • In Action
  • In Practice
  • In Depth
  • In a Month of Lunches


Readers can access our books through the Manning Early Access Program, O’Reilly Learning (formerly Safari Books Online), and iBooks. Print copies, wherever they are bought, come with free electronic versions in PDF, ePub and Kindle formats. With your print copy in hand, register it on the Manning site and you can download the digital versions from your account.

At this time, our eBooks are available only from and Apple’s iBookstore.


Fair Use Sources:

Bibliography C# .NET Software Engineering

C# .NET Bibliography

See also C# and .NET Framework and JavaScript Bibliography

Bibliography C# .NET Software Engineering

C# 9.0 in a Nutshell: The Definitive Reference

See also: C# .NET Bibliography and C# and .NET Framework

See: C# 9.0 in a Nutshell: The Definitive Reference, 1st Edition, by Joseph Albahari, 2021, B08XN578HZ (CSNS9)

Fair Use Source: B08XN578HZ (CSNS9)

About This Book:

When you have questions about C# 9.0 or .NET 5, this best-selling guide has the answers you need. C# is a language of unusual flexibility and breadth, but with its continual growth there’s so much more to learn. In the tradition of O’Reilly’s Nutshell guides, this thoroughly updated edition is simply the best one-volume reference to the C# language available today.

Organized around concepts and use cases, C# 9.0 in a Nutshell provides intermediate and advanced programmers with a concise map of C# and .NET that also plumbs significant depths.

  • Get up to speed on C#, from syntax and variables to advanced topics such as pointers, records, closures, and patterns
  • Dig deep into LINQ with three chapters dedicated to the topic
  • Explore concurrency and asynchrony, advanced threading, and parallel programming
  • Work with .NET features, including regular expressions, networking, spans, reflection, and cryptography

About the Author:

Book Details:

  • ASIN: B08XN578HZ
  • Publisher: O’Reilly Media; 1st edition (February 26, 2021)
  • Publication date: February 26, 2021
  • Language: English
  • Print length: 1884 pages

Table of Contents:


Fair Use Sources:

Android OS Apple iOS Apple macOS C Language C# .NET C++ Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin Linux Operating Systems PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript Windows Desktop Windows Server

Operating systems (OS)

An operating system (OS) is system software that manages computer hardwaresoftware resources, and provides common services for computer programs.

Time-sharing operating systems schedule tasks for efficient use of the system and may also include accounting software for cost allocation of processor timemass storage, printing, and other resources.

For hardware functions such as input and output and memory allocation, the operating system acts as an intermediary between programs and the computer hardware,[1][2] although the application code is usually executed directly by the hardware and frequently makes system calls to an OS function or is interrupted by it. Operating systems are found on many devices that contain a computer – from cellular phones and video game consoles to web servers and supercomputers.

The dominant general-purpose[3] desktop operating system is Microsoft Windows with a market share of around 76.45%. macOS by Apple Inc. is in second place (17.72%), and the varieties of Linux are collectively in third place (1.73%).[4] In the mobile sector (including smartphones and tablets), Android’s share is up to 72% in the year 2020.[5] According to third quarter 2016 data, Android’s share on smartphones is dominant with 87.5 percent with also a growth rate of 10.3 percent per year, followed by Apple’s iOS with 12.1 percent with per year decrease in market share of 5.2 percent, while other operating systems amount to just 0.3 percent.[6] Linux distributions are dominant in the server and supercomputing sectors. Other specialized classes of operating systems (special-purpose operating systems)[7][8]), such as embedded and real-time systems, exist for many applications. Security-focused operating systems also exist. Some operating systems have low system requirements (i.e. light-weight Linux distribution). Others may have higher system requirements.

Some operating systems require installation or may come pre-installed with purchased computers (OEM-installation), whereas others may run directly from media (i.e. live cd) or flash memory (i.e. usb stick).

Artificial Intelligence AWS Azure Bibliography C Language C# .NET C++ Cloud Data Science - Big Data DevOps DevSecOps-Security-Privacy Django Web Framework Flask Web Framework GCP Go Programming Language Java JavaScript Kotlin Kubernetes Linux Networking Operating Systems PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript Windows Server


See Dr. Angela Yu, Udemy’s best instructor: 100 Days of Code – The Complete Python Pro Bootcamp

Udemy, Inc. is an American massive open online course (MOOC) provider aimed at professional adults and students. It was founded in May 2010 by Eren Bali, Gagan Biyani, and Oktay Caglar.

As of February 2021, the platform has more than 40 million students, 155,000 courses and 70,000 instructors teaching courses in over 65 languages. There have been over 480 million course enrollments. Students and instructors come from 180+ countries and 2/3 of the students are located outside of the U.S.[3]

Students take courses largely as a means of improving job-related skills.[4] Some courses generate credit toward technical certification. Udemy has made a special effort to attract corporate trainers seeking to create coursework for employees of their company.[5] As of 2021, there are more than 155,000 courses on the website.[6][3]

The headquarters of Udemy is located in San Francisco, California, with offices in Denver, Colorado; Dublin, Ireland; Ankara, Turkey; Sao Paulo, Brazil; and Gurugram, India.[7]



Fair Use Sources:

C Language C# .NET C++ Cloud DevOps Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript

Software design pattern

In software engineering, a software design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. Rather, it is a description or template for how to solve a problem that can be used in many different situations. Design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system.

Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Patterns that imply mutable state may be unsuited for functional programming languages, some patterns can be rendered unnecessary in languages that have built-in support for solving the problem they are trying to solve, and object-oriented patterns are not necessarily suitable for non-object-oriented languages.

Design patterns may be viewed as a structured approach to computer programming intermediate between the levels of a programming paradigm and a concrete algorithm.

In a recent review study, Wedyan and Abufakher investigate design patterns and software quality and conclude: “Our study has shown that the primary studies provide an empirical evidence on the positive effect of documentation of designs pattern instances on program comprehension, and therefore, maintainability. While this result is not surprising, it has, however, two indications. First, developers should pay more effort to add such documentation, even if in the form of simple comments in the source code. Second, when comparing results of different studies, the effect of documentation has to be considered.”[1]

C Language C# .NET C++ Cloud Data Science - Big Data DevOps Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript

Integrated Development Environment (IDE)

“An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of at least a source code editorbuild automation tools and a debugger. Some IDEs, such as Visual Studio, NetBeans and Eclipse, contain the necessary compilerinterpreter, or both; others, such as SharpDevelop and Lazarus, do not.” (WP)

“The boundary between an IDE and other parts of the broader software development environment is not well-defined; sometimes a version control system or various tools to simplify the construction of a graphical user interface (GUI) are integrated. Many modern IDEs also have a class browser, an object browser, and a class hierarchy diagram for use in object-oriented software development.” (WP)

Bibliography C# .NET Software Engineering

C# 8 Quick Syntax Reference: A Pocket Guide to the Language, APIs, and Library

See also: C# and .NET Framework, C# Bibliography

C# 8 Quick Syntax Reference: A Pocket Guide to the Language, APIs, and Library by Mikael Olsson, 2020, B08313LS19 (CS8QSR)

Fair Use Source: B08313LS19 (CS8QSR)

This quick C# 8 guide is a condensed code and syntax reference to the C# programming language, updated with the latest features of C# 8 for .NET and Windows 10. This book presents the essential C# 8 syntax in a well-organized format that can be used as a handy reference.  Specifically, it covers nullable reference types, async streams, ranges and indices, default implementations of interface members, recursive patterns, switch expressions, target-typed new-expressions, platform dependencies and more.
In the C# 8 Quick Syntax Reference, you will find a concise reference to the C# language syntax: short, simple, and focused code examples; a well laid out table of contents; and a comprehensive index allowing easy review. You won’t find any technical jargon, bloated samples, drawn-out history lessons, or witty stories. What you will find is a language reference that is to the point and highly accessible. The book is packed with useful information and is a must-have for any C# programmer.

What You Will Learn

  • Discover what’s new in C# 8 and .NET for Windows 10 programming
  • Employ nullable reference types 
  • Explore the advanced async streams now available in C# 8
  • Work with ranges and indices 
  • Apply recursive patterns to your applications
  • Use switch expressions 

Who This Book Is For

Those with some experience in programming, looking for a quick, handy reference. Some C# or .NET recommended but not necessary.

Book Details

  • ASIN: B08313LS19
  • Publisher: Apress; 3rd edition (December 20, 2019)
  • Publication date: December 20, 2019
  • Print length: 175 pages