View source for Join-pattern

{{Infobox programming language
| name                   = Join-pattern
| paradigm               = [[Concurrent computing|concurrent computing]], distributed programming
| implementations        = [[Join Java]], Polyphonic C#, Unified Parallel C, [[Cω]], [[Joins (concurrency library)|Joins library]], [[Software:Boost (C++ libraries)|Boost]].
| influenced             = [[Join-calculus|Join Calculus]]
| developer              = INRIA Inria
| website                = [http://join.inria.fr/ Inria Join]
}}

'''Join-patterns''' provides a way to write [[Concurrent computing|concurrent]], [[Parallel algorithm|parallel]] and distributed computer programs by [[Message passing|message passing]]. Compared to the use of [[Thread (computing)|threads]] and locks, this is a high level programming model using communication constructs model to abstract the complexity of concurrent environment and to allow [[Scalability|scalability]]. Its focus is on the execution of a [[Chord (concurrency)|chord]] between messages atomically consumed from a group of channels.

This template is based on [[Join-calculus|join-calculus]] and uses [[Pattern matching|pattern matching]]. Concretely, this is done by allowing the join definition of several functions and/or channels by matching concurrent call and messages patterns. It is a type of [[Concurrency pattern|concurrency pattern]] because it makes easier and more flexible for these entities to communicate and deal with the multi-threaded programming paradigm.

== Description ==

The join-pattern (or a chord in [[Cω]]) is like a super pipeline with synchronisation and matching. In fact, this concept is summarise by match and join a set of message available from different [[Message queue|message queue]]s, then handles them all simultaneously with one handler.<ref name="Join CalculusB">{{cite web |url=http://c2.com/cgi/wiki?JoinCalculus |title=Join Calculus |author=Taral Dragon |date=October 25, 2009 |access-date= }}</ref> It could be represented by the keywords {{code|when}} to specify the first communication that we expected, with the {{code|and}} to join/pair other channels and the {{code|do}} to run some tasks with the different collected messages. A constructed join pattern typically takes this form:

<source lang="text">
j.When(a1).And(a2). ... .And(an).Do(d)
</source>

{{quote|Argument {{mono|a1}} of {{code|When(a1)}} may be a synchronous or asynchronous channel or an array of asynchronous channels. Each subsequent argument {{mono|ai}} to {{code|And(ai)}} (for {{code|i > 1}}) must be an asynchronous channel.<ref>{{cite journal
 | last1 = Russo | first1 = Claudio V.
 | title = Join Patterns for Visual Basic
 | journal = ACM SIGPLAN Notices
 | volume = 43
 | issue = 10
 | page=10
 | date= 23 October 2008
 | doi = 10.1145/1449955.1449770
 }}</ref>}}

More precisely, when a message matches with a chain of linked patterns causes its ''handler'' to run (in a new thread if it's in asynchronous context) otherwise the message is queued until one of its patterns is enabled; if there are several matches, an unspecified pattern is selected.<ref name="Join CalculusA">{{cite web |url=http://www.parallelcsharp.com/ |title=Parallel C#|access-date= }}</ref> {{quote|Unlike an event handler, which services one of several alternative events at a time, in conjunction with all other handlers on that event, a join pattern waits for a conjunction of channels and competes for execution with any other enabled pattern.<ref>{{cite journal |last1=Russo |first1=Claudio V. |title=Join patterns for visual basic |journal=ACM SIGPLAN Notices |date=27 October 2008 |volume=43 |issue=10 |page=2 |doi=10.1145/1449955.1449770}}</ref>}}

[[File:JoinPatternFlowDiagram.png|framed|center|This flow diagram shows how the join pattern is executed by a general match with different channels (wait a chord) and synchronizes the resources (free or lock).]]

Join-pattern is defined by a set of pi-calculus channels {{mono|x}} that supports two different operations, sending and receiving, we need two join calculus names to implement it: a channel name {{mono|x}} for sending (a message), and a function name {{mono|x}} for receiving a value (a request). The meaning of the join definition is that a call to {{code|x()}} returns a value that was sent on a channel {{code|x<>}}.  Each time functions are concurrently, triggers the return process and synchronizes with other joins.<ref>{{cite book
 | last1 = Fournet | first1 = Cédric
 | title = Applied Semantics
 | volume = 2395
 | last2 = Gonthier | first2 = Georges
 | chapter = The Join Calculus: A Language for Distributed Mobile Programming
 | pages=268–332
 | publisher = Springer
 | year = 2002
 | doi = 10.1007/3-540-45699-6_6
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-44044-4
 | citeseerx = 10.1.1.4.4788
 }}</ref>

<source lang="pascal">
J ::= //join patterns
| x<y> //message send pattern
| x(y) //function call pattern
| J | JBIS //synchronization
</source>

{{quote|From a client’s perspective, a channel just declares a method of the same name and signature. The client posts a message or issues a request by invoking the channel as a method. A continuation method must wait until/unless a single request or message has arrived on each of the channels following the continuation’s When clause. If the continuation gets to run, the arguments of each channel invocation are dequeued (thus consumed) and transferred (atomically) to the continuation’s parameters.''<ref name="Russo2008">{{cite journal |last1=Russo |first1=Claudio V. |title=Join patterns for visual basic |journal=ACM SIGPLAN Notices |date=27 October 2008 |volume=43 |issue=10 |pages=53–72 |doi=10.1145/1449955.1449770}}</ref>}}

[[File:JoinPatternClassDiagram.png|framed|center|Class diagram of the Join pattern]]

In most of cases, the order of synchronous calls is not guaranteed for performance reasons. Finally, during the match the messages available in the queue could be stolen by some intervening thread; indeed, the awakened thread may have to wait again.<ref>{{cite journal
 | last1 = Russo | first1 = Claudio V.
 | title = Join Patterns for Visual Basic
 | journal = ACM SIGPLAN Notices
 | volume = 43
 | issue = 10
 | page=5
 | date= 23 October 2008
 | doi = 10.1145/1449955.1449770
 }}</ref>

== History ==

=== π-calculus – 1992 ===

The [[Π-calculus|π-calculus]] belongs to the family of process calculi, allows mathematical formalisms for describing and analyzing properties of concurrent computation by using channel names to be communicated along the channels themselves, and in this way it is able to describe concurrent computations whose network configuration may change during the computation.

=== Join-Calculus – 1993 ===

Join patterns first appeared in Fournet and Gonthier’s foundational join-calculus, an asynchronous process algebra designed for efficient implementation in a distributed setting.<ref>{{cite journal
 | last1 = Russo | first1 = Claudio V.
 | title = Join Patterns for Visual Basic
 | journal = ACM SIGPLAN Notices
 | volume = 43
 | issue = 10
 | page=18
 | date= 23 October 2008
 | doi = 10.1145/1449955.1449770
 }}</ref> The [[Join-calculus|join-calculus]] is a [[Process calculus|process calculus]] as expressive as the full [[Π-calculus|π-calculus]]. It was developed to provide a formal basis for the design of distributed programming languages, and therefore intentionally avoids communications constructs found in other process calculi, such as rendezvous communications.

=== Distributed Join-Calculus – 1996 ===

The Join-Calculus is both a name passing calculus and a core language for concurrent and distributed programming.<ref name="Compiling Join-Patterns">{{cite web
 | last1 = Maranget | first1 = Luc
 | last2 = Le Fessant | first2 = Fabrice
 | title = Compiling Join-Patterns
 | url = http://hevea.inria.fr/examples/pat.html
 | date= 25 September 2007
 | location = Le Chesnay France
 }}</ref> That's why the Distributed Join-Calculus<ref name="mobileagents">{{cite book
 | last1 = Fournet | first1 = Cédric
 | title = CONCUR '96: Concurrency Theory
 | volume = 1119
 | last2 = Gonthier | first2 = Georges
 | last3 = Levy | first3 = Jean-Jacques
 | last4 = Maranget | first4 = Luc
 | chapter = A calculus of mobile agents
 | location = Le Chesnay
 | year = 1996
 | pages=406–421
 | publisher = Concurrency Theory
 | doi = 10.1007/3-540-61604-7_67
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-61604-7
 }}</ref> based on the Join-Calculus with the [[Distributed computing|distributed programming]] was created on 1996. This work use the mobile agents where agents are not only programs but core images of running processes with their communication capabilities.

=== JoCaml, Funnel and Join Java – 2000 ===

[http://jocaml.inria.fr/ JoCaml]<ref>{{cite book|last1=Fournet|first1=Cedric|last2=Le Fessant|first2=Fabrice|last3=Maranget|first3=Luc|last4=Schmitt|first4=A. |title=Advanced Functional Programming |chapter=JoCaml: A Language for Concurrent Distributed and Mobile Programming |series=Lecture Notes in Computer Science |date=2003 |volume=2638 |pages=129–158 |doi=10.1007/978-3-540-44833-4_5|isbn=978-3-540-40132-2 }}</ref><ref>{{cite book|last1=Conchon|first1=S.|last2=Le Fessant|first2=F.|title=Proceedings. First and Third International Symposium on Agent Systems Applications, and Mobile Agents |chapter=Jocaml: Mobile agents for Objective-Caml |date=1999 |pages=22–29 |doi=10.1109/ASAMA.1999.805390|isbn=0-7695-0342-X |s2cid=14355301 }}</ref> and Funnel<ref>{{cite journal|last1=Odersky|first1=Martin|title=An overview of functional nets.|journal=Summer School, Caminha, Portugal, September 2000|volume=2395|date=September 2000}}</ref><ref>{{cite book|last1=Odersky|first1=Martin|title=Programming Languages and Systems |chapter=Functional Nets|volume=1782|pages=1–25|year=2000|doi=10.1007/3-540-46425-5_1|series=Lecture Notes in Computer Science|isbn=978-3-540-67262-3|doi-access=free}}</ref> are functional languages supporting declarative join patterns. They present the ideas to direct implement a process calculi in a functional setting.

Another extensions to (non-generic) Java, [[Join Java|JoinJava]], were independently proposed by von Itzstein and Kearney.<ref>{{cite journal|last1=Itzstein|first1=G. S.|last2=Kearney|first2=D.|title=Join Java: An alternative concurrency semantics for Java|journal=Technical Report ACRC-01-001, University of South Australia|year=2001}}</ref>

=== Polyphonic C# – 2002 ===

Cardelli, Benton and Fournet proposed an object-oriented version of join patterns for C# called Polyphonic C#.<ref>{{cite journal |last1=Benton|first1=N.|last2=Fournet|first2=C.|title=Modern concurrency abstractions for C#.|journal=In Proceedings of the 16th European Conference on Object-Oriented Programming (ECOOP 2002), Number 2374 in LNCS|date=June 2002}}</ref>

=== Cω – 2003 ===

Cω is adaptation of join-calculus to an object-oriented setting.<ref>{{cite book |last1=Benton|first1=N.|last2=Cardelli|first2=L.|title=Modern Concurrency Abstractions for C#. ACM Transactions on Programming Languages and Systems |volume=26|year=2004}}</ref> This variant of Polyphonic C# was included in the public release of Cω (a.k.a. Comega) in 2004.

=== Scala Joins – 2007 ===

[http://lampwww.epfl.ch/~phaller/joins/index.html Scala Joins] is a library to use Join-Pattern with Scala in the context of extensible pattern matching in order to integrate joins into an existing actor-based concurrency framework.

=== JErlang – 2009 ===

[[Erlang (programming language)|Erlang]] is a language which natively supports the concurrent, real time and distributed paradigm. Concurrency between processes was complex, that's why the project build a new language, [https://web.archive.org/web/20171208175247/http://www.doc.ic.ac.uk/~susan/jerlang/ JErlang] (''J'' stands for ''Join'') using based on the Join-calculus.

== Join-pattern in classic programming literature ==

"Join-patterns can be used to easily encode related concurrency idioms like actors and active objects."<ref>{{cite web
 | last = Singh | first = Satnam
 | title = Higher Order Combinators for Join Patterns using STM
 | url = https://urresearch.rochester.edu/fileDownloadForInstitutionalItem.action?itemId=3699&itemFileId=5278
 | page = 1
 | date= 6 January 2007
 }}</ref>

* [[Barrier (computer science)|Barriers]]<ref name="Scalable Join Patterns">{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | page=4
 | isbn = 978-1-4503-0940-0
 }}</ref>
<source lang="csharp">
class SymmetricBarrier
{
    public readonly Synchronous.Channel Arrive;

    public SymmetricBarrier(int n)
    {
        // Create j and init channels (elided)
        var pat = j.When(Arrive);
        for (int i = 1; i < n; i++)
            pat = pat.And(Arrive);
        pat.Do(() => { });
    }
}
</source>
* [[Dining philosophers problem]]<ref>{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | page=1
 | isbn = 978-1-4503-0940-0
 }}</ref>
<source lang="csharp">
var j = Join.Create();
Synchronous.Channel[] hungry;
Asynchronous.Channel[] chopstick;
j.Init(out hungry, n);
j.Init(out chopstick, n);

for (int i = 0; i < n; i++)
{
    var left = chopstick[i];
    var right = chopstick[(i+1) % n];
    j.When(hungry[i]).And(left).And(right).Do(() => {
        eat();
        left();
        right(); // replace chopsticks
    });
}
</source>
* [[Mutual exclusion]]<ref name="research.microsoft.com">{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | page=3
 | isbn = 978-1-4503-0940-0
 }}</ref>
<source lang="csharp">
class Lock
{
    public readonly Synchronous.Channel Acquire;
    public readonly Asynchronous.Channel Release;

    public Lock()
    {
        // Create j and init channels (elided)
        j.When(Acquire).And(Release).Do(() => { });
        Release(); // initially free
    }
}
</source>

* [[Producer–consumer problem|Producers/Consumers]]<ref>{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | page=2
 | isbn = 978-1-4503-0940-0
 }}</ref>
<source lang="csharp">
class Buffer<T>
{
    public readonly Asynchronous.Channel<T> Put;
    public readonly Synchronous<T>.Channel Get;

    public Buffer()
    {
        Join j = Join.Create(); // allocate a Join object
        j.Init(out Put);
        // bind its channels
        j.Init(out Get);
        j.When(Get).And(Put).Do // register chord
        (t => { return t; });
    }
}
</source>
* [[Readers–writer lock|Reader-writer locking]]<ref name="Scalable Join Patterns" />
<source lang="csharp">
class ReaderWriterLock
{
    private readonly Asynchronous.Channel idle;
    private readonly Asynchronous.Channel<int> shared;
    public readonly Synchronous.Channel AcqR, AcqW, RelR, RelW;

    public ReaderWriterLock()
    {
        // Create j and init channels (elided)
        j.When(AcqR).And(idle).Do(() => shared(1));
        j.When(AcqR).And(shared).Do(n => shared(n+1));
        j.When(RelR).And(shared).Do(n => {
            if (n == 1)
            {
                idle();
            }
            else
            {
                shared(n-1);
            }
        });
        j.When(AcqW).And(idle).Do(() => { });
        j.When(RelW).Do(() => idle());
        idle(); // initially free
    }
}
</source>

* [[Semaphore (programming)|Semaphores]]<ref name="research.microsoft.com" />
<source lang="csharp">
class Semaphore
{
    public readonly Synchronous.Channel Acquire;
    public readonly Asynchronous.Channel Release;

    public Semaphore(int n)
    {
        // Create j and init channels (elided)
        j.When(Acquire).And(Release).Do(() => { });
        for (; n > 0; n--)
            Release(); // initially n free
    }
}
</source>

== Fundamental features and concepts ==
* [[Join-calculus]] : The first apparition of the Join-Pattern comes out with this process calculus.
* [[Message passing]] : Join-pattern works with a message passing system for parallel reason.
* Channel : Channels are used to synchronize and pass messages between concurrently executing threads. In general, a channel may be involved in more than one join pattern, each pattern defines a different continuation that may run when the channel is invoked .<ref name="Russo2008" />
* Synchronous : The join-pattern could use a synchronous channel which return a result. The continuation of a synchronous pattern runs in the thread of the synchronous sender.<ref name="Russo2008" />
* Asynchronous :  It could also use an asynchronous channel which return no result but take arguments. The continuation of an asynchronous pattern runs in a newly spawned thread. A join pattern may be purely asynchronous, provided its continuation is a subroutine and its When clause only lists asynchronous channels.<ref name="Russo2008" />
* Combine synchronous and asynchronous : Merging the declarations of synchronous and asynchronous buffer would yield a module that supports the two communication type of consumers.<ref name="Russo2008" />
* [[Scheduling (computing)|Scheduler]] : There is a scheduling between join patterns (e.g. a round-robin scheduler, first-match scheduler).<ref name="Russo2008" />
* [[Software design pattern|Design patterns]] : The join-pattern is first of all a behavioral and a concurrency pattern.
* Concurrent programming : It's execute in a concurrent way.
* [[Pattern matching]] : The join-pattern works with matching tasks.
* Parallel programming : It performs tasks in parallel.
* Distributed programming : Jobs could be scatter on different agent and environments with this pattern.
* [[Software transactional memory]] : Software transactional memory (STM) is one of the possible implementation for the communications between joint.
* Overlapping : The pattern could allow patterns declared on overlapping sets of channels.

== Application domain ==

=== Mobile agent ===
A [[Mobile agent|mobile agent]] is an autonomous software agent with a certain social ability and most importantly, mobility. It is composed of computer software and data which can move between different computers automatically while continuing their executions.

The mobile agents can be used to match concurrency and distribution if one uses the Join-calculus. That's why a new concept named "distributed Join-calculus" was created; it's an extension of Join-calculus with locations and primitives to describe the mobility.
This innovation use agents as running processes with their communication capabilities to allow an idea of location, which is a physical site expressing the actual position of the agent. Thanks to the Join-calculus, one location can be moved atomically to another site.<ref name="A Calculus of Mobile Agents">{{cite book
 | last1 = Fournet | first1 = Cédric
 | title = CONCUR '96: Concurrency Theory
 | volume = 1119
 | pages = 406–421
 | last2 = Gonthier | first2 = Georges
 | last3 = Levy | first3 = Jean-Jacques
 | last4 = Maranget | first4 = Luc
 | last5 = Remy | first5 = Didier
 | chapter = A calculus of mobile agents
 | location = Le Chesnay
 | year = 1996
 | publisher = Concurrency Theory
 | doi = 10.1007/3-540-61604-7_67
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-61604-7
 }}</ref>

The processes of an agent is specified as a set which define its functionality including asynchronous emission of a message, migration to other location. Consequently, locations are organized in a tree to represent the movement of the agent easier. With this representation, a benefit of this solution is the possibility to create a simple model of failure. Usually a crash of a physical site causes the permanent failure of all its locations. But with the join-calculus a problem with a location can be detected at any other running location, allowing error recovery.<ref name="A Calculus of Mobile Agents" />

{{quote|So the Join-calculus is the core of a distributed programming language. In particular, the operational semantics is easily implementable in a distributed setting with failures. So the distributed join-calculus treats channel names and location names as first class values with lexical scopes. A location controls its own moves, and can only move towards a location whose name it has received. This provides a sound basis for static analysis and for secure mobility. This is complete for expressing distributed configurations. In the absence of failure, however, the execution of processes is independent of distribution. This location transparency is essential for the design of mobiles agents, and very helpful for checking their properties.<ref name="A Calculus of Mobile Agents" />}}

In 2007, an extension of the basic join calculus with methods which make agents proactive has come out. The agents can observe an environment shared between them. With this environment, it is possible to define shared variables with all agents (e.g. a naming service to discover agents between themselves).<ref>{{cite book
 | last1 = Maludzinski | first1 = Slawomir
 | title = Multi-Agent Systems and Applications V
 | volume = 4696
 | last2 = Dobrowolski | first2 = Grzegorz
 | year = 2007
 | pages=298–300
 | doi = 10.1007/978-3-540-75254-7_30
 | chapter = Agent Environment and Knowledge in Distributed Join Calculus
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-75253-0
 }}</ref>

=== Compilation ===
Join-languages are built on top of the join-calculus taken as a core language. So all the calculus are analysed with asynchronous processes and the join pattern provides a model to synchronize the result.<ref name="Compiling Join-Patterns" /><br />
To do this, it exists two Compilers:
* Join Compiler: A compiler of a language named "join langage". This language has been created only for the join calculus
* [http://pauillac.inria.fr/jocaml/ Jocaml Compiler] {{Webarchive|url=https://web.archive.org/web/20051001115238/http://pauillac.inria.fr/jocaml/ |date=2005-10-01 }}: A compiler of an extension of Objectif Caml created to use the join calculus.

This two compiler works with the same system, an automaton.
<source lang=text>
let A(n) | B() = P(n)
and A(n) | C() = Q(n)
;;
</source>

It represents the consumption of message arrive at a completed join model. Each state is a possibly step for the code execution and each transitions is the reception of a message to change between two steps. And so when all messages are grab, the compiler execute the body join code corresponding to the completed model joint.

So in the join-calculus, the basic values are the names like on the example is A,B or C. So the two compiler representing this values with two ways.<br />
Join compiler use a vector with Two slots, the first to the name it-self and the second to a queue of pending messages.<br />
Jocaml use name like a pointer on definitions. This definitions store the others pointer of the others names with a status field and a matching date structure by message.<br />
The fundamental difference is when the guard process is executed, for the first, it was verify if all names are the pending messages ready whereas the second use only one variable and access at the others to know if the model is completed.<ref name="Compiling Join-Patterns" />

Recent research describe the compilation scheme as the combination of two basic steps: dispatching and forwarding. The design and correctness of the dispatcher essentially stems from pattern matching theory, while inserting an internal forwarding step in communications is a natural idea, which intuitively does not change process behavior. They made the observation that ''the worth observing is a direct implementation of extended join-pattern matching at the runtime level would significantly complicate the management of message queues, which would then need to be scanned in search of matching messages before consuming them.''<ref>{{cite book
 | last1 = Ma | first1 = Qin
 | volume = 3170
 | last2 = Maranget | first2 =  Luc
 | title = CONCUR 2004 - Concurrency Theory
 | chapter = Compiling Pattern Matching in Join-Patterns
 | pages=417–431
 | date= 5 April 2004
 | publisher=INRIA
 | doi = 10.1007/978-3-540-28644-8_27
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-22940-7
 | citeseerx = 10.1.1.499.8443
 | s2cid = 9956643
 }}</ref>

== Implementations and libraries ==

There are many uses of the Join-patterns with different languages. Some languages use join-patterns as a base of theirs implementations, for example the Polyphonic C# or [http://www.mcsharp.net/ MC#] but others languages integrate join-pattern by a library like Scala Joins<ref name=" Implementing Joins Using Extensible Pattern Matching">{{cite book
 | last1 = Haller | first1 = Phillip
 | title = Coordination Models and Languages
 | volume = 5052
 | last2 = Van Cutsem | first2 = Tom
 | chapter = Implementing Joins Using Extensible Pattern Matching
 | location = Lausanne
 | year = 2008
 | publisher = Coordination Models and Languages
 | pages=135–152
 | doi = 10.1007/978-3-540-68265-3_9
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-68264-6
 | citeseerx = 10.1.1.210.1242
 }}</ref> for Scala or the Joins library for VB.<ref name="Join Patterns for Visual Basic">{{cite journal
 | last1 = Russo | first1 = Claudio V.
 | title = Join Patterns for Visual Basic
 | journal = ACM SIGPLAN Notices
 | volume = 43
 | issue = 10
 | pages=53–72
 | date= 23 October 2008
 | doi = 10.1145/1449955.1449770
 }}</ref> Moreover, the join-pattern is used through some languages like [[Scheme (programming language)|Scheme]] to upgrade the join-pattern.<ref name="scheme">{{cite web
 | last1 = Sulzmann | first1 = Martin
 | last2 = S. L. Lam | first2 = Edmund
 | title = Parallel Join Patterns with Guards and Propagation
 | location = Denmark
 | url = http://moscova.inria.fr/~maranget/papers/mobile.ps
 }}</ref>

{| class="wikitable" style="margin:1em auto;"
! !! JErlang  !! CB !! Joins Library !! Polyphonic C# !! Parallel C# !! Cω !! Scala Joins !! F# !! Scheme !! Join Java !! Hume !! JoCaml
|-
| Patterns matching || {{yes}} || {{yes}} || {{yes}}  || {{yes}} || {{yes}} || {{yes}}  || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}}
|-
| Scheduler between join-patterns || {{yes}} : first match || {{yes}} : first/round robin || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} || {{yes}} : random || {{yes}} : first/round robin || {{yes}} : random
|-
| Generics || {{yes}} || {{n/a}} || {{yes}} || {{no}}|| {{n/a}} || {{no}} || {{yes}}  || {{yes}} || {{no}} || {{no}} || {{no}} || {{no}}
|-
| Overriding || {{no}} || {{yes}} || {{n/a}} || {{n/a}} || {{n/a}} || {{yes}}  || {{yes}} || {{yes}} || {{no}} || {{yes}} || {{no}} || {{no}}
|}

=== Join Java ===
[[Join Java]]<ref name="Join Java">{{cite book
 | last1 = Hopf
 | first1 = J.
 | last2 = von Itzstein
 | first2 = G.
 | last3 = Stewart
 | first3 = al.
 | title = Hardware Join Java: A High Level Language For Reconfigurable Hardware Development 
 | url = http://ura.unisa.edu.au/R/?func=dbin-jump-full&object_id=unisa36854
 | archive-url = https://archive.today/20130219170713/http://ura.unisa.edu.au/R/?func=dbin-jump-full&object_id=unisa36854
 | url-status = dead
 | archive-date = 2013-02-19
 | year = 2002
 | location = Hong Kong |publisher=IEEE
 }}</ref> is a language based on the [[Java (programming language)|Java programming language]] allowing the use of the join calculus. It introduces three new language constructs:
* '''Join methods''' is defined by two or more Join fragments. A Join method will execute once all the fragments of the Join pattern have been called. If the return type is a standard Java type then the leading fragment will block the caller until the Join pattern is complete and the method has executed. If the return type is of type signal then the leading fragment will return immediately. All trailing fragments are asynchronous so will not block the caller.

Example:
<source lang="java">
class JoinExample {
    int fragment1() & fragment2(int x) {
        // Will return value of x to caller of fragment1
        return x;
    }
}
</source>
* '''Asynchronous methods''' are defined by using the signal return type. This has the same characteristics as the void type except that the method will return immediately. When an asynchronous method is called a new thread is created to execute the body of the method.

Example:
<source lang="java">
class ThreadExample {
    signal thread(SomeObject x) {
        // This code will execute in a new thread
    }
}
</source>
* '''Ordering modifiers'''
Join fragments can be repeated in multiple Join patterns so there can be a case when multiple Join patterns are completed when a fragment is called. Such a case could occur in the example below if B(), C() and D() then A() are called. The final A() fragment completes three of the patterns so there are three possible methods that may be called. The ordered class modifier is used here to determine which Join method will be called. The default and when using the unordered class modifier is to pick one of the methods at random. With the ordered modifier the methods are prioritised according to the order they are declared.

Example:
<source lang="java">
class ordered SimpleJoinPattern {
    void A() & B() {
    }
    void A() & C() {
    }
    void A() & D() {
    }
    signal D() & E() {
    }
}
</source>
The closest related language is the Polyphonic C#.

=== JErlang ===
In [[Erlang (programming language)|Erlang]] coding synchronisation between multiple processes is not straightforward. That's why the
JErlang,<ref name="JErlang">{{cite book
 | last1 = Plociniczak
 | first1 = Hubert
 | last2 = Eisenbach
 | first2 = Susan
 | title = Coordination Models and Languages
 | chapter = JErlang: Erlang with Joins
 | series = Lecture Notes in Computer Science
 | date = 2010
 | publisher=Springer 
 | volume = 6116
 | pages = 61–75
 | bibcode = 2010LNCS.6116...61P
 | doi = 10.1007/978-3-642-13414-2_5
 | isbn = 978-3-642-13413-5
 | doi-access = free
 }}</ref> an extension of [[Erlang (programming language)|Erlang]] was created, The J is for Join. Indeed, To overcome this limitation JErlang was implemented, a [[Join-calculus|Join-Calculus]] inspired extension to [[Erlang (programming language)|Erlang]].
The features of this language are:

* '''Joins''' allows first Match semantics and the possibility of having multiple patterns with a preservation of the messages's order.

<source lang="erlang">
operation() ->
    receive
        {ok, sum} and {val, X} and {val, Y} ->
            {sum, X + Y};
        {ok, mult} and {val, X} and {val, Y} ->
            {mult, X * Y};
        {ok, sub} and {val, X} and {val, Y} ->
            {sub, X - Y};
    end
end
</source>

* '''Guards''' provides additional filtering not expressing in terms of patterns. Limited number of expression without side-effects

<source lang="erlang">
receive
    {Transaction, M} and {limit, Lower, Upper}
        when (Lower <= M and M <= Upper ) ->
    commit_transaction(M, Transaction)
end
</source>

* With '''Non-linear patterns''', messages can match multiple joins

<source lang="erlang">
receive
    {get, X} and {set, X} ->
        {found, 2, X}
end
...
receive
    {Pin, id} and {auth, Pin} and {commit, Id} ->
        perform_transaction(Pin, Id)
end
</source>

* '''propagation''' allows for copying correct messages instead of removing them.

<source lang="erlang">
receive
    prop({session, Id}) and {act, Action, Id} ->
        perform_action(Action, Id);
    {session, Id} and {logout, Id} ->
        logout_user(Id)
end
...
receive
    {Pin, id} and {auth, Pin} and {commit, Id} ->
        perform_transaction(Pin, Id)
end
</source>

* '''Synchronous calls'''

<source lang="erlang">
receive
    {accept, Pid1} and {asynchronous, Value}
                   and {accept, Pid2} ->
        Pid1 ! {ok, Value},
        Pid2 ! {ok, Value}
end
</source>

=== C++ ===

Yigong Liu has written some [http://channel.sourceforge.net/boost_join/libs/join/doc/synopsis_port.html classes for the join pattern] including all useful tools like asynchronous and synchronous channels, [[Chord (concurrency)|chords]], etc. It's integrated in the project [http://www.boost.org/ Boost c++].

<source lang="cpp">
template <typename V>
class buffer: public joint {
public:
  async<V> put;
  synch<V,void> get;
  buffer() {
    chord(get, put, &buffer::chord_body);
  }
  V chord_body(void_t g, V p) {
    return p;
  }
};
</source>

This example shows us a thread safe buffer and message queue with the basic operations put and get.<ref>{{cite web |url=http://channel.sourceforge.net/ |title=Join – Asynchronous Message Coordination and Concurrency Library |first1=Yigong |last1= Liu |date=2007–2009 |access-date= }}</ref>

=== C# ===

==== Polyphonic C# ====
Polyphonic C# is an extension of the C# programming language. It introduces a new concurrency model with synchronous and asynchronous (which return control to the caller) methods and chords (also known as ‘synchronization patterns’ or ‘join patterns’).

<source lang="csharp">
public class Buffer
{
    public String get() & public async put(String s)
    {
        return s;
    }
}
</source>
This is a simple buffer example.<ref>{{cite web |url=http://research.microsoft.com/en-us/um/people/nick/polyphony/intro.htm |title=Introduction to Polyphonic C#|access-date= }}</ref>

==== MC# ====
[http://www.mcsharp.net/ MC#] language is an adaptation of the Polyphonic C# language for the case of concurrent distributed computations.

<source lang="csharp">
public handler Get2 long () & channel c1 (long x)
& channel c2 (long y)
{
    return (x + y);
}
</source>
This example demonstrates the using of chords as a synchronization tool.

==== Parallel C# ====
[http://www.parallelcsharp.com/ Parallel C#] is based Polyphonic C#  and they add some new concepts like movables methods, high-order functions.
<source lang="csharp">
using System;

class Test13
{
    int Receive() & async Send(int x)
    {
        return x * x;
    }

    public static void Main(string[] args)
    {
        Test13 t = new Test13();
        t.Send(2);
        Console.WriteLine(t.Receive());
    }
}
</source>

This example demonstrates how to use joins.<ref>{{cite web|url=http://www.parallelcsharp.com/tests/tests.htm|title=Parallel C#|access-date= |archive-url=https://web.archive.org/web/20131126050938/http://parallelcsharp.com/tests/tests.htm|archive-date=2013-11-26|url-status=dead}}</ref>

==== Cω ====

[[Cω]] adds new language features to support concurrent programming (based on the earlier Polyphonic C#). The Joins Concurrency Library for C# and other .NET languages is derived of this project.<ref>{{cite book |url=http://research.microsoft.com/apps/pubs/default.aspx?id=67944 |title=The Joins Concurrency Library|volume=4354|access-date= |isbn=978-3-540-69608-7|date=January 2007|last1=Hanus|first1=Michael}}</ref><ref>{{cite web |url=http://research.microsoft.com/en-us/um/cambridge/projects/comega/|title=Comega|access-date= }}</ref>

==== Scalable Join Patterns ====

It's an easy to use declarative and scalable join-pattern library. In opposite to the Russo library,<ref name="Join Patterns for Visual Basic" /> it has no global lock. In fact, it's working with a [[Compare-and-swap|compare-and-swap]] CAS and Atomic message system. The library<ref>{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | isbn = 978-1-4503-0940-0
 }}</ref> use three improvements for the join-pattern :
* Stealing message for unused resources (allowing barging);
* Lazy queue saves both on allocation and potentially on interprocessor communication by avoiding allocate or enqueue with an optimistic fast-path;
* A status "WOKEN" : ensures that a blocked synchronous caller is woken only once.

=== JoCaml ===
[[Software:JoCaml|JoCaml]] is the first language where the join-pattern was implemented. Indeed, at the beginning all the different implementation was compiled with the JoCaml Compiler.
[http://jocaml.inria.fr/ JoCaml language] is an extension of the [[OCaml]] language. It extends OCaml with support for concurrency and synchronization, the distributed execution of programs, and the dynamic relocation of active program fragments during execution.<ref name="jocaml">{{cite book|title=Advanced Functional Programming|last2=Le Fessant|first2=Fabrice|last3=Maranget|first3=Luc|last4=Schmitt|first4=Alan|publisher=Springer-Verlag|year=2003|series=Lecture Notes in Computer Science|pages=129–158|chapter=JoCaml: a Language for Concurrent Distributed and Mobile Programming|chapter-url=http://research.microsoft.com/en-us/um/people/fournet/papers/jocaml-afp4-summer-school-02.pdf|last1=Fournet|first1=Cedric}}</ref>

<source lang="ocaml">
type coins = Nickel | Dime
and drinks = Coffee | Tea
and buttons = BCoffee | BTea | BCancel;;

(* def defines a Join-pattern set clause
 * "&" in the left side of = means join (channel synchronism)
 * "&" in the right hand side means: parallel process
 * synchronous_reply :== "reply" [x] "to" channel_name
 * synchronous channels have function-like types (`a -> `b)
 * asynchronous channels have types (`a Join.chan)
 * only the last statement in a pattern rhs expression can be an asynchronous message
 * 0 in an asynchronous message position means STOP ("no sent message" in CSP terminology).
   *)

def put(s) = print_endline s ; 0 (* STOP *)
  ;; (* put: string Join.chan *)

def serve(drink) = match drink with
                 Coffee -> put("Cofee")
                 | Tea -> put("Tea")
              ;; (* serve: drinks Join.chan *)

def refund(v) = let s = Printf.sprintf "Refund %d" v in put(s)
    ;; (* refund: int Join.chan *)

let new_vending serve refund =
  let vend (cost:int) (credit:int) = if credit >= cost
                      then (true, credit - cost)
                      else (false, credit)
  in
  def coin(Nickel) & value(v) = value(v+5) & reply () to coin
  or coin(Dime) & value(v) = value(v+10) & reply () to coin

  or button(BCoffee) & value(v) = 
     let should_serve, remainder = vend 10 v in
     (if should_serve then serve(Coffee) else 0 (* STOP *))
             & value(remainder) & reply () to button

  or button(BTea) & value(v) = 
     let should_serve, remainder = vend 5 v in
     (if should_serve then serve(Tea) else 0 (* STOP *))
             & value(remainder) & reply () to button

  or button(BCancel) & value(v) = refund( v) & value(0) & reply () to button
  in spawn value(0) ;
  coin, button  (* coin, button: int -> unit *)
  ;; (* new_vending: drink Join.chan -> int Join.chan -> (int->unit)*(int->unit) *)

let ccoin, cbutton = new_vending serve refund in
  ccoin(Nickel); ccoin(Nickel); ccoin(Dime);
  Unix.sleep(1); cbutton(BCoffee);
  Unix.sleep(1); cbutton(BTea);
  Unix.sleep(1); cbutton(BCancel);
  Unix.sleep(1) (* let the last message show up *)
  ;;
</source>
gives
<pre>Coffee
Tea
Refund 5
</pre>

=== Hume ===

[[Hume (programming language)|Hume]]<ref>[http://www.cs.nott.ac.uk/~nhn/TFP2006/Papers/31-HammondMichaelsonSun-EA2-ProgrammingReactiveSystemsInHume.pdf Hammond/Michaelson/Sun – Programming reactive systems in Hume]</ref> is a strict, strongly typed [[Functional programming|functional]] language for limited resources platforms, with concurrency based on asynchronous message passing, [[Dataflow programming|dataflow programming]], and a [[Haskell (programming language)|Haskell]] like syntax.

Hume does not provide synchronous messaging.

It wraps a join-pattern set with a channel in common as a ''box'', listing all channels in an ''in'' tuple and specifying all possible outputs in an ''out'' tuple.

Every join-pattern in the set must conform to the ''box'' input tuple type specifying a '*' for non required channels, giving an expression whose type conform to the output tuple, marking '*' the non fed outputs.

A ''wire'' clause specifies
# a tuple of corresponding input origins or sources and optionally start values
# a tuple of output destinations, being channels or sinks (stdout, ..).

A ''box'' can specify exception handlers with expressions conforming to the output tuple.
<source lang="haskell">
data Coins = Nickel | Dime;
data Drinks = Coffee | Tea;
data Buttons = BCoffee | BTea | BCancel;

type Int = int 32 ;
type String = string ;
show u = u as string ;

box coffee
in ( coin :: Coins, button :: Buttons, value :: Int ) -- input channels
out ( drink_outp :: String, value’ :: Int, refund_outp :: String)  -- named outputs

match
-- * wildcards for unfilled outputs, and unconsumed inputs
  ( Nickel, *, v)  -> ( *, v + 5, *)
| ( Dime, *, v)    -> ( *, v + 10, *)
| ( *, BCoffee, v) -> vend Coffee 10 v
| ( *, BTea, v)    -> vend Tea 5 v
| ( *, BCancel, v) -> let refund u = "Refund " ++ show u ++ "\n"
                      in ( *, 0, refund v)
;

vend drink cost credit = if credit >= cost
                      then ( serve drink, credit - cost, *)
                      else ( *, credit, *);

serve drink = case drink of
               Coffee -> "Cofee\n"
               Tea -> "Tea\n"
;

box control
in (c :: char)
out (coin :: Coins, button:: Buttons)
match
 'n' -> (Nickel, *)
 | 'd' -> (Dime, *)
 | 'c' -> (*, BCoffee)
 | 't' -> (*, BTea)
 | 'x' -> (*, BCancel)
 | _ -> (*, *)
;

stream console_outp to "std_out" ;
stream console_inp from "std_in" ;

-- dataflow wiring

wire cofee
    -- inputs (channel origins)
    (control.coin, control.button, coffee.value’ initially 0)
    -- outputs destinations
    (console_outp, coffee.value, console_outp)
;

wire control
    (console_inp)
    (coffee.coin, coffee.button)
;
</source>

=== Visual Basic ===

==== Concurrent Basic – CB ====

An extension of Visual Basic 9.0 with asynchronous concurrency constructs, called Concurrent Basic (for short CB), offer the join patterns. CB (builds on earlier work on Polyphonic C#, Cω and the Joins Library) adopts a simple event-like syntax familiar to VB programmers, allows one to declare generic concurrency abstractions and provides more natural support for inheritance, enabling a subclass to augment the set of patterns. CB class can declare method to execute ''when'' communication has occurred on a particular set of local channels asynchronous and synchronous, forming a join pattern.<ref name="Join Patterns for Visual Basic" />

<source lang="vbnet">
Module Buffer

    Public Asynchronous Put(ByVal s As String)
    Public Synchronous Take() As String

    Private Function CaseTakeAndPut(ByVal s As String) As String _
        When Take, Put
            Return s
    End Function

End Module
</source>
This example shows all new keywords used by Concurrent Basic: Asynchronous, Synchronous and When.<ref>{{cite web |url=http://research.microsoft.com/en-us/projects/concurrentbasic/default.aspx|title=Concurrent Basic|access-date= |archive-url=https://web.archive.org/web/20150425172921/http://research.microsoft.com/en-us/projects/concurrentbasic/default.aspx|archive-date=2015-04-25|url-status=dead}}</ref>

=== Joins library (C# and VB) ===

This library is a high-level abstractions of the Join Pattern using objects and generics. Channels are special delegate values from some common Join object (instead of methods).<ref>{{cite book
 | last1 = Russio | first1 = Claudio
 | title = Practical Aspects of Declarative Languages
 | volume = 4354
 | location = Cambridge
 | pages=260–274
 | publisher  = Practical Aspects of Declarative Languages
 | doi = 10.1007/978-3-540-69611-7_17
 | series = Lecture Notes in Computer Science
 | date = 2006
 | isbn = 978-3-540-69608-7
 | chapter = The Joins Concurrency Library
 | citeseerx = 10.1.1.187.8792
 }}</ref>

<source lang="csharp">
class Buffer
{
    public readonly Asynchronous.Channel<string> Put;
    public readonly Synchronous<string>.Channel Get;

    public Buffer()
    {
        Join join = Join.Create();
        join.Initialize(out Put);
        join.Initialize(out Get);
        join.When(Get).And(Put).Do(delegate(string s) {
            return s;
        });
    }
}
</source>
This example shows how to use methods of the Join object.<ref>{{cite web |url=http://research.microsoft.com/en-us/um/people/crusso/joins/ |title=The Joins Concurrency Library|access-date= }}</ref>

=== Scala ===

There is a library in Scala called "Scala Joins" [http://lampwww.epfl.ch/~phaller/joins/index.html Scala Joins] to use the Join-Pattern, it proposes to use pattern matching [[Pattern matching|Pattern Matching]] as a tool for creating models of joins. You can find examples of the use of the join pattern in scala here: [https://web.archive.org/web/20070423181850/http://lampwww.epfl.ch/~cremet/join_in_scala/index.html Join definitions in Scala].

The pattern matching facilities of this language have been generalized to allow representation independence for objects used in pattern matching. So now it's possible to use a new type of abstraction in libraries. The advantage of join patterns is that they allow a declarative specification of the synchronization between different threads. Often, the join patterns corresponds closely to a finite state machine that specifies the valid states of the object.

In Scala, it's possible to solve many problem with the pattern matching and Scala Joins, for example the Reader-Writer.<ref name=" Implementing Joins Using Extensible Pattern Matching" />
<source lang="scala">
class ReaderWriterLock extends Joins {

  private val Sharing = new AsyncEvent[Int]
  val Exclusive, ReleaseExclusive = new NullarySyncEvent
  val Shared, ReleaseShared = new NullarySyncEvent
  join {
    case Exclusive() & Sharing(0) => Exclusive reply
    case ReleaseExclusive() => { Sharing(0); ReleaseExclusive reply }
    case Shared() & Sharing(n) => { Sharing(n+1); Shared reply }
    case ReleaseShared() & Sharing(1) => { Sharing(0); ReleaseShared reply }
    case ReleaseShared() & Sharing(n) => { Sharing(n-1); ReleaseShared reply }
  }
  Sharing(0) }
</source>

With a class we declare events in regular fields. So, it's possible to use the Join construct to enable a pattern matching via a list of case declarations. That list is representing by => with on each side a part of the declaration. The left-side is a model of join pattern to show the combinaison of events asynchronous and synchronous and the right-side is the body of join which is executed with the join model is completed.

In Scala, it's also possible to use the Scala's actor library<ref name="actorScala">{{cite book
 | last1 = Haller | first1 = Phillip
 | last2 = Odersky| first2 = Martin
 | chapter = Actors that unify threads and events |title=Coordination Models and Languages
 | series = Lecture Notes in Computer Science
 | date = June 2007
 | volume = 4467
 | pages = 171–190
 | publisher = Springer |doi=10.1007/978-3-540-72794-1_10
 | isbn = 978-3-540-72793-4
 | chapter-url = http://infoscience.epfl.ch/record/104549
 }}</ref> with the join pattern. For example, an unbounded buffer:<ref name=" Implementing Joins Using Extensible Pattern Matching" />

<source lang="scala">
val Put = new Join1[Int]
val Get = new Join
class Buffer extends JoinActor {
  def act() {
    receive { case Get() & Put(x) => Get reply x }
  } }
</source>

Actor-based concurrency is supported by means of a library and we provide join patterns as a library extension as well, so there are the opportunity to combine join patterns with the event-driven concurrency model offered by actors. Like you see in the example, it's the same way to use join pattern with actors, it just do it a list of case declaration in the method receive to show when the model is completed.

Practically the same tools are available in F# to use join pattern

[https://github.com/Jiansen/ScalaJoin Scala Join] and [https://github.com/Chymyst/chymyst-core Chymyst] are newer implementations of the Join Pattern, improving upon Dr. Philipp Haller's [https://web.archive.org/web/20160303222156/http://homepages.inf.ed.ac.uk/s1024484/join/ Scala Joins].

=== Haskell ===
[https://github.com/syallop/Join-Language Join Language] is an implementation of the Join Pattern in Haskell.

=== Scheme ===
The Join Patterns allows a new programming type especially for the multi-core architectures available in many programming situations with a high-levels of abstraction. This is based on the Guards and Propagation. So an example of this innovation has been implemented in Scheme .<ref name="scheme" />

Guards is essential to guarantee that only data with a matching key is updated/retrieved. Propagation can cancel an item, reads its contents and puts backs an item into a store. Of course, the item is also in the store during the reading. The guards is expressed with shared variables. And so the novelty is that the join pattern can contains now propagated and simplified parts. So in Scheme, the part before / is propagated and the part after / is removed.
The use of the Goal-Based is to divise the work in many tasks and joins all results at the end with the join pattern. A system named "MiniJoin" has implemented to use the intermediate result to solve the others tasks if it's possible. If is not possible it waits the solution of others tasks to solve itself.<br />
So the concurrent join pattern application executed in parallel on a multi-core architecture doesn't guarantee that parallel execution lead to conflicts. To Guarantee this and a high degree of parallelism, a Software Transactional Memory (STM) within a highlytuned concurrent data structure based on atomic compare-and-swap (CAS) is use. This allows to run many concurrents operations in parallel on multi-core architecture. Moreover, an atomic execution is used to prevent the "false conflict" between CAS and STM.<ref name="scheme" />

== Other similar design patterns ==

Join Pattern is not the only pattern to perform multitasks but it's the only one that allow communication between resources, synchronization and join different processes.

* Sequence pattern : consists of waiting that a task have completed to switch to another (the classic implementation).<ref>{{citation
 | last = MONSIEUR | first = Geert
 | title = Pattern-based Coordination in Process-based Service Compositions
 | url = https://lirias.kuleuven.be/handle/123456789/284037
 | year = 2010
 | page = 68
 | location = Leuven Belgium
 | publisher= Katholiek Universiteit Leuven
 }}</ref>

* Split pattern (''parallel split'') : perform several tasks in parallel at the same time (e.g. Map reduce).<ref>{{citation
 | last = MONSIEUR | first = Geert
 | title = Pattern-based Coordination in Process-based Service Compositions
 | url = https://lirias.kuleuven.be/handle/123456789/284037
 | year = 2010
 | page = 70
 | location = Leuven Belgium
 | publisher= Katholiek Universiteit Leuven
 }}</ref>

== See also ==

* [[Join Java]] – Join Java is a programming language that extends the standard Java programming language
* [[Joins (concurrency library)]] – Joins is an asynchronous concurrent computing API from Microsoft Research for the .NET Framework.
* [[Join-calculus]] – The join-calculus was developed to provide a formal basis for the design of distributed programming languages.

== References ==
{{refbegin}}
<!--=== Website === -->
*{{cite web
|last1       = Cédric
|first1      = Fournet
|last2       = Luc
|first2      = Maranget
|date       = 2006-08-15
|title      = The Join-Calculus language
|publisher  = Institut National de Recherche en Informatique et Automatique
|url        = http://moscova.inria.fr/join/manual/index.html
|access-date = 2012-10-09
}}
*{{cite web
|title      = JoinCalculus
|publisher  = Cunningham & Cunningham, Inc.
|url        = http://c2.com/cgi/wiki?JoinCalculus
|access-date = 2012-10-09
| date = October 25, 2009
}}
<!-- === White paper === -->
<!-- @ERIC -->
*{{cite book
 | last1 = Fournet | first1 = Cédric
 | title = CONCUR '96: Concurrency Theory
 | volume = 1119
 | last2 = Gonthier | first2 = Georges
 | last3 = Levy | first3 = Jean-Jacques
 | last4 = Maranget | first4 = Luc
 | chapter = A calculus of mobile agents
 | location = Le Chesnay
 | year = 1996
 | pages=406–421
 | publisher = Concurrency Theory
 | doi = 10.1007/3-540-61604-7_67
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-61604-7
 }}
*{{cite book
 | last1 = Maludzinski | first1 = Slawomir
 | last2 = Dobrowolski | first2 = Grzegorz
 | title = Multi-Agent Systems and Applications V
 | chapter = Agent Environment and Knowledge in Distributed Join Calculus
 | series = Lecture Notes in Computer Science
 | year = 2007
 | pages=298–300
 | doi=10.1007/978-3-540-75254-7_30
 | volume = 4696
 | isbn = 978-3-540-75253-0
 }}
*{{cite book
 | last1 = Russio | first1 = Claudio
 | title = Practical Aspects of Declarative Languages
 | volume = 4354
 | location = Cambridge
 | pages=260–274
 | publisher  = Practical Aspects of Declarative Languages
 | doi = 10.1007/978-3-540-69611-7_17
 | series = Lecture Notes in Computer Science
 | date = 2006
 | isbn = 978-3-540-69608-7
 | chapter = The Joins Concurrency Library
 | citeseerx = 10.1.1.187.8792
 }}
*{{cite web
 | last1 = Maranget | first1 = Luc
 | last2 = Le Fessant | first2 = Fabrice
 | title = Compiling Join-Patterns
 | url = http://hevea.inria.fr/examples/pat.html
 | date= 25 September 2007
 | location = Le Chesnay France
 }}
*{{cite book
 | last1 = Haller | first1 = Phillip
 | title = Coordination Models and Languages
 | volume = 5052
 | last2 = Van Cutsem | first2 = Tom
 | chapter = Implementing Joins Using Extensible Pattern Matching
 | location = Lausanne
 | year = 2008
 | publisher = Coordination Models and Languages
 | pages=135–152
 | doi = 10.1007/978-3-540-68265-3_9
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-68264-6
 | citeseerx = 10.1.1.210.1242
 }}
*{{cite web
 | last1 = Sulzmann | first1 = Martin
 | last2 = S. L. Lam | first2 = Edmund
 | title = Parallel Join Patterns with Guards and Propagation
 | location = Denmark
 | url = http://moscova.inria.fr/~maranget/papers/mobile.ps
 }}
<!-- @NICO -->
*{{cite book
 | last1 = Fournet | first1 = Cédric
 | title = Applied Semantics
 | volume = 2395
 | last2 = Gonthier | first2 = Georges
 | chapter = The Join Calculus: A Language for Distributed Mobile Programming
 | pages=268–332
 | publisher = Springer
 | year = 2002
 | doi = 10.1007/3-540-45699-6_6
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-44044-4
 | citeseerx = 10.1.1.4.4788
 }}
*{{cite book
 | last1 = Ma | first1 = Qin
 | volume = 3170
 | last2 = Maranget | first2 =  Luc
 | title = CONCUR 2004 - Concurrency Theory
 | chapter = Compiling Pattern Matching in Join-Patterns
 | pages=417–431
 | date= 5 April 2004
 | publisher=INRIA
 | doi = 10.1007/978-3-540-28644-8_27
 | series = Lecture Notes in Computer Science
 | isbn = 978-3-540-22940-7
 | citeseerx = 10.1.1.499.8443
 | s2cid = 9956643
 }}
*{{cite web 
 | last = Singh | first = Satnam
 | title = Higher Order Combinators for Join Patterns using STM
 | url = https://urresearch.rochester.edu/fileDownloadForInstitutionalItem.action?itemId=3699&itemFileId=5278
 | date= 6 January 2007
 }}
*{{citation
 | last = MONSIEUR | first = Geert
 | title = Pattern-based Coordination in Process-based Service Compositions
 | url = https://lirias.kuleuven.be/handle/123456789/284037
 | year= 2010
 | location = Leuven Belgium
 | publisher= Katholiek Universiteit Leuven
 }}
*{{cite journal
 | last1 = Russo | first1 = Claudio V.
 | title = Join Patterns for Visual Basic
 | journal = ACM SIGPLAN Notices
 | volume = 43
 | issue = 10
 | pages=53–72
 | date= 23 October 2008
 | doi = 10.1145/1449955.1449770
 }}
<!-- @ALL -->
*{{cite book
 | last1 = Aaron | first1 = Turon
 | last2 = Russo | first2 = Claudio V.
 | title = Scalable Join Patterns
 | url = http://research.microsoft.com/en-us/um/people/crusso/papers/scalablejoins.pdf
 | date= 27 October 2011
 | publisher=Association for Computing Machinery |location=New York
 | isbn = 978-1-4503-0940-0
 }}
*{{cite book
 | last = Guzev | first = Vadim B.
 | chapter = Parallel C#: The Usage of Chords and Higher-Order Functions in the Design of Parallel Programming Languages |title=Proceedings of the 2008 International Conference on Parallel and Distributed Processing Techniques and Applications, PDPTA 2008 
 | url = http://parallelcsharp.com/docs/conferences/PDPTA08/PDPTA08.pdf
 | date= April 2008
 | isbn = 978-1601320841 |publisher=CSREA Press
 }}
{{refend}}

== Notes ==
{{reflist|3}}

== External links ==
* [https://web.archive.org/web/20150425172921/http://research.microsoft.com/en-us/projects/concurrentbasic/default.aspx Concurrent Basic]
* [https://web.archive.org/web/20120101114108/http://research.microsoft.com/en-us/projects/scalablejoins/ Scalable Joins]
* [http://research.microsoft.com/en-us/um/people/crusso/joins/  The Joins Concurrency Library]
* INRIA, [http://moscova.inria.fr/join/index.shtml Join Calculus homepage]

{{Design Patterns patterns}}
{{Software engineering}}
{{Types of programming languages}}

<!-- This will add a notice to the bottom of the page and won't blank it! The new template which says that your draft is waiting for a review will appear at the bottom; simply ignore the old (grey) drafted templates and the old (red) decline templates. A bot will update your article submission. Until then, please don't change anything in this text box and press "Save page". -->

[[Category:Distributed computing]]
[[Category:Software design patterns]]

{{Sourceattribution|Join-pattern}}