‘Spring Boot in Action’ can help you push aside the old drudgeries of configuring Spring applications – #programming #bookreview

Spring in Action

Craig Walls

Manningpaperback

If you have worked with the decade-old Spring framework, you know well that it has a long history of providing configuration headaches for developers. The new Spring Boot framework, on the other hand, literally brings much-needed simplification and automation to the process of using Spring. And it can put some refreshing fun back into application development.

“Spring Boot,” Craig Walls states in his new book, “is an exciting new way to develop Spring applications with minimal friction from the framework itself. Auto-configuration eliminates much of the boilerplate configuration that infests traditional Spring applications. Spring Boot starters enable you to specify build dependencies by what they offer rather than use explicit library names and version. The Spring Boot CLI takes Spring Boot’s frictionless development model to a whole new level by enabling quick and easy development with Groovy from the command line. And the [Spring Boot] Actuator lets you look inside your running application to see what and how Spring Boot has done.”

You do not need a lot of Spring experience to benefit from this book. You do need some Java background, and it is helpful to have used Groovy, Gradle and Maven a few times. But the book’s text is written smoothly, and it is well illustrated, with numerous code examples and a few screen shoots. So Java developers who are fairly new likely can use it and pick up new skills.

While going through the book, you develop a reading-list application using Spring Initializr, Spring Boot, Spring Tool Suite, and other tools. In the project, you “use Spring MVC to handle web requests, Thymeleaf to define web views, and Spring Data JPA to persist the reading selections to a database,” Craig Walls explains. Initially, at least, “an embedded H2 database” is employed during development.

Walls’s book is divided into eight chapters:

1. Bootstarting Spring
2. Developing your first Spring Boot Application
3. Customizing configuration
4. Testing with Spring Boot
5. Getting Groovy with the Spring Boot CLI
6. Applying Grails in Spring Boot
7. Taking a peek inside the Actuator
8. Deploying Spring Boot applications

Four appendices also are presented: Spring Boot developer tools, Spring Boot starters, Configuration properties, and Spring Boot dependencies.

Bottom line: with Spring Boot providing much of the heavy lifting, you likely will gain better feelings about the venerable Spring framework. You may even wind up with a healthy new respect for it. And Spring Boot certainly should add more years to Spring’s usefulness and viability in the marketplace.

Si Dunn

Advertisements

Java 8 in Action – Ready for lambdas, streams and functional-style programming? #bookreview

 

Java 8 in Action

Lambdas, streams, and functional-style programming

Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft

(Manning – paperback)

 Java 8, we were sometimes assured, would just be Java 7 with a few slick new (or past-due) features added.

Actually, now that it’s here, Java 8 represents “the biggest change to Java in the 18 years since Java 1.0 was released,” the three authors of this fine new book point out.

Of course, news of “big changes” seldom sits well with developers who have spent countless hours learning and getting comfortable with one particular version of a programming language.

And many coders and companies will continue sticking with Java 7 for a while longer, because it still works. But the adoption pace for Java 8 keeps picking up. So, to misquote an old sci-fi slogan, resistance soon will become somewhat futile.

Lambdas, streams, and functional-style programming capabilities are Java 8’s headline additions. And there are some other major and minor additions, as well, including default methods and a new Date and Time API.

Java 8 in Action does an excellent job of introducing these new capabilities, and the book offers many short code examples and other illustrations to show how to put the new Java 8 capabilities to work.

Indeed, short (and shorter!) code is one of the hallmarks of Java 8. “In Java 8 you can write more concise code that reads a lot closer to the problem statement,” the writers emphasize. To illustrate that point, they offer a five-line example of verbose Java 7 code and follow it with a one-line Java 8 code example that accomplishes the same thing. Other examples also drive home the coding efficiencies that Java 8 can offer.

Lambdas, also known as anonymous functions, enable you to skip writing method definitions that will only be used once. The authors note that “passing code is currently tedious and verbose in Java [meaning 7 and earlier]. Well, good news! Lambdas fix this problem: they let you pass code in a concise way. Lambdas technically don’t let you do anything you couldn’t do prior to Java 8. But you no longer have to write clumsy code using anonymous classes to benefit from behavior parameterization!”

The new Streams API makes it much easier to work with collections in Java and provides “a much different way to process data in comparison to the Collections API.” Using the Streams API, “you don’t need to think in terms of loops at all. The data processing happens internally inside the library.”

Meanwhile, if you are a diehard object-oriented programmer, you may be leery of the term “functional programming” and the notion of using functions as values. (“In practice, you can’t completely program in pure functional style in Java,” the authors note. Instead, you will learn how to write “functional-style programs” in which you hide the side effects.)

With Java 8, “two core ideas from functional programming…are now part of Java: using methods and lambdas as first-class values, and the idea that calls to functions or methods can be efficiently and safely executed in parallel in the absence of mutable shared state. Both of these ideas are exploited by the new Streams API,” the writers state.  Also, in Java 8, they add, “there’s an Optional class that, if used consistently can help you avoid NullPointer exceptions.”

This review barely dents the surface of this excellent how-to book’s contents. Whether you are learning Java now or you are a Java developer who wants to keep your coding skills up-to-date and sharp, Java 8 in Action should be a book you will read soon.

Si Dunn

Scala for Java Developers – A practical guide to building apps and integrating code – #programming #bookreview

Scala for Java Developers

Build reactive, scalable applications and integrate Java code with the power of Scala

Thomas Alexandre

(Packtpaperback, Kindle)

 

The increasingly popular Scala programming language runs on the Java Virtual Machine (JVM). And “Java and Scala stacks can be freely mixed for totally seamless integration,” Scala’s website proudly trumpets.

The Scala site goes on to note: “Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages.”

Indeed, in Scala, “every value is an object” and “every function is a value.”

Scala’s continuing  rise poses something of a dilemma for many Java developers. Their questions include:

  • Should I learn Scala and blend it with Java?
  • Should I take up Scala and use it instead of  Java?
  • Should I just keep my head down, ignore Scala, and focus on getting better at developing with Java?

Thomas Alexandre’s well-written new book, Scala for Java Developers, clearly is aimed at those who would much rather add Scala to their skills and resumes than attempt to hide from the changes Scala can offer to Java development.

He notes in his preface: “When I tell people around me that I now program in Scala rather than Java, I often get the question, ‘So, in simple words, what is the main advantage of using Scala compared to Java?’  I tend to respond with this: ‘With Scala, you reason and program closer to the domain, closer to plain English.’ “

However, Alexandre’s new how-to guide does not try to browbeat developers into abandoning Java and pledging allegiance to Scala alone. Instead, Alexandre shows how the two programming languages can be used together. And he demonstrates how Scala solutions often can be shorter and less complex than their Java equivalents.

He focuses on “exploring progressively some of the new concepts brought by Scala, in particular, how to unify the best of Object-Oriented and functional programming without giving away any of the established and mature technologies built around Java for the past fifteen years.”

Decisions regarding how far to go with Scala remain with the reader. Yet Alexandre and his numerous code examples make a compelling case for becoming at least reasonably familiar with the language and experiencing how easily it can integrate with Java.

And, yes, he does evangelize a bit; this is, after all, a book about Scala. “Scala is the only language that has it all,” Alexandre touts. “It is statically typed, runs on the JVM and is totally Java compatible, is both object-oriented and functional, and is
not verbose, thereby leading to better productivity, less maintenance, and therefore more fun.”

His book is divided into 10 chapters:

  • Chapter 1: Programming Interactively within Your Project – Includes advantages of using Scala, learning Scala via the REPL, and performing operations on collections.
  • Chapter 2: Code Integration – Focuses on creating a REST API from an existing database, adding a test in Scala, setting up Scala within a Java Maven project, and showing how Scala and Java work together despite some differences in code style.
  • Chapter 3: Understanding the Scala Ecosystem – Includes inheriting Java Integrated Development Environments (IDEs), building with Simple Build Tool (SBT), using Scala worksheets, working with HTTP, and using Typesafe Activator.
  • Chapter 4: Testing Tools – Writing tests with ScalaTest and testing with ScalaCheck.
  • Chapter 5: Getting Started with the Play Framework – Getting started with the classic Play distribution, getting started with the Typesafe Activator, the architecture of a Play application, authentication, and practical tips when using Play.
  • Chapter 6: Database Access and the Future of ORM – In this case, ORM is Object Relational Modeling. Chapter topics include integrating an existing ORM – Hibernate and JPA, dealing with persistence in the Play framework, replacing ORM, learning about Slick, and scaffolding a Play application.
  • Chapter 7: Working with Integration and Web Services – Includes binding XML data in Scala, working with XML and JSON, and handling Play requests with XML and JSON.
  • Chapter 8: Essential Properties of Modern Applications – Asynchrony and Concurrency – Covers the pillars of concurrency, the async library – SIP-22-Async, and getting started with Akka.
  • Chapter 9: Building Reactive Web Applications – Includes describing reactive applications, handling streams reactively, experimenting with WebSockets and Iteratees in Play, learning from activator templates, and playing with Actor Room.
  • Chapter 10: Scala Goodies – Covers exploring MongoDb and scratching the surface of Big Data. Also introduces DSLs in Scala and introduces Scala.js, which compiles Scala to JavaScript.

Alexandre makes a strong pitch for using the Play framework in Scala web development. And he again speaks out for Scala at the conclusion of his well-structured book:

“The concise and expressive syntax of the Scala language should make your code not only more readable but also more maintainable for yourself and other developers,” he writes. “You don’t have to give up any of the libraries of the very large and mature Java ecosystem as all the APIs can be reused directly within Scala. Moreover, you benefit from many additional great Scala-specific libraries. Our recommendation is to take a piece of Java code from a domain you understand well, maybe because you wrote it in the first place one or several times before. Then, try to convert it to Scala code and refactor it to get rid of the boilerplate and to make it in a more functional style.”

Si Dunn

 

 

 

 

 

 

 

 

Play for Java – Good intro to the Play 2 Java web framework – #programming #bookreview

Play for Java

Nicolas Leroux and Sietse de Kaper

(Manning, paperback)

 

“There are,” co-author Nicolas Leroux writes, ” many Java web frameworks, but most of them have a key flaw: they try to hide the web behind an abstraction layer, rather than embracing it. That is the most important difference between Play and most other Java web frameworks (Servlets, we’re looking at you!).”

His writing partner, Sietse de Kaper,  adds: “Play ‘gets it.’ For ‘it,’ in this case, a lot of things can be substituted. Play ‘gets’ HTTP and the web in general, how developing web application works, what makes a nice and clean API, and more. This was clear from the early Play 1 beta versions, and that’s why we’ve used it on many projects since 1.0 came out. It didn’t disappoint. Now, with Play 2, Play continues to improve web development for the Java platform.”

Their new book from Manning is nicely written, adequately illustrated and structured properly to help newcomers get started with Play and with basic web application development. Play for Java also can help experienced web app developers quickly get up to speed quickly with this powerful development platform.

You start by creating and modifying the ubiquitous “Hello world!” application. Then you spend the remaining chapters developing, expanding and enhancing a warehouse management application, one designed to meet specific requirements within a made-up company. “Enterprise applications usually live inside the IT department and are usually hosted within the organization,” Leroux and de Kaper explain. Indeed, businesses may have several or many enterprise applications serving specific purposes, and those apps often do not communicate with each other.

As both writers note: “Web developers are used to interacting with their applications through the browser. With Play, you can also use the console to interact with your web application’s development environment and build system. This is important for both quick experiments and automating things.”

The web app framework Play is, indeed, fun to play with–and work with. For example, it is very good at showing you exactly (ona browser screen) where you have made a keystroke mistake or other blunder in your code. And the words  “Compilation error” on the screen display can’t be missed. Indeed, they can be read from across a room. (Fortunately, in my office, so no one sees them but me.)

If you decide to download Play and give it a try, be sure you (1) have Java installed correctly and (2) know how to set PATHs correctly on your Windows, Linux, or Mac machine. (I had a lingering Java glitch in one of my machines, and I nearly flung a Windows 7 PC into a wall in frustration. But I finally found the problem and fixed it, and Play immediately popped to life as shown in the book. Meanwhile, Play installed smoothly on a Windows 8.1 machine and an ex-XP PC now running Ubuntu.) 

The authors show how to use Play with three IDEs: Eclipse, NetBeans and IntelliJ. Or, if you prefer, you can stick with the Play console and a text editor such as Notepad++ (my current favorite). And they repeatedly emphasize that (1) you should not worry that their Java framework called Play actually is written in Scala and (2) you will encounter some bits of Scala while working with template files.

“Any template language has structures you need to know to build your templates, and Scala templates are no different,” they explain. “Once you know what you have to do to, for example, iterate over a collection or insert a variable value somewhere, you know all you have to know to use that feature. You don’t have to think of it as Scala if you don’t want to. Think of it as another template language.” (Actually, Scala is not scary at all once you’ve spent a little time with it or taken an online class.)

Play supports the optional use of some compiled assets, and “[o]ut of the box, Play 2 comes with support for LESS, CoffeeScript, and Google’s Closure compiler,” the co-authors note.

According to Playframework.org, Play is built on Akka and offers “a lightweight, stateless, web-friendly architecture.” It also offers built-in testing tools and speedy “hit refresh” workflow capabilities.

Whether you are an experienced web app developer, a newcomer, a student or a hobbyist programmer, it can be serious fun to work with–or play with–Play. And Nicolas Leroux’s and Sietse de Kaper’s Play for Java can be exactly the well-tuned guide you need to learn Play 2.

 — Si Dunn

 

 

 

 

 

 

Enterprise Application Development with Ext JS and Spring – (And a lot more!) – #programming #bookreview

Enterprise Application Development with Ext JS and Spring

Develop and deploy a high-performance Java web application using Ext JS and Spring

Gerald Gierer

(Packt Publishing paperback, Kindle)

A powerful JavaScript web framework such as Ext JS deserves a powerful platform for enterprise desktop application development. Gerald Gierer delivers a good one in his well-crafted new how-to book from Packt Publishing.

Gierer’s book is a bit unusual in today’s pare-it-down marketplace. It contains many before, during and after screen prints to illustrate the actions and outcomes of steps and commands. The 446-page book also has lengthy code listings that enable you to check and verify the outcomes of code changes you have made.

Ext JS and the Spring framework, however, are just a few of the packages that you work with as you set up your development tools and create, modify, expand, test and deploy a sample enterprise application (a task time tracker).

The other programs and tools include MySQL, the Java SE development kit (with the new Java API for JSON), NetBeans, Maven, Glassfish, and JUnit. And, with Ext JS, you learn to work with the Sencha Cmd tool and the Ext JS Software Development Kit (SDK).

But please note, particularly if you are new to some of this : You must pay careful attention to each paragraph as you load and configure software and as you keep building and enhancing your enterprise application.

In this book, it is easy start jumping from one screen print to the next, or from one code listing to the next, while skipping the intervening text. When you do, you can miss key steps that sometimes are buried without highlights in the wording.

This was my first time to work with some of the required software packages, so I had to force myself to really slow down and pay close attention to each paragraph, as well as each graphic.  My initial development attempt went off the rails when I discovered, more than 100 pages into the book, that I had misconfigured a couple of tables, skipped a couple of data changes, and generally screwed up the database. And, being new to some of the software, I couldn’t figure out to repair everything. So I simply started over from scratch and this time moved carefully from one page to the next, closely checking code entries and the book’s text before clicking “Enter.” That made all the difference in my results.

If you are looking to do enterprise application development with a JavaScript framework, definitely consider Ext JS and definitely consider Gerald Gierer’s fine Enterprise Application Development with Ext JS and Spring.

And definitely take your time as you work your way through his book.

Si Dunn

Gradle in Action – Had enough of Maven and Ant? Try this powerful Java build tool – #programming #bookreview

Gradle in Action

Benjamin Muschko

(Manning, paperback)

Apache Maven and Apache Ant are perhaps the two best-known and most widely used Java build tools. But Gradle is gainmuschkoing users and aficionados ( if, indeed, there can be “fans” of software build tools). And this well-prepared new book likely will help Gradle achieve even wider acceptance and employment in the workplace.

“Gradle,” writes Benjamin Muschko, “is the next evolutionary step in JVM-based build tools. It draws on lessons learned from established tools like Ant and Maven and takes their best ideas to the next level. Following a build-by-convention approach, Gradle allows for declaratively modeling your problem domain using a powerful and expressive domain-specific language (DSL) implemented in Groovy instead of XML. Because Gradle is a JVM native, it allows you to write custom logic in the language you’re most comfortable with, be it Java or Groovy.”

Muschko has a strong bias toward Gradle, of course. He is a member of the Gradleware engineering team and has written several popular Gradle plugins.

Nonetheless, his well-written, 15-chapter, 456-page book makes a compelling case for Java developers to add Gradle to their build-tool cabinet and list of skills.

“Over the course of years,” Muschko contends, Maven and Ant “[have] significantly improved and extended their feature set. But even though both are highly popular and have become industry standards, they have one weak point: build logic has to be described in XML. XML is great for describing hierarchical data, but falls short on expressing program flow and conditional logic. As a build script grows in complexity, maintaining the build code becomes a nightmare.”

To use Gradle, you do have to learn parts of yet another programming language, Groovy. But, if you already know Java, you are much of the way there.  “The language [Groovy] integrates with existing Java classes and libraries, which makes it easy for Java developers to learn it.” Muschko stresses. “Not only does Groovy build upon the strengths of Java, it also provides powerful programming features inspired by those of Ruby, Python, and others. Groovy can be used as a scripting language without having to compile the code. Alternatively, Groovy code can be compiled to Java bytecode.” (Both approaches are used in the book.)

“Gradle’s core functionality is built with Java,” Muschko points out. “On top of this functionality sits a domain-specific language (DSL) written in the dynamic programming language Groovy. When writing a Gradle build script, you automatically use the language constructs exposed by this DSL to express the desired build instructions. Gradle build scripts are executable Groovy scripts, but they can’t be run by the Groovy runtime. When the need to implement custom logic arises, you can use Groovy’s language features to build out the desired functionality directly in the Gradle build script.”

Gradle in Action uses some Groovy in most of its code examples. But you are not expected to have experience with that language. Instead, Muschko gradually introduces Groovy and shows how it is used in the build processes, while keeping the book’s focus on Gradle and Gradle’s advantages over Maven and Ant (with Ivy). (You can run many of the book’s code examples from the Gradle command line and also, as I did, try out some of the Groovy code snippets using Groovy’s console. And Chapter 10 describes Gradle’s IDE plug-ins for Eclipse and NetBeans.)

“This book is primarily for developers and build automation engineers who want to implement a repeatable build that’s easy to read and extend,” Muschko says.

Muschko’s book is organized into three parts:

  • Part 1, Introducing Gradle
  • Part 2, Mastering the Fundamentals
  • Part 3, From Build to Deployment.

Part 1 includes an introduction to project automation and illustrates the differences in how builds are put together in Maven, Ant, and Gradle. It also shows how to write and execute a simple Gradle script, run Gradle on the command line, and build a Gradle project by example.

Part 2 delves into more advanced topics such as dependency management, testing an application with Gradle, extending a build with plugins, and other subjects, such as multiproject builds. It also digs deeper into testing, Gradle’s extension mechanism, and “how to translate existing build logic from one tool to another, identify integration points, and depict migration strategies.”

Part 3  emphasizes how to use Gradle in deployment. “In times of increased pressure to deliver software quickly and frequently,” Muschko writes, “automating the deployment and release process is extremely important. In part 3, you’ll learn how to use Gradle to its fullest in the context of continuous delivery.”

Meanwhile, Appendix A provides a closer look at how to use Gradle’s Command Line Interface, while Appendix B, titled “Groovy for Gradle users,” provides an introduction to what the author terms “Groovy’s most important language features,” with recommendations to help you learn more Groovy on your own. 

“For years, builds had the simple requirements of compiling and packaging software,” Muschko says. “But the landscape of modern software development has changed, and so have the needs for build automation. Today, projects involve large and diverse software stacks, incorporate multiple programming languages, and apply a broad spectrum of testing strategies. With the
rise of agile practices, builds have to support early integration of code as well as frequent and easy delivery to test and production environments. Established build tools continuously fall short in meeting these goals in a simple but customizable fashion.”

So, will it be Gradle to the rescue? In some settings, perhaps yes. In other environments, you may need to know how to use Maven, Ant and Gradle, plus some other build tools. And in still other work settings, the powers that be may insist on Maven or Ant or something else.

In any case, if you work with Java software builds, you may want to consider learning Gradle (and, by default, some Groovy, too). If so, give serious consideration to Benjamin Muschko’s excellent new how-to book.  In its foreword, Hans Dockter, the founder of Gradle and Gradleware, terms Gradle in Action “the authoritative guide.”

Si Dunn

Rapid Android Development – Using Processing to build apps fast – #programming #bookreview

Rapid Android Development

Build Rich, Sensor-Based Applications with Processing
Daniel Sauter
(Pragmatic Bookshelfpaperback)

The main goal of Daniel Sauter’s nicely written new book is to help you learn “how to develop interactive, sensor-based Android apps” quickly.

At first glance, you may question how “quickly” you can go through 13 chapters with a total of 363 pages, including the index.

But there’s good news here, particularly if you are not a patient programmer. The book is divided into five parts, all structured to serve as “self-contained mini-courses.” And the author has geared his text toward six semi-specific categories of readers.

Sauter, by the way, is an artist and educator with some eight years’ experience teaching Processing. Processing is a free “award-winning, graphics-savvy” programming language and development environment that can be used to work with Android devices and software.

Let’s go to the six reader categories first. Rapid Android Development is aimed at:

  1. Readers with at least “a basic understanding of programming concepts….”
  2. Intermediate Processing users “looking to create Android apps from within the Processing IDE….”
  3. “Educators who teach courses on mobile technologies” and need “a free tool that does not require developer licenses or subscriptions.”
  4. Java and Android developers who want to use Processing to leverage “a host of libraries for productivity gains.” (Java developers will quickly see that Processing builds on Java.)
  5. JavaScript and Web developers who want to use Processing.js syntax to help them create “JavaScript-powered web applications that can run inside browsers without plugins or other modifications. Processing.js also takes advantage of WebGL hardware acceleration.”
  6. Arduino users and hobbyists, particularly those “interested in adapting Android phones or tablets for use as sensing devices, controllers, or graphics processors.”

Now let’s look at the five parts of Rapid Android Development.

  • Part I focuses on installing Processing and the Android SDK but also looks at touch screens and Android sensors and cameras.
  • Part II is devoted to “working with the camera and location devices found on most Androids.”
  • Part III’s emphasis is on peer-to-peer networking, including Wi-Fi, Bluetooth and Wi-Fi Direct, plus Near Field Communication (NFC), which is “expected to revolutionize the point-of-sale industry,” Sauter notes.
  • Part IV “deals with data and storage,” he adds, “as all advanced apps require some sort of data storage and retrieval to keep user data up-to-date.”
  • Part V examines 3D graphics and cross-platform apps.

You will need several software tools and at least one Android device to work with the code examples in this book. (The book lists several Android phones and tablets that have been tested with the code examples, which are available online.)

If you want to do some work in Part III, you will need at least two Android devices (so your peer can have a peer). And if you have absolutely no programming experience, you should get some first. Sauter, an associate professor of New Media art at the University of Illinois–Chicago School of Art and Design, offers some suggestions for good sources.

His new book seems a bit light on illustrations. But its well-displayed, well-explained code examples and clear how-to paragraphs keep the reader moving and making progress.

If you are a creative coder looking for some new skills, projects and challenges, check out Rapid Android Development, ASAP.

Si Dunn