Developers need to understand how to use constraints as guiderails that ensure desired outcomes, and how seemingly small changes can affect a system's properties.

    With this book, you'll get a candid and insightful look at how software is constructed and maintained by some of the world's leading practitioners.Titus Winters, Tom Manshreck, and Hyrum K. Wright, software engineers and a technical writer at Google, reframe how software engineering is practiced and taught: from an emphasis on programming to an emphasis on software engineering, which roughly translates to programming over time.You'll learn:Fundamental differences between software engineering and programmingHow an organization effectively manages a living codebase and efficiently responds to inevitable changeWhy culture (and recognizing it) is important, and how processes, practices, and tools come into play

    The twelve-factor app is a methodology for building software-as-a-service apps that: - Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; - Have a clean contract with the underlying operating system, offering maximum portability between execution environments; - Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration; - Minimize divergence between development and production, enabling continuous deployment for maximum agility; - And can scale up without significant changes to tooling, architecture, or development practices.The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc).

    This work includes the practices and techniques of Responsibility-Driven Design, and show how to apply them as you develop modern object-based applications. It is suitable for software designers and students.

    Many of these patterns are successful by themselves, but as this practical ebook demonstrates, they provide a more holistic and compelling approach when applied together.Author Ben Stopford explains how service-based architectures and stream processing tools such as Apache Kafka® can help you build business-critical systems.* Learn why streaming beats request-response based architectures in complex, contemporary use cases* Understand why replayable logs such as Kafka provide a backbone for both service communication and shared datasets* Explore how event collaboration and event sourcing patterns increase safety and recoverability with functional, event-driven approaches* Apply patterns including Event Sourcing and CQRS, and how to build multi-team systems with microservices and SOA using patterns such as “inside out databases” and “event streams as a source of truth”* Build service ecosystems that blend event-driven and request-driven interfaces using a replayable log and Kafka's Streams API* Scale beyond individual teams into larger, department- and company-sized architectures, using event streams as a source of truth

    

    Thread programming enables developers to design applications that are more responsive to user demands, faster, and more easily controlled. This book offers comprehensive coverage of this vital aspect of the Java language. The book is completely up-to-date with the new thread model that is now incorporated into the most recent version of the Java Virtual Machine. All Java programmers interested in doing concurrent programming must understand these new concepts. The book approaches the topic from a design pattern point of view. It introduces and summarizes Java's concurrency support, shows readers how to initiate, control, and coordinate concurrent activities, and offers numerous recipe-like techniques for designing and implementing Java structures that solve common concurrent programming challenges. Specifically, the book presents important strategies for avoiding the inconsistencies that can crop up in multi-threaded programs, addresses the concept of liveness-how to ensure that all threads in use are kept active simultaneously, examines state-dependent action, and demonstrates effective methods for handling user requests in a multi-threaded environment.

    Discover how more than 35 Tech Leads find the delicate balance between the technical and non-technical worlds. Discover the challenges a Tech Lead faces and how to overcome them. You may be surprised by the lessons they have to share.Now available at https://leanpub.com/talking-with-tech...

    After splitting a monolithic application or building a microservice ecosystem from scratch, many engineers are left wondering what s next. In this practical book, author Susan Fowler presents a set of microservice standards in depth, drawing from her experience standardizing over a thousand microservices at Uber. You ll learn how to design microservices that are stable, reliable, scalable, fault tolerant, performant, monitored, documented, and prepared for any catastrophe.Explore production-readiness standards, including:Stability and Reliability: develop, deploy, introduce, and deprecate microservices; protect against dependency failuresScalability and Performance: learn essential components for achieving greater microservice efficiencyFault Tolerance and Catastrophe Preparedness: ensure availability by actively pushing microservices to fail in real timeMonitoring: learn how to monitor, log, and display key metrics; establish alerting and on-call proceduresDocumentation and Understanding: mitigate tradeoffs that come with microservice adoption, including organizational sprawl and technical debt"

    While it's safe to say that relational databases aren't going anywhere, we can also say that the ecosystem around data is never going to be the same.Of all the new tools and solutions, for me, Redis has been the most exciting. Why? First because it's unbelievably easy to learn. Hours is the right unit to use when talking about length of time it takes to get comfortable with Redis. Secondly, it solves a specific set of problems while at the same time being quite generic. What exactly does that mean? Redis doesn't try to be all things to all data. As you get to know Redis, it'll become increasingly evident what does and what does not belong in it. And when it does, as a developer, it's a great experience.While you can build a complete system using Redis only, I think most people will find that it supplements their more generic data solution - whether that be a traditional relational database, a document-oriented system, or something else. It's the kind of solution you use to implement specific features. In that way, it's similar to an indexing engine. You wouldn't build your entire application on Lucene. But when you need good search, it's a much better experience - for both you and your users. Of course, the similarities between Redis and indexing engines end there.The goal of this book is to build the foundation you'll need to master Redis. We'll focus on learning Redis' five data structures and look at various data modeling approaches. We'll also touch on some key administrative details and debugging techniques.LicenseThe Little Redis Book is licensed under the Attribution-NonCommercial 3.0 Unported license. You should not have paid for this book.You are free to copy, distribute, modify or display the book. However, I ask that you always attribute the book to me, Karl Seguin, and do not use it for commercial purposes.You can see the full text of the license at:http://creativecommons.org/licenses/b...About The AuthorKarl Seguin is a developer with experience across various fields and technologies. He's an active contributor to Open-Source Software projects, a technical writer and an occasional speaker. He's written various articles, as well as a few tools, about Redis. Redis powers the ranking and statistics of his free service for casual game developers: mogade.com.Karl wrote The Little MongoDB Book, the free and popular book about MongoDB.His blog can be found at http://openmymind.net and he tweets via @karlseguinWith Thanks ToA special thanks to Perry Neal for lending me his eyes, mind and passion. You provided me with invaluable help. Thank you.Latest VersionThe latest source of this book is available at: http://github.com/karlseguin/the-litt...

    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.

    Management is a key part of any organization, yet the discipline is often self-taught and unstructured. Getting to the good solutions of complex management challenges can make the difference between fulfillment and frustration for teams, and, ultimately, the success or failure of companies. Will Larson's An Elegant Puzzle orients around the particular challenges of engineering management--from sizing teams to technical debt to succession planning--and provides a path to the good solutions. Drawing from his experience at Digg, Uber, and Stripe, Will Larson has developed a thoughtful approach to engineering management that leaders of all levels at companies of all sizes can apply. An Elegant Puzzle balances structured principles and human-centric thinking to help any leader create more effective and rewarding organizations for engineers to thrive in.

    The Reactive Application model addresses these demands through new patterns designed to "react" effectively to user and system events, changes in load, competition for shared system resources, and unanticipated failures. Although reactive design patterns can be implemented using standard enterprise development tools, you best realize the benefits when you pair them with a functional programming language like Scala and an Actor-based concurrency system like Akka.Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development. You'll discover technologies and paradigms that can be used to build reactive applications including Akka and other actor-based systems, functional programming, replication and distribution, and implementation techniques such as futures, iteratees, and reactive streams. While the book presents concrete examples in Scala, Java, JavaScript, and Erlang, the primary goal is to introduce patterns and best practices that you can use to apply reactive principles to common problems you'll face when building distributed systems.WHAT'S INSIDE* Discover best practices and patterns for building responsive applications* Build applications that can withstand hardware or software failure at any level* Patterns for fault tolerance, scalability, and responsiveness* Maximize multicore hardware using asynchronous and event-driven solutions* Scale applications under tremendous loadReaders should be familiar with a standard programming language like Java, C++ or C# and be comfortable with the basics of distributed systems. Software engineers and architects will learn how to avoid common pitfalls and apply patterns for solving day-to-day problems in a fault-tolerant and scalable way to maximize their application's responsiveness to users and clients. Project leaders and CTOs will gain a deeper understanding of the philosophy behind resilience and scalability in distributed systems, as well as their limitations, challenges and benefits.

     Rails(TM) AntiPatterns identifies these widespread Rails code and design problems, explains why they're bad and why they happen--and shows exactly what to do instead.The book is organized into concise, modular chapters--each outlines a single common AntiPattern and offers detailed, cookbook-style code solutions that were previously difficult or impossible to find. Leading Rails developers Chad Pytel and Tammer Saleh also offer specific guidance for refactoring existing bad code or design to reflect sound object-oriented principles and established Rails best practices. With their help, developers, architects, and testers can dramatically improve new and existing applications, avoid future problems, and establish superior Rails coding standards throughout their organizations.This book will help you understand, avoid, and solve problems withModel layer code, from general object-oriented programming violations to complex SQL and excessive redundancy Domain modeling, including schema and database issues such as normalization and serialization View layer tools and conventions Controller-layer code, including RESTful code Service-related APIs, including timeouts, exceptions, backgrounding, and response codes Third-party code, including plug-ins and gems Testing, from test suites to test-driven development processes Scaling and deployment Database issues, including migrations and validations System design for "graceful degradation" in the real world

    But with so many distributed databases and tools available today, it’s often difficult to understand what each one offers and how they differ. With this practical guide, Alex Petrov guides developers through the concepts behind modern database and storage engine internals.Throughout the book, you’ll explore relevant material gleaned from numerous books, papers, blog posts, and the source code of several open source databases. These resources are listed at the end of parts one and two. You’ll discover that the most significant distinctions among many modern databases reside in subsystems that determine how storage is organized and how data is distributed.This book examines:Storage engines: Explore storage classification and taxonomy, and dive into B-Tree-based and immutable log structured storage engines, with differences and use-cases for eachDistributed systems: Learn step-by-step how nodes and processes connect and build complex communication patterns, from UDP to reliable consensus protocolsDatabase clusters: Discover how to achieve consistent models for replicated data