Downloads & Free Reading Options - Results

There is often a sort of a protocol associated to each class, stating when and how certain methods should be called. Given that this protocol is, if at all, described in the documentation accompanying the class, current mainstream object-oriented languages cannot provide for the verification of client code adherence against the sought class behaviour. We have defined a class-based concurrent object-oriented language that formalises such protocols in the form of usage types. Usage types are attached to class definitions, allowing for the specification of (1) the available methods, (2) the tests clients must perform on the result of methods, and (3) the object status - linear or shared - all of which depend on the object's state. Our work extends the recent approach on modular session types by eliminating channel operations, and defining the method call as the single communication primitive in both sequential and concurrent settings. In contrast to previous works, we define a single category for objects, instead of distinct categories for linear and for shared objects, and let linear objects evolve into shared ones. We introduce a standard sync qualifier to prevent thread interference in certain operations on shared objects. We formalise the language syntax, the operational semantics, and a type system that enforces by static typing that methods are called only when available, and by a single client if so specified in the usage type. We illustrate the language via a complete example.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

Experiments were conducted at NASA Ames Research Center to define multi-tasking software requirements for multiple-instruction, multiple-data stream (MIMD) computer architectures. The focus was on specifying solutions for algorithms in the field of computational fluid dynamics (CFD). The program objectives were to allow researchers to produce usable parallel application software as soon as possible after acquiring MIMD computer equipment, to provide researchers with an easy-to-learn and easy-to-use parallel software language which could be implemented on several different MIMD machines, and to enable researchers to list preferred design specifications for future MIMD computer architectures. Analysis of CFD algorithms indicated that extensions of an existing programming language, adaptable to new computer architectures, provided the best solution to meeting program objectives. The CoFORTRAN Language was written in response to these objectives and to provide researchers a means to experiment with parallel software solutions to CFD algorithms on machines with parallel architectures.

Experiments were conducted at NASA Ames Research Center to define multi-tasking software requirements for multiple-instruction, multiple-data stream (MIMD) computer architectures. The focus was on specifying solutions for algorithms in the field of computational fluid dynamics (CFD). The program objectives were to allow researchers to produce usable parallel application software as soon as possible after acquiring MIMD computer equipment, to provide researchers with an easy-to-learn and easy-to-use parallel software language which could be implemented on several different MIMD machines, and to enable researchers to list preferred design specifications for future MIMD computer architectures. Analysis of CFD algorithms indicated that extensions of an existing programming language, adaptable to new computer architectures, provided the best solution to meeting program objectives. The CoFORTRAN Language was written in response to these objectives and to provide researchers a means to experiment with parallel software solutions to CFD algorithms on machines with parallel architectures.

Bruce Merry https://2018.za.pycon.org/talks/27-an-introduction-to-concurrent-programming-with-asyncio/ Concurrent programming is useful any time one needs to deal with multiple concurrent tasks: a server answering requests from multiple clients, a client scraping data from multiple servers, a workflow manager running external processes in a pipeline, and more. While there are many concurrent programming frameworks for Python, there is one that is included out of the box: asyncio. I will introduce the framework and explain the syntax and APIs. Perhaps more importantly, I will offer practical tips on development with asyncio, such as exception handling, testing, debugging, and integration with existing code. Attendees will come away with an understanding of why they will want to use asyncio instead of multi-threading, an understanding of the basic concepts, and knowledge of some additional libraries that will help them be productive with asyncio. pyconza2018 python

A concurrent program is one defining actions that may be performed simultaneously. This module discusses the nature of such programs and provides an overview of the means by which they may be constructed and executed. Emphasis is given to the terminology used in this field and the underlying concepts involved. This module is largely concerned with explicit concurrency, where concurrent behavior is specified by the program designer. Particular attention is paid to programs that can be considered inherently concurrent, that is, programs that are constructed to control or model physical systems that involve parallel activity. The module also includes a brief introduction to performance- oriented concurrency, where concurrency is used to improve program performance by taking advantage of hardware support for parallel processing. The module is divided into three sections. The first deals with basic concepts in concurrent programming, covering characteristic attributes, formal properties, standard design problems, and execution details. The second section discusses the steps in constructing concurrent programs for specification to coding. The final section briefly examines concurrency from the point of view of some common application areas. The module gives a foundation for a deeper study of specific topics in concurrent programming. It also provides the preparatory material for a study of the concurrent aspects of application areas such as real-time (embedded) systems, database systems, operating systems, and many simulation systems.

Concurrency of activities has long been recognized as an important feature in many computer systems. These systems allow concurrent operations for a number of reasons on which three are particularly common. First, by executing several jobs, simultaneously, multiprogramming and time-sharing systems can make fuller use of the computing resources. Second, real-time transaction systems, such as airline reservation and point-of-sale terminal systems, allow a number of users to access a single database concurrently and to obtain responses in real-time. Finally, high speed parallel computers, such as array processors dedicate a number of processors to the execution of a single program to speed up completion of a computation. (Author)

Concurrency of activities has long been recognized as an important feature in many computer systems. These systems allow concurrent operations for a number of reasons on which three are particularly common. First, by executing several jobs, simultaneously, multiprogramming and time-sharing systems can make fuller use of the computing resources. Second, real-time transaction systems, such as airline reservation and point-of-sale terminal systems, allow a number of users to access a single database concurrently and to obtain responses in real-time. Finally, high speed parallel computers, such as array processors dedicate a number of processors to the execution of a single program to speed up completion of a computation. (Author)

Includes bibliographical references (pages 229-237) and index

Includes bibliographical references (pages 229-237) and index

We present a concurrent framework for Win32 programming based on Concurrent ML, a concurrent language with higher-order functions, static typing, lightweight threads and synchronous communication channels. The key points of the framework are the move from an event loop model to a threaded model for the processing of window messages, and the decoupling of controls notifications from the system messages. This last point allows us to derive a general way of writing controls that leads to easy composition, and can accommodate ActiveX Controls in a transparent way.

A verification method for distributed systems based on decoupling forward and backward behaviour is proposed. This method uses an event structure based algorithm that, given a CCS process, constructs its causal compression relative to a choice of observable actions. Verifying the original process equipped with distributed backtracking on non-observable actions, is equivalent to verifying its relative compression which in general is much smaller. We call this method Declarative Concurrent Programming (DCP). DCP technique compares well with direct bisimulation based methods. Benchmarks for the classic dining philosophers problem show that causal compression is rather efficient both time- and space-wise. State of the art verification tools can successfully handle more than 15 agents, whereas they can handle no more than 5 following the traditional direct method; an altogether spectacular improvement, since in this example the specification size is exponential in the number of agents.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

Concurrency has been rapidly gaining importance in general-purpose computing, caused by the recent turn towards multicore processing architectures. As a result, an increasing number of developers have to learn to write concurrent programs, a task that is known to be hard even for the expert. Language designers are therefore working on languages that promise to make concurrent programming "easier" than using traditional thread libraries. However, the claim that a new language is more usable than another cannot be supported by purely theoretical considerations, but calls for empirical studies. In this paper, we present the design of a study to compare concurrent programming languages with respect to comprehending and debugging existing programs and writing correct new programs. A critical challenge for such a study is avoiding the bias that might be introduced during the training phase and when interpreting participants' solutions. We address these issues by the use of self-study material and an evaluation scheme that exposes any subjective decisions of the corrector, or eliminates them altogether. We apply our design to a comparison of two object-oriented languages for concurrency, multithreaded Java and SCOOP (Simple Concurrent Object-Oriented Programming), in an academic setting. We obtain results in favor of SCOOP even though the study participants had previous training in Java Threads.

Concurrency has been rapidly gaining importance in general-purpose computing, caused by the recent turn towards multicore processing architectures. As a result, an increasing number of developers have to learn to write concurrent programs, a task that is known to be hard even for the expert. Language designers are therefore working on languages that promise to make concurrent programming "easier" than using traditional thread libraries. However, the claim that a new language is more usable than another cannot be supported by purely theoretical considerations, but calls for empirical studies. In this paper, we present the design of a study to compare concurrent programming languages with respect to comprehending and debugging existing programs and writing correct new programs. A critical challenge for such a study is avoiding the bias that might be introduced during the training phase and when interpreting participants' solutions. We address these issues by the use of self-study material and an evaluation scheme that exposes any subjective decisions of the corrector, or eliminates them altogether. We apply our design to a comparison of two object-oriented languages for concurrency, multithreaded Java and SCOOP (Simple Concurrent Object-Oriented Programming), in an academic setting. We obtain results in favor of SCOOP even though the study participants had previous training in Java Threads.

Concurrent Constraint Programming (CCP) is a simple and powerful model for concurrency where agents interact by telling and asking constraints. Since their inception, CCP-languages have been designed for having a strong connection to logic. In fact, the underlying constraint system can be built from a suitable fragment of intuitionistic (linear) logic --ILL-- and processes can be interpreted as formulas in ILL. Constraints as ILL formulas fail to represent accurately situations where "preferences" (called soft constraints) such as probabilities, uncertainty or fuzziness are present. In order to circumvent this problem, c-semirings have been proposed as algebraic structures for defining constraint systems where agents are allowed to tell and ask soft constraints. Nevertheless, in this case, the tight connection to logic and proof theory is lost. In this work, we give a proof theoretical interpretation to soft constraints: they can be defined as formulas in a suitable fragment of ILL with subexponentials (SELL) where subexponentials, ordered in a c-semiring structure, are interpreted as preferences. We hence achieve two goals: (1) obtain a CCP language where agents can tell and ask soft constraints and (2) prove that the language in (1) has a strong connection with logic. Hence we keep a declarative reading of processes as formulas while providing a logical framework for soft-CCP based systems. An interesting side effect of (1) is that one is also able to handle probabilities (and other modalities) in SELL, by restricting the use of the promotion rule for non-idempotent c-semirings.This finer way of controlling subexponentials allows for considering more interesting spaces and restrictions, and it opens the possibility of specifying more challenging computational systems.

Concurrent Constraint Programming (CCP) is a simple and powerful model for concurrency where agents interact by telling and asking constraints. Since their inception, CCP-languages have been designed for having a strong connection to logic. In fact, the underlying constraint system can be built from a suitable fragment of intuitionistic (linear) logic --ILL-- and processes can be interpreted as formulas in ILL. Constraints as ILL formulas fail to represent accurately situations where "preferences" (called soft constraints) such as probabilities, uncertainty or fuzziness are present. In order to circumvent this problem, c-semirings have been proposed as algebraic structures for defining constraint systems where agents are allowed to tell and ask soft constraints. Nevertheless, in this case, the tight connection to logic and proof theory is lost. In this work, we give a proof theoretical interpretation to soft constraints: they can be defined as formulas in a suitable fragment of ILL with subexponentials (SELL) where subexponentials, ordered in a c-semiring structure, are interpreted as preferences. We hence achieve two goals: (1) obtain a CCP language where agents can tell and ask soft constraints and (2) prove that the language in (1) has a strong connection with logic. Hence we keep a declarative reading of processes as formulas while providing a logical framework for soft-CCP based systems. An interesting side effect of (1) is that one is also able to handle probabilities (and other modalities) in SELL, by restricting the use of the promotion rule for non-idempotent c-semirings.This finer way of controlling subexponentials allows for considering more interesting spaces and restrictions, and it opens the possibility of specifying more challenging computational systems.

From the bitsavers.org collection, a scanned-in computer-related document. microsoft :: visual studio :: Duffy - Concurrent Programming on Windows 2008

The \"von Neumann bottleneck\" imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignment statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and also allow is to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative \"library\" programs into functional ones which are well suited to concurrent processing.

The \"von Neumann bottleneck\" imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignment statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and also allow is to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative \"library\" programs into functional ones which are well suited to concurrent processing.

This document proposes a unifying theory for the development of programs for a variety of architectures and applications. The computational model is unbounded nondeterministic iterative transformations of the program state. Transformations of the program state are represented by multiple assignments. The theory attempts to decouple the programmer's thinking about a program and its implementation on an architecture; we attempt to separate the concerns of what from those of where, when, and how. Details about implementations are considered in mappings of programs to architectures. We hope to demonstrate that we can develop, specify and refine solution strategies independent of architectures. The utility of a new approach is suspect, especially when it is a radical departure from the conventional. Therefore, we have made a conscientious effort to apply our ideas to a number of architectures and application domains. Our experience is encouraging. Keywords: Parallel programming; Unity computer programs.

The first example is an implementation in each of four languages (Ada, Concurrent C, Co-Pascal, and occam) of the famous Dining Philosophers problem first stated by Dijkstra. In this metaphorical statement of deadlock and resource allocation problems, five philosophers sit around a circular table, in the center of which is a infinitely large bowl of Chinese food. To the left and right of each philosopher is a single chopstick; each philosopher must try to acquire both chopsticks, each for awhile, then put down the chopsticks and think for awhile; this cycle repeats for some total number of meals. (Dijkstra's original formulation used spaghetti and forks; we prefer the chopstick setting because most people can eat spaghetti with one fork.) The algorithm for chopstick selection must be chosen carefully, otherwise if all philosophers grab, say, their left chopsticks and refuse to yield them, all will starve! The second example is one we have used with repeated success at The George Washington University, namely a sort race in which the three different sorting methods are activated as processes. Each sort displays its progress in its window (usually a single row) on the terminal; mutual exclusion is necessary to protect the screen, which is a writable shared resource. We have found this example interesting and fun-there is a lot of screen activity, the problem being solved is obvious, and the three independent sorts serve as placeholders for any three independent applications contending for the processor and a shared data structure. (kr)

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

The proposed framework provides a general model of concurrent imperative programming. Programs are modeled as formal languages and concurrency as an interleaving (or shuffle) operator. This yields a simple and elegant algebra of programs. The framework supports the views program logic by Dinsdale-Young and others, which generalizes various type systems and separation logic approaches to program correctness. It also validates familiar operational calculi in small-step and big-step flavours. The consistency of the program logic with respect to the operational rules is established directly and does not use induction on derivations. In fact the whole framework uses only straightforward mathematics. Parametric in states, views and basic commands, it can be instantiated to a variety of concrete languages and settings.

The digital logic simulator, LOGSIM248, a re-engineered version of LOGSIM, version 5.5, has been implemented as a component of the digital design environment, IDIET (Integrated Digital Engineering Tool). This new design expands the capabilities of the older version by improving run time performance, maintainability, and compatability. Written in the C programming language, LOGSIM248 boasts looser coupling between functional modules while exhibiting greater functional cohesion within these modules. As an integral part of IDIET, the simulator overcomes difficulties created by the complicated user interface of earlier versions. With greater run time performance as a goal, this new simulator was studied and adapted to produce a concurrent implementation. Here, several roadblocks were encountered which essentially showed this algorithm and data structure implementation to be difficult to parallelize at best.

Soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. While there are many soft constraint solving formalisms, even distributed ones, by now there seems to be no concurrent programming framework where soft constraints can be handled. In this paper we show how the classical concurrent constraint (cc) programming framework can work with soft constraints, and we also propose an extension of cc languages which can use soft constraints to prune and direct the search for a solution. We believe that this new programming paradigm, called soft cc (scc), can be also very useful in many web-related scenarios. In fact, the language level allows web agents to express their interaction and negotiation protocols, and also to post their requests in terms of preferences, and the underlying soft constraint solver can find an agreement among the agents even if their requests are incompatible.

Soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. While there are many soft constraint solving formalisms, even distributed ones, by now there seems to be no concurrent programming framework where soft constraints can be handled. In this paper we show how the classical concurrent constraint (cc) programming framework can work with soft constraints, and we also propose an extension of cc languages which can use soft constraints to prune and direct the search for a solution. We believe that this new programming paradigm, called soft cc (scc), can be also very useful in many web-related scenarios. In fact, the language level allows web agents to express their interaction and negotiation protocols, and also to post their requests in terms of preferences, and the underlying soft constraint solver can find an agreement among the agents even if their requests are incompatible.

[EuroPython 2014] Benoit Chesneau - Concurrent programming with Python and my little experiment [EuroPython 2014] [25 July 2014] Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time and my little experiment in porting the Go concurrency model in Python. ----- Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time with code examples, from asyncore to asyncio, passing by gevent, eventlet, twisted and some new alternatives like evergreen or gruvi. It will also present my little experiment in porting the Go concurrency model in Python named [offset](http://github.com/benoitc/offset), how it progressed in 1 year and how it became a fully usable library . This presentation will be an update of the presentation I gave at the FOSDEM 2014. It will introduce to the concurrency concepts and how they are implemented in the different libraries.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.