Jeans Store Hier klicken Neuerscheinungen Cloud Drive Photos UHD TVs Learn More Slop16 Hier klicken Fire Shop Kindle WalkingOnCars Summer Sale 16
Profil für Jonas Bandi > Rezensionen

Persönliches Profil

Beiträge von Jonas Bandi
Top-Rezensenten Rang: 5.029.942
Hilfreiche Bewertungen: 16

Richtlinien: Erfahren Sie mehr über die Regeln für "Meine".

Rezensionen verfasst von
Jonas Bandi (Bern, Switzerland)

Seite: 1
Azure in Action
Azure in Action
von Chris Hay
Preis: EUR 34,40

1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen This book is the perfect guide on your journey into the Cloud., 1. November 2010
Rezension bezieht sich auf: Azure in Action (Taschenbuch)
If you are a .NET developer you should definitely read this book. Cloud computing is becoming a major topic for the future and the Microsoft Azure Platform is the way to go for .NET developers.

Even when you are not going to write a Cloud application in the nearest future, you should have an idea of the principles and concepts that come with the Cloud.

Also some of the concepts of programming for the Cloud and their difference to traditional programming can be very enlightening and can provide you a new perspective, that is also applicable in non-cloud projects.

I can recommend this book also for developers that are not developing for the .NET platform. So far this is the best book I have seen for explaining how programming for the Cloud works and discussing the underlying concepts.
The book shows concrete examples hot to architect and build applications for the Cloud. This is valuable knowhow, even when you build your Cloud applications on another platform than Azure.

The book is written in a light way that makes it an easy and enjoyable read. The style is entertaining with little amusing jests spattered throughout the chapters. Nevertheless the light style is never distracting from the real goal to provide valuable technical content.

As I said before, I think the book is very interesting, because it not only explains the technology/API but also the concepts and principles behind it.
Two examples of this are:
- Through discussion about the different storage options in the Cloud (Table Service, BLOB storage, SQL Azure, local storage, CDN). The book provides good guidelines when to choose what and shows the implications on the architecture and the design of the system.
- The clear differentiation between web-apps (web-roles), storage and background processing (worker-roles, queues) and how to architect scalable applications with this separation.

Pro JPA 2: Mastering the Java Persistence API (Expert's Voice in Java Technology)
Pro JPA 2: Mastering the Java Persistence API (Expert's Voice in Java Technology)
von Mike Keith
Preis: EUR 46,00

7 von 8 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen New reference book for Java Persistence, 22. Januar 2010
Until now I always recommended "Java Persistence with Hibernate (King/Bauer)" as reference book for Java Persistence.

I think this book has the potential to become the new reference book for this topic.
It is more concise and better structured than "Java Persistence with Hibernate" since it concentrates on JPA and does not confuse the reader with Hibernate specific details.
This was not possible with JPA1, because some important features were missing. But now with JPA2 for a big part of the applications, it is enough to just know JPA without having to know the differences/additional features of Hibernate.

ActiveMQ in Action
ActiveMQ in Action
von Bruce Snyder
Preis: EUR 33,95

6 von 7 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Review of July MEAP version, 12. August 2009
Rezension bezieht sich auf: ActiveMQ in Action (Taschenbuch)
(this review is also published on my blog: [...])

Manning was so kind to send me a copy of ActiveMQ in Action.

Note that this review is based on the July MEAP version of the book. Not all chapters are available in this version yet.

*** Chapter 1: Understanding Message-Oriented Middleware and JMS ***
This is a solid introduction to JMS. The chapter first touches briefly the topics of Enterprise Messaging and Message-Oriented Middleware and then dives into an overview of JMS. The core concepts of JMS are explained and the main Java APIs are introduced.
For readers who don't know JMS, this chapter offers a clear and concise overview. It is written in an easily understandable way which helps to get you a kickstart on the topic. If you have already worked with JMS, then this chapter offers nothing new, but it can be a valuable repetition.

*** Chapter 2: Introduction to Apache ActiveMQ ***
This chapter first gives a theoretical overview over ActiveMQ: What is it and why, when and where should you use it. Then the chapter explains how to set up a basic installation of ActiveMQ and how to run the basic examples. Finally some usecases are explained, that will be used as reference throughout the rest of the book.
This chapter is very hands on. Don't expect any grand insights. But it provides a quick and reliable way to get ActiveMQ up and running.

*** Chapter 3: Understanding Connectors ***
This chapter takes a profound look at connectors, which provide the core mechanism for communication in JMS. The chapter explains the different configuration options that are available and the advantages and disadvantages of them. The provided information is quite detailed and extensive. There are a lot of code examples that illustrate the different configuration options.
While this chapter is quite low-level (meaning it deals a lot with networks protocols) it also provides the base concepts for different broker topologies, which is one of the major design decisions when creating a messaging system.

*** Chapter 4: Message Persistence ***
At the beginning of this chapter there is a short theoretical explanation about the differences concerning storage for Queues and Topics. The rest of the chapter is again a hands on. It explains the different storage options that are provided by ActiveMQ and discusses their advantages and disadvantages. Again a lot of code examples illustrate how to configure the different persistence options.
This chapter gives you a good overview and is useful a reference when you have to evaluate and set up ActiveMQ in a concrete project.

*** Chapter 5: Securing ActiveMQ ***
This is rather short chapter that discusses the security mechanisms that are provided by ActiveMQ and shows different strategies for authentication and authorization with concrete examples. The chapter is a pragmatic introduction to the topic, don't expect anything fancy about security concepts or how to secure applications.

*** Chapter 6: Creating Java Applications With ActiveMQ ***
Up to this chapter the book dicusses ActiveMQ as an infrastructure that could be run standalone or embedded. This chapter bow shows how to integrate ActiveMQ in a Java application. Two ways of integration are shown: basic Java integration and Spring integration.
This chapter is quite short. I was a bit disappointed, because I hoped for some information or guidelines about the architecture and design of applications using ActiveMQ (or more generally MOM/JMS). This kind of high-level overview is not part of this chapter. The chapter simply explains how to instantiate, configure and get running ActiveMQ with plain Java or with Spring.

*** Chapter 8: Connecting to ActiveMQ With Other Languages ***
This chapter is mainly a big collections of examples how to use ActiveMQ with other languages/platforms. In this use-case ActiveMQ is set-up as a MOM-service and different clients are used as message producers and consumers.
There are examples for the scripting languages Ruby, Python, PHP and Perl. Those are using the text-oriented STOMP protocol and some third-party APIs for the respective language.
The examples for .NET and C++ use the NMS resp. CMS APIs that are also provided by the ActiveMQ project.
Finally there are examles for the REST and Ajax interfaces that ActiveMQ provides out of the box.
The chapter is a good overview and tutorial to get up working examples with the different clients. However the examples are very simplistic, and I guess for a real world project some more information will be necessary very soon.

*** Chapter 12: Tuning ActiveMQ For Performance ***
This chapter shows and explains some different factors that can influence performance in a system based on ActiveMQ. Different options and configurations are discussed and a complete example is shown.
The discussed options reach from low-level network/protocol configurations (like cacheSize, tcpDelay ...) over application-level design-options (like embedding a broker in the same VM) to system-level considerations (like transactions or flow-control from producer to consumer).
In my opinion that is the most interesting chapter of the book, since it treats some topics that have an influence on the architecture and the design of a system that is based on ActiveMQ (or more generally MOM/JMS).

*** Chapter 14: Administering and Monitoring ActiveMQ ***
This chapter shows several ways how to monitor and manage ActiveMQ at runtime. This starts with discussing the possibilities to get or set information via JMX and shows how to get monitoring information by special JMS-Messages ("Advisory Messages"). Then several tools for monitoring/managing are shown: command-line, JConsole, and WebConsole. Especially cool is the possibility to use a XMMP-chat-client instead of the commandline. Finally logging configurations for client and broker are discussed.
Again, this is a very hand-on chapter. The different options are explained in great detail with the necessary code-examples and screenshots.

*** Conclusion: ***
This is a very solid hands-on book, but I had no real epiphany while reading the book.

This is a very good book if you have one of the following goals:

- Get to know the features of ActiveMQ
- Get ActiveMQ up and running
- Get a reference and explanations for the most important configurations and options that ActiveMQ offers
- Get guidance for advanced usage scenarios when using ActiveMQ

However do not expect the following from the book:
- Learning how to architect and design applications/systems that use ActiveMQ (or generally MOM/JMS)
- How to evaluate if ActiveMQ is the right technology for a new system
- For me the book did not contain any real eye-openers nor did I feel that it did widen my horizon (unlike other Manning titles like Grails in Action of jQuery in Action)
- There is not much to learn if you are just a plain "user" of JMS and it is not your task to run the JMS infrastucture.

If the above criteria matches your needs, I can fully recommend ActiveMQ in Action.

Grails in Action
Grails in Action
von Peter Ledbrook
Preis: EUR 41,25

2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen New perspective for Java EE developers, 1. Juli 2009
Rezension bezieht sich auf: Grails in Action (Taschenbuch)
This book should be a must read for every Java enterprise developer! Grails shows a pragmatic lightweight approach to the Java EE platform which is eye-opening and will change your perspective on Java enterprise projects.

This books fulfilled my high expectations concerning content and quality that comes wiht Mannings "In Action" series.

The book has a good mix between explaining the underlying technology and pragmatic solutions.
I especially liked the chapter "Using plugins: adding Web 2.0 in 60 minutes". In this chapeter the high-productivity-mentality of grails is demonstarted by example.

Seite: 1