Functional Programming of Behavior-Based Systems

Total Page:16

File Type:pdf, Size:1020Kb

Functional Programming of Behavior-Based Systems Functional Programming of Behavior-Based Systems Ian Douglas Horswill Computer Science Department and The Institute for the Learning Sciences Northwestern University Evanston, IL 60201 [email protected] Abstract dozen robot configurations ranging from a sonar-based In this paper, I describe a simple functional programming system with an 8-bit microcontroller to a vision-based language, GRL, in which most of the characteristic quadruped. It has also been used to teach an features of the popular behavior-based robot architectures undergraduate seminar. can be concisely written as reusable software abstractions. This makes it easier to write clear, modular Although evaluation of programming languages is code, to “mix and match” arbitration mechanisms, and to always difficult, students who have used both raw LISP experiment with variations on existing mechanisms. I and GRL report that GRL code is much easier to write describe the compilation process for the language, our and debug. As an anecdotal example, the NWU entry in experiences with it, and issues of efficiency, the 1998 AAAI robotics exhibition was a program that expressiveness, and code size relative to other stalked people in the crowd and followed them around languages.1 while spinning paranoid fantasies about the government turning people into robots. It was constructed in three Introduction weeks by one of our undergraduates. It was his first robot program. In this paper I describe a simple language, GRL (Generic Robot Language, formerly “GiRL”, and still pronounced “girl”), that extends traditional functional programming Programming languages and behavior-based techniques to behavior-based systems.2 GRL is an systems architecture-neutral language embedded within Scheme. It provides a wide range of constructs for defining data In spite of its name, GRL is really only intended for flow within communicating parallel control loops and implementing behavior-based systems (it’s called GRL manipulating them at compile time using functional because “GBBL” would be hard to pronounce). programming techniques. A simple compiler (about 3000 Although many different behavior-based architectures lines of code) then distills the code into a single while- exist (see Arkin 98 for a survey), all consist of a set of loop containing straight-line code, and emits it as independent control loops running in parallel, usually Scheme, C, C++, BASIC, or Unrealscript3 code. The with some sort of arbitration mechanism to combine language allows programmers to write in a much more their outputs. Many of the distinctions between modular and compositional manner, but generates C behavior-based architectures amount to disagreements code that is typically faster than hand-written C code.4 about what a behavior is and how a system should We have implemented the language and used it as the arbitrate between behaviors. In subsumption (Brooks basis for our behavior-based systems at NWU for 86), a behavior is a finite-state machine and arbitration is approximately two years. We have run it on a half- performed with suppression. In the motor-schema architecture (Arkin 98), behaviors are mappings from sensor vectors to motor vectors, and arbitration is a 1 Support for this work was provided in part by the National Science Foundation under award #IRI-9625041 and in part by the Defense performed using linear combination. In behavior Advanced Research Projects Agency Mobile Autonomous Robot Software networks (Maes 90), behaviors (competence modules) Program under award N66001-99-1-8919 and by the DARPA Distributed are unrestricted black boxes, but are arbitrated using a Robotics Program and the U.S. Army Soldier Systems Command under spreading activation mechanism that forms an award #DAAN02-98-C-4023/MOD P3. approximation to STRIPS planning (Fikes, Hart, Nilsson 72). 2 The name is, of course, a gross exaggeration. It was contrived to allow the name. Many behavior-based architectures are implemented as 3 Unrealscript is the extension language for a popular computer game. application-specific programming languages and 4 This is achieved in part because the GRL compiler is maniacal about inlining, so its object code, while very fast, is typically somewhat bloated. compilers. For example, the MIT mobot lab has This could be changed, but so far, it hasn’t been a problem. developed a series of languages for writting subsumption code (Brooks 86, Brooks 90, Brooks and Rosenberg 95). • An application of a finite-state transducer to a set of Maes’ paper describes her architecture, in part, in terms signals. Again, the programmer must provide of a macrology and interpreter embedded in LISP. Scheme source code for computing the value of the Thrun (98) describes a C-like language that supports transducer from the instantaneous values of the input probability distributions and gradient descent function signals. Transducers are finite state in that they may approximators as primitive data types. Several not dynamically allocate storage. researchers have also written architectures as C++ class libraries (Velsquez 98, Schaad 98). Unfortunately, since most robotics researchers don’t have time to be Primitive procedures are mappings from instantaneous professional compiler writers, these systems are often signal values to values. Values may be scalars (integers, quite primitive as programming languages. In particular, floats, Booleans, …) or vectors. Transducers, since they their abstraction capabilities, if any, are typically limited contain history information, are mappings from signal to macro expansion. They also tend to make it painful or time histories to time histories. However, they are impossible to implement the other architectures as user restricted to be finite state. Sources and transducers are code. Thus one can’t easily compare the subsumption the only constructs in which programmers are allowed to architecture with behavior-networks because they have escape to Scheme and write Scheme code that will be completely separate languages. It is possible of course, executed at run time. This Scheme code is restricted, but it typically involves hand-compiling one architecture however, to be statically typeable and to be non-consing, into the primitives of another. at least if the compiler is to generate C or BASIC code for the final output. Assuming the code provided for The goal of GRL is to have a language with the sources and transducers runs in O(1) time, then the abstraction facilities of LISP and the run-time efficiency network as a whole runs in O(1) space and can compute of the subsumption compiler. Although it is limited to updates in O(1) time. the kinds of real-time finite state computations used in behavior-based systems (and therefore cannot implement Primitive signals make up a straightforward language for full symbolic programming systems like theorem writing real-time control loops. Although most of the provers), it does provide the programmer with an advantages of GRL come from more sophisticated architecture-neutral language for experimenting with constructs, the primitive signal sub-language does have different kinds of arbitration mechanisms. the advantage that allows functions over time histories (transducers) to be composed more naturally than is possible in most programming languages. For example, GRL primitives consider the problem of detecting a doorway using a directional proximity sensor, such as a sonar or IR, while GRL supports circuit semantics (Nilsson 1994). driving down a hallway. A simple approach is to look Ultimately, GRL programs consist of networks of signals for a long reading from one of the sideways-facing which are thought of as being computed in parallel and sensors: updated continuously. In reality, of course, GRL code runs on serial uniprocessors or loosely coupled networks (define-signal door? of uniprocessors, so the parallelism and continous update (> (max left-reading right-reading) are only approximate. Any signal that exists at run time thresh)) must be a primitive signal, meaning more or less that it must be easily computed in C. A primitive signal may be: However, this might generate spurious readings because of sensor errors. Programmers often post-process the sensor output by requiring that the long reading be seen • A constant for at least a certain amount of time: • A signal source, for which raw Scheme code has been provided by the programmer. They are used for (define-signal door? sensor and effector interface code. (> (true-time • (> (max left-reading An application of a primitve procedure (+, -, log, …) right-reading) to a set of signals. Note that if, and, and or, are dist-thresh)) normal procedures in GRL, not special forms.1 time-thresh)) 1 This is for technical reasons. Conditionals are usually special-forms in languages with applicative-order evaluation because programmers unintentional range errors do not occur, such as in the expression (if typically don’t want conditionals to pre-evaluate all their subexpressions. (zero? a) 0 (/ 1 a)). Since GRL signals have quasi-parallel semantics, conditionals always evaluate all their arguments. Care must be taken, therefore to ensure that where true-time is a finite-state transducer that returns (define-group-type xy-vector the number of milliseconds for which its input has been (xy-vector x y) true. It is a standard part of the GRL library and is (x x-of) defined by the code: (y y-of)) (define-transducer (true-time input) This example declares that the xy-vector data type1 (state-variables (onset 0)) consists of x and y elements, which are accessed with (when (not input) the x-of and y-of procedures, respectively. New xy- (set! onset ms-clock)) (- ms-clock onset)) vectors are created with the xy-vector procedure, which takes the x and y components as arguments. Unfortunately, you can’t write true-time conveniently in LISP or C because it doesn’t behave like a normal Groups are explicitly represented at compile-time so that function – it requires an internal state variable, onset. they can be manipulated and simplified.
Recommended publications
  • Functional Languages
    Functional Programming Languages (FPL) 1. Definitions................................................................... 2 2. Applications ................................................................ 2 3. Examples..................................................................... 3 4. FPL Characteristics:.................................................... 3 5. Lambda calculus (LC)................................................. 4 6. Functions in FPLs ....................................................... 7 7. Modern functional languages...................................... 9 8. Scheme overview...................................................... 11 8.1. Get your own Scheme from MIT...................... 11 8.2. General overview.............................................. 11 8.3. Data Typing ...................................................... 12 8.4. Comments ......................................................... 12 8.5. Recursion Instead of Iteration........................... 13 8.6. Evaluation ......................................................... 14 8.7. Storing and using Scheme code ........................ 14 8.8. Variables ........................................................... 15 8.9. Data types.......................................................... 16 8.10. Arithmetic functions ......................................... 17 8.11. Selection functions............................................ 18 8.12. Iteration............................................................. 23 8.13. Defining functions ...........................................
    [Show full text]
  • The Machine That Builds Itself: How the Strengths of Lisp Family
    Khomtchouk et al. OPINION NOTE The Machine that Builds Itself: How the Strengths of Lisp Family Languages Facilitate Building Complex and Flexible Bioinformatic Models Bohdan B. Khomtchouk1*, Edmund Weitz2 and Claes Wahlestedt1 *Correspondence: [email protected] Abstract 1Center for Therapeutic Innovation and Department of We address the need for expanding the presence of the Lisp family of Psychiatry and Behavioral programming languages in bioinformatics and computational biology research. Sciences, University of Miami Languages of this family, like Common Lisp, Scheme, or Clojure, facilitate the Miller School of Medicine, 1120 NW 14th ST, Miami, FL, USA creation of powerful and flexible software models that are required for complex 33136 and rapidly evolving domains like biology. We will point out several important key Full list of author information is features that distinguish languages of the Lisp family from other programming available at the end of the article languages and we will explain how these features can aid researchers in becoming more productive and creating better code. We will also show how these features make these languages ideal tools for artificial intelligence and machine learning applications. We will specifically stress the advantages of domain-specific languages (DSL): languages which are specialized to a particular area and thus not only facilitate easier research problem formulation, but also aid in the establishment of standards and best programming practices as applied to the specific research field at hand. DSLs are particularly easy to build in Common Lisp, the most comprehensive Lisp dialect, which is commonly referred to as the “programmable programming language.” We are convinced that Lisp grants programmers unprecedented power to build increasingly sophisticated artificial intelligence systems that may ultimately transform machine learning and AI research in bioinformatics and computational biology.
    [Show full text]
  • Functional Programming Laboratory 1 Programming Paradigms
    Intro 1 Functional Programming Laboratory C. Beeri 1 Programming Paradigms A programming paradigm is an approach to programming: what is a program, how are programs designed and written, and how are the goals of programs achieved by their execution. A paradigm is an idea in pure form; it is realized in a language by a set of constructs and by methodologies for using them. Languages sometimes combine several paradigms. The notion of paradigm provides a useful guide to understanding programming languages. The imperative paradigm underlies languages such as Pascal and C. The object-oriented paradigm is embodied in Smalltalk, C++ and Java. These are probably the paradigms known to the students taking this lab. We introduce functional programming by comparing it to them. 1.1 Imperative and object-oriented programming Imperative programming is based on a simple construct: A cell is a container of data, whose contents can be changed. A cell is an abstraction of a memory location. It can store data, such as integers or real numbers, or addresses of other cells. The abstraction hides the size bounds that apply to real memory, as well as the physical address space details. The variables of Pascal and C denote cells. The programming construct that allows to change the contents of a cell is assignment. In the imperative paradigm a program has, at each point of its execution, a state represented by a collection of cells and their contents. This state changes as the program executes; assignment statements change the contents of cells, other statements create and destroy cells. Yet others, such as conditional and loop statements allow the programmer to direct the control flow of the program.
    [Show full text]
  • Functional and Imperative Object-Oriented Programming in Theory and Practice
    Uppsala universitet Inst. för informatik och media Functional and Imperative Object-Oriented Programming in Theory and Practice A Study of Online Discussions in the Programming Community Per Jernlund & Martin Stenberg Kurs: Examensarbete Nivå: C Termin: VT-19 Datum: 14-06-2019 Abstract Functional programming (FP) has progressively become more prevalent and techniques from the FP paradigm has been implemented in many different Imperative object-oriented programming (OOP) languages. However, there is no indication that OOP is going out of style. Nevertheless the increased popularity in FP has sparked new discussions across the Internet between the FP and OOP communities regarding a multitude of related aspects. These discussions could provide insights into the questions and challenges faced by programmers today. This thesis investigates these online discussions in a small and contemporary scale in order to identify the most discussed aspect of FP and OOP. Once identified the statements and claims made by various discussion participants were selected and compared to literature relating to the aspects and the theory behind the paradigms in order to determine whether there was any discrepancies between practitioners and theory. It was done in order to investigate whether the practitioners had different ideas in the form of best practices that could influence theories. The most discussed aspect within FP and OOP was immutability and state relating primarily to the aspects of concurrency and performance. ​ ​ ​ ​ ​ ​ This thesis presents a selection of representative quotes that illustrate the different points of view held by groups in the community and then addresses those claims by investigating what is said in literature.
    [Show full text]
  • Functional Javascript
    www.it-ebooks.info www.it-ebooks.info Functional JavaScript Michael Fogus www.it-ebooks.info Functional JavaScript by Michael Fogus Copyright © 2013 Michael Fogus. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/ institutional sales department: 800-998-9938 or [email protected]. Editor: Mary Treseler Indexer: Judith McConville Production Editor: Melanie Yarbrough Cover Designer: Karen Montgomery Copyeditor: Jasmine Kwityn Interior Designer: David Futato Proofreader: Jilly Gagnon Illustrator: Robert Romano May 2013: First Edition Revision History for the First Edition: 2013-05-24: First release See http://oreilly.com/catalog/errata.csp?isbn=9781449360726 for release details. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Functional JavaScript, the image of an eider duck, and related trade dress are trademarks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trade‐ mark claim, the designations have been printed in caps or initial caps. While every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.
    [Show full text]
  • Functional Programming Lecture 1: Introduction
    Functional Programming Lecture 13: FP in the Real World Viliam Lisý Artificial Intelligence Center Department of Computer Science FEE, Czech Technical University in Prague [email protected] 1 Mixed paradigm languages Functional programming is great easy parallelism and concurrency referential transparency, encapsulation compact declarative code Imperative programming is great more convenient I/O better performance in certain tasks There is no reason not to combine paradigms 2 3 Source: Wikipedia 4 Scala Quite popular with industry Multi-paradigm language • simple parallelism/concurrency • able to build enterprise solutions Runs on JVM 5 Scala vs. Haskell • Adam Szlachta's slides 6 Is Java 8 a Functional Language? Based on: https://jlordiales.me/2014/11/01/overview-java-8/ Functional language first class functions higher order functions pure functions (referential transparency) recursion closures currying and partial application 7 First class functions Previously, you could pass only classes in Java File[] directories = new File(".").listFiles(new FileFilter() { @Override public boolean accept(File pathname) { return pathname.isDirectory(); } }); Java 8 has the concept of method reference File[] directories = new File(".").listFiles(File::isDirectory); 8 Lambdas Sometimes we want a single-purpose function File[] csvFiles = new File(".").listFiles(new FileFilter() { @Override public boolean accept(File pathname) { return pathname.getAbsolutePath().endsWith("csv"); } }); Java 8 has lambda functions for that File[] csvFiles = new File(".")
    [Show full text]
  • Notes on Functional Programming with Haskell
    Notes on Functional Programming with Haskell H. Conrad Cunningham [email protected] Multiparadigm Software Architecture Group Department of Computer and Information Science University of Mississippi 201 Weir Hall University, Mississippi 38677 USA Fall Semester 2014 Copyright c 1994, 1995, 1997, 2003, 2007, 2010, 2014 by H. Conrad Cunningham Permission to copy and use this document for educational or research purposes of a non-commercial nature is hereby granted provided that this copyright notice is retained on all copies. All other rights are reserved by the author. H. Conrad Cunningham, D.Sc. Professor and Chair Department of Computer and Information Science University of Mississippi 201 Weir Hall University, Mississippi 38677 USA [email protected] PREFACE TO 1995 EDITION I wrote this set of lecture notes for use in the course Functional Programming (CSCI 555) that I teach in the Department of Computer and Information Science at the Uni- versity of Mississippi. The course is open to advanced undergraduates and beginning graduate students. The first version of these notes were written as a part of my preparation for the fall semester 1993 offering of the course. This version reflects some restructuring and revision done for the fall 1994 offering of the course|or after completion of the class. For these classes, I used the following resources: Textbook { Richard Bird and Philip Wadler. Introduction to Functional Program- ming, Prentice Hall International, 1988 [2]. These notes more or less cover the material from chapters 1 through 6 plus selected material from chapters 7 through 9. Software { Gofer interpreter version 2.30 (2.28 in 1993) written by Mark P.
    [Show full text]
  • Purely Functional Data Structures
    Purely Functional Data Structures Chris Okasaki September 1996 CMU-CS-96-177 School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy. Thesis Committee: Peter Lee, Chair Robert Harper Daniel Sleator Robert Tarjan, Princeton University Copyright c 1996 Chris Okasaki This research was sponsored by the Advanced Research Projects Agency (ARPA) under Contract No. F19628- 95-C-0050. The views and conclusions contained in this document are those of the author and should not be interpreted as representing the official policies, either expressed or implied, of ARPA or the U.S. Government. Keywords: functional programming, data structures, lazy evaluation, amortization For Maria Abstract When a C programmer needs an efficient data structure for a particular prob- lem, he or she can often simply look one up in any of a number of good text- books or handbooks. Unfortunately, programmers in functional languages such as Standard ML or Haskell do not have this luxury. Although some data struc- tures designed for imperative languages such as C can be quite easily adapted to a functional setting, most cannot, usually because they depend in crucial ways on as- signments, which are disallowed, or at least discouraged, in functional languages. To address this imbalance, we describe several techniques for designing functional data structures, and numerous original data structures based on these techniques, including multiple variations of lists, queues, double-ended queues, and heaps, many supporting more exotic features such as random access or efficient catena- tion. In addition, we expose the fundamental role of lazy evaluation in amortized functional data structures.
    [Show full text]
  • Functional Programming with C++ Template Metaprograms
    Functional Programming with C++ Template Metaprograms Zolt´an Porkol´ab E¨otv¨os Lor´and University, Faculty of Informatics Dept. of Programming Languages and Compilers P´azm´any P´eter s´et´any 1/C H-1117 Budapest, Hungary [email protected] Abstract. Template metaprogramming is an emerging new direction of generative programming: with the clever definitions of templates we can enforce the C++ compiler to execute algorithms at compilation time. Among the application areas of template metaprograms are the expres- sion templates, static interface checking, code optimization with adap- tion, language embedding and active libraries. However, as this feature of C++ was not an original design goal, the language is not capable of elegant expression of template metaprograms. The complicated syn- tax leads to the creation of code that is hard to write, understand and maintain. Despite that template metaprogramming has a strong rela- tionship with functional programming paradigm, language syntax and the existing libraries do not follow these requirements. In this paper we give a short and incomplete introduction to C++ templates and the ba- sics of template metaprogramming. We will enlight the role of template metaprograms, some important and widely used idioms and techniques. 1 Introduction Templates are key elements of the C++ programming language [3, 32]. They enable data structures and algorithms to be parameterized by types, thus cap- turing commonalities of abstractions at compilation time without performance penalties at runtime [37]. Generic programming [28, 27, 17] is a recently popu- lar programming paradigm, which enables the developer to implement reusable codes easily. Reusable components { in most cases data structures and algo- rithms { are implemented in C++ with the heavy use of templates.
    [Show full text]
  • Functional Programming at Work in Object-Oriented Programming
    Functional Programming at Work in Object-Oriented Programming Narbel version 2010 Narbel Functional Programming at Work in Object-Oriented Programming 1 A Claim about Programming Styles Claim: Adding functional programming capabilities to an object-oriented language leads to benefits in object-oriented programming design. Narbel Functional Programming at Work in Object-Oriented Programming 2 Existing Languages with a FP-OOP Mix Some old and less old languages with FP+OOP: For instance, Smalltalk, Common Lisp (CLOS). More recently, Python or Ruby. Notations: FP, Functional programming; OOP, Object-oriented programming, Narbel Functional Programming at Work in Object-Oriented Programming 3 FP techniques emulated in OOP Practices in OOP languages include emulations of FP techniques: C++ programmers: function pointers and overloadings of the () operator, i.e. “object-functions” or functors. Java programmers: anonymous classes and introspection/reflexion. Narbel Functional Programming at Work in Object-Oriented Programming 4 Existence of FP-OOP Comparison Points The idea of using FP to enrich OOP is old, see e.g. the discussions about the problem of the user-defined datatype extension: User-defined types and procedural data structures as complementary approaches to data abstraction. Reynolds. 1975. The Expression Problem. Wadler. 1998. Narbel Functional Programming at Work in Object-Oriented Programming 5 A Trend: FP Extensions for OO Languages A recent trend: to propose and include typed FP extensions in mainstream static OO languages. Extensions for C++ (see e.g. Laufer, Striegnitz, McNamara, Smaragdakis), and work in progress in the C++ standard committees. Java 7 expected to include FP constructs. C# offers FP constructs (even more in its 3.0 version).
    [Show full text]
  • Concurrency and Parallelism in Functional Programming Languages
    Concurrency and Parallelism in Functional Programming Languages John Reppy [email protected] University of Chicago April 21 & 24, 2017 Introduction Outline I Programming models I Concurrent I Concurrent ML I Multithreading via continuations (if there is time) CML 2 Introduction Outline I Programming models I Concurrent I Concurrent ML I Multithreading via continuations (if there is time) CML 2 Introduction Outline I Programming models I Concurrent I Concurrent ML I Multithreading via continuations (if there is time) CML 2 Introduction Outline I Programming models I Concurrent I Concurrent ML I Multithreading via continuations (if there is time) CML 2 Introduction Outline I Programming models I Concurrent I Concurrent ML I Multithreading via continuations (if there is time) CML 2 Programming models Different language-design axes I Parallel vs. concurrent vs. distributed. I Implicitly parallel vs. implicitly threaded vs. explicitly threaded. I Deterministic vs. non-deterministic. I Shared state vs. shared-nothing. CML 3 Programming models Different language-design axes I Parallel vs. concurrent vs. distributed. I Implicitly parallel vs. implicitly threaded vs. explicitly threaded. I Deterministic vs. non-deterministic. I Shared state vs. shared-nothing. CML 3 Programming models Different language-design axes I Parallel vs. concurrent vs. distributed. I Implicitly parallel vs. implicitly threaded vs. explicitly threaded. I Deterministic vs. non-deterministic. I Shared state vs. shared-nothing. CML 3 Programming models Different language-design axes I Parallel vs. concurrent vs. distributed. I Implicitly parallel vs. implicitly threaded vs. explicitly threaded. I Deterministic vs. non-deterministic. I Shared state vs. shared-nothing. CML 3 Programming models Different language-design axes I Parallel vs.
    [Show full text]
  • Functional Programming Patterns in Scala and Clojure Write Lean Programs for the JVM
    Early Praise for Functional Programming Patterns This book is an absolute gem and should be required reading for anybody looking to transition from OO to FP. It is an extremely well-built safety rope for those crossing the bridge between two very different worlds. Consider this mandatory reading. ➤ Colin Yates, technical team leader at QFI Consulting, LLP This book sticks to the meat and potatoes of what functional programming can do for the object-oriented JVM programmer. The functional patterns are sectioned in the back of the book separate from the functional replacements of the object-oriented patterns, making the book handy reference material. As a Scala programmer, I even picked up some new tricks along the read. ➤ Justin James, developer with Full Stack Apps This book is good for those who have dabbled a bit in Clojure or Scala but are not really comfortable with it; the ideal audience is seasoned OO programmers looking to adopt a functional style, as it gives those programmers a guide for transitioning away from the patterns they are comfortable with. ➤ Rod Hilton, Java developer and PhD candidate at the University of Colorado Functional Programming Patterns in Scala and Clojure Write Lean Programs for the JVM Michael Bevilacqua-Linn The Pragmatic Bookshelf Dallas, Texas • Raleigh, North Carolina Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals.
    [Show full text]