oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
oder
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Jetzt eintauschen
und EUR 8,09 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

The Well-Grounded Java Developer: Java 7 and Polyglot Programming on the JVM [Englisch] [Taschenbuch]

Benjamin J. Evans , Martijn Verburg
4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
Preis: EUR 30,95 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 10 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Samstag, 23. August: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Taschenbuch EUR 30,95  

Kurzbeschreibung

16. August 2012
DESCRIPTION The Java community has always been dynamic and fast-moving, with constant innovation on the core platform as well as a vibrant community ecosystem. New JVM-based languages like Groovy, Scala, and Clojure are redefining what it means to be a Java developer. The core Standard and Enterprise APIs now co-exist with a large and growing body of open source technologies. Multicore processors, concurrency, and massive data stores require new patterns and approaches to development. And with Java 7 due to release in 2011, there's still more to absorb. The Well-Grounded Java Developer is a unique guide written for developers with a solid grasp of Java fundamentals. It provides a fresh, practical look at new Java 7 features along with the array of ancillary technologies that a working developer will use in building the next generation of business software. KEY POINTS F * Covers new Java 7 features F * Quick tutorials on several new JVM languages F * Integrating new features and languages with existing systems

Wird oft zusammen gekauft

The Well-Grounded Java Developer: Java 7 and Polyglot Programming on the JVM + Effective Java: A Programming Language Guide (Java Series)
Preis für beide: EUR 65,90

Die ausgewählten Artikel zusammen kaufen


Produktinformation

  • Taschenbuch: 462 Seiten
  • Verlag: Manning (16. August 2012)
  • Sprache: Englisch
  • ISBN-10: 1617290068
  • ISBN-13: 978-1617290060
  • Größe und/oder Gewicht: 23 x 18,7 x 2,9 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 81.154 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Über den Autor und weitere Mitwirkende

Ben Evans is Java developer working in the financial industry. He's an organizer for the UK Graduate Developer Community and a regular public speaker on Java and related topics. Martijn Verburg is an independent consultant, the co-organizer for the London Java Users Group, and a JavaRanch moderator.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

5 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
4.0 von 5 Sternen
4.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
1 von 3 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Guter Überblick, aber sehr wenig Tiefe 22. Dezember 2012
Von Pascal D.
Format:Taschenbuch|Verifizierter Kauf
Dieses Buch ist wunderbar geeignet für relativ neue Java-Programmierer - z.B. Auszubildende im 2. Jahr. Es spricht sämtliche Themen an, die ein guter, professioneller Java-Entwickler kennen sollte - angefangen bei neuen JDK7-Bibliotheken bis hin zum Build-Prozess und anderen JVM-Sprachen. Die Grundlagen der Java-Programmierung werden als bekannt vorausgesetzt.
Aufgrund der Fülle der Themen werden die einzelnen Aspekte aber nur sehr oberflächlich geschildert. Das Buch verfolgt konsequent den Ansatz: "Man sollte wissen, dass es XY gibt, und wofür man es brauchen kann. Wenn man sich aber näher dafür interessiert, dann sollte man sich weitere Bücher zu XY besorgen."

Wie gesagt: für Menschen, die erst seit kurzer Zeit in der professionellen Entwicklung tätig sind, ist dies ein sehr gutes Buch. Wenn man aber beim Lesen des Inhaltsverzeichnisses auf wenig Themen stößt, die einem bisher noch nicht bekannt sind, dann wird man nicht sehr viel Neues lernen.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.5 von 5 Sternen  20 Rezensionen
24 von 27 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Java 7, TDD, Concurrency, Polyglotism and Beyond 25. Juli 2012
Von Summer Hasani - Veröffentlicht auf Amazon.com
Format:Taschenbuch
The authors of Well Grounded Java Developer promise the reader a book that will help modernize their knowledge base, brush up on vital techniques, and learn a new language or two. Promise delivered!

The book is split into four parts. First part covers Java 7 with its new features, such as NIO, Project Coin that comes with the diamond operator, string in switch statements and try-with-resources features. With lots of clear examples, written in both Java 6 and 7, the book showcases the new features and what problems they attempt to solve.

While part one covered new language features, part two focuses on universal practices and methodologies vital to any developer regardless of experience. Among the covered topics: TDD, CI, DI and the Java implementation of javax.inject, performance tuning, and modern concurrency.

Part three of the book is for those of us who believe in and/or want know about polyglotism. It provides an easy starting point to a number of languages without neither overwhelming novices, nor boring the experienced. The book has chapters on Scala, Groovy and Clojure. I bought this book a little over a week ago and now halfway through part three but did briefly skim thought the fourth part of the book. In this final part, the focus is on applying everything from previous three parts into creating a new project; it dedicates a whole chapter on TDD highlighting its paramount importance in modern software development. I will update the review with more details after finishing this part.

The best thing about this book is that it will inspire you to take part in the evolution of JVM ecosystem currently underway. After all, a well grounded java developer would :)
13 von 16 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A good model for modern Java 12. August 2012
Von Rick Goff - Veröffentlicht auf Amazon.com
Format:Taschenbuch
The Well Grounded Java Developer is a welcome addition to the library of this work-a-day Java developer. I think I acquired this title for its promise to introduce features new to Java 7, which it does, but I find much more value than just this. As new concepts and techniques are introduced, the code samples demonstrate not only the new idea, but also the implementation of the various enhancements Java 7 provides. In other words, the code samples in this book look like Java 7 code from top to bottom, rather than Java 6 code with a sore thumb. Throughout the second section, you see code that uses the Path abstraction, multi-catch, underscores in number literals, and the other features that were introduced in Part 1.

Section 2 contains a lot of information that is new to me. As a Java developer incubated in a corporate setting, I have been nurtured to produce code, more than to understand it.

Chapter 3 discusses IoC and DI usefully. I am, just as the authors anticipated, one who probably heard the term Spring before I heard the term Inversion of Control. This chapter makes DI make sense as a design solution with many possible implementations, including Guice 3, the RI for JSR-330.

Chapter 4 discusses concurrency. The authors stress the inevitability of the rising importance of concurrency programming as multicore CPU's become standard. They discuss the advantages of immutability in the context of concurrency, foreshadowing the rise of functional programming styles and languages for the JVM. See for example the Callable interface, which they describe as "the closest that Java 7 gets to having functions as first-class objects." They laud java.util.concurrent, and elucidate Atomic and Locks. They also introduce ConcurrentHashMap, and suggest we always favor it over HashMap. And they present fork/join with "a simple example" that I had to read a half-dozen times to grok. Probably just me.

Chapter 5 discusses Class files and bytecode. It steps through the class loading process. MethodHandles are introduced as an answer to certain shortcomings of the Callable interface. The constant pool was a brand new concept for me, as was javap, the tool to use for examining these constants. There is a section on Bytecode, which is "an intermediate representation of a program - halfway between human readable source code and machine code." This representation takes the form of a list of operation codes ("opcodes") that may take arguments. Each opcode is represented by a single byte, "hence the name bytecode." Opcodes are organized into logical groups by function, such as "Load and Store" and "Arethmetic." Java 7 introduces a new opcode - a first! The new opcode is invokedynamic, which allows deferral of method selection to runtime. This is a JVM thing for dynamic languages; Java-the-language doesn't emit invokedynamic. This is another reminder that the future of the JVM is polyglot, with increasing support for dynamic languages.

Chapter 6 discusses performance tuning. The topic of this sermon is, "You have to measure. You can't tune properly without measuring." It discusses some metrics, such as latency and utilization. It also mentions transforming bytecode as it is loaded in order to attach tuning instrumentation. This chapter doesn't provide a lot of code samples, and I don't know how I individually will apply much of it. It's an interesting read, though. The imperative to utilize caches closest to the CPU is demonstrated visually. There's a section on Garbage Collection, in which Areas of memory (Eden, Survivor, Tenured and PermGen) are defined, as well as the jmap and VisualVM tools for viewing memory contents. Escape analysis is a neat idea, where a method is assessed as a candidate to create its dependencies on the stack, rather than on the heap, if its local reference variables are used only inside the method. The G1 collector is a radical departure from previous collector models. It learns how much collection it can expect to accomplish in a given amount of time (the pause), and plans its workload according to your pause goals of duration and frequency. Finally, Just-in-Time compilation is discussed, with an introduction to compilation strategies. Inlining methods is described as "eliminating the call to the inlined method, and instead placing the code of the called method inside the caller." The compiler uses runtime statistics to determine where to apply this strategy.

I have perused Part 3, and I look forward to reading it and Part 4 thoroughly.

This book is an excellent resource for Java developers who are capable of enthusiasm about programming. The book is of no value to the reader who is new to Java. I would highly recommend the book to a curious colleague who is fundamentally sound and insists on enjoying the next few years creating code for the JVM.
5 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Very well balance in its breadth, somehow lacking in depth 30. September 2013
Von Emre Sevinc - Veröffentlicht auf Amazon.com
Format:Taschenbuch
If you have ever had the chance to witness the live performance of the authors, you know what a dynamic duo they are, taking a no nonsense, pragmatic and very down to earth attitude towards the perils and treasures of modern day Java development. It is easy to see that almost every page of 'The Well-Grounded Java Developer' is full of that energy.

The world of Java development is wide and this book is very well balanced in its selection of topics. In other words, almost any serious Java development team would would welcome a new developer well versed in the topics of this book, or to put it differently, unless you don't know much about most of those topics, do not consider yourself fit for a sharp and focused Java development team.

Having said that, the breadth and the depth of the Java and JVM world makes this book look like a relatively large tip of an iceberg. Most of the chapters provide a solid starting point, but for example, when it comes to performance analysis and evaluation, you will be much better off with an in-depth study such as Java Performance. Or when it comes to explaining IoC (Inversion of Control) and DI (Dependency Injection), you might feel like the exposition is made a little overcomplicated: you might be better off reading a proper tutorial on Guice or the relevant chapter from GWT in Action. I could make a similar set of comments regarding the concurrency chapter, but the added value of the book on that topic lies not in the summary introduction of Java concurrency, or modern features such as Fork/Join but rather the introduction of state-of-the-art paradigms such as actor based message passing systems, e.g. Akka. The same goes for book's exposition of modern languages that run on JVM, such as Groovy, Scala, and Clojure. It is certainly very difficult to do justice to these wildly different languages in a few short chapters, but the authors succeed in capturing and presenting very clearly the essential characteristics of those languages (albeit they do not focus one of the tenets of functional programming: easy composability thanks to pure functions). They provide the reader with the pragmatic reasons to try out these languages, and they don't refrain to evaluate each of those languages from many angles, such as the tooling support.

Apart from that, the chapter discussing the internals of class files and bytecode, even though not being very technically in-depth, nevertheless provides nice, self-contained overview of the topic just enough to be ocassionally useful for the daily needs of a not-too-specialized developer (and if you are a very specialized one, then you already know where to look for more technical details).

The chapter on TDD (Test Driven Development) is neither too detailed, nor too superficial, it gives solid grounding and rationale, that is if you are still skeptic about the advantages of unit testing, doing it properly, easily, most important of all, doing it right from the start. The examples using open source Mockito testing framework are not bad, but they would be brilliant if the authors did not refrain to demonstrate how Dependency Injection (e.g. Guice in particular) could be useful for unit tests, using a self-contained example (and I wonder if all of these could be even better presented using something like Jukito framework).

The rest of the book, particularly chapters related to Continuous Integration and building using Jenkins and Maven present just enough material to digest and coupled with code metrics, they hint at what a modern and healty development team should aim for. On the other hand, web development part will probably polarize the audience due to the selection of particular languages and frameworks, but I don't think any author can escape from this, given the volatility of the subject matter.

I can easily recommend this solid book to junior and senior developers to learn more or to strengthen their understanding of modern Java & JVM development practices. Not only will you be very well-grounded, enforcing a pragmatic approach with healthy look at the current and future developments, but also smile, or even chuckle at the use of witty & geeky humour, highlighting some important historical aspects of the Java world.
4 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Sharp tools for busy Java developer 6. April 2013
Von vrto - Veröffentlicht auf Amazon.com
Format:Taschenbuch
The Well-Grounded Java Developer is an interesting mixture of new stuff happening all around Java and JVM-related technologies. Targeted audience should be represented by two main groups: developers still rather new to Java and developers that have been around Java for a while, but got stucked at certain point (and might feel a bit rusty). This book provides brief, but pragmatic information on many topics. It consists of four large parts and here are my thoughts on each part:

First part will show you what's new in Java 7 and demonstrates stuff like Project Coin, new I/O and so on.

Second part should be interesting for people using Java programming language who want to try to hit its sweet spot by introducing bunch of vital techniques. You will learn about new Java "musts" like Dependency Injection and alternative concurrent approaches that compete with standard Java's synchronized-based facilities. You will also learn plenty of stuff about JVM, its internal mechanisms and tuning possibilities.

Next two parts of the book target audience that wants to stay around JVM but is interested in using alternative languages like Scala, Groovy or Clojure. Authors will try to show you syntactic basics and differences of three languages mentioned above and demonstrate it on common uses cases. You will also have a chance to see some popular alternative languages frameworks in action (e.g. Grails).

This book managed to cover really wide area of Java and JVM related topics and is viable source of information for developers of different skill levels and interests.

As a minus I have to mention the quality of source code in the book - not only it lacks some reasonable syntax highlighting whatsoever, but it is also quite often poorly formatted and not too nice to read. This is the only reason why this book is not getting full score from me.
2 von 3 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Excellent, I want to visit the London JUG now 5. Juli 2013
Von Sisu - Veröffentlicht auf Amazon.com
Format:Taschenbuch
I'm in California's Silicon Valley/Bay Area but after reading several chapters of this book I want to go to London and hang out with the Java User Group there for a while. The vibe I get is that the teaching style and distilling of what really matters is done incredibly well by the LJUG and by the book's authors. The parts on alternative languages for the JVM is great, and pleasurable to read even if you're tired.

I like too how the authors instinctively understand what parts of Java the language and Java the platform we tend to get fuzzy on as developers, since inevitably we get caught up in delivering projects, refactoring methods, understanding what the *real* requirements are, and all that noise of daily life. The parts about how Java specs are developed, how the JVM really works, etc. are great for sharpening core knowledge.

I've been reading this on Safari but may order the paper version now. This is in the same league as Joshua Bloch's work on Effective Java.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar