 |
|
|
|
|
|
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: 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: 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: 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: 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 |
|
| |
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: 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: 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: 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 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: 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: 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: 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: 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: 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: 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 |
|
| |
Java theory and practice: More flexible, scalable locking in JDK 5.0
JDK 5.0 offers developers some powerful new choices for developing high-performance concurrent applications. For example, the ReentrantLock class in java.util.concurrent.lock is offered as a replacement for the synchronized facility of the Java language -- it has the same memory semantics, the same locking semantics, better performance under contention, and features not offered by synchronized. Does this mean that we should forget about synchronized, and instead use ReentrantLock exclusively? Concurrency expert Brian Goetz returns from his summer hiatus to supply the answer.
|
|
Articles |
|
26 Oct 2004 |
|
| |
Ajax for Java developers: Write scalable Comet applications with Jetty and Direct Web Remoting
Ajax applications driven by asynchronous server-side events can be tricky to implement and difficult to scale. Returning to his popular series, Philip McCarthy shows an effective approach: The Comet
pattern allows you to push data to clients, and Jetty 6's Continuations API lets your
Comet application scale to a large number of clients. You can conveniently take advantage
of both Comet and Continuations with the Reverse Ajax technology in Direct Web Remoting
(DWR) 2.
|
|
Articles |
|
17 Jul 2007 |
|
| |
Scala and XML
Scala is a popular new programming language that runs on the Java Virtual Machine (JVM.) Scala compiles into byte-code and thus it can leverage the Java programming language. Its syntax, however, makes it a powerful alternative to Java in certain scenarios. One of those scenarios is XML processing. Scala lets you navigate and process parsed XML in several ways. It also has first class support for XML built right in, so there is no need to create strings of XML or programmatically build DOM trees. In this article, you will see these aspects of Scala in action and see how Scala can make working with XML a joy to do.
|
|
Articles |
|
22 Apr 2008 |
|
| |
FastSOA: Accelerate SOA with XML, XQuery, and native XML database technology
Many SOA implementations rely on message formats defined with XML. The resulting message schemas can become complex, incompatible, and difficult to maintain, and can cause serious scalability and performance problems. In this article, Frank Cohen describes a new strategy and techniques for accelerating SOA performance through the use of XML, XQuery, and native XML database technology in the SOA mid-tier.
|
|
Articles |
|
07 Feb 2006 |
|
| |
Java EE meets Web 2.0
Web 2.0 applications developed using standard Java Platform,
Enterprise Edition 5 (Java EE)-based approaches face serious performance and scalability problems. The reason is that many principles that underlie the Java EE platform's design especially, the use of synchronous APIs don't apply to the requirements of Web 2.0 solutions. This article explains the disparity between the Java EE and Web 2.0 approaches, explores the benefits of asynchronous designs, and evaluates some solutions for developing asynchronous Web applications with the Java platform.
|
|
Articles |
|
06 Nov 2007 |
|
| |
Comment lines by Kevin Sutter: An update on Java Persistence API 2.0
As the JPA Expert Group (JSR-317) nears completion of the JPA 2.0
specification, this article introduces you to some of the new concepts and features in this updated specification. It also explains how you can experience this new functionality with the Apache OpenJPA project, an open-source, robust, high performance, scalable implementation of the JPA specification.
|
|
Articles |
|
30 Sep 2009 |
|
| |
Crossing borders: A Rails case study
Ruby on Rails development and Java development differ in fundamental ways. In this final installment of Crossing borders, Bruce Tate outlines the major differences he's discovered by using Rails to develop a complex, scalable Web site from the ground up.
|
|
Articles |
|
10 Apr 2007 |
|
| |
Ajax and REST, Part 1
The more that server-side Web applications become immersive by following rich-application models and delivering personalized content, the more their architectures violate Representational State Transfer (REST), the Web's architectural style. These violations can decrease application scalability and increase system complexity. By achieving harmony with REST, Ajax architecture lets immersive Web applications eliminate these negative effects and enjoy REST's desirable properties.
|
|
Articles |
|
02 Oct 2006 |
|
| |
Google App Engine for Java: Part 1: Rev it up!
Remember when Google App Engine was just for Pythonistas? Those
were some dark days. Google Inc. opened up its cloud-computing platform to
Java developers in April 2009. In this three-part article series, Java technology author and
trainer Rick Hightower gets you started with this reliable, robust, and fun platform
for Java-based development. In this article, you'll get an overview of why Google App
Engine for Java could
be the deployment platform for your next highly scalable killer app, then start using
the Google Plugin for Eclipse to build two example apps: one based on Google Web Toolkit (GWT) and one based on the Java Servlet API. You'll learn for yourself what a difference Google App
Engine for Java makes, both in building out an application from scratch and in deploying it to the tune of up to five million views. (And that's just the free version.)
|
|
Articles |
|
11 Aug 2009 |
|
| |
Java theory and practice: State replication in the Web tier
How state will be managed and replicated in a clustered server application has a significant impact on the scalability of the application. Many Java applications store state in the HttpSession provided by the Servlet API. This article examines some of the options for HttpSession replication and how to most effectively use HttpSession to provide good scalability and performance.
|
|
Articles |
|
29 Jul 2004 |
|
| |
Extend JAAS for class instance-level authorization
The Java Authentication and Authorization Service (JAAS) is an extension to the Java 2 SDK. Under JAAS, a user or service may be given specific permissions to execute code in a Java class. In this article, software engineer Carlos Fonseca shows you how to extend the JAAS framework for the enterprise. Adding class instance-level authorization and special relationships to the JAAS framework lets you build more dynamic, flexible, and scalable enterprise applications.
|
|
Articles |
|
01 Apr 2002 |
|
| |
Threading lightly, Part 2: Reducing contention
In Part 1 of this series, we examined the performance overhead of uncontended synchronization. With each successive JVM version, overall performance has improved, and the cost of uncontended synchronization has been reduced, making the issue of uncontended synchronization overhead less significant. Contended synchronization, however, is quite expensive. This article will explore several techniques for reducing contention, and hence improving scalability, in your programs.
|
|
Articles |
|
05 Sep 2001 |
|
| |
Spice up collections with generics and concurrency
The Java Collections Framework is an important aspect of the Java platform.
Both desktop and enterprise applications typically collect items to work with. This
article shows you how to work with collections while taking advantage of
enhancements made to the framework in Java SE 6. You can go far beyond HashMap or
TreeSet by using generics and concurrency features to make your applications more
maintainable and scalable.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Google App Engine for Java: Part 3: Persistence and relationships
Data persistence is a cornerstone of scalable application delivery in
enterprise environments. In this final article of his series introducing Google App
Engine for Java, Rick Hightower takes on the challenges of App Engine's current
Java-based persistence framework. Learn the nuts and bolts of why Java persistence in
the current preview release isn't quite ready for prime time, while also getting a
working demonstration of what you can do to persist data in App Engine for Java
applications. Note that you will need to have the contact-management application from
Part 2 up and running as you learn how to use the JDO API to persist, query, update, and delete Contact objects.
|
|
Articles |
|
25 Aug 2009 |
|
| |
Best practices for location-aware services
This tutorial gets you started with IBM Enterprise LAS middleware. Learn the concepts behind the middleware and write a simple location-tracking Web application with the help of Asynchronous JavaScript and XML (Ajax) and Scalable Vector Graphics (SVG) technologies. With these best practices in mind, you'll be on your way to building faster location-tracking systems that can easily integrate with positioning/sensoring technologies, such as RFID and Zigbee.
|
|
Tutorials |
|
06 Jun 2006 |
|
| |
Crossing borders: Continuations, Web development, and Java programming
The Crossing borders series looks at how non-Java languages solve major problems and what those solutions mean to Java developers today. This article explores continuations, the technique behind frameworks like Smalltalk's Seaside. Continuation servers make it much easier to build Web applications by offering a stateful programming model without giving up the scalability inherent in statelessness.
|
|
Articles |
|
21 Mar 2006 |
|
| |
Concurrency in JDK 5.0
JDK 5.0 added major new support for developing concurrent applications, including JVM changes, new low-level synchronization utilities, and higher-level, thread-safe, high-performance concurrency classes such as thread pools, concurrent collections, semaphores, latches, and barriers. Learn how these new classes can help make your code faster, more scalable, more reliable, and easier to maintain.
|
|
Tutorials |
|
23 Nov 2004 |
|
| |
Java theory and practice: Going atomic
Until JDK 5.0, it was not possible to write wait-free, lock-free algorithms in the Java language without using native code. The addition of the atomic variable classes in java.util.concurrent changes that situation. Follow along with concurrency expert Brian Goetz as he explains how these new classes have enabled the development of highly scalable nonblocking algorithms in the Java language. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
23 Nov 2004 |
|
| |
Merlin brings nonblocking I/O to the Java platform
The Java technology platform is long overdue for a nonblocking I/O mechanism. Fortunately, Merlin (JDK 1.4) has a magic wand for almost every occasion, and unblocking blocked I/O is this magician's specialty. Software engineers Aruna Kalagnanam and Balu G introduce the nonblocking features of Merlin's new I/O package, java.nio (NIO), and employ a socket-programming example to show you just what NIO can do.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Tip: Make the best use of asynchronous callbacks
It takes some finesse to make the best use of asynchronous callbacks for
Ajax data sources in JavaScript applications. This tip discusses
why you should use asynchronous callbacks for Ajax data sources and
gives examples of coordinating the readiness of mutually dependent
application data sources that may become ready at undefined times
with asynchronous calls.
|
|
Articles |
|
11 Dec 2007 |
|
| |
Google App Engine for Java: Part 2: Building the killer app
The whole point of a cloud platform like Google App Engine for Java is
in being able to imagine, build, and deploy professional-quality killer apps that
scale -- without breaking the bank or driving yourself insane. In this second part of
his three-part introduction to Google App Engine for Java, Rick Hightower takes you
beyond the ready-made examples of Part 1 with a step-by-step guide to writing and
deploying a simple contact-management application using Google App Engine for Java.
|
|
Articles |
|
11 Aug 2009 |
|
| |
Dead like COBOL
With the recent reports of Java's imminent demise, you're
probably wondering if it's time to leave the platform behind for
greener pastures. Before you make a decision, step back and examine the Java ecosystem, along with
that of its competitors, to see if the rumors have any substance. It's time, in other
words, to have a State of the Java Union address, holding neither pride nor prejudice in
the evaluation of the platform.
|
|
Articles |
|
27 May 2008 |
|
| |
Java theory and practice: Synchronization optimizations in Mustang
In the September installment of Java theory and
practice, columnist Brian Goetz examined escape analysis, an
optimization that has been on the "to-do" list for many JVMs for quite
some time and which is expected in HotSpot in the Mustang (Java SE
6) release. Escape analysis can be used to convert heap-based object
allocation into the less-expensive, stack-based allocations, but it can
also be used to make other optimization decisions as well, including
optimizing the use of synchronization. This month Brian introduces some of the synchronization
optimizations slated for Mustang. Note: This column describes features of a future version of
Sun's HotSpot JVM implementation. Specific features discussed herein
may or may not appear in Java SE 6 ("Mustang"); some may be delayed
until Java SE 7 ("Dolphin").
|
|
Articles |
|
18 Oct 2005 |
|
| |
AOP@Work: AOP tools comparison, Part 2
In this second half of his two-part AOP tools comparison, aspect-oriented programming expert Mik Kersten focuses on the tools' integration with the development environment and build process, including a point-by-point comparison of the tools' IDE features. To help you make your final decision, the author concludes with a look at what's to come for these rapidly evolving tools, and provides a summary of each one's strengths and weaknesses. Note that this article addresses the implications of the recently announced merging of the AspectJ and AspectWerkz projects.
|
|
Articles |
|
08 Feb 2005 |
|
| |
AOP@Work: AOP tools comparison, Part 1
AOP is a technology whose time has come, but how do you choose the right tool for your projects? In this first article in the new AOP@Work series, aspect-oriented programming expert Mik Kersten compares the four leading AOP tools (AspectJ, AspectWerkz, JBoss AOP, and Spring AOP) to help you decide which one is for you. In Part 1 of this two-part discussion, the author focuses on the tools' language mechanisms and the trade-offs imposed by the different approaches.
|
|
Articles |
|
08 Feb 2005 |
|
| |
