Product Description
In computer science control flow (or alternatively, flow of control) refers to the order in which the individual statements, instructions, or function calls of an imperative or functional program are executed or evaluated. Within an imperative programming language, a control flow statement is a statement whose execution results in a choice being made as to which of two or more paths should be followed. For non-strict functional languages, functions and language constructs exist to achieve the same result, but they are not necessarily called control flow statements. The kinds of control flow statements supported by different languages vary, but can be categorized by their effect: continuation at a different statement (unconditional branch or jump), executing a set of statements only if some condition is met (choice - i.e. conditional branch), executing a set of statements zero or more times, until some condition is met (i.e. loop - the same as conditional branch), executing a set of distant statements, after which the flow of control usually returns (subroutines, coroutines, and continuations), stopping the program, preventing any further execution (unconditional halt). ... Read more

Product Description
Drawing Programs: The Theory and Practice of Schematic Functional Programming describes a diagrammatic (schematic) approach to programming. It introduces a sophisticated tool for programmers who would rather work with diagrams than with text. The language is a complete functional language that has evolved into a representation scheme that is unique. The result is a simple coherent description of the process of modelling with the computer. The experience of using this tool is introduced gradually with examples, small projects and exercises. The new computational theory behind the tool is interspersed between these practical descriptions so that the reasons for the activity can be understood and the activity, in turn, illustrates some elements of the theoryAccess to the tool, its source code and a set of examples that range from the simple to the complex is free (see www.springer.com/978-1-84882-617-5). A description of the tool’s construction and how it may be extended is also given.The authors’ experience with undergraduates and graduates who have the understanding and skill of a functional language learnt through using schema have also shown an enhanced ability to program in other computer languages. Readers are provided with a set of concepts that will ensure a good robust program design and, what is more important, a path to error free programming. ... Read more

Product Description

This self-contained textbook assumes that the reader has some familiarity with one programming language, and adopts a simple yet rigorous approach.

The author explains the main programming paradigms (imperative, object-oriented, functional, and logic), and makes clear separation between the design, implementation and pragmatic aspects of programming languages.

As well as an excellent guide for undergraduates the content will also be useful for software practitioners who want to consolidate and update their knowledge of programming languages.

Product Description
The authors describe here a framework in which the type notation of functional languages is extended to include a notation for binding times (that is run-time and compile-time) that distinguishes between them. Consequently, the ability to specify code and verify program correctness can be improved. Two developments are needed, the first of which introduces the binding time distinction into the lambda calculus in a manner analogous with the introduction of types into the untyped lambda calculus. Methods arealso presented for introducing combinators for run-time. The second concerns the interpretation of the resulting language, which is known as the mixed lambda-calculus and combinatory logic.The notion of "parametrized semantics" is used to describe code generation and abstract interpretation. The code generation is for a simple abstractmachine designed for the purpose, it is close to the categorical abstract machine. The abstract interpretation focuses on a strictness analysis that generalizes Wadler's analysis for lists. It is also shown how the results of abstract interpretation may be used to improve the code generation. ... Read more

Product Description
After the success of the first edition of Introduction to Functional Programming, the authors have thoroughly updated and revised this bestselling title. This book is unusual amongst books on functional programming in that it is primarily directed towards the concepts of functional programming, rather than their realization in a specific programming language. The book clearly expounds the construction of functional programs as a process of mathematical calculation, but the mathematics is restricted to that relevant to the actual construction of programs. ... Read more

Customer Reviews (2)

Original classic, theoretical
Bird and Wadler got me started on functional programming. Before that, I'd only seen discussions of C++/STL functors and functions like for, map etcetera.

B&W was dense, and magic. It reminded me of the first time I read the K&R C book, you're following along fine, and all of a sudden you're off the deep end!

The syntax, sort of ML-like adds to the 'magic' feel of it all. Overall I think it's a good book. But like with K&R, make this your second or third book, to ground you in the fundamentals after you've become somewhat familiar with the syntax and application of a particular fnal language.

That said, it covers a wide breadth of topics, and does justice to them as well. But this opinion comes from a newbie at functional programming, so caveat lector!

For me, it made me realise that there was a whole 'new' way of programming, vastly bigger than the few functions C++ had in its STL, and that C++ syntax mostly got in the way. However, perhaps because of this book, I never quite grokked Haskell/ML syntax either, though LISP I find easy (easier).

Nice book on functional programming
This is a good introduction to functional programming.
It is less language specific than some of the other books. ... Read more

Product Description
The class of programming languages commonly known as functional includes Lisp, Scheme, ML, and Miranda TM. This book explores a subclass known as lazy functional languages, beginning with the theoretical issues and continuing through abstract interpretation and offering improved techniques for implementation.

Now that advanced compiler technology has made it possible for lazy functional languages to compare favorably in run-time with more traditional languages such as C and Pascal, this monograph tackles problems of implementation such as time and memory overheads and restrictions on parallelism. Specifically, it describes a more efficient implementation model, the evaluation transformer model, that can be used when information is known about how functions use their arguments, develops a semantically sound analysis technique called abstract interpretation, which can determine this information, and shows how to use the information to compile more efficient code for sequential and parallel machines.

Contents: Introduction. Operational and Denotational Semantics of the Typed Lambda Calculus. A Framework for the Abstract Interpretation of Functional Languages. Some Example Abstract Interpretations. Evaluation Transformers. Implementing Functional Languages on Sequential and Parallel Machines. Relationship to Other Work. Epilogue. Appendixes: Additional Proofs. The Spineless G-Machine. ... Read more

Customer Reviews (2)

Table of Contents
Preface
List of figures
1 Introduction
1.1 Functional Programming Languages and Lazy Evaluation
1.2 The Evaluation Transformer Model of Reduction
1.3 An Introduction to Abstract Interpretation
1.4 Outline of Book
2 Operational and Denotational Semantics of the Typed Lambda Calculus
2.1 The Typed Lambda-Calculus
2.2 Sets with Structure
2.3 Interpretations
2.4 A Result Relating the Operational Semantics and Standard Interpretations of AT

2.5 Drawing it Together
3 A Framework for the Abstract Interpretation of Functional Languages
3.1 The Abstract Interpretation of AT
3.2 Abstraction and Concretisation Maps
3.3 Correctness of the Framework
3.4 Drawing it Together
4 Some Example Abstract Interpretations
4.1 An Abstract Interpretation for Evaluation Transformers
4.2 On Defining Abstract Domains
4.3 A Systematic Approach to Deriving Abstract Domains for Lists and Trees
4.4 Drawing it Together
5 Evaluation Transformers
5.1 Safe Changes to the Evaluation Strategy
5.2 Definition of Evaluators
5.3 Determining Evaluation Transformers
5.4 Drawing it Together
6 Implementing Functional Languages on Sequential and Parallel Machines
6.1 Graph Reduction
6.2 The Spineless G-machine
6.3 Relating the Graph Reduction Model to the Typed Lambda Calculus
6.4 Compiling Code for Evaluation Transformers
6.5 Drawing it Together
7 Relationship to Other Work
7.1 Abstract Interpretation
7.2 Polymorphism
7.3 Other Program Analysis Techniques
7.4 Implementation of Lazy Functional Languages
8 Epilogue
A Proofs Omitted in Earlier Chapters
B The Spineless G-Machine
B.1 Compilation Rules
B.2 Initial G-machine state
B.3 An Interpreter for the Spineless G-Machine
Bibliography
Index of Symbols
Index

I enjoyed it.
Forced into the world of denotational semantics of functional languages, I found this book actually quite interesting and informative. Using lattice theory to look at the properties of functional evaluation provides forhours of entertaining reading. ... Read more

Product Description
This book constitutes the refereed proceedings of the 4th Fuji International Symposium on Functional and Logic Programming, FLOPS'99, held in Tsukuba, Japan, in November 1999. The 23 revised full papers presented were carefully reviewed and selected from a total of 51 submissions. The papers are devoted to various current aspects of functional and logic programming as well as to the integration of these two paradigms. Among the topics addressed are typing, partial evaluation, program transformations, parsing, formal verification, program analysis, static analysis, narrowing, etc. ... Read more

Product Description
The design of algorithms for problem-solving lies at the heart of computer science. Concise yet authoritative, Algorithms: A Functional Programming Approach teaches the skills needed to master this essential subject.The authors challenge more traditional methods of teaching algorithms by using a functional programming context, with Haskell as the implementation language. This leads to smaller, clearer and more elegant programs which enable the programmer to understand the algorithm itself more quickly and to use that understanding to explore alternative solutions. Placing the emphasis on program development rather than the mathematical properties of algorithms, the book uses a succession of practical programming examples to develop in the reader problem-solving skills which can be easily transferred to other language paradigms.Key features of this innovative text include:Unmatched collection of functional programming algorithmsA wealth of practical examples, bringing the algorithms into clear focus

End of chapter exercises throughoutSource code and selected solutions freely available onlineComprehensive index and bibliographical notesAppendices on Haskell implementations and mathematicalbackground For computer science students taking algorithms and/or functional programming courses, Algorithms: A Functional Programming Approach represents the ideal textbook. It is also an invaluable reference source of functional programs for practitioners. ... Read more

Customer Reviews (2)

Eh...
It took me a while to find this book, and I had to ultimately buy it used. It turned out not to be quite as good as I expected.

The book is littered with single-letter variable names and is in love with mutually-recursive functions.It includes a quicksort implementation that runs on lists (instead of an ST-based array implementation).If this book were easy to find, I'd say go for it.But since it's out of print, don't bother.

A book with no purpose
I bought this book as I thought it would make a good companion to the excellent Purely Functional Data Structures. How wrong I was. It was supposed to be a book about implementing algorithms in a functional language, but instead the content spreads far a wide. In the opening chapters the authors starts out with a incredible short introduction to Haskell, which quickly turns into a vague discussion on algorithm optimization in functional languages (and this is before! they have even shown how to implement "quick sort") - this writing style is completely unacceptable, either you set the bar high by requiring the audience to know Haskell beforehand or you explain it properly.

The book continues in the same random style, with the authors starting out trying to accomplish something simple, quickly throwing in a few random related computer science topics and then ultimately failing to explain what they set out to do. In short, if you want to learn how to implement classic algorithms in a functional programming language go read Purely Functional Data Structures instead (perhaps after first getting acquaintedwith Haskell via Real World Haskell). ... Read more

Product Description

Customer Reviews (9)

Amazing book
Probably one of the most interesting book about functionality programming, with incredible easy language.Thank a lot to authors.

Bad book for starting F#
I had no F# experience before and found this book difficult to understand. IMHO, Programming F# by Chris Smith is a much better one to learn F#

a pragmatic approach to F#, especially for C# programmers
A hallmark of this book is a very pragmatic, Rosetta stone approach to F#.

Since F# lives in .Net, and .Net is inherently object-oriented; it makes sense to understand something of the mapping that takes place behind the scenes when F# code is mapped into the .Net world.

Many of the interesting new features introduced into C# are actually hand-me-downs from FP (functional programming).This includes generics, LINQ, anonymous methods, lambdas, type inference, etc..Since many programmers need to use C# in the work-a-day world, it makes sense to understand the functional elements of C# by seeing them in a functional language like F#, where they can be seen in their purest (least hobbled) state.Once these concepts are understood, it is then much easier to understand how to wield these tools effectively in C#.

That said, there are also limits to how much functional programming can be done in C# (and how effectively it can be accomplished).This book clearly demarcates the boundaries of what is (and isn't) feasible in C# vis-à-vis functional programming.

One of the things I liked best about this book is the discussion on why functional programming makes code easier to read, write, and verify.This discussion does not appeal to what might be (for many) inaccessible theory (i.e. denotational semantics, category theory, etc.).Instead it is demonstrated in amazingly simple, straightforward ways!This discussion is very effective.

Another facet of this book's approach that I applaud is the demonstration of lambda calculus.Why would a practical book dabble in theory?There's actually a very pragmatic payoff in doing this:functional programming has a lot of underpinnings in lambda calculus.Those that have been exposed to lambda calculus will feel right at home in F#.Those that haven't are likely to feel more "culture shock" when being exposed to concepts like currying and lazy evaluation.Functional programming really does represent a substantially different way of thinking about computation.

This book also features an excellent discussion about design patterns; comparing and contrasting how they are implemented in OOP (object-oriented programming) versus FP.Some classic design patterns in OOP essentially comes for free in FP (e.g. the "visitor" pattern).

Excellent teaching of functional ideas and style
Excellent, in depth, very ideological - in a good meaning of this word, - book. If you're passionate in your desire to understand and feel functional principles - which are spreading everywhere now (in C#, F#, andScala, for example) - it's a must-read. I really love this book's approach of comparing implementations of functional algorithms in F# and C#. Just add Scala (Programming in Scala, 978-0981531601) to the game - and you are good!
I bought this book directly from Manning while it was still in beta and participated in its error-fixing, improvement as much as I could. It was exciting experience.
I highly recommend everybody not only to buy this book, but also go toTomas Petricek's blog at (...) you'll find a lot of interesting stuff there. (I'm not talking about Jon Skeet just because everybody already knew about him. (...)

Excellent introduction to Functional programming
My primary goal is to learn Scala. The primary reference (Programming in Scala) assumes the reader already understands functional programming and its associated terminology (such as point free code). Real world Haskell has good explanations of functional programming concepts but the language is too unusual to allow easy mapping to Scala.

This book has good explanations of key FP concepts. It avoids the common pitfall of FP books that are essentially self referential and do not provide a starting point familiar to an OO developer.

The C# and F# examples are easily understood from a Java and Scala point of view, respectively.

I would really like to see a book that follows the same approach and material but using Scala. ... Read more

Product Description
Richard Bird takes a radically new approach to algorithm design, namely, design by calculation. These 30 short chapters each deal with a particular programming problem drawn from sources as diverse as games and puzzles, intriguing combinatorial tasks, and more familiar areas such as data compression and string matching. Each pearl starts with the statement of the problem expressed using the functional programming language Haskell, a powerful yet succinct language for capturing algorithmic ideas clearly and simply. The novel aspect of the book is that each solution is calculated from an initial formulation of the problem in Haskell by appealing to the laws of functional programming. Pearls of Functional Algorithm Design will appeal to the aspiring functional programmer, students and teachers interested in the principles of algorithm design, and anyone seeking to master the techniques of reasoning about programs in an equational style. ... Read more

Product Description
Product Description

Understanding Programming Languages provides

A comprehensive look at the design elements of programming languages. It will enable the developers, managers and architects to compre programming languages using the listed design elements to decide which language is the best suited to the solution being developed. It covers over 75 elements of programming languages. From imperative, functional, concurrent, domain-specific & multi-paradigm languages, type systems, continuations, currying, partial application, lambda expressions, turing completeness, virtual machine comparisons to name just a dozen of over 75 topics covered. Basic knowledge of programming is assumed and familiarity with the most common languages available will help the reader grasp the context of the topic being discussed. Makes a good casual read. And is an essential part of a software professionals vocabulary and engineering practice.

The first step to polyglot programmers, improving code quality and a refresher for those working in software engineering.

Who is this book for?

This book is for Developers, Architects and Managers who want to understand and compare various programming languages to choose the best one(s) for their solution development.

About the Author

Aditya has been involved with Software Engineering before the time Internet came to India in 1992-1993. During his more than a decade of industry stint he has played the roles of developer, analyst, product manager through CTO. He is the founder of one of the top 25 startups in India. Before he took his sabbatical to write this book he was a Sr. Architect at Thoughtworks. And is a well known Agile coach. Leads an independant consulting company Aditya Yadav & Associates which offers Technology and Technology strategy consulting services to Fortune companies. He is a contrarian when it comes to SOA & EAI on which he believes there is no need for Governance or COE's and has proven his approach over the years successfully. Aditya is a Cloud Computing evangelist and has been following this space since Amazon launched AWS. He is technology, platform and domain agnostic and specialises in Internet Scale Architectures.

When he is not doing something related to software development. He is busy composing music, learning guitar and swimming. Aditya has been a long distance 24 hour swimmer since his college days. He has a B.Tech and M.Tech degree from Indian Institute Of Technology, Bombay, India.

The author can be reached via http://adityayadav.com ... Read more

Product Description
This book is a thoroughly revised edition of a monograph that presents an approach to the design and implementation of sequential programming languages based on the relationship between lambda-calculus and category theory. The foundations of a new "categorical" combinatory logic are laid down. Compilation and evaluation techniques are investigated. A simple abstract machine, called the Categorical Abstract Machine, is presented: it has served as the core of the implementation of the language CAML, of the ML family, developed at INRIA-Roquencourt and Ecole Normale Superieure, and first released in 1987. The main characteristics of this approach are conceptual simplicity and compactness, with bearings on portability, efficiency, and correctness proofs. A mathematical semantics of sequentiality is proposed, in which "sequential algorithms" rather than functions are used to interpret procedures. The theoretical investigation has led to the development of a programming language, CDSO, in which basic and functional types are not differentiated. The evaluation framework is a demand-driven data flow network.The model of sequential algorithms is fully abstract with respect to this language: two procedures have the same denotation if and only if they have the same behaviour. Background on full abstraction is given. The new edition covers new results, and introduces new connections, as suggested by the following non-exhaustive fist of keywords: confluence properties of categorical combinators, explicit substitutions, control operations, linear logic, geometry of interaction, strong stability. ... Read more

Customer Reviews (1)

Nothing introductory about it.
This book requires serious familiarity with calculus to get through. If equations filled with Greek symbols makes your head spin then stay away.

As for the Functional programming part:
"The language described is called CDS0, and should be the 'machine language' of a higher level programming lannguage CDS taking some features of ML (mostly data abstraction facilities); hence CDS should be compiled into CDS0 before execution. Only the material of sections 2 and 3 (i.e. the calculus of the expressions of CDS0, without type control), is already implemented."

This book Looks like it has a lot of good content but it's by no means an introductory text to the topics in the title. Being anything but comfortable in calculus and not even remotely interested in learning functional programming at such a low level I can't really comment on the quality of the content. ... Read more

Product Description
Most books on data structures assume an imperative language such as C or C++.However, data structures for these languages do not always translate well to functional languages such as Standard ML, Haskell, or Scheme.This book describes data structures from the point of view of functional languages, with examples, and presents design techniques that allow programmers to develop their own functional data structures.The author includes both classical data structures, such as red-black trees and binomial queues, and a host of new data structures developed exclusively for functional languages.All source code is given in Standard ML and Haskell, and most of the programs are easily adaptable to other functional languages. This handy reference for professional programmers working with functional languages can also be used as a tutorial or for self-study. ... Read more

Customer Reviews (8)

Haskell speakers may be daunted.
Despite the editorial description of the book, the book is really about Standard ML.It happens to have an appendix where source code has been translated -- out of order, and without reference to the text -- into Haskell.This makes it very difficult to read through the book without speaking Standard ML.

The exercises, also, are only SML.Several appear to use idiosyncratic SML features -- I say "appear" because no answers to the exercises, even the basic ones, are provided for me to check my understanding.

Essentially, the content is good, but expect to learn Standard ML to really get the most out of this book.

Good, but a bit dense
This book is great for someone who already understands the basics of functional programming but wants to learn more.I should note that terseness is one of this book's greatest strong points.In other words, don't assume that just because the book is short that it will be a short read.There's just a lot of information packed into so few words!

Theoretically Interesting and Practically Useful
I use this book all the time to implement and improve purely functional data-structures. It is amazing the performance improvements possible by using good data-structures in functional programs.

Intro to the functional style and fun algorithmic content
If you are beginning to learn functional programming, this is a good book to study. It focuses much on the "no assignment" aspect of the functional style; a good place to start. And does this on one data structure after another allowing it to be easily understood by readers with a procedural background. For the more advanced reader, the algorithmic content of the book is good reading and I find myself picking this book every year or so just to entertain myself. The applicability of the data structures is limited in that most languages come with basic libraries that suffice most of the time.

Strange choice of implementation languages
The description of the book says it includes source code in both ML and Haskell. Unfortunately, the body of the text uses ML exclusively, and the Haskell code is banished to an appendix.

I say "unfortunately", because many of the data structures used depend on lazy evaluation, which comes quite naturally to Haskell, and seems to require some sort of non-standard extension in ML.

While the content is good, I wish it would have used Haskell as the primary exposition language. ... Read more

Customer Reviews (1)

Mathematical notation-based approach
The author utilizes mathematical notation rather than suffering through the inevitable inadequacies and limitations of any particular language (LISP, ML, Haskell, ..) However this actually simplifies the instruction,assuming the reader is familiar with set theory and the basics of formallogic.

The illustrations are primarily of the kind familiar to anyoneinvolved in computer science, such as parse trees, flowcharts, andschematics of memory allocation. There are also mathematical typesignatures.

Program examples include [very] infrequent ones in LISP, aswell as occasional procedural examples given in antiquated-yet-adequatePascal.

For the purpose of general instruction this may well beunexcelled in the field. Upon completion the reader will have a betterunderlying understanding of any particular functional language than peerswho have been programming in one ad-hoc for a substantially longer time.Many of the general topics are fundamental to other language paradigms aswell, including procedural and object-orientation (of which the author isan expert and contributor). Of particular note are the topics of recursion,binding, and computability issues, as discussed using the lambdacalculus.

This is an extremely clear work, systematically coveringsubjects ranging through logic, computing and math without drawing anyattention to distinctions between them. Throughout, it maintains a completefocus upon functional programming. In this way there is a satisfying flowto the book, allowing the incredibly rich and fine detail to be betterunderstood in context.

It is important to take note that this work doesnot merely teach the reader about programming in a functional language.Many tangent subjects will become familiar in the process, including somewhich may have previously been a source of intimidation. And, asprogramming languages evolve, such a foundation will prove over time to bean invaluable resource. ... Read more