Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (The Addison-Wesley Signature Series)

Quite simply, test-driven development is meant to eliminate fear in application development. While some fear is healthy (often viewed as a conscience that tells programmers to "be careful!"), the author believes that byproducts of fear include tentative, grumpy, and uncommunicative programmers who are unable to absorb constructive criticism. When programming teams buy into TDD, they immediately see positive results. They eliminate the fear involved in their jobs, and are better equipped to tackle the difficult challenges that face them. TDD eliminates tentative traits, it teaches programmers to communicate, and it encourages team members to seek out criticism However, even the author admits that grumpiness must be worked out individually! In short, the premise behind TDD is that code should be continually tested and refactored. Kent Beck teaches programmers by example, so they can painlessly and dramatically increase the quality of their work.

Praise for Beyond Software Architecture

“Luke Hohmann is that rare software technologist who views software development from the viewpoint of the end user. He passionately believes that one hour spent with an end user is worth many hours making software architectural choices or days documenting perceived user requirements. Most of what is written about software development focuses on methods used to design and develop robust software. Luke’s latest effort, Beyond Software Architecture, illuminates the more mundane aspects of creating true business solutions by supporting the user throughout the lifecycle of the software product. By concerning himself with creating business value, Luke tightens the connection between a software application and the business function it performs.”

         &#8212Bruce Bourbon
             General Partner, Telos Venture Partners

“There are two kinds of people that read the Dilbert comic strip: folks that take a moment to marvel at how accurately it reflects life at their company before moving on to the next comic strip, and folks that think Dilbert is an amusing reminder that high tech companies can and should be better than Dilbert’s world. Anyone in the first group should stick to reading comics. This book is for people in the latter group.”

         —Tony Navarrete
             Vice President, Diamondhead Ventures

“Luke brings a proven methodology to the challenge of software development. In Beyond Software Architecture, Luke provides practical and proven techniques that all development executives can employ to improve the productivity of their software organization.”

         —G. Bradford Solso
             CEO, Taviz Technology

“Beyond Software Architecture is the first book I have read which contains an insider’s perspective of both the business and technical facets of software architecture. This is a great book to get marketers and software managers on the same page!”

         &#8212Damon Schechter
             CEO, LOC Global
             author of Delivering the Goods

“There are books on technical architecture and books on product marketing, but few, if any, on how architecture and marketing information must be integrated for world class product development. Beyond Software Architecture provides this valuable bridge between technology and marketing&#8212it explains how to deliver quality products that are profitable in the marketplace.”

         &#8212Jim Highsmith
             Director, Cutter Consortium
             author of Adaptive Software Development

“Product development managers, marketing managers, architects, and technical leads from all functions should read this book. You’ll see a pragmatic view of how to define and use a product architecture throughout a project’s lifecycle and a product's lifetime.”

         &#8212Johanna Rothman
             Rothman Consulting Group, Inc.

“Luke Hohmann has captured the essence of product creation in his latest book. He cleverly discusses the need for both the marketing and engineering roles in product creation and ties the two together building a good foundation for understanding and executing successful product creation.”

         &#8212Lee Sigler
             Principal, 360 Market View, Inc.

“Finally a book that deals with those often ignored but critical operational issues like licensing, deployment, installation, configuration and support. Beyond Software Architecture is the “What they don't teach you at Harvard Business School” book for anyone who develops software products&#8212or buys them.”

         &#8212Mary Poppendieck
             Managing Director, Agile Alliance
             President, Poppendieck LLC

“Luke Hohmann delivers a passionate, articulate wake-up call to software architects: it ain’t just technical any more! Technical architectures have profound business ramifications, and ignoring the business ramifications of portability, usability, configuration, upgrade and release management, security, and other architectural choices can not only lead to project failures, but ultimately to nasty lawsuits from disappointed customers. Beyond Software Architecture is a must-read for successful software product managers!”

         &#8212Ed Yourdon
             Author of numerous books and articles on software development

“Beyond Software Architecture is not just for software engineering professionals! Executives and product managers will find that the book provides the necessary background to make informed decisions about the software that their companies build. I have found that the book is a useful tool for building consensus between management and engineering, because it discusses business and customer-related issues without delving too deeply into implementation details.”

         &#8212David Chaiken
             Vice President, Systems Architecture
             AgileTV Corporation

“Product marketing influences product architecture. This shouldn’t be a surprise, yet most texts on software architecture are silent on this fact. This may be because we lack the language for distinguishing between the technical aspects of an architecture and the marketing aspects. Beyond Software Architecture provides the language to draw this important distinction, and provides strategies for overall architectural success.”

         &#8212Dave W. Smith

“Beyond Software Architecture, as the title implies, successfully addresses the often neglected aspects of developing total solutions. Hohmann demonstrates both passion and depth for the broad set of topics discussed.”

         &#8212Craig Priess
             Director Product Management, Resonant Software

“Looking through my technical library, it’s apparent that many books are obsolete, casualties of technical innovation and change. There are a few, however, that remain and continue to be relevant. Adding Luke Hohmann’s new book, Beyond Software Architecture: Creating and Sustaining Winning Solutions expands that selection and fills an important gap. It is the first book that I recall presenting a holistic approach to software creation. Going beyond the technical aspects by weaving together and linking critical business and marketing development in such a way to elevate and show how both technical and marketing processes must coalesce to create a winning solution. The topic's importance extends beyond programmers, designers and other technical staff, just as does its content. For marketing professionals, it shows how their decisions and strategies can impact technical decisions. For consumers, it can give them insight on the best ways to work with software manufacturers. For the software entrepreneur, it offers a plan for creating a successful venture. The content, at just the right amount of detail, is presented in easy-to-understand language and in such a way that the information is easy to retain and apply. The topics are timeless. The book will be relevant for a long time.”

         &#8212Clay Miller

“I highly recommend this book. As a former software company CEO and founder I have worked with many software engineers and had a number of VPs of engineering report to me. Luke was and is one of the best. He is not only a great engineer, but has a keen grasp of the strategic business issues that must drive good code and architectural decisions. I consider Beyond Software Architecture required reading for anyone building software systems.”

         &#8212Kevin Rivette
             Executive Advisor, BCG Consulting
             author of Rembrandts In The Attic

“Perhaps you’ve met, or worked with, or heard speak at events, or read the writings of someone who expects reverence because he commands academic knowledge of the latest software patterns, technologies, or development processes and tools. So what, you say. Suppose you take such knowledge for granted. Suppose that knowledge is the minimum qualification for a member of your team. Then what? What separates a real contributor to the success of your project and organization, from the average bookish expert of the day? In Beyond Software Architecture, Luke Hohmann writes of the stuff that makes up those answers. Installation and upgrade. Configurability and customization of your software. Integration with other software. Usability. Logging. Interdepartmental processes and release management. Business models, licensing, and deployment choices. The stuff that makes software development much bigger, and much messier, than UML diagrams of some pattern implemented with components. The stuff that makes software development real. Luke knows because he’s been in the trenches, trying to make businesses successful. He spends his time doing it more than writing and talking about it. But now he distills his insights and shares the benefit of his experience. If you’re like me, you’ll find yourself nodding your head and underlining passages as you read this book. Luke’s observations will resonate with you. Your organization, and the software development profession as a whole, can benefit from using the vocabulary and ideas in this book. So you’ll want to recommend it to others, which is exactly what I’m doing here.”

         &#8212Randy Stafford
             Chief Architect, IQNavigator, Inc.

“Hohmann’s book provides a unique perspective on how the many and subtle technology decisions shape the economic and strategic landscape. Corporate strategists in many industries will find these insights enormously valuable.”

         &#8212Martha Amram
             Strategic Advisor and Consultant
             author of Value Sweep and co-author of Real Options

“Luke put his tremendous experience to good use by eliminating the us versus them approach of marketing and engineering departments. This book is a must for every senior engineer, software architect, and product manager. With the practical advice in this book they can concentrate on beating the competitors.”

         &#8212Heinrich Gantenbein

“I once was a QA manager for Luke Hohmann. I can tell you the guy knows competitive software development. He was in the trenches with us, working through technical problems and sweating the difficult business decisions. He’s uniquely qualified to write about both the business and technical side of software architecture, and this book successfully bridges both worlds. The result is a seminal handbook for product managers and directors of software engineering.”

         &#8212James Bach
             Founder, Satisfice, Inc.

“Too many times my firm is asked to resolve a dispute that could have been avoided had the companies involved with the dispute more clearly defined their business and licensing models before the contract was signed. In Beyond Software Architecture, Luke Hohmann clearly explains how to avoid unnecessary and costly disputes regarding business and licensing models. This is a must read book for senior product managers and technical executives.”

         &#8212Rob Sterne
             Founder, Sterne, Kessler, Goldstein and Fox
             International Authority in Intellectual Property

“Luke Hohmann’s excellent BSA communicates essential hard-won insights from a rare individual&#8212both architect and business leader&#8212who shows us that architecture is more than describing layers; it’s about creating winning solutions through understanding, and resolving the market, business, and technical forces.”

         &#8212Craig Larman
             author, Applying UML and Patterns: An Introduction to OOA&D and the Rational Unified Process

“By stepping back and evaluating the interaction between business drivers and software development, Beyond Software Architecture provides the perspective to create a winning solution. This book is a practical guide for achieving quick time to market solutions through the identification of pitfalls and suggests pragmatic alternatives to effective solution development. Real life examples provide an instructional view of the life cycle phases, including clear roles and responsibilities, as seen by the entire project team. Knowing when to give up the ghost, seek the help of others, or simply leverage a proven model, Beyond Software Architecture explores the alternatives and identifies key decision points. A must read for software architects and product managers seeking an understanding of the challenges and dynamics of a successful software development effort, and a winning solution&#8212the first time.”

         &#8212Mark Welke
             High Availability Marketing Manager, Hewlett Packard

“The thing you need to consider when creating a great application is “Everything.” Great applications do not usually come from a single great idea, great architecture, or great appreciation of the customer’s need. Instead they come out of a unique confluence of a large number of factors encompassing marketing, technology, psychology, support, economics, legal factors, and more. While many books address individual aspects of software application development, Luke Hohmann’s book, Beyond Software Architecture, addresses a very broad range of topics, all of which should be addressed in the creation of every application, but often aren’t. I would recommend that anyone involved in the creation of a software application read this book as a guide to the things that need to be considered in the process. No book can cover “everything,” but this one is a laudable attempt.”

         &#8212Jim Gay
             One Jump Consulting

“A successful software product’s technical architecture must align with the realities of the marketplace. While the goal is obvious, marketers and technologist often find themselves in two warring camps, separated by a chasm of incompatible attitudes and expectations. If you want to close this gap and focus on product success, this book is required reading for both sides.”

         &#8212Dave Quick
             Architect, Integrated Solutions Development Group, Microsoft, Inc.

“As a technologist who has transitioned to product team leadership, this book distils many of the lessons I’ve learned through study, trial, and error. As someone who still bridges the gap between software development and executive management, I found this book a great refresher and filled with little “oh yeah!” insights. And, as I continue to work with teams to manage and develop new products, I’m sure I’ll use it as a reference and a teaching resource, bringing the “big picture” into view and avoiding costly pitfalls. Anyone managing product development or marketing, aspiring to manage, or unhappy with current management should definitely read Hohmann’s work.”

         &#8212Todd Girvin
             President, Optiview Inc.

“Over the years, I’ve seen many projects that have failed, or struggled, to cross the bridge between new product invention and creating a winning solution. This book provides a practical set of guidelines—it’s a useful, and usable, book.”

         —Dan'l Lewin
             Corporate Vice President of Microsoft .NET Business Development

“The real magic happens where business and technology ideas meet. This book will help you make the connection.”

         —David A. Lancashire
             CEO, Geniant

Successfully managing the relationship between business and technology is a daunting task faced by all companies in the twenty-first century. Beyond Software Architecture is a practical guide to properly managing this mission-critical relationship. In our modern economy, every software decision can have a significant impact on business; conversely, most business decisions will influence a software application's viability. This book contains keen insights and useful lessons about creating winning software solutions in the context of a real-world business.

Software should be designed to deliver value to an organization, but all too often it brings turmoil instead. Powerful applications are available in the marketplace, but purchasing or licensing these technologies does not guarantee success. Winning solutions must be properly integrated into an organization's infrastructure.

Software expert Luke Hohmann teaches you the business ramifications of software-architecture decisions, and further instructs you on how to understand and embrace the business issues that must be resolved to achieve software success. Using this book as a roadmap, business managers and development teams can safely navigate the minefield of important decisions that they face on a regular basis. The resulting synergy between business and technology will allow you to create winning technology solutions, and ensure your organization's success--now and in the future.

Cover......Page 1 Contents......Page 8 Foreword......Page 16 Foreword......Page 18 Preface......Page 20 Acknowledgments......Page 26 Introduction......Page 30 The Need for Integration......Page 54 Integration Challenges......Page 55 How Integration Patterns Can Help......Page 57 The Wide World of Integration......Page 58 Loose Coupling......Page 62 One-Minute EAI......Page 64 A Loosely Coupled Integration Solution......Page 68 Widgets & Gadgets 'R Us: An Example......Page 70 Taking Orders......Page 71 Processing Orders......Page 73 Checking Status......Page 79 Change Address......Page 83 New Catalog......Page 85 Announcements......Page 86 Testing and Monitoring......Page 87 Summary......Page 90 Introduction......Page 92 File Transfer......Page 96 Shared Database......Page 100 Remote Procedure Invocation......Page 103 Messaging......Page 106 Introduction......Page 110 Message Channel......Page 113 Message......Page 119 Pipes and Filters......Page 123 Message Router......Page 131 Message Translator......Page 138 Message Endpoint......Page 148 Introduction......Page 152 Point-to-Point Channel......Page 156 Publish-Subscribe Channel......Page 159 Datatype Channel......Page 164 Invalid Message Channel......Page 168 Dead Letter Channel......Page 172 Guaranteed Delivery......Page 175 Channel Adapter......Page 180 Messaging Bridge......Page 186 Message Bus......Page 190 Introduction......Page 196 Command Message......Page 198 Document Message......Page 200 Event Message......Page 204 Request-Reply......Page 207 Return Address......Page 212 Correlation Identifier......Page 216 Message Sequence......Page 223 Message Expiration......Page 229 Format Indicator......Page 233 Request-Reply Example......Page 236 Publish-Subscribe Example......Page 238 Request-Reply Example......Page 240 Request-Reply Code......Page 242 Invalid Message Example......Page 249 Conclusions......Page 250 Request-Reply Example......Page 251 Request-Reply Code......Page 253 Invalid Message Example......Page 258 Conclusions......Page 259 The Observer Pattern......Page 260 Distributed Observer......Page 261 Publish-Subscribe......Page 262 Comparisons......Page 265 Push and Pull Models......Page 266 Channel Design......Page 272 Conclusions......Page 275 Introduction......Page 278 Content-Based Router......Page 283 Message Filter......Page 290 Dynamic Router......Page 296 Recipient List......Page 302 Splitter......Page 312 Aggregator......Page 321 Resequencer......Page 336 Composed Message Processor......Page 347 Scatter-Gather......Page 350 Routing Slip......Page 354 Process Manager......Page 365 Message Broker......Page 375 Introduction......Page 380 Envelope Wrapper......Page 383 Content Enricher......Page 389 Content Filter......Page 395 Claim Check......Page 399 Normalizer......Page 405 Canonical Data Model......Page 408 Obtaining a Loan Quote......Page 414 Designing the Message Flow......Page 415 Sequencing: Synchronous versus Asynchronous......Page 417 Addressing: Distribution versus Auction......Page 419 Managing Concurrency......Page 421 Three Implementations......Page 422 Solution Architecture......Page 424 Web Services Design Considerations......Page 425 Apache Axis......Page 429 The Loan Broker Application......Page 432 Components of the Loan Broker Application......Page 434 Client Application......Page 449 Running the Solution......Page 450 Performance Limitations......Page 452 Summary......Page 453 Loan Broker Ecosystem......Page 454 Laying the Groundwork: A Messaging Gateway......Page 455 Base Classes for Common Functionality......Page 458 Designing the Bank......Page 463 Designing the Credit Bureau......Page 465 Designing the Loan Broker......Page 466 Refactoring the Loan Broker......Page 484 Improving Performance......Page 488 A Few Words on Testing......Page 493 Limitations of This Example......Page 496 Summary......Page 497 Solution Architecture......Page 498 The Implementation Toolset......Page 501 The Interfaces......Page 504 Implementing the Synchronous Services......Page 505 The Loan Broker Process......Page 508 Managing Concurrent Auctions......Page 512 Execution......Page 513 Conclusions......Page 515 Introduction......Page 516 Messaging Gateway......Page 521 Messaging Mapper......Page 530 Transactional Client......Page 537 Polling Consumer......Page 547 Event-Driven Consumer......Page 551 Competing Consumers......Page 555 Message Dispatcher......Page 561 Selective Consumer......Page 568 Durable Subscriber......Page 575 Idempotent Receiver......Page 581 Service Activator......Page 585 Introduction......Page 590 Control Bus......Page 593 Detour......Page 598 Wire Tap......Page 600 Message History......Page 604 Message Store......Page 608 Smart Proxy......Page 611 Test Message......Page 622 Channel Purger......Page 625 Loan Broker System Management......Page 630 Instrumenting the Loan Broker......Page 631 Loan Broker Quality of Service......Page 632 Verify the Credit Bureau Operation......Page 640 Credit Bureau Failover......Page 645 Enhancing the Management Console......Page 648 Limitations of This Example......Page 655 Building a System......Page 656 Architecture with Patterns......Page 657 Structuring Channels......Page 663 Selecting a Message Channel......Page 667 Flashing Market Data Updates......Page 671 Major Production Crash......Page 673 Summary......Page 676 Emerging Standards and Futures in Enterprise Integration......Page 678 The Relationship between Standards and Design Patterns......Page 679 Survey of Standards Processes and Organizations......Page 680 Business Process Components and Intra-Web Service Messaging......Page 682 ebXML and the Electronic Business Messaging Service (ebMS)......Page 684 Business Process Execution Language for Web Services (BEPL4WS)......Page 687 Web Service Choreography Interface (WSCI)......Page 689 Java Business Process Component Standards......Page 690 WS-*......Page 692 Conclusions......Page 700 Bibliography......Page 702 A......Page 712 B......Page 713 C......Page 714 D......Page 716 E......Page 718 G......Page 719 I......Page 720 L......Page 721 M......Page 723 N......Page 726 P......Page 727 R......Page 729 S......Page 733 T......Page 734 W......Page 735 X......Page 736 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

Clean code that works--now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox--test the program before you write it.

A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works--now.

Developers face complex programming challenges every day, yet they are not always readily prepared to determine the best solution. More often than not, such difficult projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence.

By driving development with automated tests and then eliminating duplication, any developer can write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages programmers to learn quickly, communicate more clearly, and seek out constructive feedback.

Readers will learn to:

• Solve complicated tasks, beginning with the simple and proceeding to the more complex.
• Write automated tests before coding.
• Grow a design organically by refactoring to add design decisions one at a time.
• Create tests for more complicated logic, including reflection and exceptions.
• Use patterns to decide what tests to write.
• Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools.

This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques.

0321146530B10172002

Annotation Clean code that works--now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox--test the program before you write it. A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works--now. Developers face complex programming challenges every day, yet they are not always readily prepared to determine the best solution. More often than not, such difficult projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence. By driving development with automated tests and then eliminating duplication, any developer can write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages programmers to learn quickly, communicate more clearly, and seek out constructive feedback. Readers will learn to: Solve complicated tasks, beginning with the simple and proceeding to the more complex. Write automated tests before coding. Grow a design organically by refactoring to add design decisions one at a time. Create tests for more complicated logic, including reflection and exceptions. Use patterns to decide what tests to write. Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools. This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques. 0321146530B10172002 The practice of enterprise application development has benefited from the emergence of many new enabling technologies. Multi-tiered object-oriented platforms, such as Java and.NET, have become commonplace. These new tools and technologies are capable of building powerful applications, but they are not easily implemented. Common failures in enterprise applications often occur because their developers do not understand the architectural lessons that experienced object developers have learned. Patterns of Enterprise Application Architecture is written in direct response to the stiff challenges that face enterprise application developers. The author, noted object-oriented designer Martin Fowler, noticed that despite changes in technology--from Smalltalk to CORBA to Java to.NET--the same basic design ideas can be adapted and applied to solve common problems. With the help of an expert group of contributors, Martin distills over forty recurring solutions into patterns. The result is an indispensable handbook of solutions that are applicable to any enterprise application platform. This book is actually two books in one. The first section is a short tutorial on developing enterprise applications, which you can read from start to finish to understand the scope of the book's lessons. The next section, the bulk of the book, is a detailed reference to the patterns themselves. Each pattern provides usage and implementation information, as well as detailed code examples in Java or C#. The entire book is also richly illustrated with UML diagrams to further explain the concepts. Armed with this book, you will have the knowledge necessary to make important architectural decisions about building an enterprise application and the proven patterns for use when building them. The topics covered include · Dividing an enterprise application into layers · The major approaches to organizing business logic · An in-depth treatment of mapping between objects and relational databases · Using Model-View-Controller to organize a Web presentation · Handling concurrency for data that spans multiple transactions · Designing distributed object interfaces Patterns of Enterprise Application Architecture is written in direct response to the stiff challenges that face enterprise application developers. The author, noted object-oriented designer Martin Fowler, noticed that despite changes in technology--from Smalltalk to CORBA to Java to .NET--the same basic design ideas can be adapted and applied to solve common problems. With the help of an expert group of contributors, Martin distills over forty recurring solutions into patterns. The result is an indispensable handbook of solutions that are applicable to any enterprise application platform. This book is actually two books in one. The first section is a short tutorial on developing enterprise applications, which you can read from start to finish to understand the scope of the book's lessons. The next section, the bulk of the book, is a detailed reference to the patterns themselves. Each pattern provides usage and implementation information, as well as detailed code examples in Java or C#. The entire book is also richly illustrated with UML diagrams to further explain the concepts. Armed with this book, you will have the knowledge necessary to make important architectural decisions about building an enterprise application and the proven patterns for use when building them Developers of enterprise applications (e.g reservation systems, supply chain programs, financial systems, etc.) face a unique set of challenges, different than those faced by their desktop system and embedded system peers. For this reason, enterprise developers must uncover their own solutions. In this new book, noted software engineering expert Martin Fowler turns his attention to enterprise application development. He helps professionals understand the complex -- yet critical -- aspects of architecture. While architecture is important to all application development, it is particularly critical to the success of an enterprise project, where issues such as performance and concurrent multi-user access are paramount. The book presents patterns (proven solutions to recurring problems) in enterprise architecture, and the context provided by the author enables the reader to make the proper choices when faced with a difficult design decision. Annotation At last, a book that provides the software engineering community with a clearer understanding of the business value of software architecture. There are currently a significant number of books on creating, documenting, and implementing software architecture, but precious few resources have addressed how to build a software architecture that aligns with a customer's overall business goals. In this new book, Luke Hohmann borrows from his extensive experience managing successful enterprise software projects to provide practical wisdom on creating and sustaining winning software solutions. This book helps technologists grasp the business ramifications of their decisions, and provides business-oriented software professionals (e.g. sales people and marketers) with better knowledge of how robust software can be built and maintained. "This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques."--Jacket Contains insights and lessons about creating winning software solutions in the context of a real-world business. This book provides practical techniques that development executives can employ to improve the productivity of their software organization. It deals with issues like licensing, deployment, installation, configuration, and support. A collection of hands-on lessons based upon the authors' considerable experience in enterprise integration, the 65 patterns included with this guide show how to use message-oriented middleware to connect enterprise applications