|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: 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: 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: 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: 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: 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: 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: 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: 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|
concurrency: Asynchronous event handling in Scala
Scala Future and Promise classes give you powerful ways to handle asynchronous processing, including nonblocking ways to organize and sequence events. The async / await constructs, implemented as a macro, make it even easier to write nonblocking event handling in Scala. This tutorial shows you the basic Future and Promise techniques in action, then demonstrates how async / await can convert what looks like simple blocking code to nonblocking execution.
|Articles||02 Sep 2014|
|Java development 2.0: Scalable searching with ElasticSearch
Like the word google, search technology has evolved tremendously over the past 10 years. Learn how one of the newer cloud-friendly search platforms brings simple, scalable search to your Java enterprise applications.
|Articles||27 Nov 2012|
|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|
|JVM concurrency: Java and Scala concurrency basics
The Java platform provides excellent support for concurrent programming in all JVM-based languages. Scala extends the concurrency support in the Java language with even more ways to share work among processors and coordinate the results. This first article in a new series on JVM concurrency covers the state of the art in concurrent programming in Java 7 and introduces some of the Scala enhancements. The article also helps prepare the way for understanding concurrency features in Java 8.
|Articles||25 Mar 2014|
|Java.next: Common ground in Groovy, Scala, and Clojure, Part 3
The last of three installments about commonalities among Clojure, Scala, and Groovy investigates how these languages handle exceptions, expressions, and null -- all problem areas for the Java language. Each of the Java.next languages addresses the shortcomings of the Java language through a unique implementation that highlights that language's characteristics.
|Articles||14 May 2013|
|Java.next: Common ground in Groovy, Scala, and Clojure, Part 1
The Java.next languages (Groovy, Scala, and Clojure) have more commonalities than differences, converging toward common ground in many of their features and conveniences. This installment explores how they each address a longstanding deficiency in the Java language -- the inability to overload operators. It also discusses the related concepts of associativity and precedence.
|Articles||14 May 2013|
|Playful web development, Part
1: Manage user authentication with the Play Framework and Scala
Implement user management for your Play Framework applications and put your Scala skills to work. Pablo Pedemonte takes you through building a basic Play application that handles authentication and authorization. You can even use the application code as a starter for your own Play projects to shorten user-management development time.
|Articles||12 Nov 2015|
|Improving performance and scalability for IBM Sterling Order Management
This article discusses the design best practices that are important for the performance and scalability of the IBM Sterling Order Management solution. Adopting these design best practices during implementation, helps eliminate the common performance bottlenecks that are introduced with custom design or code.
|Articles||07 Aug 2014|
|Java.next: Common ground in Groovy, Scala, and Clojure, Part 2
Common complaints about the Java language concern excessive ceremony for simple tasks and defaults that are sometimes confusing. All three of the Java.next languages take more sensible approaches in those areas. This installment of Java.next shows how Groovy, Scala, and Clojure smooth out the Java language's rough edges.
|Articles||14 May 2013|
|Apache Mahout: Scalable machine learning for everyone
Apache Mahout committer Grant Ingersoll brings you up to speed on the current version of the Mahout machine-learning library and walks through an example of how to deploy and scale some of Mahout's more popular algorithms.
|Articles||08 Nov 2011|
|Java.next: Memoization and functional synergy
Both Scala and Clojure are functional languages, and Groovy includes many functional features through libraries. This Java.next installment explores how memoization is implemented in the Java.next languages and how the combination of functional features leads to concise power.
|Articles||18 Feb 2014|
|Java development 2.0: Cloud-based messaging with Amazon SQS
Amazon Simple Queue Service (SQS) borrows what it needs from message-oriented middleware (MOM) but doesn't lock you in to any one implementation language or framework. Learn how to use Amazon SQS to alleviate the burden of installing and maintaining a message-queuing system, while leveraging the pay-as-you-go scalability of AWS.
|Articles||22 Mar 2011|
|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.next: Currying and partial application
All of the Java.next languages include currying and partial application but implement them in different ways. This installment explains both techniques, distinguishes between them, and shows implementation details -- and practical uses -- in Scala, Groovy, and Clojure.
|Articles||26 Nov 2013|
|Next-generation search and analytics with Apache Lucene and Solr 4
Apache Lucene and Solr are highly capable open source search technologies that make it easy for organizations to enhance data access dramatically. With the 4.x line of Lucene and Solr, it's easier than ever to add scalable search capabilities to your data-driven applications. Lucene and Solr committer Grant Ingersoll walks you through the latest Lucene and Solr features that relate to relevance, distributed search, and faceting. Learn how to leverage these capabilities to build fast, efficient, and scalable next-generation data-driven applications.
|Articles||28 Oct 2013|
|Java development 2.0: Sharding with Hibernate Shards
Sharding isn't for everyone, but it's one way that relational systems can meet the demands of big data. For some shops, sharding means being able to keep a trusted RDBMS in place without sacrificing data scalability or system performance. In this installment of the Java development 2.0 series, find out when sharding works, and when it doesn't, and then get your hands busy sharding a simple application capable of handling terabytes of data.
|Articles||31 Aug 2010|
|Java development 2.0: Climb the Elastic Beanstalk
For those who want more control over their environment but like the plug-and-play scalability of PaaS, Beanstalk could be a good and welcome alternative to Google App Engine. Andrew Glover's guided tour of Beanstalk starts with a location-based mobile application (built using the Play framework and MongoDB), which he then ports to the Beanstalk environment. Configuring Beanstalk is both easy and rewarding, he finds, with choice and flexibility over and above what's offered by GAE.
|Articles||22 Feb 2011|
|Java.next: Overcome synonym suffering
The previous Java.next installment ("Functional coding styles") compared and contrasted functional coding styles in Scala, Groovy, and Clojure. In this article, series author Neal Ford delves more deeply into the filter, map, and reduce functions in the Java.next languages. A series of short coding examples help you to sort out the somewhat confusing differences in how the three languages name these key functional constructs.
|Articles||28 Jan 2014|
|Build server-cluster-aware Java applications
Server clustering has become commonplace for highly scalable Java enterprise application development, but application-level server-cluster awareness is not currently part of Java EE. In this article, Mukul Gupta and Paresh Paladiya show you how to leverage two open source projects, Apache ZooKeeper and LinkedIn's Project Norbert, for server-group coordination in distributed enterprise Java applications.
|Articles||27 Aug 2013|
|Best practices for location-aware services
|Tutorial||06 Jun 2006|
|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|
|Use SQL-like languages for the MapReduce framework
Select the most suitable MapReduce implementation for large scale data analysis jobs based on your skills, preferences, and requirements. MapReduce is a simple and powerful programming model that enables the easy development of scalable parallel applications to process vast amounts of data on large clusters of commodity machines. It isolates the application from the details of running a distributed program. But many programmers are unfamiliar with the MapReduce programming style and prefer to use a SQL-like language to perform their tasks. In this article, read an overview of high-level languages and systems designed to tackle these problems and add declarative interfaces on top of the MapReduce framework.
|Articles||17 Apr 2012|
|Java.next: Extension without inheritance, Part 2
The Java language suffers from intentional limitations in its extension mechanisms, relying primarily on inheritance and interfaces. Groovy, Scala, and Clojure offer many more extension alternatives. This installment further explores Clojure's use of protocols as an extension mechanism.
|Articles||30 Jul 2013|
|Leveraging OpenJPA with WebSphere Application Server V6.1
The Apache OpenJPA project is an open-source implementation of the Java Persistence API, focused on building a robust, high performance, scalable implementation of the JPA specifications. This article introduces OpenJPA with a complete example of how to take advantage of some of these features using IBM WebSphere Application Server V6.1. Updated for JPA 2.0.
|Articles||30 Mar 2011|
|Java.next: Extension without inheritance, Part 3
The Java.next languages
|Articles||03 Sep 2013|
concurrency: Java 8 concurrency basics
Java 8 incorporates new language features and added classes that give you easier ways to construct programs, including concurrent programs. Learn about new, powerful parallel-processing support in the language made possible by Java 8 extensions, including CompletableFuture and streams. You'll recognize similarities between these new features and some of the Scala capabilities that you explored in the first article of this series.
|Articles||08 Apr 2014|
|Configure JMS clustering in IBM SSFS V9.2
IBM Sterling Selling and Fulfillment Suite (SSFS) V9.2 introduces support for JMS clustering. This article explains how to configure JMS clustering to improve the scalability and high availability of SSFS.
|Articles||02 Nov 2012|
|Introduction to VoltDB
Learn about VoltDB, an in-memory database that offers the scalability of NoSQL databases with the ACID-compliance of traditional relational database systems. You'll design and partition database tables, store and retrieve data with stored procedures written in Java code. You'll also explore VoltCache, a key-value store built on top of VoltDB.
|Articles||11 Dec 2012|
|Java.next: Mixins and traits
The Java language's primary paradigm, object orientation with single inheritance, effectively models most but not all programming problems. The Java.next languages extend this paradigm in various ways, including mixins and traits. This Java.next installment defines the mechanisms that mixins and traits share, and it delves into the subtle differences between mixins in Groovy and traits in Scala.
|Articles||19 Sep 2013|
|Java development 2.0: NoSQL
NoSQL datastores like Bigtable and CouchDB are moving from margin to center in the Web 2.0 era because they solve the problem of scalability, and they solve it on a massive scale. Google and Facebook are just two of the big names that have bought in to NoSQL, and we're in early days yet. Schemaless datastores are fundamentally different from traditional relational databases, but leveraging them is easier than you might think, especially if you start with a domain model, rather than a relational one.
|Articles||11 May 2010|
|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|
|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|
|Explore the eXtreme Scale-based caching service options in IBM
Caching services are a popular solution to address performance and scalability issues for cloud enterprise applications. Explore three caching options available with the IBM
|Articles||28 Jun 2014|
concurrency: Building actor applications with Akka
Actor applications require a different style of programming from the linear approach that is used for single-threaded applications. Go deeper into structuring systems in terms of actors and messages from Scala code, using the Akka toolkit and runtime.
|Articles||12 Aug 2015|
concurrency: Acting asynchronously with Akka
The actor model, a long-established approach to concurrent programming, gives you an easy way to build applications for high concurrency and scalability. Learn about the actor model and start working in Scala or Java with the Akka implementation of the model.
|Articles||08 Apr 2015|
|Java.next: Contrasting concurrency
Perhaps the starkest difference among the Java.next languages lies in threading, concurrency, and parallelism. This installment shows easy ways to make existing functional code in Scala, Groovy, and Clojure parallel. Then it investigates the actor currency model in Scala.
|Articles||31 Mar 2014|
|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|
|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.
Also available in: Japanese
|Articles||05 Sep 2001|
|Java.next: Extension without inheritance, Part 1
Groovy, Scala, and Clojure offer many extension mechanisms, whereas inheritance is virtually the Java language's only option. This installment looks at category classes, the ExpandoMetaClass, implicit casts, and protocols as ways to extend Java classes with the Java.next languages.
|Articles||12 Jun 2013|
|Functional thinking: Why functional programming is on the rise
Java developers should learn functional paradigms now, even if they have no immediate plans to move to a functional language such as Scala or Clojure. Over time, all mainstream languages will become more functional; Neal Ford explores the reasons why in this installment.
|Articles||29 Jan 2013|
|Java.next: The Java.next languages
This article launches a new developerWorks series by Neal Ford that performs a deep comparison of three next-generation JVM languages: Groovy, Scala, and Clojure. In this initial installment, find out what you'll gain from understanding their similarities and differences -- whether or not you choose to keep using Java as your main programming language for now.
|Articles||14 May 2013|
|Introducing Spring Roo, Part 7: Develop Spring MongoDB applications using Spring Roo
MongoDB is a very popular document-oriented, horizontally-scalable NoSQL datastore. With Spring Roo version 1.2, you can build Spring applications with MongoDB as data storage solutions. Investigate MongoDB and then build an enterprise Spring MongoDB application using Spring Roo.
|Articles||07 Sep 2012|
|Functional thinking: Rethinking dispatch
Next-generation languages for the Java platform have more-flexible method-dispatch mechanisms than the Java language. In this Functional thinking installment, Neal Ford explores dispatch mechanisms in functional languages like Scala and Clojure, showing new ways to think about executing code.
|Articles||21 Aug 2012|
|Functional thinking: Either trees and pattern matching
Scala's ability to perform dispatch based on pattern matching is a feature much envied by Java developers. This installment shows how a combination of standard data structures and generics provides a pattern-matching-like syntax in pure Java.
|Articles||10 Jul 2012|
|Functional thinking: Functional design patterns, Part 3
The Gang of Four's Interpreter design pattern encourages extending a language by building a new language from it. Most functional languages let you extend the language in a variety of ways, such as operator overloading and pattern matching. Although Java doesn't permit any of these techniques, next-generation JVM languages do, with varying implementation details. In this article, Neal Ford investigates how Groovy, Scala, and Clojure realize the intent of the Interpreter design pattern by allowing functional extensions in ways that Java does not.
|Articles||15 May 2012|
|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|
|Functional thinking: Thinking functionally, Part 3
Functional thinking series author Neal Ford continues his guided tour of functional programming constructs and paradigms. You'll look at number-classification code in Scala and take a glance at unit testing in the functional world. Then you'll learn about partial application and currying -- two functional approaches that facilitate code reuse -- and see how recursion fits into the functional way of thinking.
|Articles||28 Jun 2011|
|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|
|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.
|Tutorial||23 Nov 2004|
|Java development 2.0: Gaelyk for Google App Engine
The introduction of the Google App Engine saw a wave of frameworks emerge to facilitate developing applications targeted for it. The Gaelyk framework, one such framework written in Groovy, eases development of lightweight applications that leverage a datastore. And the scalability you can achieve is impressive.
|Articles||15 Dec 2009|
|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|
|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|
|Node.js for Java developers
|Articles||29 Nov 2011|
|Functional thinking: Laziness, Part 2
Implementing lazy evaluation is easy in a language that supports closures. This Functional thinking installment shows how to derive a lazy list using Groovy's closures as building blocks. Then it explores some of the performance and conceptual benefits of lazy evaluation, including the ability to initialize fields lazily in some languages.
|Articles||19 Dec 2012|
|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|
|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|
|Functional thinking: Laziness, Part 1
A common feature of many functional programming languages is lazy evaluation, whereby expressions are evaluated only when necessary rather than upon declaration. Java doesn't support this style of laziness, but several frameworks and related languages do. This article shows how to build laziness into your Java applications, using pure Java and functional frameworks.
|Articles||20 Nov 2012|
|5 things you didn't know about ... Java Database Connectivity
JDBC, or Java Database Connectivity, is one of the most frequently used packages in the entire JDK, and yet few Java developers use it to its fullest -- or most up-to-date -- capacity. Ted Neward offers an introduction to newer JDBC features like ResultSets that automatically scroll and update on the fly, Rowsets that can work with or without an open database connection, and batch updates that can execute multiple SQL statements in one fast trip around the network.
|Articles||10 Aug 2010|
|Java.next: Functional coding styles
All of the Java.next languages include functional programming constructs, which enable you to think at a higher level of abstraction. However, differences in terminology among the languages can make it difficult to see similar constructs. This installment shows how common functional programming constructs manifest in the Java.next languages, pointing out some subtle differences in the implementation details of those features.
|Articles||24 Dec 2013|
|Resolve common concurrency problems with GPars
Alex Miller shows you how to use the Groovy-based DSLs found in GPars to solve common concurrency problems.
|Articles||07 Sep 2010|
|Functional thinking: Tons of transformations
Functional programming constructs are appearing in all major languages now, but they can be hard to spot because they're identified by a wide variety of common names. This installment of Functional thinking shows the same example written using seven different functional frameworks and languages, investigating similarities and differences.
|Articles||25 Sep 2012|
|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|
|Functional thinking: Thinking functionally, Part 1
Functional programming has generated a recent surge of interest with claims of fewer bugs and greater productivity. But many developers have tried and failed to understand what makes functional languages compelling for some types of jobs. Learning the syntax of a new language is easy, but learning to think in a different way is hard. In the first installment of his Functional thinking column series, Neal Ford introduces some functional programming concepts and discusses how to use them in both Java and Groovy.
|Articles||03 May 2011|
|Notes from developerWorks Technology: Top Java tutorials from 2015
The developerWorks Technologies editor showcases the top tutorials published in 2015 for Java developers.
|Articles||17 Nov 2015|
|Java.next: Choosing your next JVM language
Any of the Java.next languages is a suitable candidate for your next language, so how do you choose? Investigate the factors that contribute to this important decision.
|Articles||13 May 2014|
|Functional thinking: Transformations and optimizations
Various functional languages and frameworks feature many of the same abstractions and behaviors but name them differently. In this Functional thinking article, series author Neal Ford optimizes the solution from the preceding installment by improving the algorithm and adding caching, illustrating how each language or framework accommodates the required changes.
|Articles||16 Oct 2012|
|A Java actor library for parallel execution
Actors aren't supported on the Java platform, but there are still plenty of ways to use them in your Java programs. Barry Feigenbaum returns to developerWorks with μJavaActors, a lightweight actor library for highly parallel execution on the Java platform.
|Articles||30 May 2012|
|Java technology, IBM
style, Part 6: A new era in Java technology
The eagerly awaited final release of Java SE 7 is expected to include enhancements to all the major aspects of the language and the virtual machine. Both Oracle and IBM have released Early Access downloads of their respective implementations for review and feedback. In this article, Chris Bailey, architect of the Java service strategy at the IBM Java Technology Center, introduces some of the changes in store, from both the Oracle specification and the value-add that IBM provides.
|Articles||20 Apr 2010|
|Manage a J2EE app with TSAM extensions
IBM Tivoli Service Automation Manager (TSAM) V7.2.2 introduces the extension: A set of TSAM software components that can implement a new IT service automation solution (known as a service definition) or add capabilities to existing service definitions. In this article, the authors explain how to tune the load balancer policy to your system's needs; how to add and remove application servers as the workload of the business application changes; and how to modify the firewall rules and why you might need to do that.
|Articles||02 Mar 2012|
|Deploy a J2EE app with TSAM extensions
IBM Tivoli Service Automation Manager (TSAM) 7.2.2 introduces the extension, a set of TSAM software components that can implement a new IT service automation solution (known as a service definition) or add capabilities to existing service definitions. In this article, the authors define a scenario in which the desired result is to securely deploy a three-tiered enterprise application (in this case J2EE) to the cloud. They demonstrate how to set up and provision extensions in TSAM as the first step to accomplishing this task.
|Articles||26 Jan 2012|
|Functional thinking: Immutability
Immutability is one of the building blocks of functional programming. This Functional thinking installment discusses the many aspects of immutability in the Java language and shows how to create immutable Java classes in both traditional and newer styles. It also shows two ways to create immutable classes in Groovy, removing much of the pain of the Java implementation. Finally, you'll learn when this abstraction is appropriate.
|Articles||26 Jul 2011|