15 research outputs found
Recommended from our members
Multicore OSes: Looking Forward from 1991, er, 2011
Upcoming multicore processors, with hundreds of cores or more in a single chip, require a degree of parallel scalability that is not currently available in today’s system software. Based on prior experience in the super-computing sector, the likely trend for multicore processors is away from shared memory and toward shared-nothing architectures based on message passing. In light of this, the lightweight messages and channels programming model, found among other places in Erlang, is likely the best way forward. This paper discusses what adopting this model entails, describes the architecture of an OS based on this model, and outlines a few likely implementation challenges.Engineering and Applied Science
Concurrent Programming in Education: Time for a Change
Writing concurrent programs using shared memory causes many programmers much trouble, due primarily to unsafe semantics. Memory corruption, race conditions, deadlocks, and even livelocks are trivially easy to introduce into a program and painful to hunt down due the nearly infinite possible interleavings of instructions between the threads.
Undergraduate curricula traditionally introduce students to the idea of shared memory multithreading in a systems programming or operating systems class, but rarely expose them to any alternate models of concurrent programming. This leaves them with the idea that shared memory is the only way to do concurrent programming.
After students were exposed to alternate models, they came to prefer them to the standard shared memory model. This happened despite their distaste of the programming language that was utilized in performing the study. The students also expressed interest in alternate models of concurrency being taught in the computer science curricula at WPI
Automatic Verification of Erlang-Style Concurrency
This paper presents an approach to verify safety properties of Erlang-style,
higher-order concurrent programs automatically. Inspired by Core Erlang, we
introduce Lambda-Actor, a prototypical functional language with
pattern-matching algebraic data types, augmented with process creation and
asynchronous message-passing primitives. We formalise an abstract model of
Lambda-Actor programs called Actor Communicating System (ACS) which has a
natural interpretation as a vector addition system, for which some verification
problems are decidable. We give a parametric abstract interpretation framework
for Lambda-Actor and use it to build a polytime computable, flow-based,
abstract semantics of Lambda-Actor programs, which we then use to bootstrap the
ACS construction, thus deriving a more accurate abstract model of the input
program. We have constructed Soter, a tool implementation of the verification
method, thereby obtaining the first fully-automatic, infinite-state model
checker for a core fragment of Erlang. We find that in practice our abstraction
technique is accurate enough to verify an interesting range of safety
properties. Though the ACS coverability problem is Expspace-complete, Soter can
analyse these verification problems surprisingly efficiently.Comment: 12 pages plus appendix, 4 figures, 1 table. The tool is available at
http://mjolnir.cs.ox.ac.uk/soter
Evaluating the GO Programming Language with Design Patterns
GO is a new object-oriented programming language developed at Google by Rob Pike, Ken Thompson, and others. GO has the potential to become a
major programming language. GO deserves an evaluation.
Design patterns document reoccurring problems and their solutions. The problems presented are programming language independent. Their
solutions, however, are dependent on features programming languages provide.
In this thesis we use design patterns to evaluate GO. We discuss GO features that help or hinder implementing design patterns, and present a
pattern catalogue of all 23 Gang-of-Four design patterns with GO specific solutions.
Furthermore, we present GoHotDraw, a GO port of the pattern dense drawing application framework JHotDraw. We discuss design and implementation
differences between the two frameworks with regards to
GO
An extension-oriented compiler
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2008.This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.Includes bibliographical references (leaves 107-110).The thesis of this dissertation is that compilers can and should allow programmers to extend programming languages with new syntax, features, and restrictions by writing extension modules that act as plugins for the compiler. We call compilers designed around this idea extension-oriented. The central challenge in designing and building an extension-oriented compiler is the creation of extension interfaces that are simultaneously powerful, to allow effective extensions; convenient, to make these extensions easy to write; and composable, to make it possible to use independently-written extensions together. This dissertation proposes and evaluates extension-oriented syntax trees (XSTs) as a way to meet these challenges. The key interfaces to XSTs are grammar statements, a convenient, composable interface to extend the input parser; syntax patterns, a way to manipulate XSTs in terms of the original program syntax; canonicalizers, which put XSTs into a canonical form to extend the reach of syntax patterns; and attributes, a lazy computation mechanism to structure analyses on XSTs and allow extensions to cooperate. We have implemented these interfaces in a small procedural language called zeta. Using zeta, we have built an extension-oriented compiler for C called xoc and then 13 extensions to C ranging in size from 16 lines to 245 lines.To evaluate XSTs and xoc, this dissertation examines two examples in detail: a reimplementation of the programming language Alef and a reimplementation of the Linux kernel checker Sparse. Both of these examples consist of a handful of small extensionsby Russell Stensby Cox.Ph.D
An Efficient Run-Time System for Concurrent Programming Language
Our objective is to construct a Run-time System for Erasmus. Software systems
nowadays are becoming very complex, so the last thing a programmer would want to do is to worry about the internal management of communication. We describe a system that provides Erasmus with a well-defined level of abstraction. This run-time system also provides processes with independence, which means that no two processes know each others' location. Erasmus is a process oriented concurrent programming language being developed by Peter Grogono at Concordia University and Brian Shearing at The Software Factory in England. Erasmus is based mainly on cells, processes, and their interactions through message passing. For every cell there will be a manager to initiate the communication and also to route the communication, whether it is local or remote. Programmers should only be deciding which kind of data they want to send and the rest will be taken care by the run-time system. For communication within a cell, channels with local communication methods will be used; for communication over the network or on different processors, a broker with
remote communication methods will complete the communication link. There is also a separate protocol for a manager process to decide between local and remote communication. This thesis discusses in detail the issues related to process independence. It also explains how processes can be separated from the communication protocols. This run-time system will provide software of greater simplicity and fewer irrelevant details
Composing graphical user interfaces in a purely functional language
This thesis is about building interactive graphical user interfaces in a compositional manner. Graphical user interface application hold out the promise of providing users with an interactive, graphical medium by which they can carry out tasks more effectively and conveniently. The application aids the user to solve some task. Conceptually, the user is in charge of the graphical medium, controlling the order and the rate at which individual actions are performed.
This user-centred nature of graphical user interfaces has considerable ramifications for how software is structured. Since the application now services the user rather than the other way around, it has to be capable of responding to the user's actions when and in whatever order they might occur. This transfer of overall control towards the user places heavy burden on programming systems, a burden that many systems don't support too well. Why? Because the application now has to be structured so that it is responsive to whatever action the user may perform at any time.
The main contribution of this thesis is to present a compositional approach to constructing graphical user interface applications in a purely functional programming language
The thesis is concerned with the software techniques used to program graphical user interface applications, and not directly with their design. A starting point for the work presented here was to examine whether an approach based on functional programming could improve how graphical user interfaces are built. Functional programming languages, and Haskell in particular, contain a number of distinctive features such as higher-order functions, polymorphic type systems, lazy evaluation, and systematic overloading, that together pack quite a punch, at least according to proponents of these languages. A secondary contribution of this thesis is to present a compositional user interface framework called Haggis, which makes good use of current functional programming techniques. The thesis evaluates the properties of this framework by comparing it to existing systems