Neal Ford

Mark Richards

Although salary surveys worldwide regularly identify software architect as one of the top ten best jobs, no decent guides exist to help developers become architects. Until now. This practical guide provides the first comprehensive overview of software architecture's many aspects. You'll examine architectural characteristics, architectural patterns, component determination, diagramming and presenting architecture, evolutionary architecture, and many other topics. Authors Neal Ford and Mark Richards help you learn through examples in a variety of popular programming languages, such as Java, C#, JavaScript, and others. You'll focus on architecture principles with examples that apply across all technology stacks.

An Engineering Approach

Fundamentals of Software Architecture

Patrick Kua

Rebecca Parsons

"The software development ecosystem is constantly changing, providing a constant stream of new tools, frameworks, techniques, and paradigms. Over the past few years, incremental developments in core engineering practices for software development have created the foundations for rethinking how architecture changes over time, along with ways to protect important architectural characteristics as it evolves. This practical guide ties those parts together with a new way to think about architecture and time."--Amazon.com.

Support Constant Change

Building Evolutionary Architectures

Pramod Sadalage

Zhamak Dehghani

Architects are often harried because they have no clean, easy decisions: everything is an awful tradeoff between two or more less than perfect alternatives. These are the difficult problems architects face, what this book's authors call "the hard parts." These topics have no best practices, forcing architects to understand various tradeoffs to succeed. This book discusses these hard parts by not only investigating what makes architecture so difficult, but also by providing proven ways to address these problems and make them easier. The book explores topics such as choosing an appropriate architecture, deciding on service granularity, managing workflows and orchestration, managing and decoupling contracts, managing distributed transactions, and optimizing operational characteristics such as scalability, elasticity, and performance. As practicing consultants, the authors focus on questions they commonly hear architects ask and provide techniques that enable them to discover the tradeoffs necessary to answer these questions.

Modern Tradeoff Analysis for Distributed Architectures

Software Architecture: the Hard Parts

Anyone who develops software for a living needs a proven way to produce it better, faster, and cheaper. The Productive Programmer offers critical timesaving and productivity tools that you can adopt right away, no matter what platform you use. Master developer Neal Ford not only offers advice on the mechanics of productivity-how to work smarter, spurn interruptions, get the most out your computer, and avoid repetition-he also details valuable practices that will help you elude common traps, improve your code, and become more valuable to your team. You'll learn to: Write the test before you write the code Manage the lifecycle of your objects fastidiously Build only what you need now, not what you might need later Apply ancient philosophies to software development Question authority, rather than blindly adhere to standards Make hard things easier and impossible things possible through meta-programming Be sure all code within a method is at the same level of abstraction Pick the right editor and assemble the best tools for the job This isn't theory, but the fruits of Ford's real-world experience as an Application Architect at the global IT consultancy ThoughtWorks. Whether you're a beginner or a pro with years of experience, you'll improve your work and your career with the simple and straightforward principles in The Productive Programmer.

The Productive Programmer

Matthew J. McCullough

Nathaniel T. Schutta

The first practical, patterns-based guide to creating technical presentations that are powerful, effective - and never, ever boring! * *Time-tested patterns and concrete solutions that can bring life and RESULTS to any technical presentation, no matter how complex or challenging the material. *Organized to use the standard 'Patterns' format thousands of software developers, architects, and other technical professionals already know and love. *Companion website demonstrates many key patterns at work. There are plenty of books on making better presentations, but many focus on theory, not practice - and few address the unique challenges of making a great technical presentation. For thousands of technical presenters, Presentation Patterns offers a far better solution. It brings together concrete solutions any technical professional can use to create compelling, engaging, successful presentations, no matter how complex or difficult their material. This book is organized to follow the classic 'patterns' format that has already helped thousands of software developers and architects master best practices for becoming more effective in their fields. The authors identify and illuminate more than 50 patterns for creating high-impact technical presentations. Each is introduced with a memorable name, defined, and motivated. Readers learn where it is applicable, the consequences of applying it, and specific step-by-step mechanics for utilizing it. The authors also present a series of anti-patterns: clichés, fallacies, and major design mistakes - all of them easy to avoid, once presenters know how. Many of this book's patterns are linked to a companion website, presentationpatterns.com, where the authors show them at work. The solutions in this book are designed to work even for presenters with no visual talent, no design training, no presentation experience, and no budget!

Techniques for Crafting Better Presentations

Presentation Patterns

The software development ecosystem is constantly changing, providing a constant stream of new tools, frameworks, techniques, and paradigms. Over the past few years, incremental developments in core engineering practices for software development have created the foundations for rethinking how architecture changes over time, along with ways to protect important architectural characteristics as it evolves. This practical guide ties those parts together with a new way to think about architecture and time.

Michael Keeling

Dave Farley

Christian Ciceri

Andrew Harmel-Law

Case Studies to Improve the Quality of Your Architecture

Software Architecture Metrics

Salary surveys worldwide regularly place software architect in the top 10 best jobs, yet no real guide exists to help developers become architects. Until now. This book provides the first comprehensive overview of software architecture’s many aspects. Aspiring and existing architects alike will examine architectural characteristics, architectural patterns, component determination, diagramming and presenting architecture, evolutionary architecture, and many other topics. Mark Richards and Neal Ford—hands-on practitioners who have taught software architecture classes professionally for years—focus on architecture principles that apply across all technology stacks. You’ll explore software architecture in a modern light, taking into account all the innovations of the past decade. This book examines: Architecture patterns: The technical basis for many architectural decisions Components: Identification, coupling, cohesion, partitioning, and granularity Soft skills: Effective team management, meetings, negotiation, presentations, and more Modernity: Engineering practices and operational approaches that have changed radically in the past few years Architecture as an engineering discipline: Repeatable results, metrics, and concrete valuations that add rigor to software architecture

There are no easy decisions in software architecture. Instead, there are many hard parts--difficult problems or issues with no best practices--that force you to choose among various compromises. With this book, you'll learn how to think critically about the trade-offs involved with distributed architectures. Architecture veterans and practicing consultants Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani discuss strategies for choosing an appropriate architecture. By interweaving a story about a fictional group of technology professionals--the Sysops Squad--they examine everything from how to determine service granularity, manage workflows and orchestration, manage and decouple contracts, and manage distributed transactions to how to optimize operational characteristics, such as scalability, elasticity, and performance. By focusing on commonly asked questions, this book provides techniques to help you discover and weigh the trade-offs as you confront the issues you face as an architect. Analyze trade-offs and effectively document your decisions Make better decisions regarding service granularity Understand the complexities of breaking apart monolithic applications Manage and decouple contracts between services Handle data in a highly distributed architecture Learn patterns to manage workflow and transactions when breaking apart applications

Software Architecture: The Hard Parts

If you’re familiar with functional programming basics and want to gain a much deeper understanding, this in-depth guide takes you beyond syntax and demonstrates how you need to think in a new way. Software architect Neal Ford shows intermediate to advanced developers how functional coding allows you to step back a level of abstraction so you can see your programming problem with greater clarity. Each chapter shows you various examples of functional thinking, using numerous code examples from Java 8 and other JVM languages that include functional capabilities. This book may bend your mind, but you’ll come away with a much better grasp of functional programming concepts. Understand why many imperative languages are adding functional capabilities Compare functional and imperative solutions to common problems Examine ways to cede control of routine chores to the runtime Learn how memoization and laziness eliminate hand-crafted solutions Explore functional approaches to design patterns and code reuse View real-world examples of functional thinking with Java 8, and in functional architectures and web frameworks Learn the pros and cons of living in a paradigmatically richer world If you’re new to functional programming, check out Josh Backfield’s book Becoming Functional.

Paradigm Over Syntax

Functional Thinking

Salary surveys worldwide regularly place software architect in the top 10 best jobs, yet no real guide exists to help developers become architects. Until now. This updated edition provides a comprehensive overview of software architecture's many aspects, with five new chapters covering the latest insights from the field. Aspiring and existing architects alike will examine architectural characteristics, architectural patterns, component determination, diagramming architecture, governance, data, generative AI, team topologies, and many other topics. Mark Richards and Neal Ford—hands-on practitioners who have taught software architecture classes professionally for years—focus on architecture principles that apply across all technology stacks. You'll explore software architecture in a modern light, taking into account all the innovations of the past decade. This book examines: Architecture styles and patterns: Microservices, modular monoliths, microkernels, layered architectures, and many more Components: Identification, coupling, cohesion, partitioning, and granularity Soft skills: Effective team management, collaboration, business engagement models, negotiation, presentations, and more Modernity: Engineering practices and operational approaches that have changed radically in the past few years, including cloud considerations and generative AI Architecture as an engineering discipline: Repeatable results, metrics, and concrete valuations that add rigor to software architecture

Eoin Woods

Carola Lilienthal

João Rosa

Alexander von Zitzewitz

Rene Weiss

Software architecture metrics are key to the maintainability and architectural quality of a software project and they can warn you about dangerous accumulations of architectural and technical debt early in the process. In this practical book, leading hands-on software architects share case studies to introduce metrics that every software architect should know. This isn't a book about theory. It's more about practice and implementation, about what has already been tried and worked. Detecting software architectural issues early is crucial for the success of your software: it helps mitigate the risk of poor performance and lowers the cost of repairing those issues. Written by practitioners for software architects and software developers eager to explore successful case studies, this guide will help you learn more about decision and measurement effectiveness. Through contributions from 10 prominent practitioners, this book shares key software architecture metrics to help you set the right KPIs and measure the results. You'll learn how to: Measure how well your software architecture is meeting your goals Choose the right metrics to track (and skip the ones you don't need) Improve observability, testability, and deployability Prioritize software architecture projects Build insightful and relevant dashboards

Wer seine Brötchen mit Software-Entwicklung verdient, braucht Strategien, um besser, schneller und kostengünstiger zu programmieren. Dieses Buch bietet Ihnen erprobte Hilfsmittel, die Zeit sparen, Ihre Produktivität erhöhen, und die Sie unabhängig von der.

Produktiv programmieren

Brandon Byars

Premanand Chandrasekaran

Karthik Krishnan

Allard Buijze

Adopt a practical and modern approach to architecting and implementing DDD-inspired solutions to transform abstract business ideas into working software across the entire spectrum of the software development life cycle Key Features Implement DDD principles to build simple, effective, and well-factored solutions Use lightweight modeling techniques to arrive at a common collective understanding of the problem domain Decompose monolithic applications into loosely coupled, distributed components using modern design patterns Book Description Domain-Driven Design (DDD) makes available a set of techniques and patterns that enable domain experts, architects, and developers to work together to decompose complex business problems into a set of well-factored, collaborating, and loosely coupled subsystems. This practical guide will help you as a developer and architect to put your knowledge to work in order to create elegant software designs that are enjoyable to work with and easy to reason about. You'll begin with an introduction to the concepts of domain-driven design and discover various ways to apply them in real-world scenarios. You'll also appreciate how DDD is extremely relevant when creating cloud native solutions that employ modern techniques such as event-driven microservices and fine-grained architectures. As you advance through the chapters, you'll get acquainted with core DDD's strategic design concepts such as the ubiquitous language, context maps, bounded contexts, and tactical design elements like aggregates and domain models and events. You'll understand how to apply modern, lightweight modeling techniques such as business value canvas, Wardley mapping, domain storytelling, and event storming, while also learning how to test-drive the system to create solutions that exhibit high degrees of internal quality. By the end of this software design book, you'll be able to architect, design, and implement robust, resilient, and performant distributed software solutions. What you will learn Discover how to develop a shared understanding of the problem domain Establish a clear demarcation between core and peripheral systems Identify how to evolve and decompose complex systems into well-factored components Apply elaboration techniques like domain storytelling and event storming Implement EDA, CQRS, event sourcing, and much more Design an ecosystem of cohesive, loosely coupled, and distributed microservices Test-drive the implementation of an event-driven system in Java Grasp how non-functional requirements influence bounded context decompositions Who this book is for This book is for intermediate Java programmers looking to upgrade their software engineering skills and adopt a collaborative and structured approach to designing complex software systems. Specifically, the book will assist senior developers and hands-on architects to gain a deeper understanding of domain-driven design and implement it in their organization. Familiarity with DDD techniques is not a prerequisite; however, working knowledge of Java is expected.

Create simple, elegant, and valuable software solutions for complex business problems

Domain-Driven Design with Java - A Practitioner's Guide

Terry Dietzler

Edward C. Weber

Talal Azzouka

Casey Williams

Jennifer Streeter

JBuilder 3 Unleashed is designed to help intermediate to advanced level Java developers obtain the information and techniques needed to create mission critical JBuilder applications. The book picks up where most JBuilder books leave off and provides the information needed by developers to create robust and maintainable JBuilder Client/Server and multi-tier applications. Topics covered include: Advanced object-oriented design and programming techniques in Java, Enterprise JavaBeans, Serialization, Threading, NMI, Multi-tier development: implementation of applications and applets, RMI, CORBA, Enprise's MIDAS technology, N-tier, Application Development, Source code control, Deployment.

JBuilder 3 Unleashed

Presents a collection of articles covering such topics as web services, DSLs, Shale, legacy code, and CSS.

The 2006 Edition

No Fluff, Just Stuff Anthology

A guide to the skills required for state-of-the-art web development, this book covers a variety of web development frameworks. The uses of the standard web API to create applications with increasingly sophisticated architectures are highlighted, and a discussion of the development of industry-accepted best practices for architecture is included. The history and evolution toward this architecture and the reasons it is superior to previous efforts are described, and an overview of the most popular web application frameworks, their architecture, and use is provided. The same application is built in six different frameworks, allowing developers to conduct an informed comparison. An evaluation of the pros and cons of each framework is provided to assist developers in making decisions or evaluating frameworks on their own. Best practices covered include sophisticated user interface techniques, intelligent caching and resource management, performance tuning, debugging, testing, and web services.

Struts, Tapestry, Commons, Velocity, Junit, Axis, Cocoon, Internetbeans, Webwork

Art of Java Web Development

"Software architecture has often been described as 'the parts that are hard to change later.' But the widespread adoption of microservices demonstrates that when architects build evolvability into the architecture, change becomes easier. This video introduces the principles of evolutionary architecture -- the software architecture that supports constant change. Designed for the intermediate-level software architect or developer tasked with migrating to or implementing a new cloud-based or distributed-system architecture, the course equips you with the knowledge and tools you'll need to put evolutionary architecture into practice."--Resource description page.

Neal Ford

Books

Your next favorite book is out there