Parallel machines are now affordable and available to many users in the form of small symmetric shared-memory multiprocessors (SMPs). Unfortunately, programming practices have not kept pace with this hardware advance. The vast majority of developers still write applications in sequential programming languages that do not exploit multiple processors. The traditional approaches for adding parallelism to applications are prone to introducing new, strange, and difficult-to-eliminate bugs. In this important new text, the authors offer a completely different vision of the future, where parallel programming is the default and sequential programming is a special case. The foundation of this vision is an implicitly parallel programming language, pH, which is the result of two decades of research by the authors. A dialect and extension of the standard nonstrict and purely functional language Haskell, pH is essentially Haskell with implicitly parallel semantics. pH's extensions to Haskell comprise a disciplined approach to shared parallel state, so that a pH program-even a beginner's program-is implicitly parallel. The authors have developed this text over ten years while teaching implicit parallel programming to graduate students at MIT and specialized short courses to undergraduates and software professionals in the U.S., Japan, and India.

Programming is hard. Building a large program is like constructing a steam locomotive through a hole the size of a postage stamp. An artefact that is the fruit of hundreds of person-years is only ever seen by anyone through a lOO-line window. In some ways it is astonishing that such large systems work at all. But parallel programming is much, much harder. There are so many more things to go wrong. Debugging is a nightmare. A bug that shows up on one run may never happen when you are looking for it - but unfailingly returns as soon as your attention moves elsewhere. A large fraction of the program's code can be made up of marshalling and coordination algorithms. The core application can easily be obscured by a maze of plumbing. Functional programming is a radical, elegant, high-level attack on the programming problem. Radical, because it dramatically eschews side-effects; elegant, because of its close connection with mathematics; high-level, be cause you can say a lot in one line. But functional programming is definitely not (yet) mainstream. That's the trouble with radical approaches: it's hard for them to break through and become mainstream. But that doesn't make functional programming any less fun, and it has turned out to be a won derful laboratory for rich type systems, automatic garbage collection, object models, and other stuff that has made the jump into the mainstream.

If you have a working knowledge of Haskell, this hands-on book shows you how to use the language’s many APIs and frameworks for writing both parallel and concurrent programs. You’ll learn how parallelism exploits multicore processors to speed up computation-heavy programs, and how concurrency enables you to write programs with threads for multiple interactions. Author Simon Marlow walks you through the process with lots of code examples that you can run, experiment with, and extend. Divided into separate sections on Parallel and Concurrent Haskell, this book also includes exercises to help you become familiar with the concepts presented: Express parallelism in Haskell with the Eval monad and Evaluation Strategies Parallelize ordinary Haskell code with the Par monad Build parallel array-based computations, using the Repa library Use the Accelerate library to run computations directly on the GPU Work with basic interfaces for writing concurrent code Build trees of threads for larger and more complex programs Learn how to build high-speed concurrent network servers Write distributed programs that run on multiple machines in a network

The peer-reviewed papers featured in this volume were chosen from the revised notes of lectures given at the third CEFP School in 2009. They cover a number of topics such as design patterns, semantics, types, and advanced programming in various FP languages.

This book constitutes the thoroughly refereed post-conference proceedings of the 12th International Symposium on Trends in Functional Programming, TFP 2011, held in Madrid, Spain, in May 2011. The 12 papers presented were carefully reviewed and selected from 21 submissions. They deal with all aspects of functional programming, taking a broad view of current and future trends in this area. The topical sections the papers are organized in are named as follows: types, compiling, paralelelism and distribution, data structures, and miscellaneous.

This tutorial book presents seven carefully revised lectures given at the 6th International School on Functional Programming, AFP 2008, in Heijen, The Netherlands in May 2008. The book presents the following seven, carefully cross-reviewed chapters, written by leading authorities in the field: Self-adjusting: Computation with Delta ML, spider spinning for dummies, from reduction-based to reduction-free normalization, libraries for generic programming in Haskell, dependently typed programming in agda, parallel and concurrent programming in Haskell and an iTask case study: a conference management system.

This book constitutes the thoroughly refereed post-conference proceedings of the First International Conference on Mobile, Secure, and Programmable Networking, MSPN 2015, held in Paris, France, in June 2015. The 14 papers presented in this volume were carefully reviewed and selected from 36 submissions. They discuss new trends in networking infrastructures, security, services and applications while focusing on virtualization and cloud computing for networks, network programming, software defined networks (SDN) and their security.