| OverviewBruce Tate, author of the Jolt Award-winning
Better, Faster, Lighter Java has an
intriguing notion about the future of Java, and it's causing
some agitation among Java developers. Bruce believes Java
is abandoning its base, and conditions are ripe for an
alternative to emerge.
In Beyond Java, Bruce chronicles the
rise of the most successful language of all time, and then
lays out, in painstaking detail, the compromises the
founders had to make to establish success. Then, he
describes the characteristics of likely successors to Java.
He builds to a rapid and heady climax, presenting
alternative languages and frameworks with productivity and
innovation unmatched in Java. He closes with an evaluation
of the most popular and important programming languages, and
their future role in a world beyond Java.
If you are agree with the book's premise--that Java's reign
is coming to an end--then this book will help you start to
build your skills accordingly. You can download some of the
frameworks discussed and learn a few new languages. This
book will teach you what a new language needs to succeed, so
when things do change, you'll be more prepared. And even if
you think Java is here to stay, you can use the best
techniques from frameworks introduced in this book to
improve what you're doing in Java today.
Editorial Reviews| Book Description | | Bruce Tate, author of the Jolt Award-winning Better, Faster, Lighter Java has an intriguing notion about the future of Java, and it's causing some agitation among Java developers. Bruce believes Java is abandoning its base, and conditions are ripe for an alternative to emerge. In Beyond Java, Bruce chronicles the rise of the most successful language of all time, and then lays out, in painstaking detail, the compromises the founders had to make to establish success. Then, he describes the characteristics of likely successors to Java. He builds to a rapid and heady climax, presenting alternative languages and frameworks with productivity and innovation unmatched in Java. He closes with an evaluation of the most popular and important programming languages, and their future role in a world beyond Java. If you are agree with the book's premise--that Java's reign is coming to an end--then this book will help you start to build your skills accordingly. You can download some of the frameworks discussed and learn a few new languages. This book will teach you what a new language needs to succeed, so when things do change, you'll be more prepared. And even if you think Java is here to stay, you can use the best techniques from frameworks introduced in this book to improve what you're doing in Java today. |
|
Other Readers Also Read | Top Sellers in This Category | Browse Similar Topics | | | Top Level Categories:Sub-Categories: | | | | |
Reader Reviews From Amazon (Ranked by 'Helpfulness') | Average Customer Rating: |  | based on 32 reviews. |
| It will arrive..., 2007-06-26 | | Reviewer rating: |  |
| Bruce wrote this book on 2005 and today (2007) it is as actual as ever.
I am into Java since 2005 (i had 7 years of JScript programming), i've token two SUN certifications (SCJP, SCWCD) and after two years of efforts i found out this: the more i study Java the more i find it lacks something as a programming language.
Believe it or not, Java will soon collapse over more agile, dynamic and (much)simpler languages, no matter how many years it takes, but the judgement day will arrive... |
| | Food for thought, 2007-04-06 | | Reviewer rating: |  |
| This book was a quick and enjoyable read. I think the premise is right on: Java is too complex and has become a hindrance to productivity.
I liked the conversational style of the book. The author makes some good arguments against Java, and provides alternatives. He attempts to make a strong case for Ruby. After reading the book, I will definitely give Ruby a look.
I have several problems with the book:
#1 It is highly repetitive. This is more noticeable because the book and its chapters are very short, so it can be read in one sitting. It doesn't feel like any research went into the book (aside from personal interviews) so the scope is only what the author is most familiar with (ie. he mentions Hibernate/Spring/Tapestry over and over again. He brings up static typing impeding productivity many times over the course of the book...obviously a personal gripe of his.)
#2 It is not an objective analysis. After reading the book, I believe the author to be a Ruby evangelist. In particular, I didn't appreciate a section where the author shows an example of how Ruby outperforms Java. He clarifies by saying the evidence is unscientific (the Java implementation was not tuned for performance.) Well if that is the case, then it doesn't belong in a technical book (from O'Reilly no less.)
The author suggests the possibility of fixing Java, but it strikes me as an obligatory mention. Beyond Java is this author's (well informed) opinion, no more no less. It did not convince me to throw out the Java baby with the bathwater. Nonetheless, it provided some interesting food for thought. |
| | Java's great, but what is next?, 2006-12-24 | | Reviewer rating: |  |
| No doubt about it, Java is king of the hill right now, as of this review, I'm trying to hire 3 Senior Java/J2EE people in Atlanta and I'm not having much luck. Well if that's true then why am I reading a book about what's next after Java?? Bruce spells it out pretty clearly in this book, Java made developers much more productive than C++ developers for about 10 years now, but if you look at accomplishing some simple tasks like sticking a Web UI in front of a database it requires a lot of plumbing and knowledge.
Does it have to be that hard? Not really, he really keys in on Ruby and Ruby on Rails to meet the needs of middle tier, those just trying to get a database driven application in the web. One thing he did not present, but is a big issue driving PHP and Ruby on Rails is how hard putting a Java App is on a shared hosting platform; in fact I gave up and went with Ruby on Rails.
So where does that leave the hard-core Java/J2EE programmers? Well right now that leaves us at the enterprise level, where Java is still king talking to all the legacy systems. This is not a bad place to be though, since large companies are the ones with the big development budgets but you still need to look out for what's next. |
| | The Next Big Thing..., 2006-07-24 | | Reviewer rating: | |
| What held me back from 4 stars was the repetition. This is a small book -- easy to read in one sitting -- and I felt that there was some repetition in a few places that would have made the book tighter, smaller, and a better read.
That said, repetition is the mother of skill and I think the author is making a very good point here in his speculation.
Java is growing 'old' and while the future and present has shifted away from EJBs and toward lightweight containers and aspects, this may not be enough.
There is a 'next big thing' looming on the horizon... the trick is, what is it?
Ruby with Rails is the author's guess. It isn't made by Microsoft and it addresses the 80-90% of distributed applications that need to bolt a website to a database. It'll be made to scale and hit up against enterprise needs (eventually) but it's sweet spot is commodity and indeed smaller apps.
While I think the author discounted MS a little prematurely, and PHP as well. I agree with the point completely. There will be a 'next thing' in application programming, it will be web based, and Java and JEE are too complicated to win this battle.
A good read. |
| | Interesting, but narrowly-focussed, error-ridden and frequently annoying, 2006-03-29 | | Reviewer rating: | |
| There is a lot to like in this book, and a lot not to like. I'll talk about the negatives first and then discuss the positives.
The style of the book is extremely annoying. The author is a kayaker and a mountain biker, and he introduces each chapter with a kayaking/mountain biking story meant to serve as some kind of analogy to the programming topics he'll cover in the chapter. I found this unnecessary and distracting (I don't need sugar coating on my technical reading), and it felt like the real purpose of the stories was for the author to demonstrate how cool he is. In addition, the author uses the phrase "a perfect storm" over and over and over to describe the factors that led to Java's position of dominance in the programming world. I hated that expression even before I read the book; it has to be the most abused expression of the last few years.
Despite the fact that the book is ostensibly about programming languages, the author is by no means an expert on the subject. To his credit, he admits this freely, but he also makes numerous small and not-so-small mistakes when describing programming language features which may lead more knowledgeable readers to wonder if he's really qualified to write this book. For instance, in several places he describes the advantages of static typing as being mainly for early error detection, without also pointing out another big advantage of static typing: faster code (there are other advantages as well). In another place he makes the blatantly false statement that "Smalltalk is where all the continuation research is happening", ignoring the fact that Scheme (a Lisp dialect) has had continuations since 1986, and that there has been and continues to be active research on continuations in Scheme ever since. Then he says that "In Lisp, everything is a list." Wrong again. He also seems to assume that statically-typed programs will always be verbose, indicating that he is unfamiliar with statically-typed languages like Objective Caml which have type inference. The bottom line is that he often doesn't know what he's talking about when he compares the features of different programming languages.
The author's programming expertise appears to be primarily in the domain of small to medium-sized web applications. This is an important domain, but it's far from the only programming domain. So the book's subtitle "A Glimpse At the Future of Programming Languages" should really be "A Glimpse At the Future of Programming Languages for People Who Exclusively Write Small to Medium-Sized Web Applications and Nothing Else". If you want a broader picture, or are primarily interested in another domain, look elsewhere.
The author is clearly aiming the book at programmers who primarily program for money. Not that there's anything wrong with that, but given the author's expressed fondness for open source software (which I share) it might have been nice to acknowledge that some people also write programs for the joy of it in addition to (or in lieu of) the financial rewards.
Now that I've covered the bad, let's look at the good. The author seems to know his domain well, and he makes a good case that Java frameworks for writing web applications have gotten so baroque and tedious that they are simply miserable to use and lead to very slow development cycles. This might be just the fault of the frameworks and not the language, but the author makes a good case that specific language features (or the lack thereof) are what make Java so clumsy for writing web applications. He contrasts Java primarily with the Ruby language, and specifically with the Ruby on Rails web framework, and shows that several features of Ruby make for a much more productive programmer experience. For instance, Ruby's ability to express configuration information inside the language obviates the need for much of the XML that clutters up Java web applications. The author spends a lot of time discussing Ruby's metaprogramming capabilities and how they make it possible to write much more concise code with much less repetition. An example is a class which reads from a database and populates itself on-the-fly with methods to access specific database fields. (Small gripe: the term "metaprogramming" has a variety of semi-related meanings, all coming down to the notion of code being automatically generated instead of being written by hand, but the way that e.g. Lisp or Scheme macros or C++ templates represent metaprogramming is very different from Ruby's metaprogramming, and the author doesn't discuss that.)
The most interesting chapter by far is the chapter on continuation servers. The author gives a clear (though short) description of continuations, which is no mean feat given that they are one of the most difficult-to-explain concepts in the entire universe of programming languages. More importantly, he discusses how they turn out to be extremely useful in web servers, allowing web-based programs to be written in a much more natural and concise style than is possible without them. He uses the Smalltalk language as an example, because there is a continuation server written in Smalltalk. (Another gripe: while I'm happy to see him acknowledge that Smalltalk is a good language, I might have liked it better if he also mentioned that the Scheme dialect of Lisp also has continuations (as I mentioned above), and that there is also a web server in PLT Scheme that is also continuation-based).
The take-home message of the book is that writing small to medium-sized web apps in Java is rapidly becoming more trouble than it's worth, that more dynamic languages like Ruby have features that make it much easier, and that therefore there is a good chance that these languages will take over much of the programmer mindshare. I agree with all of these points, and think that today's Java web programmers are well advised to look at other programming languages. However, I also feel on general principles that all programmers would do well to learn another programming language every year or two, so for me this book just reinforces my pre-existing view.
On the other hand, the author mentions, but doesn't emphasize the fact that the JVM has many capabilities which far outstrip those available in Ruby or Python or indeed most other languages. He does point out that many advanced features of Java frameworks are only useful for very large scale web
applications (the domain that J2EE targets explicitly), and are unnecessary for the majority of (smaller scale) web applications. He leaves open the extremely important question of whether frameworks like Ruby on Rails will scale well to larger applications, or to smaller applications when they need to grow larger, though he seems to believe that they will (if not now, then later when the language and its implementation or implementations mature).
In summary, I think this book is a decent read with a lot of food for thought, if you can handle the irritating style, the mistakes and the omissions. This book is far from the last word on this subject (the reader should be aware that there are lots of interesting computer languages that are not even mentioned in this book, with Objective Caml and E being two obvious candidates), but it's interesting nonetheless. |
|
Some information above was provided using data from Amazon.com. View at Amazon > |
| |
|
|
