Book Review for 'Hands-On Cloud Development with Wildfly'

This is a nice book that gives a high-level explanation of a multitude of tools used in modern cloud development. 

The book starts with a history of Enterprise Java Development, then turns to Wildfly Swarm.  Swarm is the JBoss equivalent of Spring Boot, allowing developers to choose the Java components required ala carte instead of coming packaged in an all-in-one application server.

The next stop is at Arquillian, which makes unit-testing of Enterprise Java applications practical. 

In all of these cases, the depth of instruction is restrained.  You aren't given enough material to master the topics, just enough to run a working example.  This is good technique for a book that targets a wide tech footprint.

The next chapter introduces cloud computing and Red Hat's OpenShift container operating framework.  This chapter covers a lot of territory, introducing  hot topics like Docker and Kubernetes along the way.  If you aren't yet caught up in cloud development, this chapter will be very valuable for you.

The next few chapters cover some necessary topics for cloud computing, namely storage and networking.  Invaluable also.

The book next moves on to Jenkins, token-based security (as used in cloud solutions) and some application development sugar (in the form of Hystrix.  At the time of this review, Hystrix is under assailment from other tools and looks like it may not be the long-term winner.)

The final chapter makes some predictions about possible future directions.

All things considered, this is a book with a very ambitious tech footprint.  It does a pretty good job of covering all of the above (some pretty important topics) while giving the reader a fair amount of hands-on practical experience.

For coders on the front-side of the cloud computing slope, I'd recommend this book.  It's a shortcut to contemporary development knowledge.




The book can be found here and here.

Happy coding!

Book Review for "Mastering Embedded Linux Programming"

Book Review for "Mastering Embedded Linux Programming"

Are you interested in Embedded Programming?  Are you a Linux programmer interested in expanding your horizons?  If so, this book might be one you'd be interested in.

Packt Publishing categorizes books by depth, this one is in the 'Mastering' category.  That means the book does not teach to a beginning level, the author can assume the reader has the fundamentals developed already.  If you are new to Linux programming, this is probably not going to be an easy read for you.

The author leads the reader through selection of the necessary tools, then launches into the nitty-gritty low-level material an embedded coder will need.  Bootloaders, kernel details, working with a root file filesystem and device drivers are all discussed.  There are chapters on the Linux init/systemd mechanisms, processes and threads, and memory management.  Development issues are GDB, profiling and tracing are provided.  The final chapter is about real-time programming.

This is a big book, nearly 400 pages.  The material is clearly presented, the explanations are understandable.  The author clearly has deep expertise in the subject matter and is good about sharing the knowledge.

The verdict?  If you are interested in programming embedded devices for Linux, this book probably has a place in your library.




The book can be found here.

Happy coding!

Book Review for "Learning OpenStack" by Packt Publishing

Book review for "Learning OpenStack" by Packt Publishing

I'm going to jump right to the conclusion for those in a hurry: If you are new to OpenStack and seek a book that lays out very clearly how to get up and running, this book is for you.  It's clear, concise and informative.  The components of OpenStack are briefly, but adequately described.  It's a good book.

If you haven't heard of OpenStack before:  OpenStack is an open-source software platform for cloud-computing, mostly deployed as an infrastructure-as-a-service (IaaS).  It's backed by many major industry players.  This book is aimed at the entry-level OpenStack user.

The contents, roughly:

Chapter 1 describes why an orchestrator is necessary in a good cloud environment.  It compares OpenStack services to AWS equivalents, lists dependencies between components, and outlines a 4 node sample.  It also lists the various components of OpenStack and lists what they do.  As you'll see, these components are then covered in detail in the chapters that immediately rollow.

Chapter 2 covers Keystone, the Authentication and Authorization component.

Chapter 3 - Data storage with Swift, Glance and Cinder

Chapter 4 - Nova cloud fabric controller

Chapter 5 - Networking with Neutron

Chapter 6 - The OpenShift Portal. 

Chapter 7 - Using Openstack.  This includes adding users, making a project, mapping users to roles, adding a network and adding vms.  It provides an outline of how everything works (which services are called, for which purpose) as OpenStack operates.

Chapter 8 - Building on the cloud with Heat and Ceilometer.  Heat is an orchestration engine, it can be scripted.  Ceilometer is a metering system that collects usage statistics, it can be used for billing.

Chapter 9 - Titled "Looking ahead", it compares OpenStack offerings from different vendors, lists pros and cons of each.

There is an appendix, it compares different release versions of OpenStack.  Installation and Configuration tips for different versions.

The book is adequately illustrated.  Diagrams are simple and convey good information about the major components of OpenStack.

The book provides very plain step-by-step instructions on how to install and configure OpenStack, without being too dry. 

All things considered, I'd call this book a very good resource for those learning to use OpenStack.

The book can be found here.

Happy Cloud computing!

Book Review for "Hybrid Cloud Management with Red Hat CloudForms"

'CloudForms' is Red Hat's tooling for cloud management.  The product provides simple and intuitive web UIs for setting up a hybrid cloud and running it. 

A hybrid cloud is made up of public and private components.  This book explains the various components you will need to work with, and how they are manipulated through the UI.  Examples:  'Cloud Providers' would include Amazon EC2 and OpenStack.  A 'Virtualization Provider' would be VMWare.  These concepts are explained, and you are given instructions how to set up and maintain your cloud environment.

The book takes you from installation, through configuration, and into maintenance of the environment.  You are shown how to provision machine instances from the framework you have configured.  You are given instructions on how machine lifecycles can be managed through hooks, and how automation can be introduced. 

Cloud Forms provides Policies, Events and Actions as a means of maintaining the working environment, these are explained.  You are given tips on monitoring your cloud.  There is a chapter on optimization of your hybrid cloud, and lastly you are informed about the APIs (REST and SOAP) provided by Cloud Forms.

Overall, this book is clear and informative.  I wish it had a little more conceptual information about some of the described constructs, but this is a small nit.  There are plenty of screen shots, the book makes it clear how you are to accomplish various tasks.  The layout is well-organized, the chapters are presented in a logical order.

What's the verdict?  If you have reasonable linux administration skills and you wish to begin configuring a hybrid cloud, this book will be a good place to start. 

The book can be found here.

Happy Cloud Hopping!

Book Review for "Mastering Apache Maven 3"

There's been a 'build tool' war in the Java community for many years.  On one side are fans of Ant, the original Java script-and-build toolkit.  On the other side are users of Maven, a newer kit with an emphasis on dependency management and a predefined lifecycle.  The battle has been waged fiercely for quite a while.

It looks to me as if the Maven side has taken the upper hand.  I try to be pragmatic about such things, but must admit that I have had some difficult times with Maven.  For simple projects (based on examples from the internet, called archetypes) it's a great tool.  But Maven is a two-edged sword:  For every simple archetype I've benefited from, I've had a more complicated project that caused me some problem that required hours of research to solve or at least the rebuilding of my local repository.  Maven can be somewhat mysterious at inopportune times.

Maven also has a giant appetite for artifacts it pulls from the internet.  Pull any Maven-based open source project onto your machine some time and kick off a build cycle.  If it's any kind of project at all, you'll be horrified by the number or things Maven fetches from the internet.  (Ant most likely would have referred to a /lib directory that had everything cached for you.  But there are pros and cons to this.) 

Given this situation, I was delighted to lay hands on a copy of "Mastering Apache Maven 3" so I could learn more about this build monster.  I was not disappointed.

The book covers a lot of ground.  You are given knowledge of how the build cycle works and definitions for all the involved terminology ("Mojo", "plugin", "phase", "lifecycle", "assembly", etc.)  Different chapters are devoted to some of the things I always thought would be cool to understand:  Writing plugins, associating them with a given part of the build cycle, writing my own archetype, setting up a Nexus repository, etc. It turns out Maven is really a framework for running arbitrary code plugins-- cool!  Pretty much every question I had about Maven is at least touched upon in this book.  The author gives us decent examples of not only how to configure Maven, but also how to extend it.  I thought this was excellent.

If the book has a shortcoming, it would be that it's a little low on illustrations.   Reading page after page about a build tool (with accompanying configuration XML!) can be tedious.  Just a few stick drawings or sequence diagrams would have gone a long way towards helping the reader get immediate context about what is being discussed. That's about the only harsh criticism I have for this book.  For the most part, it's a very good book and will no doubt be one I'll reach for on occasion as I battle Maven in my day-to-day duties.

To summarize:

• Who would I recommend this book for?  
• Any enterprise Java developer.  
• Is it a great book?  
• It's not a page turner, but it's likely to be a treasured resource.  
• Will it stay relevant for long?  
• Given the length of the Ant/Maven battle, I'd guess a very long time.  
  

I consider this book a welcome addition to my tech library.

The book can be found here. 

Happy Building!

Book Review for "Mastering Java Server Faces 2.2"

Book Review for "Mastering Java Server Faces 2.2"



Quick Version:  This book contains a lot of advice distilled from a wide range of JSF usages.  It's a big book and offers a lot of ideas that will be valuable to the JSF practitioner.  There is more intermediate-to-advanced material than there is low-level, so if you're just starting out this might not be the right book for you.  Experienced JSF users will find this a good resource.

This is a big book (nearly 550 pages) and it offers lots of good advice for JSF users.  The chapter titles are as follows:

1.  Dynamic Access to JSF Application Data through Expression Language (EL 3.0)
2.  Communication in JSF
3.  JSF Scopes – Lifespan and Use in Managed Beans Communication
4.  JSF Configurations Using XML Files and Annotations – Part 1
5.  JSF Configurations Using XML Files and Annotations – Part 2
6.  Working with Tabular Data
7.  JSF and AJAX
8.  JSF 2.2 – HTML5 and Upload
9.  JSF State Management
10. JSF Custom Components
11. JSF 2.2 Resource Library Contracts – Themes
12. Facelets Templating
Appendix - The JSF Life Cycle

The author makes occasional mention of different JSF implementations (PrimeFaces, MyFaces, Mojarra) which might be of value to users that are familiar to one implementation or the other.  There is some introductory material (the chapters on data access, configuration, the Life Cycle, etc.) but these are not presented in an order that provides a comprehensive overview at the start of the book.

Examples are well constructed and consistent in the way they are put together.  For any particular goal (i.e. making some tabular data, working with a template, using AJAX, etc.) the user will most likely find a clean set of code artifacts that illustrate things in a comprehensible way.  Wording that differently-- the examples are minimal and easy to understand.

The book has a fair number of illustrations, but these mostly reflect renderings of JSF pages.  Conceptual illustrations are provided, but not in great abundance.  I give the book fair marks for this, but not outstanding.  IMHO a few more high-level illustrations would have been beneficial.  (In the author's defense, it's possible some were left out to keep the book as lean as possible.  As it stands, it's already a big book.)

The author does a good job of explaining how to exploit features of JSF to accomplish tasks of interest for a JSF developer.  The author speaks in a clear and direct manner, lending confidence to the suggested remedies for various situations.  I believe this book will be a good reference for the JSF coder. 

Packt uses a visual icon (it looks like a pencil and a few sheets of paper) to indicate warnings or important notes.  These are generously provided throughout the book.  I found use of this highlighting aid to be judiciously used-- not too much, not too little.

All things considered I found this book to be a solid reference for JSF topics and informative in it's description of new JSF features.  For the intermediate-to-advanced JSF user it should prove to be a valuable resource.

The book can be found here.

Happy Reading and Rendering!

Book Review for "Wildfly Performance Tuning" by Packt Publishing

Book Review for "Wildfly Performance Tuning" by Packt Publishing





This book focuses on the latest iteration of the JBoss JEE server, Wildfly.  Like many performance books, it offers advice that applies to performance in general, JEE specifically, and a particular technology (Wildfly) especially.

The first three chapters deal with methodology for performance tuning, tools of the trade (especially open source tools), and JVM tuning.  The first chapter contains material that will be largely familiar to anyone who's done much tuning in the past, but is good for those who are new to the discipline.  The second chapter outlines tools that will likewise be familiar to most experienced tuners.  There are some good tips here.  The third chapter explains JVM tuning, advice of this type seems to have a very limited shelf life.  Combined, these three chapters make for a good background for Java tuning.

The next six chapters deal with Wildfly.  They introduce the server in general, then specifically address EJBs, Persistence/JPA, Web Container (Undertow), Web Applications and Web Services (to include REST), and JMS.  These chapters include some really good expert-level tips.  If you are a user of Wildfly (or the product version, Red Hat's EAP) then these chapters alone will probably make the book a worthwhile purchase.  There's some good advice here for users of other JEE servers, but the real value here is for JBoss users.

Note:  Wildfly is the 'upstream' version of the JBoss JEE server.  After this server has undergone community testing and feedback, it will then enter the 'Productization' phase where Red Hat professional developers and QE testers iterate over the codebase before packaging it for commercial use.  For this reason, this book is a good look 'forward' for Red Hat JBoss EAP users.  The tips and descriptions in these six chapters describe the near future for EAP users, the present for Wildfly users.

The final chapter covers Wildfly clustering.  Like the previous Wildfly-centric chapters, there is some introductory material that will help the new user to understand the purpose of the feature and how it is used.  After that, tips specific to performance tuning are given.

I thought the book was very strong from a technical standpoint.  Users of Wildfly (future EAP) will be quite pleased with the insights the authors bring.  The advice is solid.

IMHO, the book could have used more illustration in the middle chapters.  The authors offered some good technical advice about Wildfly, and conversations of this type almost always benefit from coarse-grained illustrations that assure the reader they are grasping the concepts presented.  This fault isn't found throughout the book-- for instance, the clustering chapter is generously illustrated.  Maybe the authors were short on space, the book is over 300 pages as it is. 

All things considered, I'd recommend this book for any Wildfly / EAP user.  Users of other JEE servers (WebSphere, WebLogic) might consider it, but won't get the same bang for the buck.  Users of JEE in general should benefit strongly from the first chapters with incremental value added over the final chapters.

The book can be found here.

Happy (Performant) reading!

Video Series Review: "Pentaho Reporting"

Do you sometimes have a need to produce reports?  I surely have!  No matter how technical my job, it seems I've always had a need to demonstrate trends, provide information, help sell some idea.  For all of these, reports are called for.  This review is about a tool that can help you when you need to write slick, professional reports.  That tool is Pentaho Reporting.

If you're like me, you may know Pentaho as the "Kettle company".  Kettle is an open source ETL engine, and it is very useful.  If you work with batch data, you probably ought to have a look at Kettle soon if you haven't done so already.  It really is slick.

This video series mostly involves the "Pentaho Reporting" tool, though.  The video series is broken up into 8 chapters, each composed of some number of sub-units (3 or 4 seems about average).  The runtime for each video is very reasonable, usually 5 minutes or a little longer.  The moderator's voice is pleasant and proper.  The pace of presentation seems about right.

The contents of each section are presented logically.  The highlights:

Lesson 1
Installation.  Opening, saving reports.  Making PDF, etc.
Making a report using a Wizard
Adding database drivers, defining a report from scratch (no wizard)
Customizing a report (headers, grouping, adding graphics, etc.)

Lesson 2
Setting up Eclipse/Tomcat.  Embedding a report in a servlet.  Embedding in a Swing app.  Compressed reports, writing reports through a Java API.


Lesson 3
Configuring the JDBC data sources
Configuring data sources for OLAP engines, XML, Pentaho Kettle, etc.

Lesson 4
Charts and illustrations

Lesson 5
Parameters in reports.  Limiting query results by parameter, specifying this parameter from the Java API. 
Functions and expressions.  Summarizing groups and making totals.  Showing page numbers in footers.

Lesson 6
Subreports and Cross-tab reports (i.e. a report that shows totals by month). 
How to enable this experimental feature.
 
Lesson 7
Java API to capture events (with a listener), links and mouse events.
HTML reports with interactive links, firing interactive javascript, tying formulas to a button, manipulating the HTML DOM.

Lesson 8
Using Pentaho Reporting with Pentaho Business Itelligence Server.
Setting up the server.  Managing users, roles, scheduling reports.  Setting up automatic emailing of scheduled rpts.
Pentaho Data Integration ('Kettle').  Setting up a small Transformation that kicks off a Reporting job.  Including the Transformation in a Job.  Running the Job both from the IDE and command line.

Does that sound like a lot?  It is a lot to learn!  But fortunately, much of it is intuitive once you see the general way of doing things.  I built some reports along the way, to validate my understanding of what I was seeing.  It's easy once you get going!  Pentaho Reporting also seems like a very capable tool.

So, what's the end verdict?  I highly recommend this video series to anyone tasked with writing reports.  It really does make learning the tool easy, and the video series can be used as a reference if you're already going with Pentaho Reporting.  Watching the videos is painless and relatively quick.  It's hard to think of a downside for this series.

The videos can be found here.

Happy Reporting!

Now Under Review: Video Series on JBoss EAP

Readers of this blog are used to finding book reviews for programming materials here.  Today I am trying something new-- a technical video review.




The video series is over some familiar territory-- JBoss EAP Configuration, Administration and Deployment.  I've started watching today and should have a review out in the near future.

Watch this space for my impression of this medium soon.

The Video can be found here.

Book Review for "JBoss EAP6 High Availability"

JEE servers are all about "Enterprise" functionality.  A big part of the value proposition is High Availability, meaning you can harden your servers so a failure won't deprive your clients of the ability to make use of your services.  This book covers High Availability for the most recent version of Red Hat's commercial server, EAP 6.

The book is written in a very clear, well-illustrated manner that explains very plainly how to achieve load balancing and failover with EAP 6.  The early chapters explain how to obtain and set up the JBoss App Server, which is advantageous if you haven't looked at the server lately.  (It underwent a major re-write since the old 'heavy server' days.)  The methods used to deploy applications have changed too, so these are also explained.

The third chapter is where clustering begins.  This leads us to the only demerit apparent for this book:  it's scope is constrained to web-tier clustering.  (This means other clustering aspects, like messaging clustering and EJB clustering go undescribed.)  The coverage it provides within it's scope is outstanding.  You are given very explicit (and easy to understand) instructions on how to test and validate your cluster.

Web-tier clustering means you need a load balancer, and this book covers two of these well.  Both of these are hosted in Apache httpd, so it is also covered from acquisition, compilation, configuration and validation points of view.  (To repeat that:  if you know absolutely nothing about httpd, this book will show you how to get it, compile it, and run it.)  Once httpd is in place, you are given detailed coverage of mod_jk and mod_cluster, two load balancers that plug into httpd.  Both are described simply and thoroughly.

There are two chapters for SSL, these again give you everything you need from A to Z.  The author describes certificates, how they are used, how you can produce one, and how to configure your cluster to use it.  Your efforts are validated through use of tools like WireShark (naturally, we are shown how to use WireShark to do this.)  There isn't much left for the user to wonder about-- thorough, well-illustrated coverage is the order of the day.

The final chapter of the book describes JEE applications that are built for clustering.  Not much exciting here, JEE makes it pretty easy.

The book has a good number of illustrations.  These are simple and clear, exactly the kind of thing a knowledgeable colleague might sketch on a whiteboard.  Except the lines are all perfect.

The final verdict?  This is a really good book.  The author has a knack for explaining things clearly and directly.  If you wish to cluster web applications on JBoss EAP 6, this book should be on your shelf.

The book can be found here.

Happy Clustering!

Book Review for "Java Performance, the Definitive Guide"

Book Review for "Java Performance, the Definitive Guide"







Subtitle:  "Getting the most out of your code"

State:  "Early Release.  Raw and Unedited"

As the title tells, this book is ambitious in scope.  Calling something 'The Definitive Guide' is a bit presumptuous, but the author (Scott Oaks) has credentials to match anyone in the workspace.  This book is in 'Raw and Unedited' form, which means it's not yet a finished work.

So, what's here?

The first chapter outlines the target platform (Java 7), JVM tuning flags, and some very general best practices for obtaining good performance.  Not much deep-dive material here.

Chapter 2 categorizes types of benchmarks and provides different things to measure.  I found this chapter a little long on the academics, probably more applicable to professional testers than it is to garden-variety application developers.  All things considered, not my favorite chapter.

Chapter 3 covers the Java performance tester's toolkit.  It contains a good overview of tools provided by the operating system (including many for Linux).  The Java monitoring section tells us what the JVM can tell us about itself.  There's a meaty section on profilers, and finally a section on a propietary tool Oracle provides to users that choose to pay for Java 7.  This chapter held quite a few items of interest for me.

Chapter 4 was devoted to the Just-In-Time compiler.  JIT is of great importance to Java performance, and this chapter provides a wealth of information that could only come from those with very deep knowledge.  In the 'acknowledgements' section of the book the author tells us he used inside contacts at Sun/Oracle to pull this book together, it would have to be these kinds of people that assisted here.  Good stuff.

The 5th chapter is about Garbage Collection and Garbage Collectors.  This information seems to change frequently as Java updates, so the value of this chapter might be perishable.  This information is also similar to material that's readily available all over the internet, so it didn't grab my attention like the previous chapters.

The final verdict:  For a work in progress, I found this book to be rich in good content and fairly refined for the 'raw' label.  For those seeking improved Java performance, it's a worthwhile read.  I look forward to seeing the completed product.

The book can be seen here.

Happy (Performant) Coding!

Book Review for "Drools JBoss Rules 5.x Developer's Guide"

Book Review for "Drools JBoss Rules 5.x Developer's Guide"

Do you have an interest in Rule Engines?  Rule Engines have long promised to relieve the programmer of maintenance tasks, to bridge the gap between business user and developer.  This book covers JBoss's rule engine (Drools) from the Developer's view. 

Drools has expanded beyond it's roots as a rule engine and now offers additional functionality like business process management and complex event processing.  (For those not familiar, BPM used to be called 'workflow'-- it means state management for long-running business processes.)  CEP deals with detecting conditions in windows of time.  For instance, detecting when a specific stock begins trading at discounted prices over a sliding 10 minute timeframe.  These features (and more) are available with Drools, many are explained in this book.

By the way, if this book sounds somewhat familiar, it's probably because it's a refresh of the same title targeted towards Drools 5.0.  Besides the technical update, there seem to be many small adjustments made to increase readability.  If you've seen the first book, you'll want to see this one.

The author goes over the basics of business rules in the first chapters.  What a rule engine is, how to use Drools, how to write rules and how to make Domain Specific Languages (DSLs) are all explained.

Central chapters explain some viable use cases for a rule engine-- data validation and transformation.  The author provides example scenarios and the rule artifacts needed for the tasks. Through these chapters, additional material about use of Drools is covered.

Later chapters cover testing and application construction.  There are a surprising number of nuances to integrating business logic engines into enterprise applications, so this chapter will be of special interest to users who are working to integrate with enterprise frameworks.

Finally, there are some appendices which provide details about setting things up and the sample applications.

All things considered, this book has over 300 pages of valuable content for those interested in using the powerful features of the Drools.  If you are a Drools user, you probably owe it to yourself to have a look.

The book can be found here.




Happy (Rule-style) coding!

The latest Drools / JBoss Rules book - Review here soon

Do you have an interest in Drools / JBoss Rules?  There's a new title on this compelling technology from Packt Publishing. 







The book can be found here.  Watch this space for a review soon.

A happy 2014 to you and your family.

Book Review for "Java EE 7 First Look"

Book Review for Java EE 7 First Look




This is a nice read for the Enterprise Java developer.  It covers the changes that have been introduced with JEE 7, but it does it in such a way that the reader does not need to be an expert in JEE already.  That's a good thing, because JEE encompasses a lot.

Enterprise Java is a very broad topic.  From Web Services to JMS, from Servlets to Batch, from EJBs to CDI.  To even experienced Java developers, a lot of this can be acronym soup.  I would imagine most developers use a few parts of JEE frequently, and the rest infrequently.  This book is nice in that it gives simple examples for a lot of JEE, so if you're in an unfamiliar territory you can learn the very basics easily.  If you already have the basics, the book's main mission is to tell you what's new.  The author goes to the JSR specs for these, which is the right place to determine what's new.

The book explains what has changed across the JEE container for JEE 7.  (I won't go into great detail here, because there will be a link at the end of this review that will take you to the book's table of contents.  The TOC will tell you more than I would care to copy.  I'll use my words to try to explain what's of value in the book.)  The author first explains a little about the overall use of that part of JEE (i.e. why you might use a servlet, or an EJB, etc.)  The author usually then gives a simple overview of the 'old' (i.e. most simple) way to leverage that part of JEE.  Next he'll show you the new-fangled changes that came with JEE 7, which can step up your knowledge of the topic.  It's all written in an easy tone, a very easy read.

Ok, for those too lazy to read the TOC here's a quick view of part of what you get:  Servlets, JSF, EL, JPA, EJB, JMS, Jax-RS, CDI, Validators and Interceptors, and Security (JASPIC). 

The author (who does a great job throughout most of the book) chose to use GlassFish as an example JEE container.  That's a fair choice, but I would have preferred WildFly.  (Disclaimer:  I work for Red Hat.)  Still, the book does a good job of explaining Application Server configuration where it's needed.

Summarizing, who is this book good for?  I'd call this book a good refresher for anyone who uses JEE to develop their Enterprise applications.  It will get you a quick start for unfamiliar parts of the AS stack, and will show you what's new for all of JEE.






The book can be found here.

Happy Reading!

Book Review for "RESTful Java with JAX-RS 2.0, Second Edition"

This book covers Jax-RS in great detail.  It's a big book, nearly 400 pages and all of it densely populated with information.  The author (who is the lead for JBoss's Jax-RS implementation) has comprehensive knowledge of the topic, and puts this knowledge into easily transferable form.  All things considered, this is an excellent book.

The book is divided into two parts, which I think of as "theory" and "practice".

The first half of the book starts with an introduction to REST and HTTP, then gives an overview of how RESTful architecture can be applied to a typical application.   These chapters are followed by explanations of the Jax-RS spec and how the various components are used.

There's a great deal of information here, some of the topics covered include basic service construction, extraction of information from an HTTP request, Jax-RS Injection, Exception Handling, client API, filters and interceptors, and more.  There are some especially handy chapters on security, deployment and integration.  These tell you how your RESTful applications should be packaged, deployed and protected in their runtime environment.

The second half of the book is a 'workbook' that includes examples that correlate to the chapters in the first half of the book.  These are well explained (including basics of Maven) and discuss both server and client components as needed.

Together, these components provide a detailed explanation of Jax-RS and it's entire ecosystem.  The book will serve equally well as an introduction and as a reference.  (Did I mention it's comprehensive?) 

Final words:  If you have an interest in Jax-RS, this book should be on your must-have list.  It explains the hows and whys and will take you from your first RESTful service through nearly any real-world use case.

Disclaimer:  I work for the same company as this book's author, Bill Burke.  I have no reservations about giving this book a 'good' review, as I am confident any objective reader will likely agree.

The book can be found here.

Happy RESTing!

Getting up to speed with JEE 7

 

Like many Enterprise Java programmers, a big part of my job is simply staying current with the JEE spec.  The application server is constantly evolving, adding new features, and getting easier to use-- provided you stay current with the programming model.  Failing to stay current means you'll one day look at some JEE artifacts and wonder what exactly it is that you are looking at.

It's about time for me to have a look at the latest JEE spec (JEE 7) so I can be prepared for what's ahead.  (Wildfly 8, the successor to the old JBoss Application Server, is already there so I have a nice server I can learn with.) 

The vehicle for my continuing education is a new title from Packt Publishing titled "Java EE 7 First Look".  The book seems promising, it's around 150 pages and appears at first blush to have a reasonable number of clean code samples and legible diagrams.  (I *love* diagrams.)  I'll start reading soon and will report my findings here.

If you're too anxious for the review, you can have a look already here.

Happy pre-Holiday slowdown!

Book Review for "Developing RESTful Services with JAX-RS 2.0, WebSockets, and JSON"

I've just finished reading "Developing RESTful Services with JAX-RS 2.0, WebSockets, and JSON" from Packt Publishing.  It's an interesting book, mostly because the authors provide plenty of context around the technical explanations and give a good overview of the covered technologies. 

WebSockets and Server Side Events are two new features provided with JEE 7 that will allow you to develop client (browser) / server applications that benefit from server side 'push' communications.  This book explains both of these, also the previous generation answers to this problem (Polling, Long Polling) and examples of all of these.  Throughout the book, sensible diagrams are provided that help the reader understand things.  Truly, a picture is worth 1,000 words.  Too many technical books fail to provide enough useful illustrations, I'm pleased to report this book is not one of them.

Ancillary features (i.e. Bean Validation) are given coverage.  The authors spent an appropriate amount of time on these-- where things don't require a lot of text, not a lot is given.  By the way, the whole book is just a little over 100 pages, so it's not a long read.  But those 100 pages are generally well written ones, so this book still represents good value.

REST is also explained, including the new client API.  REST seems to be picking up steam, so if you're not well versed in it yet you might have a look at this book for that purpose.  Hand in hand with REST goes JSON, and this book also explains how you can produce and consume JSON documents in Java.

All things considered, this book is a good, targeted resource that delivers on it's promise.  I imagine I'll be using it as a reference resource from time to time.



The book can be found here.

Happy (RESTful) Reading!