How we did it:
For any feedback, any questions, any notes or just for chat - feel free to follow us on social networks
Michael C. Feathers
The average book on Agile software development describes a fairyland of greenfield projects, with wall-to-wall tests that run after every few edits, and clean & simple source code.
The average software project, in our industry, was written under some aspect of code-and-fix, and without automated unit tests. And we can't just throw this code away; it represents a significant effort debugging and maintaining. It contains many latent requirements decisions. Just as Agile processes are incremental, Agile adoption must be incremental too. No more throwing away code just because it looked at us funny.
Mike begins his book with a very diplomatic definition of "Legacy". I'l skip ahead to the undiplomatic version: Legacy code is code without unit tests.
Before cleaning that code up, and before adding new features and removing bugs, such code must be de-legacified. It needs unit tests.
To add unit tests, you must change the code. To change the code, you need unit tests to show how safe your change was.
The core of the book is a cookbook of recipes to conduct various careful attacks. Each presents a particular problem, and a relatively safe way to migrate the code towards tests.
Code undergoing this migration will begin to experience the benefits of unit tests, and these benefits will incrementally make new tests easier to write. These efforts will make aspects of a legacy codebase easy to change.
It's an unfortunate commentary on the state of our programming industry how much we need this book.
This volume is a handbook for enterprise system developers, guiding them through the intricacies and lessons learned in enterprise application development. It provides proven solutions to the everyday problems facing information systems developers.
Features the best practices in the art and science of constructing software--topics include design, applying good techniques to construction, eliminating errors, planning, managing construction activities, and relating personal character to superior software. Original. (Intermediate)
Robert C. Martin
Written by a software developer for software developers, this book is a unique collection of the latest software development methods. The author incudes OOD, UML, Design Patterns, Agile and XP methods with a detailed description of a complete software design for reusable programs in C++ and Java. Using a practical, problem-solving approach, it shows how to develop an object-oriented application -- from the early stages of analysis, through the low-level design and into the implementation. Walks readers through the designer's thoughts — showing the errors, blind alleys, and creative insights that occur throughout the software design process. Covers: Statics and Dynamics; Principles of Class Design; Complexity Management; Principles of Package Design; Analysis and Design; Patterns and Paradigm Crossings. Explains the principles of OOD, one by one, and then demonstrates them with numerous examples, completely worked-through designs, and case studies. Covers traps, pitfalls, and work arounds in the application of C++ and OOD and then shows how Agile methods can be used. Discusses the methods for designing and developing big software in detail. Features a three-chapter, in-depth, single case study of a building security system. For Software Engineers, Programmers, and Analysts who want to understand how to design object oriented software with state of the art methods.
Kathy Sierra, Bert Bates
An interactive guide to the fundamentals of the Java programming language utilizes icons, cartoons, and numerous other visual aids to introduce the features and functions of Java and to teach the principles of designing and writing Java programs.
Kerievsky lays the foundation for maximizing the use of design patterns by helping the reader view them in the context of refactorings. He ties together two of the most popular methods in software engineering today--refactoring and design patterns--as he helps the experienced developer create more robust software.
Gregor Hohpe, Bobby Woolf
Would you like to use a consistent visual notation for drawing integration solutions? "Look inside the front cover." Do you want to harness the power of asynchronous systems without getting caught in the pitfalls? "See "Thinking Asynchronously" in the Introduction." Do you want to know which style of application integration is best for your purposes? "See Chapter 2, Integration Styles." Do you want to learn techniques for processing messages concurrently? "See Chapter 10, Competing Consumers and Message Dispatcher." Do you want to learn how you can track asynchronous messages as they flow across distributed systems? "See Chapter 11, Message History and Message Store." Do you want to understand how a system designed using integration patterns can be implemented using Java Web services, .NET message queuing, and a TIBCO-based publish-subscribe architecture? "See Chapter 9, Interlude: Composed Messaging." Utilizing years of practical experience, seasoned experts Gregor Hohpe and Bobby Woolf show how asynchronous messaging has proven to be the best strategy for enterprise integration success. However, building and deploying messaging solutions presents a number of problems for developers. " Enterprise Integration Patterns " provides an invaluable catalog of sixty-five patterns, with real-world solutions that demonstrate the formidable of messaging and help you to design effective messaging solutions for your enterprise. The authors also include examples covering a variety of different integration technologies, such as JMS, MSMQ, TIBCO ActiveEnterprise, Microsoft BizTalk, SOAP, and XSL. A case study describing a bond trading system illustrates the patterns in practice, and the book offers a look at emerging standards, as well as insights into what the future of enterprise integration might hold. This book provides a consistent vocabulary and visual notation framework to describe large-scale integration solutions across many technologies. It also explores in detail the advantages and limitations of asynchronous messaging architectures. The authors present practical advice on designing code that connects an application to a messaging system, and provide extensive information to help you determine when to send a message, how to route it to the proper destination, and how to monitor the health of a messaging system. If you want to know how to manage, monitor, and maintain a messaging system once it is in use, get this book. 0321200683B09122003
Bryan Basham, Kathy Sierra, Bert Bates
This book gets readers up to speed on the technology necessary to write servlets and JSPs, what makes the Container tick, how to use the new JSP Expression Language (EL), how to write deployment descriptors, and even how to use some server-side design patterns.
Charlie Hunt, Binu John
The ONLY complete, up-to-date guide to all aspects of Java performance • •The first one-stop guide to identifying, isolating, and fixing Java performance issues on multicore and multiprocessor processor platforms - from two of Sun's leading Java performance experts. •Includes crucial new insights into microbenchmarking found nowhere else. •Contains up-to-the-minute coverage of Java optimization, including migration of older applications. Given Java's ubiquity and indispensability, Java software performance is of crucial importance to millions of developers worldwide. The emergence of multi-core systems and the evolution of the Java platform give developers many new opportunities to optimize performance. Now, three of Sun's leading Java performance experts have written the first start-to-finish guide to optimizing Java performance in today's multi-core systems. Java Performance gives developers, designers, and architects all the information they need to leverage Java's performance and scalability abilities on any modern multicore or multiprocessor system. This book's end-to-end coverage addresses all these topics: monitoring and profiling; the effective use of garbage collection and other language features; adaptive and platform-specific tuning; techniques for maximizing scalability; and much more. The authors' extensive benchmarking coverage includes an indispensable introduction to effective microbenchmarks - including guidance on avoiding the common microbenchmarking mistakes that mislead developers into writing badlyperforming software. The book also contains a complete section on Java performance enhancement, including opportunities and challenges associated with migrating software from Java 1.4.2 and Java 5 - issues that more and more Java developers are now facing.
David M. Geary, Cay S. Horstmann
The #1 guide to rapid user interface development with Java Server Faces (JSF) - now fully updated for the powerful new JSF 2.0 * *By two of the world's most respected Java experts: David Geary and Cay Horstmann. *Shows web developers how to automate low-level details, eliminate unnecessary complexity in server-side development, and write superior JSF 2.0 production code. *Systematically covers JSF 2.0's powerful Ajax support, open source innovations, and new feature set. JavaServer Faces (JSF) is the most powerful solution for rapid user interface development in Java-based server-side applications. Now, the world's bestselling guide to JSF, Core JavaServer Faces, has been thoroughly updated to reflect the powerful new JSF 2.0 release. In this new third edition, authors David Geary and Cay Horstmann delve into all facets of JSF 2.0 development, offering today's best practices for building robust applications, minimizing handcoding, and maximizing productivity. Drawing on unsurpassed insider knowledge of the Java platform, they present solutions, hints, tips, and 'how-tos' for writing superior JSF 2.0 production code, even if you're new to JSF, JavaServer Pages', or servlets. Geary and Horstmann systematically cover JSF's powerful Ajax development capabilities, the new open source innovations that make JSF 2.0 even more valuable, and all these new features: View Scope; Component Implicit EL Object; FacesContext; Attribute Map; New Event System; Resources; Resource Relocation; and Project Stage (Production, Development, UnitTest, SystemTest, Extension.) Web developers will discover how to: * *Automate low-level details and eliminate unnecessary complexity in serverside development. *Implement best practices in areas ranging from UI design and style sheets to internationalization. *More effectively leverage external services, including databases, LDAP directories, security, and Web services
Mike Keith, Merrick Schincariol
Pro JPA 2 introduces, explains, and demonstrates how to use the Java Persistence API (JPA). JPA provides Java developers with both the knowledge and insight needed to write Java applications that access relational databases through JPA. Authors Mike Keith and Merrick Schincariol take a hands–on approach to teaching by giving examples to illustrate each concept of the API and showing how it is used in practice. All of the examples use a common model from an overriding sample application, giving readers a context from which to start and helping them to understand the examples within an already familiar domain. After completing the book, you will have a full understanding and be able to successfully code applications using JPA. The book also serves as a reference guide during initial and later JPA application experiences. Hands-on examples for all the aspects of the JPA specification, based on the reference implementation of this specification A special section on migration to JPA Expert insight about various aspects of the API and when they are useful Portability hints to provide increased awareness of the potential for non–portable JPA code What you’ll learn Get started with enterprise applications using JPA 2 Get up to speed with object–relational mapping and Entity Manager Learn and use queries and the query language (JP QL) Employ advanced object–relational mapping techniques Use XML mapping files and learn other advanced techniques Package and deploy your Java persistence applications Test your Java persistence applications Migrate your Java persistence applications Who this book is for The book generally targets enterprise and persistence developers who fall in one of three categories: Those who are new to persistence; we will present some background information and introduce these readers to the basic persistence concepts to bring them up to speed. Those who know and/or use existing ORM persistence products such as Hibernate or TopLink. Those who have already used JPA and want to learn about newer features introduced by JPA 2, or have a good reference book to consult when they develop JPA applications. In general, we assume that the reader is knowledgeable with Java, SQL, and JDBC, and has a little knowledge of J2EE. Table of Contents Introduction Getting Started Enterprise Applications Object-Relational Mapping Collection Mapping Entity Manager Using Queries Query Language Criteria API Advanced Object-Relational Mapping Advanced Topics XML Mapping Files Packaging and Deployment Testing Migration
This pragmatic book offers the real world knowledge you need to develop lean and maintainable Java EE 5 / 6 applications. Real World Java EE Patterns - Rethinking Best Practices guides you to efficient patterns and best practices in a structured way, with code from real world projects.This book includes coverage of:An introduction into the core principles and APIs of Java EE 6 (EJB, JPA, JMS, JCA, JTA, DI, Convention Over Configuration, REST),Principles of transactions, Isolation Levels, remoting in Java EE 6 context,Discussion of superfluous patterns and outdated best practices like DAOs, Business Delegates, DTOs, extensive layering, indirections,Patterns for integration of asynchronous, legacy, or incompatible resources,Infrastructural patterns for eager-starting of services, thread tracking, pre-condition checks, Java EE 6 lookups or integration of third-party Dependency Injection frameworks like Guice,Fully functional JCA implementation with source code,EJB 2 - EJB 3 migration strategies
A complete, timely update to the classic work on capturing software architecture in writing • •Updated to use UML 2.0 throughout, with a complete Java/SOA-based case study, and covers architecture documentation in agile/lightweight/spiral environments. •Covers goals, strategies, rules, and hands-on best practices, and provides proven templates for generating coherent documentation. •Foreword by Grady Booch. This book's first edition offered breakthrough, start-to-finish guidance for software architects who want to document their architectures in a way that others can understand and accurately implement. Already a classic - and still a best-seller - this book has now been thoroughly updated to reflect today's most important software trends. Both an overview and a hands-on guide, this book introduces the uses of software architecture documentation; provides rules for sound documentation; shows how to document both interfaces and behavior; and offers proven templates for generating coherent documentation. This edition's extensive updates include: • •The use of UML 2.0 throughout. •A new case study based on Java and SOA. •Coverage of architectures generated via agile, lightweight, and spiral methods. •Updates for consistency with SEI's growing portfolio of architecture courses. •Clearer terminology and explanations throughout. •Coverage of frameworks such as TOGAF, DODAF, and FEAF. •Coverage of documentation tools such as wikis and Lattix DSMs. •New techniques for documenting variability across product lines. •Best practices for reviewing and validating documentation. •Comparisons of 'Views and Beyond' vs '4+1' approaches. •Improved alignment with the IEEE-471 standard. This book continues to stand alone in helping architects document their architectures so they will actually be implemented as intended.
Java Enterprise Edition (Java EE) continues to be one of the leading Java technologies and platforms from Oracle (previously Sun). Beginning Java EE 6 Platform with GlassFish 3, Second Edition is this first tutorial book on the final version of the Java EE 6 Platform. Step by step and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations, and shows them in action using practical examples. This book uses the new version of GlassFish 3 to deploy and administer the code examples. Written by an expert member of the Java EE 6 specification request and review board in the Java Community Process (JCP), this book contains the best information possible, from an expert’s perspective on enterprise Java technologies. What you’ll learn Get started with the final version of the Java EE 6 Platform. Explore and use the EJB 3.1 and JPA 2.0 APIs from entities to session beans to message driven beans, and more. Discover web tier development APIs including JSPs, JSTL, and Expression Language, and especially the new JSF 2.0 and Facelets. Uncover the web services, RESTful services, and more available in Java EE 6. Create dynamic user interfaces for your enterprise and transactional Java applications. Who this book is for This book is for advanced Java programmers as well as Java EE 6 beginners. Architects will also find information about how to layer their Java EE applications. Table of Contents Java EE 6 at a Glance Java Persistence Object-Relational Mapping Managing Persistent Objects Callbacks and Listeners Enterprise Java Beans Session Beans and the Timer Service Callbacks and Interceptors Transactions and Security JavaServer Faces Pages and Components Processing and Navigation Sending Messages SOAP Web Services RESTful Web Services
Java Enterprise Edition (Java EE) continues to be one of the leading Java technologies and platforms from Oracle (previously Sun). Beginning Java EE 6 Platform with GlassFish 3, Second Edition is this first tutorial book on the final (RTM) version of the Java EE 6 Platform. Step by step and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations, and shows them in action using practical examples. This book uses the new version of GlassFish 3 to deploy and administer the code examples. Written by an expert member of the Java EE 6 specification request and review board in the Java Community Process (JCP), this book contains the best information possible, from an expert’s perspective on enterprise Java technologies. What you’ll learn Get started with the final version of the Java EE 6 Platform. Explore and use the new EJB 3.1 and JPA 2.0 APIs from entities to session beans to message-driven beans, and more. Discover the web tier development APIs including JSPs, JSTL, and Expression Language, and especially JSF 2.0 and Facelets. Uncover the new web services, RESTful services, and more available in Java EE 6. Create dynamic user interfaces for your enterprise and transactional Java applications. Who this book is for This book is for advanced Java programmers as well as Java EE 6 beginners. Architects will also find information about how to layer their Java EE applications. Table of Contents Java EE 6 at a Glance Java Persistence Object-Relational Mapping Managing Persistent Objects Callbacks and Listeners Enterprise Java Beans Session Beans and the Timer Service Callbacks and Interceptors Transactions and Security JavaServer Faces Pages and Components Processing and Navigation Sending Messages SOAP Web Services RESTful Web Services
The existing books on design patterns take a catalog approach, where they show the individual design patterns in isolation. This approach is fundamentally flawed, because you can't see how the design patterns actually function in the real world. Most programmers learn by looking at computer programs. Holub on Patterns: Learning Design Patterns by Looking at Code teaches you design patterns in exactly this way: by looking at computer programs and analyzing them in terms of the patterns that they use. Consequently, you learn how the patterns actually occur in the real world and how to apply the patterns to solve real problems. This book also looks at the broader context of object-oriented (OO) design and how patterns solve commonplace OO design problems. It covers many of the principles of OO design—principles not covered by most books on Java—and shows you how to apply these principles to make your code easier to maintain and debug.