You should learn a programming language every year, as recommended by
The Pragmatic Programmer. But if one per year is good, how about
Seven Languages in Seven Weeks? In this book you'll get a hands-on
tour of Clojure, Haskell, Io, Prolog, Scala, Erlang, and Ruby. Whether
or not your favorite language is on that list, you'll broaden your
perspective of programming by examining these languages side-by-side.
You'll learn something new from each, and best of all, you'll learn how
to learn a language quickly.
Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages
in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and
beyond the 20-minute tutorial you'll find someplace online. This book
has an audacious goal: to present a meaningful exploration of seven
languages within a single book. Rather than serve as a complete
reference or installation guide, Seven Languages hits what's essential
and unique about each language. Moreover, this approach will help teach
you how to grok new languages.
For each language, you'll solve a nontrivial problem, using techniques
that show off the language's most important features. As the book
proceeds, you'll discover the strengths and weaknesses of the languages,
while dissecting the process of learning languages quickly--for example,
finding the typing and programming models, decision structures, and how
you interact with them.
Among this group of seven, you'll explore the most critical programming
models of our time. Learn the dynamic typing that makes Ruby, Python,
and Perl so flexible and compelling. Understand the underlying prototype
system that's at the heart of JavaScript. See how pattern matching in
Prolog shaped the development of Scala and Erlang. Discover how pure
functional programming in Haskell is different from the Lisp family of
languages, including Clojure.
Explore the concurrency techniques that are quickly becoming the
backbone of a new generation of Internet applications. Find out how to
use Erlang's let-it-crash philosophy for building fault-tolerant
systems. Understand the actor model that drives concurrency design in Io
and Scala. Learn how Clojure uses versioning to solve some of the most
difficult concurrency problems.
It's all here, all in one place. Use the concepts from one language to
find creative solutions in another-or discover a language that may
become one of your favorites.
