October Issue of NFJS, the Magazine published.

Here’s what is in this month’s NFJS, the Magazine

 

Tim Berglund – Plugging into Gradle Plugins

Gradle is a next-generation build system designed to provide the right balance between conventions and customization. Based on a Groovy DSL, Gradle makes it very easy to add arbitrary logic into a build script, but this approach is hostile to maintainability and will not be compatible with the tooling solutions likely to emerge over the next year. Instead, Gradle provides a powerful plugin architecture to extend the functionality of the tool and the DSL it exposes to the build masters and users of the build. In this article, we’ll look at how to program and package Gradle plugins.

Jeremy Deane – Enterprise Integration Agility

According to Programmable Web in 2010 the rate of growth in public Web APIs doubled1. This exponential trend continues in 2011 resulting in an ever more connected web. This connected contagion is not just relegated to the domain of Web 2.0 but has infected the corporate world. In fact, companies are becoming more reliant on Software as a Service (SAAS) to provide key business functions. In this article, we will explore several options for rapidly delivering flexible-integrated solutions.

Johnny Wey – Relax with CouchDB

There was a time, not terribly long ago, when choosing a data persistence technology was a relatively simple task.

Mark Volkmann – Sass…CSS Evolved

Cascading Style Sheets have a simple syntax for specifying the formatting properties to be applied to HTML content. Many would say the syntax is too simple. It is difficult to avoid repeating properties in multiple CSS rules. Sass addresses that issue and more, making it possible to keep formatting descriptions DRY. Being DRY allows a change to one property to affect the formatting of many related elements. This article assumes basic knowledge of CSS.

Here’s what is in next month’s NFJS, the Magazine

Matthew McCullough – Game Theory for Software Developers: Economics & Statistics in the Domain of Programmers

Game Theory is a fascinating focused study of strategic interactive decision making that originated in the 1950s with help from our computer science founding father, John von Neumann. It began with a focus on economics, later expanded to military battle strategy, and now even aims to describe the behavior of business teams scaled all the way up to the size of nations. It offers its students an insightful set of descriptions and simplifications, much like those of design patterns, that clarify behavior that might otherwise be described as “irrational.” Such behavior, it turns out, is rarely irrational, but merely driven by motivations that were previously just misunderstood or overlooked. This article will allow you to peer through this new lens, making the underlying motivations in the world of business, team interactions, product pricing, advertising and service offerings crystal clear. This Game Theory view, enabled by the ideas in this article, will provide professional guidance and employment tactics for engineers looking to extract maximum career and income benefits for their labor in the realm of software development.

Jessica Kerr & Ted Neward – Guava: an excellent source of vitamin C (for Concurrency)

Dive deeper into one of the biggest timesavers in Google’s Guava library: MapMaker. More than a static factory, MapMaker creates an insta-cache. The cache can calculate values on demand, expire entries as they reach a specific age, and avoid taking up too much memory. Best of all, it is completely thread-safe. While we’re at it, we’ll cover some of the other utilities in Guava that make concurrency in Java a little less painful. Guava fruit is supposed to help with high blood pressure, and these tricks just might help with yours.

Matt Stine – Vagrant: Virtualized Development Environments Made Simple

Have you ever wished that your local development sandbox could look exactly like production, but you’ve got a mismatch between your local OS and your production OS? And what about the age old “it works on my machine” excuse that quite often stems from differences between developer sandboxes? Many have turned to virtualization, creating a machine image that can be passed around the team. But who manages the template? How do you keep things in sync? In this article, we’ll explore Vagrant, an open source tool that allows you to easily create and manage virtual development environments that can be provisioned on demand and “thrown away” when no longer needed.

Mark Richards – High Performance Messaging

As Woody Allen once said “It is impossible to travel faster than the speed of light, and certainly not desirable, as one’s hat keeps blowing off”. While messages traveling through your system may never quite reach the speed of light, you could certainly make them travel fast. In this article I will explore four simple techniques that will increase the speed and throughput of your messaging system through relatively minor changes in your messaging infrastructure. So hold on to your hats and enjoy the ride (it’s a fast one).

I’m very proud of the work we do on this new magazine. The staff and I have worked hard to produce a top-notch magazine that is unique in the realm of software development magazines. The magazine costs $50 per year, which includes 10 issues. Each issue has at least four articles. You can download in a print-quality PDF and two mobile formats: EPUB (for the Nook and iPad) and MOBI (for the Kindle). The articles are professionally edited and are written by top experts in their field, so the content is worth well more than the $50 you pay.

The June issue just published this morning and you can subscribe here: http://bit.ly/fETp6d. As always, if you have questions just comment on this post and I’ll respond quickly.

August Issue of NFJS, the Magazine published.

Here’s what is in this month’s NFJS, the Magazine

Venkat Subramaniam – Programming with Scala Traits – Part One

In object modeling, mixins provide a way to create abstractions that define a common functionality that can be mixed into different abstractions. As Java programmers we did not quite have the ability to make use of this powerful concept, especially because Java does not provide multiple inheritance. In languages that do provide multiple inheritance, like C++, this is quite difficult to use in practice due to problems with method collision. Scala elegantly supports compile time mixins through traits. In this first part of the series, we’ll learn about traits in Scala and how to use them. In the second part, we’ll learn how to apply multiple traits both at class and instance levels.

Raju Gandhi - On Eloquent Conversations – Part Two

In the first installment of this series, we discussed the need for integration, and some of the potential pitfalls, especially when attempting to roll your own integration system. We then proceeded to discuss some of the patterns in Gregor Hohpe’s and Bobby Woolf’s aptly named “Enterprise Integration Patterns” and their corresponding implementations in Spring Integration. We discussed the core patterns that make up the founding blocks of Spring Integration – “Message Channel”, “Message” and “Message Endpoint”. In this article we will explore a few more patterns that will allow you to route, filter and manipulate messages as well as talk to external systems. We will learn how to do this while leveraging Spring’s declarative model that lets you focus on your domain, and let Spring Integration handle the specifics of messaging.

Craig Walls - NoXML: Spring for XML Haters

In spite of all of the great things Spring brings to Java development, one criticism it has received a lot of over the years is its heavy use of XML for configuration. It’s true that Spring configuration has traditionally required XML. Lots of XML. It seems that XML has fallen out of favor with many developers. And for those who are card-carrying members of the He-Man XML Haters Club, it’s hard to see the benefits of Spring through the haze of XML. If you’re among the XML haters, then this article is for you. Each version of Spring has taken steps to lighten the XML burden and I’m going to show you a few tricks from the latest versions of Spring that make it possible to develop a Spring application with minimal or even no XML whatsoever. To illustrate these techniques, I’ve written a simple Guestbook application using common Spring XML configuration. Throughout this article, we’ll swap XML configuration for Java configuration, until there is no more XML left in the project. If you want to follow along, you can download the before and after projects from this magazine’s download URL.

Scott Leberknight - Handling Big Data with HBase

In the past few years we have seen a veritable explosion in various ways to store and retrieve data. The so-called NoSql databases have been leading the charge and creating all these new persistence choices. These alternatives have, in large part, become more popular due to the rise of Big Data led by companies such as Google, Amazon, Twitter, and Facebook as they have amassed vast amounts of data that must be stored, queried, and analyzed. But more and more companies are collecting massive amounts of data and they need to be able to effectively use all that data to fuel their business. For example social networks all need to be able to analyze large social graphs of people and make recommendations for who to link to next, while almost every large website out there now has a recommendation engine that tries to suggest ever more things you might want to purchase. As these businesses collect more data, they need a way to be able to easily scale-up without needing to re-write entire systems.

Here’s what is in next month’s NFJS, the Magazine

Neal Ford – Build Your Own Technology Radar

ThoughtWorks’ Technical Advisory Board creates a “technolgy radar” three or four times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This article focuses on why you should undertake this exercise, both for your company and your own career development.

Venkat Subramaniam – Scala Traits Part Two

In this part two of the series, Venkat Subramaniam will discuss how to apply multiple traits at both class and instance level and to implement the decorator pattern.

Brian Sam-Bodden – MVC Meet JavaScript, JavaScript Meet MVC

For years the software community has been pushing the MVC architectural pattern to organize and separate the concerns of our applications. So far we seem to have done a decent job of accomplishing that based on the enforcement of the pattern in the most successful web frameworks such as Rails, Grails, JSF, Struts and many others. The last frontier for MVC seems to be the sometimes convoluted world of JavaScript; the client tier of our web applications. Although frameworks like jQuery, Prototype, Scriptaculous, ExtJS, DOJO and others have greatly helped in cleaning up and structuring the client tier, there’s still much to be desired. In recent years several micro-frameworks have appeared that aim to put an end to the madness of the JavaScript client tier world. In this article we’ll explore the most prominent players and see how their usage impacts modern web development.

Hamlet D’Arcy – Better DSLs with Groovy Command Expressions

Domain Specific Languages (DSLs) are often littered with the accidental complexity of the host language. Have you seen a supposedly “friendly” language expression like ride(minutes(10)).on(bus).towards(Basel)? The newest version of Groovy contains a language feature that aims to eliminate the noise of all those extra periods and parenthesis so that your DSL looks more like “ride 10.minutes on bus towards Basel”. This article shows you, step-by-step, how to use Groovy Command Expressions and plain old metaprogramming to write just this DSL and also offers advice on when, and when not, to use this new language feature.

I’m very proud of the work we do on this new magazine. The staff and I have worked hard to produce a top-notch magazine that is unique in the realm of software development magazines. The magazine costs $50 per year, which includes 10 issues. Each issue has at least four articles. You can download in a print-quality PDF and two mobile formats: EPUB (for the Nook and iPad) and MOBI (for the Kindle). The articles are professionally edited and are written by top experts in their field, so the content is worth well more than the $50 you pay.

The June issue just published this morning and you can subscribe here: http://bit.ly/fETp6d. As always, if you have questions just comment on this post and I’ll respond quickly.

July Issue of NFJS, the Magazine published.

Here’s what is in this month’s NFJS, the Magazine

 

July NFJS Magazine Cover

Raju Gandhi – On Eloquent Conversations Part 1

It goes without saying that an enterprise consists of many moving parts, with multiple applications that serve to support different business processes. These applications rarely live in a silo, and consequently need to be integrated to allow for reliable and in some cases, secure data transfer. In this two-part article series, we will discuss some of the hurdles to integration and some possible approaches. We will then turn our attention mainly to messaging. We will also take a look at Spring Integration, a library from Spring Source that lets us integrate our applications in an unobtrusive and declarative manner.

Peter Bell – MongoDB – Why and How?

Many NoSQL data stores are designed primarily to solve problems of scale. Unusually, Mongo can be a great fit for building web applications whether you need to scale or not. In this article we’ll look at why you might consider Mongo, and how to get started with it.

Daniel Hinojosa – Simple and Easy Guide to Types in Scala

There is much to love about Scala. One of the harder things to digest are types. Scala is a static typed language. Thankfully, much of the generics needed as a user are hidden. Those who have dealt with variance in Java will encounter some slight twists when working in Scala, especially when type inference and implicit function parameters are included. Many Scala books on the market do an excellent job covering variance, but the interplay between type inference and variances often lacks appropriate coverage. This article aims to apply some mental spackle to solidify the understanding of types in Scala.

Nathaniel Schutta – Ajax Library Smackdown: Dojo vs. YUI

Ajax is everywhere, from the local newspaper to sites that the CEOs surf. Contrary to popular belief, it isn’t rocket science, especially with the right library. Explore the popular YUI and Dojo libraries, and learn how they can simplify typical Ajax techniques and make JavaScript easier to work with. Discover why you should use a library in the first place and how to choose among libraries, and get some specific examples from YUI and Dojo.

Here’s what is in next month’s NFJS, the Magazine

Venkat Subramaniam – Scala Traits Part 1

In this article, we’ll learn about traits, how it is weaved in at compile time, and how to easily implement the decorator pattern with it.

Craig Walls – NoXML : Spring for XML Haters

When many think of Spring, they think of dependency injection, aspect-oriented programming, declarative transactions…and lots of XML. XML has fallen out of favor with much of the development community and with its heavy use of XML, Spring doesn’t seem as fresh as it once was.

In spite of its angle bracket-laden history, recent versions of Spring offer many non-XML configuration options. In this article we’ll explore some new features in Spring 3.0 and Spring 3.1 that can dramatically reduce or even eliminate XML from your Spring applications.

Raju Gandhi – On Eloquent Conversations Part 2

In the first installment of this series, we discussed the need for integration, and some of the potential pitfalls, especially when attempting to roll your own integration system. We then proceeded to discuss some of the patterns in Gregor Hohpe’s and Bobby Woolf’s aptly named Enterprise Integration Patterns and their corresponding implementations in Spring Integration. We discussed the core patterns that make up the founding blocks of Spring Integration – “Message Channel”, “Message” and “Message Endpoint”. In this article we will explore a few more patterns that will allow you to route, filter and manipulate messages as well as talk to external systems. We will learn how to do this while leveraging Spring’s declarative model that lets you focus on your domain, and lets Spring Integration handle the specifics of messaging.

Scott Leberknight – HBase

This article will examine HBase, a non-relational database designed to scale horizontally while still providing real-time, random read/write access to your data.

I’m very proud of the work we do on this new magazine. The staff and I have worked hard to produce a top-notch magazine that is unique in the realm of software development magazines. The magazine costs $50 per year, which includes 10 issues. Each issue has at least four articles. You can download in a print-quality PDF and two mobile formats: EPUB (for the Nook and iPad) and MOBI (for the Kindle). The articles are professionally edited and are written by top experts in their field, so the content is worth well more than the $50 you pay.

The June issue just published this morning and you can subscribe here: http://bit.ly/fETp6d. As always, if you have questions just comment on this post and I’ll respond quickly.