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.
“For software developers of all experience levels looking to improve their results, and design and implement domain-driven enterprise applications consistently with the best current state of professional practice, Implementing Domain-Driven Design will impart a treasure trove of knowledge hard won within the DDD and enterprise application architecture communities over the last couple decades.” –Randy Stafford, Architect At-Large, Oracle Coherence Product Development “This book is a must-read for anybody looking to put DDD into practice.” –Udi Dahan, Founder of NServiceBus Implementing Domain-Driven Design presents a top-down approach to understanding domain-driven design (DDD) in a way that fluently connects strategic patterns to fundamental tactical programming tools. Vaughn Vernon couples guided approaches to implementation with modern architectures, highlighting the importance and value of focusing on the business domain while balancing technical considerations. Building on Eric Evans' seminal book, Domain-Driven Design, the author presents practical DDD techniques through examples from familiar domains. Each principle is backed up by realistic Java examples–all applicable to C# developers–and all content is tied together by a single case study: the delivery of a large-scale Scrum-based SaaS system for a multitenant environment. The author takes you far beyond “DDD-lite” approaches that embrace DDD solely as a technical toolset, and shows you how to fully leverage DDD's “strategic design patterns” using Bounded Context, Context Maps, and the Ubiquitous Language. Using these techniques and examples, you can reduce time to market and improve quality, as you build software that is more flexible, more scalable, and more tightly aligned to business goals. Coverage includes Getting started the right way with DDD, so you can rapidly gain value from it Using DDD within diverse architectures, including Hexagonal, SOA, REST, CQRS, Event-Driven, and Fabric/Grid-Based Appropriately designing and applying Entities–and learning when to use Value Objects instead Mastering DDD's powerful new Domain Events technique Designing Repositories for ORM, NoSQL, and other databases
In his long-awaited book, Martin Fowler has done for application domain patterns what the Gang of Four [Gamma et al.] have done for general purpose design patterns in their book, Design Patterns: Elements of Reusable Object-Oriented Software. This book is a must have for all analysts and designers doing object-oriented business modeling and business process re-engineering. —Donald G. Firesmith, Knowledge Systems Corporation Fowler shares with you his wealth of object modeling experience and his keen eye for identifying repeating problems and transforming them into reusable models. Analysis Patterns provides a catalogue of patterns that have emerged in a wide range of domains, including trading, measurement, accounting, and organizational relationships.
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
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
Mike Keith, Merrick Schincariol
Pro JPA 2, Second Edition introduces, explains, and demonstrates how to use the new Java Persistence API (JPA) 2.1 from the perspective of one of the specification creators. A one-of-a-kind resource, it provides both theoretical and extremely practical coverage of JPA usage for both beginning and advanced developers. Authors Mike Keith and Merrick Schincariol take a hands–on approach, based on their wealth of experience and expertise, by giving examples to illustrate each concept of the API and showing how it is used in practice. 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 of JPA and be able to successfully code applications using its annotations and APIs. The book also serves as an excellent reference guide during initial and later JPA application experiences. Hands-on examples for all aspects of the JPA specification 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 How to get started with enterprise applications using JPA 2.1 Simple and advanced object–relational mapping techiques How to use the complete Entity Manager API How to create queries using the query language (JP QL) and the Criteria API Locking, concurrency, and other advanced concepts How to use XML mapping files and descriptors How to package and deploy your Java Persistence applications How to test 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 offer an introduction to persistence and to the basic concepts so these readers can have solid base from which to become proficient at JPA. Those who know and/or use existing ORM persistence products such as Hibernate or TopLink/EclipseLink. Those who have already used JPA and want to learn about newer features introduced by JPA 2.1, 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 Java EE. Table of Contents Introduction Getting Started Enterprise Applications Object Relational Mapping Collection Mapping Entity Manager Using Queries Java Persistence Query Language Criteria Advanced Object Relational Mapping Advanced Queries Advanced Topics XML Mapping Files Packaging and Deployment Testing
Peter A. Pilgrim
Java EE 7 Handbook is an example based tutorial with descriptions and explanations."Java EE 7 Handbook" is for the developer, designer, and architect aiming to get acquainted with the Java EE platform in its newest edition. This guide will enhance your knowledge about the Java EE 7 platform. Whether you are a long-term Java EE (J2EE) developer or an intermediate level engineer on the JVM with just Java SE behind you, this handbook is for you, the new contemporary Java EE 7 developer!
Gary Mak, Srinivas Guruzu
Hibernate continues to be the most popular out-of-the-box framework solution for Java Persistence and data/database accessibility techniques and patterns. It is used for e-commerce–based web applications as well as heavy-duty transactional systems for the enterprise. Gary Mak, the author of the best-selling Spring Recipes, now brings you Hibernate Recipes. This book contains a collection of code recipes and templates for learning and building Hibernate solutions for you and your clients. This book is your pragmatic day-to-day reference and guide for doing all things involving Hibernate. There are many books focused on learning Hibernate, but this book takes you further and shows how you can apply it practically in your daily work. What you’ll learn The basics of object-relational mapping and how Hibernate is best suited for it How to do various mappings, including one-to-one mapping, many-to-one mapping, collection mapping, component mapping, and inheritance mapping How to use Hibernate Query Language (HQL) How to perform batch processing and use native SQL, criteria queries, caching objects, and more How to enable Hibernate in web applications with e-commerce How to use Hibernate for heavy-duty enterprise transaction–based systems Who this book is for This book is for experienced Java developers looking to use Hibernate, but is also appropriate for Java developers new to Hibernate. Table of Contents Starting with Hibernate Basic Mapping and Object Identity Component Mapping Inheritance and Custom Mapping Many-to-One and One-to-One Mapping Collection Mapping Many-Valued Associations HQL and JPA Query Language Querying with Criteria and Example Working with Objects Batch Processing and Native SQL Cashing in Hibernate Transactions and Concurrency Web Applications
This guide is for the busy Java professional who needs quick solutions to everyday problems. Each recipe shows a concise code example right away and covers everything from getting a basic application up and running to advanced features such as deploying to other webservers and databases.