 |
|
|
|
|
|
The busy Java developer's guide to Scala: Functional programming for the object oriented
The Java platform has historically been the province of object-oriented
programming, but even Java language stalwarts are starting to pay attention to the
latest old-is-new trend in application development: functional programming. In this
new series, Ted Neward introduces Scala, a programming language that combines
functional and object-oriented techniques for the JVM. Along the way, Ted makes the
case for why you should take the time to learn Scala -- concurrency, for one -- and
shows you how quickly it will pay off.
|
|
Articles |
|
22 Jan 2008 |
|
| |
The busy Java developer's guide to Scala: Class action
It makes sense for Java developers to use objects as a first point of
reference for understanding Scala. In this installment, Ted Neward follows a basic premise of language
measurement: that the power of a language can be measured in direct relation to its
ability to integrate new facilities -- in this case, support for complex numbers.
Along the way you'll see some interesting tidbits related to class definitions and
usage in Scala.
|
|
Articles |
|
19 Feb 2008 |
|
| |
The busy Java developer's guide to Scala: Don't get thrown for a loop!
Scala was written specifically for the Java platform, so its syntax is
designed to make Java coders feel at ease. At the same time, Scala brings to the JVM
the inherent power of functional languages -- and those functional design concepts
take some getting used to. In this installment, Ted Neward starts introducing you to the subtle differences
between the two languages, starting with control constructs such as if, while, and
for. As you'll learn, Scala gives these constructs a power and complexity you won't
find in their Java equivalents.
|
|
Articles |
|
26 Mar 2008 |
|
| |
The busy Java developer's guide to Scala: Of traits and behaviors
Scala doesn't just bring functional concepts to the JVM, it
offers us a modern perspective on object-oriented language design. In this
month's installment, Ted Neward shows you how
Scala exploits traits to make objects simpler and easier to build. As you'll
learn, traits are both similar to and different from the traditional
polarities offered by Java interfaces and C++ multiple
inheritance.
|
|
Articles |
|
29 Apr 2008 |
|
| |
The busy Java developer's guide to Scala: Implementation inheritance
Scala gives you just as much support for implementation inheritance as
the Java language does -- but Scala's inheritance yields a few surprises. This month, Ted Neward
introduces you to polymorphism done the Scala way, blending functional and
object-oriented language styles while still mapping perfectly to the Java platform's inheritance model.
|
|
Articles |
|
28 May 2008 |
|
| |
The busy Java developer's guide to Scala: Collection types
Objects have their place in Scala, but so do functional types such as tuples, arrays, and lists. In this installment of Ted Neward's popular series, you'll begin to explore the functional side of Scala, starting with its support for types common to functional languages.
|
|
Articles |
|
27 Jun 2008 |
|
| |
The busy Java developer's guide to Scala: Packages and access modifiers
Code has to be referenced and packaged in the real world, and in this installment of his series, Ted Neward covers Scala's package and access modifier facilities before continuing to explore of the functional side of Scala by examining the "apply" mechanism.
|
|
Articles |
|
29 Jul 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 1
Domain-specific languages have become a hot topic; much
of the buzz around functional languages is their applicability to build such
languages. In this installment, Ted Neward starts building
a simple calculator DSL that demonstrates the power of functional languages for
building "external" DSLs. Toward that end, he explores a new feature of Scala,
case classes, and revisits an old functional friend, pattern matching.
|
|
Articles |
|
26 Aug 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 2
Domain-specific languages (DSLs) have become a hot topic; much of the buzz
around functional languages is their ability to build such languages. In this latest
installment, Ted Neward tackles the problem of transforming
textual input into the AST for interpretation by continuing with a simple calculator DSL
that demonstrates the power of functional languages for building "external" DSLs. To parse
textual input and transform it into the tree structure used by the interpreter in the last
article, Ted introduces "parser combinators," a standard Scala library designed solely for the task. (In the previous article, we built a calculator interpreter and AST.)
|
|
Articles |
|
21 Oct 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 3
Domain-specific languages (DSLs) have become a hot topic; much of the buzz around functional languages is their ability to build such languages. After having established both an AST scheme and a basic front-end parser designed to take text and produce a graph of objects suitable for interpretation, in this article the author thinks it's time to wire everything together into a seamless -- if somewhat trivial at this point -- whole. Then he'll turn around and suggest some extensions that could be made to the language and interpreter.
|
|
Articles |
|
25 Nov 2008 |
|
| |
The busy Java developer's guide to Scala: Scala and servlets
If Scala is a fully JVM-compatible language, then you should be able
to use it in various "real-world" environments such as one in which you build servlets
and other Web applications. In this article, the author explores using Scala in a servlet
environment.
|
|
Articles |
|
22 Dec 2008 |
|
| |
The busy Java developer's guide to Scala: Explore Scala concurrency
The "gateway drug" to Scala for many, if not most, Java
programmers is the promise of easier coding when dealing with concurrency
and writing thread-safe code. In this installment, Ted Neward begins to dive
into the various concurrency features and libraries provided by the Scala
language and environment.
|
|
Articles |
|
04 Feb 2009 |
|
| |
The busy Java developer's guide to Scala: Dive deeper into Scala concurrency
Concurrency quickly became the sizzling topic on the minds of every
software developer after major chip manufacturers started to release chips that
weren't necessarily faster but were running two or more cores in parallel. In this
follow-up to his introduction to
Scala concurrency, Ted Neward takes a deeper look at this hot-topic with an examination
of actors, those executing entities that pass messages among themselves to coordinate work.
|
|
Articles |
|
10 Apr 2009 |
|
| |
The busy Java developer's guide to Scala: Scala + Twitter = Scitter
Scala is fun to talk about in the abstract, but for most of the readers of this
column, using it in a practical way makes the difference between seeing it as a "toy"
and using it on the job. In this installment, Ted Neward uses Scala to build the basic
framework for a client library for accessing Twitter, a popular micro-blogging system.
|
|
Articles |
|
05 May 2009 |
|
| |
The busy Java developer's guide to Scala: Enhancing the Scitter library
Scala is fun to talk about in the abstract, but using it in a practical
way makes the difference between seeing it as a "toy" and using it on the job. In this
follow-up article to his introduction to Scitter, a Scala client library for accessing Twitter, Scala enthusiast Ted Neward offers a more interesting and useful set of features for the client library.
|
|
Articles |
|
02 Jun 2009 |
|
| |
The busy Java developer's guide to Scala: Updating Twitter, with Scitter
The Scitter client library is almost ready to be released into the
wild, but it needs a few finishing touches. In this installment of The
busy Java developer's guide to Scala, Ted Neward shows you how to incorporate update, show, and delete functionality into the Scala-based library for accessing Twitter.
|
|
Articles |
|
20 Oct 2009 |
|
| |
