Significant Software Development Developments of 2013

At the end of each calendar year, I like to summarize some of the most significant developments in the software development industry that happened during the year that is ending. The choice of these is entirely subjective and obviously colored by my own experience, background, perceptions, and preferences. Not worrying about the opinionated content of such a post, I now present the developments in software development that I consider most significant in 2013.

10. Gradle

Gradle appeared to me to enter the mainstream consciousness of software developers in a big way in 2013. I have been watching Gradle's development and playing with it a bit for some time now, but I have noticed that numerous open source projects now mention it prominently, it's referenced in many recently published Java books that aren't even about Gradle specifically, and Google selected Gradle to be delivered with its Android Studio product announced at Google I/O 2013. It took a while for Maven to breakthrough and compete with Ant and I think 2013 is seeing the beginning of Gradle's breakthrough to challenge Maven and Ant for predominance in Java-based build systems. Three books devoted to Gradle (the short Gradle: Beyond the Basics, the more comprehensive Gradle in Action, and the German Gradle: Modernes Build-Management - Grundlagen und Praxiseinsatz) have listed 2013 publication dates.

Gradle's rapidly rising popularity is nearly matched by its torrid rate of new releases. Gradle 1.4 ("faster builds that use less heap space"), Gradle 1.5 ("optimizations to dependency resolution"), Gradle 1.6 (improved Task ordering, "JaCoCo plugin for test coverage," and support for JUnit test categories), Gradle 1.7 ("fastest Gradle ever"), Gradle 1.8 (performance improvements and more native languages support), Gradle 1.9 (bug fixes and HTML dependency report), and Gradle 1.10 ("command-line usability features") were all released in 2013.

Gradle's success does not surprise me. It's Groovy foundation alone offers numerous advantages: Groovy scripts are easier to write procedural build-style code than is XML, Groovy has numerous syntactic shortcuts, Groovy is easily learned and applied by Java developers, Groovy has full JVM access, and Groovy includes built-in Ant support. On top of its inherent advantages from being built on Groovy, Gradle builds many useful and attractive features of its own on top of that Groovy foundation. Gradle adheres to several Ant and Maven conventions and supports Ivy and Maven repositories, making it straightforward to move from Maven or Ant+Ivy to Gradle.

Ruby on Rails helped bring Ruby into mainstream international prominence and, to a lesser degree, Grails helped do the same thing for Groovy. Gradle has the potential to pick up where Grails left off and push Groovy even further into the spotlight.

9. Trend Toward Single Language Development

For several years now, there has been a definite trend toward polyglot programming (polyglot persistence was even on last year's version of this post). Although this trend is likely to continue because some languages are better for scripting than others, some languages are better suited for web development than others, some languages are better suited for desktop development than others, some languages are better suited for realtime and embedded device development than others, some languages are better suited for scientific computing than others, and so on. However, I have seen indications of the pendulum swinging back at least a bit recently.

One of the arguments in favor of Node.js is the ability for JavaScript developers to use the same language on the "front-end" of a web application as on the "back-end." In the post Top Things I learned about development in 2013, Antonin Januska writes, "Working back to front in the same language is awesome." This is, of course, the reason that Java developers have in some cases been resistant to using JavaScript, Flex, or JavaFX Script (now deprecated) for front-ends of their Java applications (and why tools like Google Web Toolkit have been so popular). Java developers who write desktop applications (yes Virginia, desktop applications do exist) often experience the advantages of using the same language front-to-back as well.

One of Ceylon's most promising possibilities is the ability to write code in Ceylon that works on both Java Virtual Machines and JavaScript virtual machines and so could be used front-to-back in a Ceylon-based application. Indeed, the Ceylon page advertises, "[Ceylon] runs on both Java and JavaScript virtual machines, bridging the gap between client and server." Languages commonly associated with the Java Virtual Machine such as Scala and Kotlin also are offering the ability to compile to JavaScript.

A final example of the trend back to a single language in many environments is the use of Python in scientific computing as covered in the post The homogenization of scientific computing, or why Python is steadily eating other languages’ lunch.

I'm not arguing that this trend means that there will only be one main programming language in the future. However, I do believe it is generally human nature to want to use the same language or approach as much as possible because it's what we're familiar with and using the same language helps us to leverage our experience more broadly in the same application. The trend seems to be for each of the major languages (C/C++, Java, JavaScript, Python, .NET languages, etc.) to continue building up their own "stack" to support end-to-end functionality within that language and its ecosystem of frameworks, libraries, and tools. It's no coincidence that once a new language starts to see significant adoption, it quickly begins to see development of a variety of frameworks, libraries, and toolkits that extend the reach of that language.

I also don't want to imply that this is the end of polyglot programming. I don't see any programming language that is the best fit in all cases and there is no doubt that the most valuable developers will be those familiar with more than one programming language.

8. Internet of Things

I first heard about the concept of the Internet of Things at JavaOne 2012 and it got even more attention at JavaOne 2013. Oracle is not the only company touting the Internet of Things. IBM is into the Internet of Things as are many others.

Some believe that 2014 will be the year of the Internet of Things. Tori Wieldt has called "Java and the Internet of Things" one of the "Top Java Stories of 2013." In 2013, two series in Hinkmond Wong's Weblog have focused on the Internet of Things with featured posts on a Thanksgiving Turkey Tweeter and on a Christmas Santa Detector.

Other useful articles with differing opinions on the Internet of Things include The Internet of Things: a tangled web, Here's the Scariest Part of the Internet of Things, The Internet Of Things Will Be Huge—Just Not As Huge As The Hype, Five Challenges For The Internet of Things Ecosystem, The Internet of things will not arrive in 2014, CES 2013: The Break-Out Year For The Internet Of Things, and Here's Why 'The Internet Of Things' Will Be Huge, And Drive Tremendous Value For People And Businesses.

On a lighter (or more dire, depending on your perspective) note related to The Internet of Things, Aaron Pressman writes, "The whole crazy 'Internet of Things' movement to put everything under network control seems tailor made for Hal" (2001: A Space Odyssey).

7. Mobile Development

If someone not familiar with our industry was to start reading our software development social media sites and forums, that person would likely come to the conclusion that the vast majority of software development today is development of mobile applications. I have long argued that blog posts and articles often skew toward more leading-edge topics than established topics for a variety of reasons (perception/reality that established topics are already well-covered, resume building, fun to play with and write about new things, etc.). That being stated, there is no question that mobile development is popular in reality and not just in perception. There is no question that a big part of HTML5's popularity and rapid adoption is the opportunity to write applications in one set of languages (HTML/JavaScript/CSS) that will run on multiple mobile devices. Numerous projects and tools are being released to allow for writing applications in one language and compiling them to native formats for various mobile devices.

6. Responsive Design

At the end of 2012, Pete Cashmore predicted that 2013 would be the "Year of Responsive Web Design" because of its "obvious benefits": "You build a website once, and it works seamlessly across thousands of different screens." I like Jordan Larkin's explanation of responsive web design:

The term "responsive web design" (or responsive mobile design) refers to websites that change and adapt their appearance for optimum viewing on all screen sizes, tablets, smartphones, ipods, kindles along with desktop and laptop computer screens. Occasionally, in the digital arts industry, it is called "fluid design", "adaptive website design" or "RWD". Unresponsive websites do not change to fit different screen sizes, which means they can be difficult to navigate and look at on smaller devices.

As a person who is using a smartphone for an increasing percentage of my daily online activities, but still uses the laptop frequently and the desktop occasionally, I am appreciating firsthand the web site authors whose web sites and pages work well on all of these devices. It's often satisfactory to have two different web sites (one for mobile devices and one for everything else) from a consumer point of view, but this obviously means essentially duplicate code for the site developers. Even from a consumer point of view, there are times when I find the mobile version of a site lacking in features and in those cases it'd be preferable to have the regular site on all devices as long as that regular site appeared nicely on all devices.

The highly informative web site A List Apart has a nice set of articles related to responsive web design.

5. Node.js

JavaScript, despite its flaws, has dominated the web browser for years. Although JavaScript on the server has been available for some time (such as with Rhino and more recently Nashorn in Java), Node.js seems to be doing for JavaScript on the server what Ruby on Rails did for Ruby: the framework is popularizing the language (or in this case, popularizing the language specifically on the server).

2013 has been a big year for Node.js. There are numerous blogs and articles written on it on seemingly a daily basis. Some of these articles include What You Need To Know About Node.js and Node.js keeps stealing Rails' thunder.

Several books on Node.js have been published in 2013. These include Node.js in Action, Learning Node.js: A Hands-On Guide to Building Web Applications in JavaScript, Node.js the Right Way: Practical, Server-Side JavaScript That Scales, Pro Node.js for Developers, Node.js Recipes: A Problem-Solution Approach, Mastering Node.js, Using Node.js for UI Testing, JavaScript on the Server Using Node.js and Express, and the final version of The Node Beginner Book.

4. Big Data

Big Data holds the same #4 spot on my list as it did last year. Apache Hadoop and the R Project are just two examples of popular products/languages riding the Big Data wave. Python too, is increasingly being chosen as the programming language of choice for working with big data sets.

Readers of java.net recently answered a survey regarding Big Data in which the closest thing to a consensus seemed to be that "Big Data Is Probably Significant, but not too Surprising."

3. HTML5

HTML5 saw initial hype, disappointed for a while, and seems to be back on its rapid rise in popularity. I don't call out JavaScript individually in this post, but group it with HTML and CSS as part of HTML5 (and its also grouped with Node.js in this post). Given that HTML5, for purposes of this blog post, represents all of these things, it easily makes my top three significant software development developments in 2013. As mentioned previously with regard to mobile development, HTML5 is a popular approach for generating applications once that can theoretically run on any mobile device.

HTML5 features are seeing increasing standardization in terms of implementations in major browser. JavaScript/HTML libraries such as Angular.js and Ember.js are building on the momentum that jQuery has brought to HTML5 development in recent years.

HTML5's success is even evident in languages not considered part of HTML5 themselves. For example, one of the most heavily advertised new features of Java EE 7 is its HTML5 support. Recent versions of NetBeans IDE (considered primarily a Java IDE despite its multiple language support) have also seemed to emphasize HTML5 among their most important new features in 2013.

2. Security

As more information is online and we depend increasingly on availability of our data online, security continues to be an important issue for software developers. The trend of highly visibility security incidents continued in 2013. These incidents affected Ruby on Rails, Java, and other languages. The increasing frequency of security patches led Oracle to change how it labels the versions of Java SE.

An early 2013 article, Safeguard your code: 17 security tips for developers, outlines tips developers can take to improve the security of their applications. An earlier article in 2013 spelled out the increasing security concerns companies face. The book Java Coding Guidelines: 75 Recommendations for Reliable and Secure Programs has also been published in 2013. The 10 Biggest Security Stories Of 2013 outlines some of the biggest security-related stories of 2013.

1. Technical Dysfunction

Sadly, from a software development perspective, 2013 may be most remembered for the high profile technical glitches that occurred. Words like "debacle," "disaster," and "meltdown" have been associated with these issues and, rightly or wrongly, have reflected poorly on our industry. The most high profile dysfunction has been the embarrassing United States healthcare site healthcare.org. However, the issues that affect reputations and customer confidence have not been limited to government. Wal-Mart and Target, two major retailers in the United States, have had notable web site issues in the latter part of 2013 as well. Cloud-impacting technical dysfunction has occurred in 2013 in several notable cases including Amazon Web Services (AWS) and Google (including the search engine).

There seems to be plenty of blame to go around, but it seems difficult to get a good read on exactly what has caused these high profile technical failures. With healthcare.org, for example, I've seen people blame all types of different culprits including not allotting enough time to the effort, not being agile enough, being too agile, failing for despite agile approaches, failing to estimate user load correctly, getting government involved, etc. Although the real reasons are probably multiple and varied in nature and probably interest software developers more than others, the perception of our industry has gotten dinged up in 2013.

Honorable Mention

Although the developments in software development listed below did not make my top ten, they are significant enough to me to make this "Honorable Mention" category (in no particular or implied order).

JSON

One of the benefits of XML many years now has been the ubiquity of XML support across different languages, tools, frameworks, and libraries. For example, I recently wrote about how easy it is to use Groovy to search Subversion logs because Subversion makes its log output available in XML format and Groovy knows XML well.

JSON has been very popular with developers for some time now, but there have been many cases where standard libraries and tools that supported XML did not support JSON, meaning that developers had to write custom writing/reading code for JSON when using those libraries and tools. I'm beginning to see a lot more JSON support with tools and libraries now. Programming languages are also providing nice JSON parsing/writing capabilities. For example, Groovy has had JSON support for some time and Java EE 7 (JAX-RS 2.0) includes JSON support via the Java API for JSON.

JSON has been prominent enough in 2013 to warrant being included in titles of two Packt Publishing books published in 2013: JavaScript and JSON Essentials and Developing RESTful Services with JAX-RS 2.0, WebSockets, and JSON.

Java EE 7 Released

Java EE 7 was officially released in 2013. In a testament to Java EE's current widespread use and expected potential use of Java EE 7, book publishers have already published several books on Java EE 7 including Java EE 7 First Look, Java EE 7 Essentials, Beginning Java EE 7, Java EE 7 Recipes: A Problem-Solution Approach, Introducing Java EE 7: A Look at What's New, and Java EE 7 Developer Handbook.

Although I've never embraced JavaServer Faces (JSF), the feature of Java EE 7 that has been most interesting to me is the support for Faces Flows. I first read about this feature when reviewing Java EE 7 First Look and Neil Griffin's post Three Cheers for JSF 2.2 Faces Flows have reinforced my interest in this feature. In the post A Realistic JSF 2.2 Faces Flows Example, Reza Rahman supports my opinion that this is a key feature in Java EE 7 to watch with the quote, "Faces Flows are one of the best hidden gems in Java EE 7." Michael and Faces Flows might persuade me to give JavaServer Faces another look.

A recent blog post shows integration of AngularJS with Java EE 7.

Single Page Applications

The advantage of web applications over desktop applications has always been significant easier deployment of web applications than of desktop applications. The cost, however, has been a less fluid experience and sometimes less performing application than could be provided on the desktop. The concept of single-page applications is to make web (and by extension mobile applications that use traditional web technologies) feel and behave more like a "single-page" desktop application. Newer JavaScript libraries such as Meteor are being designed for the "thicker client" style of single-page applications.

The Wikipedia page on Single Page Application lists some technical approaches to implementing this concept. The Manning book Single Page Web Applications was also released in 2013. It's subtitle is "JavaScript end-to-end" (another piece of evidence of the general movement toward a single language).

See the description of Meteor below for another nice explanation of how web development is moving toward what is essentially this concept of single-page applications.

AngularJS

It seems like one cannot read any software development social media sites without running across mention of AngularJS. Although its Google roots are undoubtedly part of its success, AngularJS enjoys success from cleanly addressing significant needs in HTML/JavaScript development (shifting appropriate dynamic functionality from pure JavaScript to HTML with clever binding). In his post 10 Reasons Why You Should Use AngularJS, Dmitri Lau states that "Angular is the only framework that doesn’t make MVC seem like putting lipstick on a pig." Jesus Rodriguez, in his post Why Does Angular.js Rock?, writes that AngularJS "excels in the creation of single-page-applications or even for adding some 'magic' to our classic web applications." K. Scott Allen writes in his post Why Use AngularJS?, "I like Angular because I have fun writing code on top of the framework, and the framework doesn't get in the way."

Ember.js

Ember.js is another JavaScript library seeing significant online coverage in 2013. Ember 1.0 was released on 31 August 2013 and Ember 1.2.0 was released on 4 December 2013.

Like AngularJS and Knockout, Ember.js's approach is to embrace HTML and CSS rather than trying to abstract them away.

Famo.us

The famo.us web page currently requires one to "sign up for the beta" before being able to "experience famo.us." It's subtitle is "a JavaScript engine and framework that solve HTML5 performance." Another famo.us page states, "famo.us is a front end framework that solves performance for HTML5 apps" and "works for phones, tablets, computers and television."

Famo.us is discussed in two late 2013 InfoWorld posts: Did these guys just reinvent the Web? and Fast and flashy: Famo.us JavaScript framework revealed.

At this point, famo.us is still in beta, but it could be big in 2014 if it is able to deliver on what is advertised in 2013.

Meteor

Meteor is described on its main page as "an open source platform" for writing "an entire app in pure JavaScript" and using the "same APIs ... on the client and the server." In the Paul Krill interview Meteor aims to make JavaScript programming fun again, Matt DeBergalis stated that Meteor was created to address the changing web development paradigm often referred to as single-page application:

There is a shift in the Web application platform, and specifically, people are starting to write a new kind of application, what we call a thick client, where most of the code is actually running inside the Web browser itself rather than in a data center. This is an architectural change from running the software in the data center and sending HTML on the wire to a model where we have data on the wire and the actual rendering, the displaying of the user interface, is happening on the client. ... That's why it feels more interactive. It's not page-based like the old Web. It's much more engaging."

MEAN Stack

Having a witty acronym helped advertise and communicate the LAMP stack (Linux, Apache HTTP Server, MySQL/MariaDB, PHP/Perl/Python) and arguably contributed to the adoption of this combination of technologies. With this in mind, I found Valeri Karpov's post The MEAN Stack: MongoDB, ExpressJS, AngularJS and Node.js interesting. The post's author is another who points out the productivity advantages that can be gained from using a single language throughout an application. There is already a book underway: Getting MEAN with Mongo, Express, Angular, and Node. It will be interesting to watch this newly minted terminology and see if the stack and its name come close to the success that the LAMP stack and its name have enjoyed.

Commercial Support Dropped for GlassFish 4

Although it took longer to happen than most people probably anticipated, Oracle's dropping of commercial support for GlassFish 4 was formally announced in 2013 and is what most of us expected when we heard of Oracle purchasing Sun. The future of GlassFish is certainly cloudier now and expectations for GlassFish's future range from it being essentially dead to it thriving as the reference implementation.

Java IDEs

The major Java IDEs continued to add features to their already impressive feature sets in 2013. NetBeans had two major releases in 2013 with 7.3 released in February and 7.4 released in October. These two NetBeans releases added features such as Java EE 7 support, Project Easel for HTML5 development, Groovy 2.0 integration, JSON support, support for new JavaScript libraries (including Angular.js), native Java application packaging, Cordova integration, and improved support for non-JVM languages C/C++ and PHP.

IntelliJ IDEA 13 was released earlier this month. The release announcement highlights support for Java EE 7, improved Spring Framework integration, improved Android support thanks to IntelliJ IDEA Community Edition being used as the basis for Android Studio, improved database handling, and "refined Gradle support." Eclipse is often the IDE chosen for building a more specialized IDE such as Spring IDE (Spring Tool Suite), Scala IDE, or the new Ceylon IDE, so it's a particularly big deal that Google chose IntelliJ IDEA as the basis of its Android Studio.

Speaking of Eclipse, the seemingly most used Java-based IDE (especially when you consider the IDEs derived from it or based on it) also saw new releases in 2013. Eclipse 4.3 (Kepler) was released in 2013. There were also numerous popular plugins for Eclipse released in 2013.

Visual Studio 2013

Sun Microsystems was not the only company that saw desirable advantages and benefits from a single language that could be used at all layers of an application. Microsoft has implemented various efforts (Silverlight) for years to do the same thing. In 2013, Visual Studio 2013 was released with significant enhancements. These enhancements included improved support for languages not specific to Microsoft's .NET framework. Many of these better supported languages are on my list in this post: JavaScript, HTML, CSS, and Python.

Groovy

Groovy's 2.0 release (including static compilation support) made 2012 a big year for Groovy. Although 2013 did not see as significant of enhancements in the Groovy language, the year did start out with the announcement of Groovy 2.1. Perhaps the biggest part of that 2.1 release was Groovy's full incorporation of Java SE 7's invokedynamic, a major Java SE enhancement intended for non-Java languages like Groovy.

Groovy 2.2's release was announced toward the end of 2013. This release improved Groovy's invokedynamic support by adding OSGi manifests to the Groovy's invokedynamic-based JARs.

In The Groovy Conundrum, Andrew Binstock writes that "with the performance issues behind it, Groovy is a language primed for widespread use," but warns that Groovy is a language that is "easy to learn, but hard to master."

As is mentioned more than once in this post, Groovy has had a lot of additional exposure in 2013 thanks to Gradle's rapidly rising popularity. I believe that Gradle will continue to introduce Groovy to developers not familiar with Groovy or will motivate developers who have not looked at Groovy for some time to look at it again.

Scala

It seems to me that Scala continues to gain popularity among Java developers. I continue to see Scala enthusiasts gushing about Scala on various Java and JVM blog comments and forums. One piece of evidence of Scala's continuing and increasing popularity is the number of new books published in 2013 with Scala in their title. These include Scala in Action, Scala Cookbook: Recipes for Object-Oriented and Functional Programming, Functional Programming Patterns in Scala and Clojure: Write Lean Programs for the JVM, Scala Design Patterns: Patterns for Practical Reuse and Design, Play for Scala, Scala Object-Oriented Programming, and Getting Started with SBT for Scala.

For a much better background on what made 2013 a big year for Scala, see Jan Machacek's This Year in Scala (2013).

Ceylon

November 2013 saw "the first production release of the Ceylon language specification, compiler, and IDE." This announcement, available online at Ceylon 1.0.0 is now available, also states, "Ceylon 1.0 is a modern, modular, statically typed programming language for the Java and JavaScript virtual machines." Ceylon offers an Elipse-based IDE and has a formal specification. One of the factors favoring a successful future for Ceylon is its Red Hat sponsorship.

Kotlin

Kotlin is another language that compiles to the Java Virtual Machine or to a JavaScript virtual machine. It also has a strong sponsor in the world of Java in JetBrains, the company behind IntelliJ IDEA. 2013 saw several new releases of Kotlin: Kotlin M5.1, Kotlin M6, Kotlin M6.1, and Kotlin M6.2. I found the blog post Programming Android with Kotlin interesting because it demonstrates use of Kotlin and Gradle to build an Android application.

Go

The Go programming language has had strong backing from Google and continues to receive significant online coverage. Go 1.1 and Go 1.2 (with apparently improved performance) were both released in 2013. Of special interest to me is Go's advertised source code backwards compatibility for all versions 1.x.

Camel

2013 was a big year for Apache Camel, the tool that "empowers you to define routing and mediation rules in a variety of domain-specific languages." Camel-related developments in 2013 included the release of 2.11.0, release of 2.12.0, and release of 2.12.2. These frequent releases and the addition of a new committer and PMC member are among the signs of a healthy open source project.

The release of the Camel Essential Components (DZone Refcardz #170) kicked off 2013 for Camel. Camel got increased attention on software development social media sites in 2013. Zemian Deng's Getting started with Apache Camel using Java was syndicated on Java Code Geeks (as was his Apache Camel using Groovy Introduction) and Niraj Singh's Introduction to Apache Camel was also syndicated on Java Code Geeks. AndrejV's entire blog Just Did Some Code has so far (5 posts in 2013) been devoted to coverage of Camel!

Spring Boot

It's still early to tell because Spring Boot is currently only at version 0.5, but Spring Boot has potential to be be widely adopted and used in the future. It looks like Spring Boot is inspired by and takes advantage of some of the best ideas in Ruby on Rails and Groovy and applies them to easy generation of Spring Framework-based applications.

Python

As stated earlier, Big Data is big and Python is getting a share of that Big Data action. The Continuum Analytics post Python for Big Data states, "Python is a powerful, flexible, open-source language that is easy to learn, easy to use, and has powerful libraries for data manipulation and analysis. ... Python has a unique combination of being both a capable general-purpose programming language as well as being easy to use for analytical and quantitative computing." Tal Yarkoni echoes this statement and observes that his "scientific computing toolbox been steadily homogenizing" on Python.

Python 3.3.1, Python 3.3.2, and Python 3.3.3 were all released in 2013. Cython has joined Pyrex as an alternative for easily writing C extensions with Python syntax and there is even a book on Learning Cython Programming.

The article Python 3.4.0 goes to beta with slew of new modules talks about some of the new features coming with Python 3.4.0 (beta) such as a standard enumeration construct. The article also points out that one of the biggest frustrations with Python remains: the two versions of the language (2.x and 3.x) and no easy route from 2.x to 3.x. From a Java development perspective, I find this interesting because there was a time when arguments like Bruce Eckel's ("People who don't want to deal with these changes don't upgrade, and those people tend not to upgrade anyway") seemed logical and sensible. However, it's not quite as easy as it sounds, particularly when one starts to realize the impact of this on the entire set of products, libraries, and frameworks written for a language that can be heavily impacted and perhaps not usable for some time if ever with the new language.

PHP and HHVM

2013 saw the formal release of the PHP 5.5.x versions: PHP 5.5.0, PHP 5.5.1, PHP 5.5.2, PHP 5.5.3, PHP 5.5.4, PHP 5.5.5, PHP 5.5.6, and PHP 5.5.7.

At the beginning of 2013, Gabriel Manricks outlined reasons Why 2013 is the Year of PHP. Specifically Manricks described tools such as Laravel (including Eloquent ORM), Composer (dependency manager, including Packagist), and PHPUnit (test-driven development in PHP).

The Facebook project HHVM (HipHop Virtual Machine for PHP) was initially released in 2010, but seemed to see a lot more attention in 2013. The original HPHPc compiler compiled PHP into C++ and was another manifestation of the drive to use a single language for authoring an application even if its compiled form was different. The availability of the open source HipHop Virtual Machine (HHVM) for PHP should help address performance issues with PHP; that is seemingly Facebook's primary reason for developing it.

Android Studio

Android Studio was announced at Google I/O 2013 as "a new IDE that’s built with the needs of Android developers in mind" that is "based on the powerful, extensible IntelliJ IDEA Community Edition."

Cloud Computing

Interest in cloud computing remained strong and continued to grow rapidly in 2013. Many of the other items discussed in this post (Big Data, security, technical dysfunctions, etc.) have strong relationships to cloud computing. For more on the biggest cloud stories on 2013, see The 10 Biggest Cloud Stories Of 2013.

Internet Explorer 11

I have not used Internet Explorer except when forced to for a number of years. For a long time, I used Firefox almost exclusively and in recent years I've used Google Chrome almost exclusively on PCs and Firefox on Linux. When I have been forced by a particular web site to use Internet Explorer, I have done reluctantly and am reminded of the much slower performance of the browser than I'm used to in terms of startup and even navigation. I have noticed over this Christmas break, however, when I had to install Internet Explorer 11 manually because the automatic process kept failing, that it's a lot faster than even Internet Explorer 10 was. I still won't make it my primary browser, but it's nice that it performs much better when I do need to use it (such as to play Atari Arcade games without advertisements).

Internet Explorer 11 offers advantages for developers as well as users of the browser. Advertised benefits for developers (and by extension for users of these developers' applications) are improved standards compatibility, new F12 developer tools,

It's not all positive for Internet Explorer 11. Some people seem to want to downgrade to Explorer 10 and reportedly Internet Explorer 11 is presenting some problems for users of Microsoft's own CRM application (after earlier reportedly breaking Google and Outlook access).

It surprises me a bit that the main Microsoft IE URL (http://windows.microsoft.com/en-us/internet-explorer/download-ie) referenced by the Internet Explorer 11 Guide for Developers still advertises downloading of Internet Explorer 9, a version of that browser that Google has already stated they will no longer support.

Windows 8 Not As Successful

Windows 8 seems to be experiencing similar disappointment after Windows 7 that Windows Vista experienced after Windows XP. In fact, The 10 Biggest Software Stories Of 2013 states, "So it looks like Windows 7 will become the new Windows XP -- better get those downgrade rights ready."

Raspberry Pi

The Raspberry Pi continues to catch a lot of interest (2 million had been sold as of October of this year). There were seemingly endless posts on how to do a wide variety of things with the Raspberry Pi. Some of these that stood out most to me are Premium Mathematica software free on budget Raspberry Pi, GertDuino: An Arduino for Your Raspberry Pi, How an open-source computer kit for kids based on Raspberry Pi is taking over Kickstarter, Running OpenJFX on Raspberry Pi, and Simon Ritter: Do You Like Coffee with Your dessert? Java and the Raspberry Pi.

DevOps

The 10 Biggest Software Stories Of 2013 points out that "Cisco, Google and VMware last year invested in Puppet Labs" and that "another DevOps player, Opscode, raised $32 million and changed its name to Chef, the name of its flagship product."

Twitter Bootstrap

Bootstrap (alternatively known as Twitter Bootstrap and Twitter Blueprint) has become so popular and prevalent that there is now a popular (one of DZone's top posts in 2013)

post stating Please stop using Twitter Bootstrap. In August 2013, two years after the public release of Bootstrap, Bootstrap 3 was released (with 3.0.3 released in December). Everybody Should Code

The conversation of whether everybody should or code write code and develop software continued in 2013. Jessica Gross's writes about 10 places where anyone can learn to code and Megan O'Neil's article A Start-Up Aims to Teach Anyone to Write Computer Code features one of these places (Codecademy). Kevin Lindquist writes that software development isn’t just for coders anymore. Katie Elizabeth lists the reasons why everyone should learn to code while Chase Felker wonders if maybe not everybody should learn to code.

In 2013, President Obama (United States) asked America to learn computer science and it may be one of the few things Republicans and Democrats agree on, but Philip Bump argues, No, Mr. President, Not Everyone Needs to Learn How to Code.

SQL Strikes Back

NoSQL implementations have been all the rage for years, but 2013 seemed to present some resurgence in interest in SQL. Some NoSQL implementations added SQL or SQL-like syntax. SQLstream announces Return of the King: The Structured Query Language Is Back! and Jason Levitt and Sean Gallagher write "The hot new technology in Big Data is decades old: SQL."

The truth is that SQL never really went away and is heavily entrenched in software systems, but what is really interesting 2013 is the new thought and effort put into SQL development. word of Google's F1 SQL database ("a hybrid database that combines high availability, the scalability of NoSQL systems like Bigtable, and the consistency and usability of traditional SQL databases") is an example of this. Seth Proctor asks Do All Roads Lead Back to SQL? and writes of "NewSQL." In Software Development Trends for 2014, Werner Schuster states that "Many NoSQL DBs come with SQL or SQL-like languages" and asks, "Are SQL skills back in fashion?"

Conclusion

2013 may be remembered in popular culture as the year of selfies, but the developments in the software development world were far more substantive. In particular, it is interesting to see how developers in general are beginning to (or are remembering to) appreciate the ability to write an application front-to-back in a single language and to write responsive designs so that an application need be written only once for multiple platforms. The advantages of these approaches are not new to JVM (Java/Java EE) or CLR (.NET) developers, but seem to now be better appreciated by the more general developer community.

Previous Years' Significant Software Development Developments

The following are my posts similar to this one on items that I thought were of special import to software development in those respective years. I could definitely go back and add to some of these with things I've learned about since then for each of these years.

• 2012
• 2011
• 2010
• 2009
• 2008
• 2007

Simple Gradle Java Plugin Customization

As I demonstrated in the post A First Look at Building Java with Gradle, Gradle is particularly concise and easy to apply to the basics of building a Java application when one uses the Java plugin and places files and directories where this plugin expects them (convention-based project layout). However, it is not always possible to have a structure (especially in legacy systems) meeting Gradle's expected conventions. In this post, I look at overriding some of the Gradle Java Plugin's conventions to allow a simple Gradle build to work with different directory structures.

The code listing that follows contains the Gradle code for a build build.gradle. I included comments in the build code to help explain what each type of customization is doing.

build.gradle

// build.gradle
//
// This simple example of a Gradle build file exists primarily to demonstrate
// approaches to overriding Gradle's default conventions related to use of the
// Java plugin.

// The 'java' plugin must be applied before attempting to access the sourceSets
// and other properties defined by the Java plugin to avoid an error message
// similar to the following: "Could not find method sourceSets() for arguments..."
apply plugin: 'java'

// Redefine where Gradle should expect Java source files (*.java)
sourceSets {
    main {
        java {
            srcDirs 'java'
        }
        resources {
            srcDir 'resources'
        }
    }
}

// Redefine where .class files are written
sourceSets.main.output.classesDir = file("dist/classes")

// Redefine where 'jar' task should place generated JAR file.
jar {
   destinationDir = file('dist/jar')
}

// Fully qualified directory/JAR for Guava Release 16 JAR file:
//    C:\\guava16\\guava-16.0-rc1.jar
repositories { 
  flatDir{
    dirs 'C:\\guava16'
  } 
}

dependencies {
   compile 'guava:guava:16.0-rc1'
}

defaultTasks 'clean', 'jar'

The Gradle build file shown above first applies the Java plugin. It then overrides the Gradle conventional locations for Java source files (highest level directory where subdirectories represent packages and files have .jar extensions), changing this directory from the default of src/main/java to simply java. Similarly, the default src/main/resources location for production resources is changed to simply resources.

The build file shown above then changes where the *.class files (with appropriate subdirectories representing their package structure) are placed by specifying that sourceSets.main.output.classesDir is now dist/classes (build/classes/main is conventional default). Similarly, the jar task's destinationDir is overridden to point to dist/jar (build/libs is convention) and this is where the JAR file generated by the jar task is written.

The final customization shown in the simple Gradle build script shown above is the specification of "repositories" and "dependencies" to make Guava Release 16 JAR available to my application (which happens to depend on Guava Release 16). Gradle provides sophisticated support for use of Maven or Ivy repositories including special syntax for Maven Central, but this particular example gets the Guava Release 16 JAR from my local file system (C:\guava16). The dependency itself is expressed with "guava:guava:16.0-rc1" because the JAR in that specified repository directory is called "guava-16.0-rc1.jar."

To make my testing of these customizations easier, I explicitly specified defaultTasks as clean and jar so that all I needed to do was type gradle on the command line as long as I was in the same directory as the build.gradle file shown above and as long as there was a "java" subdirectory at that level with the .java source files in their appropriate package-based directories.

Gradle's builds are most concise and easiest to write and read when Gradle's conventions are followed. However, it is not terribly difficult to override these conventions and specify customized configuration to match legacy systems.

NetBeans 7.4 JSON Support

NetBeans 7.4 provides enhanced JSON support. The code folding and Navigator window support are demonstrated in a code listing for a simple Person.json file and how that code appears in the screen snapshots below.

Peson.json

{
   "person":
   {
      "firstName" : "Fred",
      "lastName" : "Flintstone",
      "city" : "Bedrock"
   }
}

The utility of being able to see the JSON in a tree-like manner in the Navigator and to code fold portions of the JSON is more obvious with more complex JSON. The next code listing and associated screen snapshots of that code in NetBeans 7.4 is based on JSON Example.

Glossary.json

{
    "glossary": {
        "title": "example glossary",
  "GlossDiv": {
            "title": "S",
   "GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
     "SortAs": "SGML",
     "GlossTerm": "Standard Generalized Markup Language",
     "Acronym": "SGML",
     "Abbrev": "ISO 8879:1986",
     "GlossDef": {
                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
      "GlossSeeAlso": ["GML", "XML"]
                    },
     "GlossSee": "markup"
                }
            }
        }
    }
}

Even though proper indenting can go along way toward making JSON more readable, the visual cues provided by the Navigator Window in NetBeans 7.4 make it even easier to see the relationships of nested data in a JSON file. The code folding also allows one to minimize desired levels of nested name/value pairs to be able to focus on whatever portion is needed at a given time. JSON is increasingly popular because of advantages inherent in this simple name/value format, but NetBeans 7.4 provides tooling that makes JSON even easier to use.

Book Review: Gradle: Beyond the Basics

Gradle: Beyond the Basics is the "sequel" to Building and Testing with Gradle. According to the Gradle Books page, a third book in this series will be a "set of recipes that uses as the demonstrative tool for enterprise build automation." I have not read the first book, but did read the short Gradle: Beyond the Basics and review that here.

Gradle: Beyond the Basics, as its name implies, assumes that the reader is already aware of "Gradle basics." The book provides no introduction to Gradle and assumes at least minimal knowledge of some related languages and tools as well (Groovy, Ant, Maven).

Gradle: Beyond the Basics is a very short book of four chapters and 67 pages of substantive content (not counting 8 pages of cover, Table of Contents, and Preface or the 3 pages of Afterword, advertisements, biography, and colophon). The subjects covered in the book are covered well with a lucid and easily understood writing style. The combination of the short length of the book and of the easy reading style make this book a quick read.

As its subtitle ("Customizing Next-Generation Builds") suggests, Gradle: Beyond the Basics focuses on customizing Gradle builds. The "Table of Contents" listed on the O'Reilly page on Gradle: Beyond the Basics summarizes the specific covered areas of this customization: file operations, custom plug-ins, build hooks (and Rules), and dependency management.

I particularly liked Chapter 2 of the book Gradle: Beyond the Basics and the way it demonstrated writing a plugin by first starting with added functionality in the main build and then refactoring that code into a plugin. I also especially appreciated the Liquibase-based examples used in this chapter.

Although I have not read the first book (Building and Testing with Gradle), the Amazon.com reviews of that book and its advertised length (116 pages) make me think these two books would have worked better as a single book. I'm guessing that the reasons they were written as two separate books are those expressed on the Gradle Books page (different aims) and to enable quicker publication of the first one.

Although I found Gradle: Beyond the Basics to be interesting and a useful read, I find it difficult to recommend purchase of it at a list price over $20 (USD) because of the amount of information covered and because some of the topics that are covered are also covered well in the Gradle User Guide (PDF). That stated, the book does have some low-level details that I have not seen in the User Guide and even subjects covered in the User Guide are covered with different perspective and approach in the book. The Amazon.com Marketplace currently has other options for purchasing the book for under $10 (plus shipping and handling) and this might be more appealing for purchasing this short book. The ebook/Kindle version of Gradle: Beyond the Basics might also be a cost effective choice.

Gradle Command-Line Conveniences

In my post A First Look at Building Java with Gradle, I briefly mentioned using Gradle's "gradle tasks" command to see the available tasks for a particular Gradle build. In this post, I expand on that brief mention a bit more and look at some related Gradle command-line conveniences.

Gradle makes it easy to determine available Gradle tasks for a given project. The next screen snapshot demonstrates using gradle tasks (or gradle :tasks) in the same directory as the simple Gradle build file (build.gradle) I used in my previously mentioned Gradle post. The screen snapshots follow the code listing of build.gradle which is reproduced here for convenience.

Basic Java Application build.gradle

apply plugin: 'java'

Adding --all to gradle tasks (gradle tasks --all) will show even more details (including tasks' dependencies) as shown in the next screen snapshot.

Something I used to do often when working with an Ant build file new to me was to add a target "showProperties" that used a series of Ant echo tasks to display the properties used by that build file. Gradle provides essentially this capability out-of-the-box. The next screen snapshot demonstrates use of gradle -q properties to display the properties associated with the Gradle project and tasks in the build.gradle file in the same directory.

Another useful command-line Gradle option is --profile. This can be used in conjunction with running a Gradle command. For example, gradle tasks --profile generates the same standard output as shown above, but also writes build performance statistics to a file with the naming convention profile-YYYY-MM-DD-HH-mm-ss.html in the build/reports/profile subdirectory of the directory from which the build was executed. An example of that generated file is shown next.

The final Gradle command-line option I cover in this post is the "dry run" option -m (or --dry-run). This option allows one to see the Gradle tasks which are run and the order in which they are run without actually executing those tasks. Because the one-line Gradle build.gradle file used in this post applies the Java plugin, the automatically added Gradle Tasks include compileJava, classes, jar, and javadoc. The following screen snapshot demonstrates running gradle -m jar to see the dry run output that shows the dependent tasks that must be run before "jar" and the order they must be run (compileJava->processResources->classes->jar). Note "SKIPPED" notation indicating that the Gradle tasks are not actually executed.

Chapter 11 ("Using the Gradle Command-Line") of the Gradle User Guide (PDF) contains additional details regarding use of Gradle's command-line interface with sections on listing projects, listing tasks, listing project dependencies, listing project properties, and listing the order Gradle tasks are executed.

Book Review: Java EE 7 First Look

Java EE 7 was formally released earlier this year. NDJOBO Armel Fabrice's book Java EE 7 First Look advertises that the reader of this Packt Publishing book can "discover the new features of Java EE 7 and learn to put them together to build a large-scale application." I review the PDF version of this book in this post.

Preface on Book Objective, Intended Audience, and Prerequisites

The Preface of Java EE 7 First Look outlines the objective of the book: "This book does not aim to show how to implement the different aspects of each Java EE 7 specification or list the best practices. Rather, ... this book will help you discover the innovations introduced by Java EE 7 and gives you ideas to build solid applications.

The Preface lists four things software products necessary "to implement the various examples present in this book": NetBeans IDE 7.3.1+, JDK 7, GlassFish 4 b89+, and MySQL 5.5+. Although all of these are used in the book, only a fraction of the examples directly use NetBeans, GlassFish, and MySQL in approaches specific or exclusive to those tools. Many of the examples could be run without those specific tools with few and minor adjustments.

According to the Preface, the book is targeted primarily at three types of individuals: Java EE beginners, experienced Java EE developers wanting to learn the new Java EE 7 features, and architects wanting to learn how to put the covered technologies together to build "robust and secure enterprise applications." For reasons that I state at the end of this post, my opinion is that this book is best suited for the second group (experienced Java EE developers wanting to learn the new Java EE 7 features).

Chapter 1: What's New in Java EE 7

Chapter 1 of Java EE 7 First Look begins with a history of Java EE. The chapter discusses the revised "main goals of Java EE 7" and then looks briefly at how Java EE 7 improves productivity and HTML5 support. The chapter concludes with a section on "Novelties of Java EE 7" in which JSR 342 is discussed. This coverage states that there are 4 new specifications (Concurrency Utilities for Java EE, Batch Applications for the Java Platform, Java API for JSON Processing, and Java API for WebSocket) and talks about some of the most significantly updated specifications including Java Servlet 3.1, Expression Language 3.0, JavaServer Faces 2.2, Java Persistence API 2.1, Enterprise JavaBeans 3.2, Java Message Service 2.0, Java API for RESTful Web Services 2.0, Contexts and Dependency Injection for Java EE 1.1, and Bean Validation 1.1.

Chapter 2: New Specifications

The second chapter of Java EE 7 First Look looks at the four new specifications highlighted in the first chapter (Concurrency Utilities for Java EE, Batch Applications for the Java Platform, Java API for JSON Processing, and Java API for WebSocket) in more detail.

The chapter provides a summary of how important concurrency has become in modern software development and why Java EE containers formally did not support concurrency. It then looks at the most important interfaces supporting concurrency in Java EE applications.

Chapter 2 begins coverage of the Batch API for the Java Platform by defining batch processing and explaining how batch processing can help performance and handling of exceptions. Examples are provided of employing batch processing in Java EE with use of batch.xml, Batchlet, JobOperator, chunk, and step.

The second chapter's coverage of Java API for JSON Processing begins with a brief introduction to JSON, which it describes as "a lightweight data-interchange text format" that is "based on a subset of JavaScript, but is completely language independent." I liked the section in this chapter that compared XML to JSON and provided a fairer representation of their respective advantages and disadvantages than one often sees in modern software development literature.

The JSON Processing coverage continues with more detailed looks at the JSON streaming API (javax.json.stream package) and the JSON object model API (javax.json package). I liked this section's explanations of their differences and likening them to XML analogs for stream and DOM manipulation.

New Java support for WebSocket is the final topic of Chapter 2 and this section starts with a definition of WebSocket and an explanation of why WebSocket is useful.

Chapter 3: The Presentation Layer

Java EE 7 First Look's third chapter talks about "improvements in the Java EE platform for the presentation layer" with specific focus on updated specifications of Servlet 3.1, Expression Language 3.0, and JavaServer Faces 2.2. After a brief history of servlets and example of a Java servlet, the author focuses on two improvements in Servlets from 3.0 to 3.1: non-blocking I/O API (javax.servlet.ReadListener and javax.servlet.WriteListener as well as ServletInputStream and ServletOutputStream) and protocol upgrade processing (HttpServletRequest.upgrade(Class), javax.servlet.http.HttpUpgradeHandler, and javax.servlet.http.WebConnection).

The section of Chapter 3 on Expression Language starts with a very brief introduction describing what Expression Language is and demonstrating it in a brief JSF code snippet. Expression Language coverage then moves to 3.0 improvements with details laid out for use of Expression Language in Java SE environments (javax.el.ELProcessor), lambda expressions, collection objects, new operators (string concatenation, assignment, and semicolon), and static fields/methods.

Chapter 3's JSF coverage begins by describing JSF as "a component-based architecture with a set of standard UI widgets and helper tags." Following the same pattern as the chapter's Expression Language coverage, the JSF coverage shows a JSF code listing before going into what's new in JSF 2.2. New JSF 2.2 features covered in this chapter include HTML5 support (pass-through attributes and pass-through elements), Resource Contract Libraries, Faces Flows, and Stateless Views.

Chapter 4: The Java Persistence API

Chapter 4 of Java EE 7 First Look covers Java Persistence API 2.1 and Java Transaction API 1.2. As was done in Chapter 3, Chapter 4 provides an overview of JPA, what it is, and how to use it, before moving onto new features of JPA 2.1. The covered new features are persistence context synchronization, CDI support, new annotations (@Index and @ForeignKey), Entity Graphs, Java Persistence Query Language improvements, Criteria API improvements, and DDL generation standardization and improvements.

Chapter 4 moves from coverage of new JPA 2.1 features to new JTA 1.2 features. This section follows the pattern established in this and earlier chapters of first explaining the overall technology and showing a code listing example of the concept before moving onto new features. New JTA 1.2 features covered in this chapter are two new annotations (javax.transaction.Transactional and javax.transaction.TransactionScoped) and a single new exception (javax.transaction.TransactionalException). The new JTA 1.2 features are covered with significantly less detail than provided for the new JPA features.

Chapter 5: The Business Layer

The fifth chapter of Java EE 7 First Look covers EJB 3.2 and "putting all Java EE 7 specifications together." The chapter describes the "business layer of an application" between the database and presentation layers and how EJB is part of that business layer. The chapter talks about features of EJB that are made optional in Java EE 7 and are now covered in a separate EJB 3.2 Optional Features for Evaluation document. The author states that EJB 3.2 only adds minor enhancements to EJB and then briefly outlines enhancements to stateful sessions beans and provides code examples and descriptions of each.

Improvements in EJB 3.2 for EJB Lite (introduced in EJB 3.1 [Java EE 6]) are covered next. Text and code examples are used to describe these EJB Lite enhancements as well.

Chapter 5 moves to a brief introduction to Java Message Service (JMS) and Message-Driven Beans (MDB). Brief coverage of how EJB 3.2 has been adjusted to conform to JMS 2.0 follows. The author points out that EJBContainer, first introduced with EJB 3.1, now implements the AutoCloseable interface, meaning that it can participate in the try-with-resources mechanism introduced with Java SE 7.

The remainder of Chapter 5 is on "putting it altogether." This section includes several UML diagrams and design artifacts and, without any code, discusses requirements of the sample project.

Chapter 6: Communicating with External Systems

Chapter 6 of Java EE 7 First Look describes changes to four APIs related to "system integration problems": JavaMail, Java EE Connector Architecture, Java Message Service, and JAX-RS. As has been done in the coverage of most of the other Java EE topics in this book, these are each introduced in general and then Java EE 7 enhancements for each are explained.

Enhancements to JavaMail 1.5 are discussed. These enhancements include two new annotations (@MailSessionDefinition and @MailSessionDefinitions) targeted at the application server environment, new "shortcut" methods, and changes to field modifiers.

Coverage of changes to Java EE Connector Architecture 1.7 (JSR 322) spends far more time describing what JCA is and hot it is used than in discussing enhancements to JCA 1.7 (one paragraph, three bullets, no code). Covered new JCA features include the new annotations @ConnectionFactoryDefinition and AdministeredObjectDefinition.

Chapter 6's JMS coverage does not spend much time covering what JMS is, presumably because this was covered to some degree in Chapter 5 on JMS and MJBs. Features new to JMS 2.0 are covered more extensively and include greater API simplicity and delivery delay and sending messages asynchronously.

Java API for RESTful Web Services 2.0 is the final major topic of Chapter 6. This section begins by considering web services and when to use them generally, but then explicitly states that the book focuses only on REST-based web services. I've been excited about JAX-RS 2.0 (see my review of related book ) and was glad to see several new features of JAX-RS 2.0 covered in this section: Client API, asynchronous processing, and filters and entity interceptors.

Chapter 7: Annotations and CDI

Java EE 7 First Look's seventh chapter begins with a review of JSR 250 (Common Annotations) followed by a description of how to write one's own custom annotation. The discussion on writing a custom annotation also illustrates the need in Java SE 6 to implement the javax.annotation.processing.Processor interface (see also my article Better JPA, Better JAXB, and Better Annotations Processing with Java SE 6 for further details). The section on annotations concludes with the introduction of javax.annotation.Priority.

Context Dependency Injection (CDI) is covered next. Like the annotations and most other concepts in this book, it is introduced generally first before coverage of new features begins. Quite a few code examples demonstrate how to use CDI in a variety of different situations. The coverage of new CDI 1.1 features includes @Vetoed, use of CDI.current() to "access the current CDI container programatically," and use of AlterableContext "to allow explicit destruction of bean instances in applications."

Chapter 8: Validators and Interceptors

The Java EE 7 specifications focused on in Chapter 8 are Bean Validation 1.1 (JSR 349) and Interceptors 1.2 (JSR 318). The chapter's coverage of Bean Validation begins with a table of built-in constraints, followed by examples and discussion of applying constraints. The section includes with coverage of implementing custom constraints. After devoting quite a few pages to illustration of and examples of using Validation, the section begins coverage of new Java EE 7 features of Validation including open sourcing of Bean Validation implementation, CDI/dependency injection integration and the ability to validate parameters of methods and constructors and return types on methods.

Like the section on Validation, the section on Interceptors begins by providing a background of what Interceptors are and how to use them. The new Interceptor 1.2 features covered in this section include intercept constructor invocation, interceptor binding, and defining interceptor order.

Chapter 9: Security

The ninth and final chapter of Java EE 7 First Look is on security. The chapter introduces Java Authentication SPI for Containers (JASPIC) [JSR 196]. The author describes the JASPIC specification as "a set of standard interfaces for the development of modules for authentication, which allow secure access to web resources (Servlets, JSP, and so on), among others." There are numerous pages of code listings, illustrative text, and screen snapshots devoted to covering implementing JASPIC with GlassFish. The chapter then moves onto new features introduced with "Maintenance Release B of JASPIC Specification." New features covered include increased level of standardization of how authentication is handled across different servers and how the application context provider is identified and support for forward and include mechanisms.

General Observations

• Nearly every introduced Java EE 7 new feature covered in this book was covered only after an overall description of the specification including its history and general usage before the new features were available.
  • The brief review of a specification's history and illustration of using that specification provides a nice review before jumping into what's new in Java EE 7 about that specification.
  • Although this review of existing specifications provides is helpful for those who have used Java EE to some degree before, I doubt these reviews would be sufficient background for someone entirely new to Java EE.
  • A true Java EE beginner would probably be better off learning Java EE in a fashion that integrates all versions of Java EE rather than focusing primarily on the latest version of Java EE (such as via the Java EE 7 Tutorial).
• Java EE 7 First Look is generally well-written and I only found a few typos, most of which were extremely minor. The most obvious were a couple cases where Java class or interface names had their first letter in lowercase even though that class or interface actually follows the Java convention of beginning with a capital letter.
• Java EE 7 First Look seems particularly well suited for someone who has used Java EE before, but has little or no exposure to Java EE 7.
• Java EE 7 First Look is about 165 pages of prose when one doesn't count the index and advertisements for related Packt Publishing books. The nine chapters don't have a lot of extra fluff and remain focused on covering Java EE 7 features, how they improve existing Java EE support, and how they can be used together.

Conclusion

Java EE 7 First Look provides convenient access to the features of Java EE 7 that will help Java EE developers be more productive and accomplish more for their clients. Although most of these features are described in detail in blogs, articles, and in the Java EE 7 Tutorial, Java EE 7 First Look collects all of them in one place and keeps its focus on the new features with only brief references to historical information and previous Java EE versions. Java EE 7 First Look provides an overall view of the collective benefit of Java EE 7 new features with some attention paid to implementing these features individually and with one another.

Anyone interested in the e-book version of Java EE 7 First Look might want to take advantage of the Packt Publishing Ebook Bonanza that runs through 3 January 2014, offering the electronic version of this book for $5 (USD).