| 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 30 reviews. |
| 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. |
| | It's not about Ruby Replacing Java: Read it before any conclusion, 2006-02-21 | | Reviewer rating: |  |
| This books doesn't say Java is dead. It points the problem that the platform and (mostly) tha language has and try to show alternatives.
Although totally relevant, this shouldn't be a book. It should be presented like a series of articles in some website or something like this, this book is totally temporal.
Anyway, if you follow the JCP and the path Java 5,6 and 7 are following you see thar Tate is not far from the truth. |
| | Java is not in your future!, 2006-02-12 | | Reviewer rating: | |
| | Great overview of where the industry is headed from a language standpoint. I've always said that Java is Complex but something like Ruby on Rails is ADVANCED! Would have like to seen CFML (i.e. ColdFusion) included as one fo the alternatives. |
| | It is not Java's fault we have something like Struts !, 2006-02-11 | | Reviewer rating: | |
| | I have read Lighter, Faster, Better, Simpler Java from the same author and I love his attitude toward the wrong things people have done with the Java language. In the top of this list, Struts and EJB holds a very strong position of the worst of the worst in the Java world. But that's not Java's fault. If people want to do things very, very complicated like EJB or very, very boring like Struts with Java, they will keep on doing it. Either with Java, Ruby or anything else. Any OO language can abstract the complexity of the most common and repetitive tasks of any web project, but as always people tend to focus on power and forget about simplicity or KISS (keep it simple stupid). Before you think Java is not suitable for web applications, I suggest you try Mentawai or Rife. I believe Ruby and Rails is the next big thing for very simple and small projects. There is no way you can compare Active Record with Hibernate or how you can use page conventions for a big project. Beyond passion there is rationality. I am still in love for Java, but the passion days are over. |
|
Some information above was provided using data from Amazon.com. View at Amazon > |
| |
|
|
