It's a thorough treatment of Spring 5. I picked it up to participate in a book club at work, but said book club sorta fizzled out after a while. (No oIt's a thorough treatment of Spring 5. I picked it up to participate in a book club at work, but said book club sorta fizzled out after a while. (No one's fault; even Coronavirus couldn't stop our momentum on Effective Java -- alas! this one here...)
ANYWAY: I'm pumping the brakes on this one because of the aforementioned book club going on hiatus. That said, a few thoughts:
FIRST: It's a worthy recommendation. I don't know that this will get you up-and-running with Spring fast necessarily -- but it WILL help you get a pretty thorough understanding of what the framework(s?) is doing, and how to apply it, and WHY to use it vs. "traditional" Java programming methods.
SECOND: and maybe this is just me but -- part of the reason I picked it up and decided to participate in the book club was to get a deeper understanding of Spring itself. And the authors do a good job of laying out concrete cases for why you would want to use Spring as opposed to [FILL IN THE BLANK "TRADITIONAL" JAVA PROGRAMMING METHOD]. But that said -- I've been using Spring for so long (without a specific focused study of it) that I was like: "Why would you do this any OTHER way?" And so on that note, I kept thinking: "Half of this chapter can get cut, because I really don't need the hard sell here."
THIRD: In its effort to be exhaustive (i.e., show us ALL that Spring has to offer!) I wound up finding myself glossing over large chunks. With the team I'm on now (and teams I've historically been on) -- we definitely prefer the in-code DI with annotations and Java config files etc. So seeing all the discussion of setting stuff up with XML was tedious to say the least.
FOURTH: I will be finishing this one eventually. But for now I'm much more likely to skip around in it, and opportunistically pick off the parts that I need to know more about, without necessarily making a linear study of every last little bit. (For example: I can just skip RIGHT OVER all the task scheduling stuff for the foreseeable future...)...more
Recommended for anyone who is doing full time professional Java development. Bloch well-codifies a lot of the otherwise cargo-culted tribal knowledge Recommended for anyone who is doing full time professional Java development. Bloch well-codifies a lot of the otherwise cargo-culted tribal knowledge and conventions that are out there, as well as shedding light on many of the weird cases that we run into everyday. And/but/so then there's a bunch of items that are NOT a part of my everyday ... though I'm sure that's just a matter of circumstance, and for someone out there: they are.
It gets pretty technical in places and by necessity can get into the weeds, but most of the content should be accessible to journeyman developers, as well as committed novices....more
I learned quite a bit about Play, though most of what I learned feels like "guess I need to go learn Scala?" As the3 stars is generous; more like 2.5?
I learned quite a bit about Play, though most of what I learned feels like "guess I need to go learn Scala?" As the title suggests, the book does a pretty good job of laying out the essential parts of Play Framework (the foundational components, tools, and techniques), but I feel like you're only going to get a "scratch the surface" view of Play unless you're already familiar with Scala. Granted: Play also comes in a "plain Java" flavor, and the author includes equivalent examples (where possible) that are in Java, but these wind up feeling more like a distraction -- like you keep context switching.
I really feel like this book could have been made much better by two things:
(1) A quick introduction to Scala -- just like the quick introduction to Groovy that shows up as Chapter 2 of Grails in Action.
(2) Drop the Java examples -- or move them into some kind of appendix. They just feel like they distract from the main point. (And honestly, I just skipped most of them.)
As the book stands right now, it seems like it's a pretty good introduction to Play (again: I learned most of what I was hoping to learn) but it does gloss over some points, and (more importantly) if you don't know Scala, you're probably going to feel a little lost....more
Disclosure: I didn't read it cover-to-cover as I have most other technical books over the past... couple years? (Always?) Regardless: I read the GC biDisclosure: I didn't read it cover-to-cover as I have most other technical books over the past... couple years? (Always?) Regardless: I read the GC bits in-depth and skimmed a lot of the rest of the text. There is a ton of useful information here -- some of it (like the sections on alternate JVM languages [1]) is mostly just for curiosity's sake, but there's also lot of really good stuff about the JVM itself (like the performance tuning bits). With the recent release of Java 8, this book (which was new when Java 7 was new) feels a little bit dated. But only a little bit.
Required reading for anyone doing anything more than just dabbling in the JVM.
Ian Darwin's Java Cookbook is out and it's a great resource for developers working in Java that are out there and scratching their heads asking "How wIan Darwin's Java Cookbook is out and it's a great resource for developers working in Java that are out there and scratching their heads asking "How would I go about...?"
The thing that makes Java Cookbook stand out is its comprehensive scope. Darwin has done an excellent job of gathering a wide array of common problems faced by Java developers and presenting solutions to those problems that are decipherable using just the language's standard library features. (Which isn't to say "ignore libraries" -- just that there are few (any?) recipes in this cookbook that require external dependencies.) By and large, the recipes are practical and are organized into sensible categories. This isn't a book that I'd recommend you read front-to-back, but if you're programming in Java, it's worth having it handy to help kickstart your thought process on a number of different problems. (Plus, 3rd edition has been updated to include solutions that highlight Java 8 features.)
In addition to the above, it's worth noting that while Java Cookbook isn't a great book to learn from, that if you have stumbled your way into Java with an otherwise solid software engineering background, that you could use it as a leg-up or crutch while you're otherwise getting up to speed....more
Short version of what may turn into a longer review:
Overall a good introduction to the Java language and its standard library. I quipped throughout thShort version of what may turn into a longer review:
Overall a good introduction to the Java language and its standard library. I quipped throughout that the book was as verbose as the language, but this is a good-natured jab, especially considering that the authors have done an excellent job in organizing and presenting the material, and in showing good concrete examples.
The book itself covers Java through version 1.7. One of the things that I really appreciated about the text (and have seen mentioned in many other reviews) is that it is not a guide to basic syntax or computer programming fundamentals. There's an assumption coming in that you already know about variables and if statements and for loops etc. They're only talking about things that are specific to Java so as to help you learn idiomatic Java. They also build a really strong case for why Java is a "good" or "productive" language, taking the time to talk about its philosophy, the language design choices, and other underpinnings (e.g., JVM bytecode) -- helping one to understand the why of Java and not just the how. (There's also a pretty sweet glossary in the back to help you get through some of the language's more arcane keywords.)
What didn't I like? A couple things jump out:
(1) Better coverage of the JVM eco-system. I realize that the book is about Java (the language itself) and not "the JVM", and I realize that the book is already 1010 pages long but I could really have used a little more about "the JVM eco-system" and less about Swing. Again, I get it: Swing is part of the core Java platform, and things like Groovy and/or Tomcat are not but... still. I don't know anyone programming in Swing, and we got basically half a chapter on servlets. Maybe that's all it needs but it seems like the biggest part of Java these days is "JVM eco-system" and not "Java by itself".
(2) More on garbage collection. Maybe I'm expecting something too low-level here but we got about... 4 pages (?) worth of coverage on GC. And what we got was basically just an explanation of what GC is. I'm as in the dark as ever about the actual GC settings, Eden, Young and Perm gen, survivors, etc. And "heap" doesn't appear in the index at all?
So I guess... a few more things at the high-level? and a little bit more at the lowest-levels? The former is definitely an expectation on my part that the book doesn't even promise to fulfill, but would have been nice to see a bit more of (though it does have pointers to good resources); the latter just seems like the editor came through and said "let's not go there".
All in all? A worthwhile book for learning the language (if you already have a solid programming and/or CS foundation), and it provides a good layer of "why Java" on top of "how to Java", but expect to use it as a springboard for further learning depending on where your work Java actually takes you. I would recommend it to any competent developer that's looking to add Java to their toolkit.
----
PS - So. Much. Swing. 3 chapters... 148 pages of it. And plenty of references to it in the 2 chapters that follow. And then a chapter on applets. Who does this anymore?
PPS - JavaBeans chapter winds up feeling like tautology. ("The following bean class example is considered a bean because it follows the bean class paradigm." Yay!)...more
Short version: good survey of building modern web apps in the JVM eco-system, and/but more oriented toward Java developers, and hardly enough JS to puShort version: good survey of building modern web apps in the JVM eco-system, and/but more oriented toward Java developers, and hardly enough JS to put it in the title.
Long version: ()
Having just wrapped up Client-Server Web Apps with JavaScript and Java by Casimir Saternos (O'Reilly, 2014), I'd say that I mostly got out of it what I wanted, and that it serves as a good jumping-off point for developers that want to build "modern" web applications on top of the JVM. More than anything else, Saternos' book is a thumbnail sketch of the architecture and tools needed to build those kind of apps, but it does not go particularly deep on any one of those items. As it says in the preface, it's probably best suited for developers who primarily work in Java and want to build a scalable web application with modern technologies -- not that front-end developers don't stand to gain something as well, but they may have more catching up to do (more on this in a moment...).
Saternos' basic approach here is to describe "modern" web applications as RESTful, API-based back-ends that primarily serve JSON to a rich front-end that is built around something like AngularJS. However, he doesn't limit himself to just the API and front-end layers here. Even a glance at the table of contents will reveal that he goes for breadth in his discussion: there are chapters on REST fundamentals and API design, API implementation with tools like Jersey, testing strategies with JUnit and Jasmine, build and deployment tooling, virtualization strategies, and more. The book's coverage is fairly shallow, but Saternos provides many references to other sources for richer coverage, and he also provides sample code with example implementations for each relevant chapter.
Was there anything missing? Yes and no... Again: the book is a shallow survey of these technologies, and as such it elegantly fulfills its main mission: to give an overview of the technologies that you would use when constructing a modern web application in the JVM. And again: there are plenty of references to solid foundational texts for those instances where you need to go deeper on some particular subject. But there are also seem to be some gaps.
First, some front-end developers may feel a bit lost coming into this; working in the JVM can be a bit daunting to the new-comer, and piling dynamic languages on top of this can be a bit eyebrow-raising. Part of me thinks that this is absolutely the right move -- I know a lot of front-end developers that are right at home in Ruby or Python, and so using JRuby or Jython as the introduction to the JVM makes sense. But there are also esoteric complications that come along with that which are not really addressed in the book. Not that a survey such as this is the right place to cover that kind of edge-case trivia, but a footnote to that effect may have been useful.
Second, the chapter on "Packaging and Deployment" focused exclusively on the server side of the web application with no substantive mention of how to package the front-end assets. Where was the discussion of minification and concatenation? Considering the depth of the discussion on REST and HTTP earlier in the book, I would have expected to loop back around on that here for a discussion of CDNs or Expires headers. This seemed like a lost opportunity to me.
In the grand scheme of what Saternos set out to do however, those critiques are pretty minor. That he assumes the reader has more familiarity with the JVM than with front-end technologies is evident, but not a detriment. The book is a good look into what technologies and techniques make up a "modern" web application, and though there is plenty of room for disagreement about some of his recommendations, it is also a great "conversation-starter" for your project, and chances are that you'll learn about a thing or two that you'll want to chase down further.
DISCLOSURE: I received an electronic copy of this book from the publisher in exchange for writing this review....more
I read the online version. (I believe that there only is an online version...) I got enough out of it; enough to get started at least. It is a decent I read the online version. (I believe that there only is an online version...) I got enough out of it; enough to get started at least. It is a decent introduction. By the end of it, you will at least have a good idea of what Maven is and (kind of) how it works; and if you work really hard and pay attention you might also be comfortable saying those things to other people....more
This is probably about as good of a "beginning"-level Java book as any other out there. It's a little bit of a language reference, a little bit of a gThis is probably about as good of a "beginning"-level Java book as any other out there. It's a little bit of a language reference, a little bit of a guided tour, and a little bit of discussion. A little bit dry, but it suits the book's aims. I don't really recommend reading it front-to-back, but if you're new to Java then it's worth at least reading the first 250-ish pages, and then cherry-picking the rest of what you need. (It didn't blow me away, but I'm glad I read it, and it gave me some of the foundational knowledge I needed.)...more
I know what you're thinking... "Why did you read the 4th edition in 2010? It only covers up to Java 1.4 - and it was published 8 years ago." My answerI know what you're thinking... "Why did you read the 4th edition in 2010? It only covers up to Java 1.4 - and it was published 8 years ago." My answer? "It was what my library had. And it covered what I needed to learn."
I suppose I should have known better, considering the O'Reilly "Nutshell" format. A couple hundred pages of "nutshell" overview material to digest some high-level concepts -- but you're wading through generic code samples. Then several hundred more pages of what is basically an index of core API stuff. And so almost all of it makes your eyes glaze over. It isn't bad or badly written; it's that the book has a target audience of which I am not really a member.
Loading...
