362 Pages 50 B/W Illustrations
    by Chapman & Hall

    362 Pages
    by Chapman & Hall

    362 Pages 50 B/W Illustrations
    by Chapman & Hall

    Programming Language Explorations is a tour of several modern programming languages in use today. The book teaches fundamental language concepts using a language-by-language approach. As each language is presented, the authors introduce new concepts as they appear, and revisit familiar ones, comparing their implementation with those from languages seen in prior chapters. The goal is to present and explain common theoretical concepts of language design and usage, illustrated in the context of practical language overviews.

    Twelve languages have been carefully chosen to illustrate a wide range of programming styles and paradigms. The book introduces each language with a common trio of example programs, and continues with a brief tour of its basic elements, type system, functional forms, scoping rules, concurrency patterns, and sometimes, metaprogramming facilities.

    Each language chapter ends with a summary, pointers to open source projects, references to materials for further study, and a collection of exercises, designed as further explorations. Following the twelve featured language chapters, the authors provide a brief tour of over two dozen additional languages, and a summary chapter bringing together many of the questions explored throughout the text.

    Targeted to both professionals and advanced college undergraduates looking to expand the range of languages and programming patterns they can apply in their work and studies, the book pays attention to modern programming practice, covers cutting-edge languages and patterns, and provides many runnable examples, all of which can be found in an online GitHub repository. The exploration style places this book between a tutorial and a reference, with a focus on the concepts and practices underlying programming language design and usage. Instructors looking for material to supplement a programming languages or software engineering course may find the approach unconventional, but hopefully, a lot more fun.

    Introduction
    WHY STUDY PROGRAMMING LANGUAGES
    PROGRAMMING LANGUAGE ELEMENTS
    EVALUATING PROGRAMMING LANGUAGES

    JavaScript
    HELLO JAVASCRIPT
    THE BASICS
    CLOSURES
    METHODS
    PROTOTYPES
    SCOPE
    CALLBACKS AND PROMISES
    JAVASCRIPT WRAP UP

    CoffeeScript
    HELLO COFFEESCRIPT
    THE BASICS
    NO SHADOWING?!
    COMPREHENSIONS
    DESTRUCTURING
    EXISTENTIAL OPERATORS
    COFFEESCRIPT WRAP UP

    Lua
    HELLO LUA
    THE BASICS
    SCOPE
    TABLES
    METATABLES
    COROUTINES
    LUA WRAP UP

    Python
    HELLO PYTHON
    THE BASICS
    SCOPE
    PARAMETER ASSOCIATION
    SPECIAL METHODS
    ITERATORS AND GENERATORS
    DECORATORS
    PYTHON WRAP UP

    Ruby
    HELLO RUBY
    THE BASICS
    OBJECT ORIENTATION
    Messaging
    Encapsulation
    Inheritance
    Polymorphism
    Singleton Classes
    BLOCKS
    MIXINS
    ACCESS CONTROL
    METAPROGRAMMING
    RUBY WRAP UP

    Julia
    HELLO JULIA
    THE BASICS
    TYPES
    Abstract Types
    Parametric Types
    Sum and Product Types
    Type Annotations
    Covariance, Contravariance, and Invariance
    MULTIPLE DISPATCH
    METAPROGRAMMING
    PARALLEL COMPUTING
    JULIA WRAP UP

    Java
    HELLO JAVA
    THE BASICS
    INTERFACES
    STATIC TYPING
    GENERICS
    THREADS
    METAPROGRAMMING
    JAVA WRAP UP

    Clojure
    HELLO CLOJURE
    THE BASICS
    NAMESPACES
    PERSISTENT DATA STRUCTURES
    TRANSIENTS
    SOFTWARE TRANSACTIONAL MEMORY
    AGENTS
    THE EXPRESSION PROBLEM
    MACROS
    CLOJURE WRAP UP

    Elm
    HELLO ELM
    THE BASICS
    TYPE INFERENCE
    TAGGED UNIONS
    RECORDS
    EFFECTS
    ELM WRAP UP

    Erlang
    HELLO ERLANG
    THE BASICS
    MATCHING
    MESSAGING
    ERLANG WRAP UP

    Go
    HELLO GO
    THE BASICS
    POINTERS
    SLICES
    INTERFACES
    PANICS
    GOROUTINES
    REFLECTION
    GO WRAP UP

    Swift
    HELLO SWIFT
    THE BASICS
    OPTIONALS
    OPERATORS
    PROTOCOLS
    EXTENSIONS
    SAFETY FEATURES
    AUTOMATIC REFERENCE COUNTING
    SWIFT WRAP UP

    Additional Languages
    THE CLASSICS
    SYSTEMS LANGUAGES
    THE ENTERPRISE
    SCRIPTING
    THE ML FAMILY
    CONCURRENCY MATTERS
    THE WEB
    CRYSTALLIZATIONS OF STYLE
    ESOTERIC LANGUAGES
    ASSEMBLY LANGUAGES

    Afterword
    WHERE WE’VE BEEN
    Functions
    Types
    Expressions
    Control Flow
    Concurrency
    Modularity
    Metaprogramming
    WHERE TO GO NEXT

    Appendix A ■ Numbers
    INTEGERS
    FLOATING POINT NUMBERS
    RATIOS AND DECIMALS

    Appendix B ■ Text
    CHARACTERS, GLYPHS, AND GRAPHEME CLUSTERS
    CHARACTER PROPERTIES
    CHARACTER ENCODING

     

    Biography

    Ray Toal is Professor of Computer Science at Loyola Marymount University in Los Angeles where he has been teaching since 1986. He received his Ph.D. from UCLA in 1993 in semantics, with minors in theoretical computer science and database systems. His current research interests are in programming language design, compilers, APIs, and large scale infrastructure. He has consulted for a number of companies in the Los Angeles area, including Citysearch/CityGrid, Medaxis, Friendbuy, Handmade Mobile, M-GO, and Criteo. Ray has authored three books on programming languages and has been involved with projects at the Human Advancement Research Community (HARC).

    "This book tackles the task of describing programming languages effectively and efficiently. The authors adopt a principle-based approach that allows readers to recognize how fundamental computer science concepts take form in each of the presented programming languages. This allows readers to experience how each language includes some subset of these concepts, and thus becomes suitable for different tasks. In this approach, functionality emerges as the embodiment of these fundamentals. Readers are then encouraged to find commonalities and themes in the material by following exercises, which also provide the means to further the study of any one of the presented languages. The final chapter links all of the material explicitly through a series of recurring themes of interest to software engineers and computer scientists. Although the book can be useful to any technical and academic audience, it will be better suited for upper-division undergraduate students, graduate students, or professionals seeking further development."
    —L. Benedicenti, Choice, May 2017

    "All in all, this book makes for a great browse, an interesting read if one wishes to learn about different programming paradigms and languages, and a very clear and well-organized textbook. The language is crisp and concise, and assumes a familiarity with programming. I teach an upper-undergraduate module on the principles of programming languages, and plan to make use of this book extensively to help give students insights into the vast but interesting landscape of programming languages."
    —Sara Kalvala, ACM Computing Reviews, May 2017