- Taschenbuch: 384 Seiten
- Verlag: Prentice Hall; Auflage: 01 (15. März 2012)
- Sprache: Englisch
- ISBN-10: 0321247132
- ISBN-13: 978-0321247131
- Größe und/oder Gewicht: 17,8 x 2 x 23,1 cm
- Durchschnittliche Kundenbewertung: 1 Kundenrezension
- Amazon Bestseller-Rang: Nr. 141.675 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
- Komplettes Inhaltsverzeichnis ansehen
Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series): A Roadmap for Enterprise Development (Agile Software Development) (Englisch) Taschenbuch – 15. März 2012
|Neu ab||Gebraucht ab|
Kunden, die diesen Artikel gekauft haben, kauften auch
Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?
Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.
Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.
Wenn Sie dieses Produkt verkaufen, möchten Sie über Seller Support Updates vorschlagen?
"The fundamentals never go out of style, and in this book Kirk returns us to the fundamentals of architecting economically interesting software-intensive systems of quality. You'll find this work to be well-written, timely, and full of pragmatic ideas." "-Grady Booch, IBM Fellow" "Along with GOF's "Design Patterns, " Kirk Knoernschild's Java Application Architecture is a must-own for every enterprise developer and architect and on the required reading list for all Paremus engineers.""-Richard Nicholson, Paremus CEO, President of the OSGi Alliance" "In writing this book, Kirk has done the software community a great service: He's captured much of the received wisdom about modularity in a form that can be understood by newcomers, taught in computer science courses, and referred to by experienced programmers. I hope this book finds the wide audience it deserves.""-Glyn Normington, Eclipse Virgo Project Lead" "Our industry needs to start thinking in terms of modules-it needs this book!""-Chris Chedgey, Founder and CEO, Structure 101" "In this book, Kirk Knoernschild provides us with the design patterns we need to make modular software development work in the real world. While it's true that modularity can help us manage complexity and create more maintainable software, there's no free lunch. If you want to achieve the benefits modularity has to offer, buy this book.""-Patrick Paulin, Consultant and Trainer, Modular Mind" "Kirk has expertly documented the best practices for using OSGi and Eclipse runtime technology. A book any senior Java developer needs to read to better understand how to create great software.""-Mike Milinkovich, Executive Director, Eclipse Foundation"
The fundamentals never go out of style, and in this book Kirk returns us to the fundamentals of architecting economically interesting software-intensive systems of quality. You ll find this work to be well-written, timely, and full of pragmatic ideas. Grady Booch, IBM Fellow
Über den Autor und weitere Mitwirkende
Kirk Knoernschild is a software developer who has filled most roles on the software development team. Kirk is the author of Java Design: Objects, UML, and Process (Addison-Wesley, 2002), and he contributed to No Fluff Just Stuff 2006 Anthology (Pragmatic Bookshelf, 2006). Kirk is an open source contributor, has written numerous articles, and is a frequent conference speaker. He has trained and mentored thousands of software professionals on topics including Java/J2EE, modeling, software architecture and design, component-based development, service-oriented architecture, and software process. You can visit his website at techdistrict.kirkk.com.
Java application architecture is not only about isolated work, it is a complete and constant effort to guide teams. For consistency reasons, the software packaging should follow the agile methods applied on it. The author delivers in a great manner all the key analyse features to reach that goal. Master key conception features, that's what the author proposes here. It's big, it's simply more that enough.
Die hilfreichsten Kundenrezensionen auf Amazon.com
This is a readable introduction to the principles of code modularity written from the perspective of a practitioner, not an academic. I can recommend it for programmers early in their careers since we all wrote code with poor dependency management when we were young, and this book guides programmers down a better path.
Beware: The book's title should be "Modularizing Java Programs" since it covers only that aspect of program design. The author appears unaware of the published field of software architecture, which would have helped him situate his good advice. This is NOT a book on software architecture, generally.
* Chapter 7 showing the progressive packaging of the example system by applying the patterns. This provides an excellent context to understand the value of each pattern since each refactoring is preceded by a business goal like "We'd like to use this part of the code elsewhere, but not that part".
* Pattern catalog is a good introduction for new programmers to the basics of code and modularization, which include the classics and several new principles (patterns) that are good guidance.
* Emphasizes the distinction between your classes / relationships and the way those are packaged. The book refers to these as the logical and physical (from John Lakos) - though I personally greatly dislike those terms since there is nothing physical about a Java JAR file.
* Effective use of code and diagrams. Not all diagrams; not all code - just right. Mostly uses UML notation (e.g., generalization, implements, associations, components) but sometimes not (e.g., classes are rounded rectangles with shadow effect).
* Grounds the advice in today's terms. Reading Parnas' 1972 paper on KWIC is harder than reading this book because Java, JAR files, OSGi, etc. are all familiar technologies to us.
* Book title. If you bought a book on "Sewing", you'd expect it to include more than how to make shirts. The book's content covers how to understand your code's modular structure and provides patterns that describe good modular structure. An architecture book, for example, would additionally cover standard runtime patterns like Client-Server, Peer-to-Peer, and Cooperating Processes, which are not discussed in this book. The book uses the term "layers" differently than the gold standard Documenting Software Architectures book - rather significant for a book on code modularity.
* Needs catch-up since 1992. In the early 90's academics pushed ahead in understanding software architecture. Before that, it was Parnas (as quoted by the book) and DeRemer & Kron, who described code modules and relationships. Perry & Wolf (1992) and Garlan & Shaw (1994) clearly described how architecture could not be understood only from modules and we must look at other views. This book makes no reference to this major shift in the field.
* Silent on runtime and allocation views. Today, the vast majority of authors in the field of software architecture endorse the following approach to architecture: A software system can be seen from several perspectives, called views. The three most common views are the code (module view), the system at runtime (sometimes called Component-and-Connector view), and how the software is assigned to hardware (allocation view). This book is 98% about the code view and provides good advice on packaging code. It touches on the allocation view in its discussion of OSGi and hot deployment. Worryingly, it has several diagrams (6.3 to 6.6) that are probably best interpreted as runtime diagrams but portrayed as code diagrams.
* Assumes/implies that SOA is the goal. SOA is just one possible (runtime) architecture. It's a good match for many systems but the book implies (at least that's my inference) it should always be your goal.
* Conflates OSGi modularity with frameworks. Chapter 17 contains a number of examples of successful frameworks (Eclipse, Hudson, ...) that can be extended with modules not written by the framework authors and seems to imply that this future is yours (a successful "ecosystem") if you modularize your code. It is important to distinguish libraries from frameworks, however. In a library, like a math library, your code calls the library in a master-servant relationship. In a framework, your code is called by the framework when the framework decides it is ready, sometimes called the Hollywood Principle (Don't call us, we'll call you). Just packaging your code into clean modules, even OSGi modules, does not yield a framework. Frameworks work because they were designed from the start with "extension points" (Eclipse's term).
Overall: A good book for non-expert developers and its pattern library goes beyond what had already been published (e.g., cohesion, coupling, cyclic dependencies). It will be better in its 2nd edition when it's embraced some of the essential concepts from the software architecture community.
Modularity is sometimes mixed with services by many developers who have trouble understanding it and describing its concepts. This books talks about modularity and describes how it differentiates from services. Furthermore, it takes a traditional application and shows, in several steps, how it can be refactored to take advantage of the OSGi platform.
While OSGi may be a new concept, I do recommend this book to anyone who is involved in computer programming in general. This book gives you another way of how you can view software components and how these can live with other components and die peacefully without having to restart the entire platform. Furthermore, the concepts described in this book applies outside of OSGi and can be used in most software domains.
There are a lot of examples and clear patterns to enable modularity.
It is very practical, though the WHY's are well explained.
Ähnliche Artikel finden