Software Development

The ability to use algorithms to solve real-world problems is a must-have skill for any developer or programmer. This book will help you not only to develop the skills to select and use an algorithm to tackle problems in the real world but also to understand how it works.

You'll start with an introduction to algorithms and discover various algorithm design techniques, before exploring how to implement different types of algorithms, with the help of practical examples. As you advance, you'll learn about linear programming, page ranking, and graphs, and will then work with machine learning algorithms to understand the math and logic behind them.

Case studies will show you how to apply these algorithms optimally before you focus on deep learning algorithms and learn about different types of deep learning models along with their practical use.

You will also learn about modern sequential models and their variants, algorithms, methodologies, and architectures that are used to implement Large Language Models (LLMs) such as ChatGPT.

Finally, you'll become well versed in techniques that enable parallel processing, giving you the ability to use these algorithms for compute-intensive tasks.

By the end of this programming book, you'll have become adept at solving real-world computational problems by using a wide range of algorithms.

What you will learn

• Design algorithms for solving complex problems
• Become familiar with neural networks and deep learning techniques
• Explore existing data structures and algorithms found in Python libraries
• Implement graph algorithms for fraud detection using network analysis
• Delve into state-of-the-art algorithms for proficient Natural Language Processing illustrated with real-world examples
• Create a recommendation engine that suggests relevant movies to subscribers
• Grasp the concepts of sequential machine learning models and their foundational role in the development of cutting-edge LLMs

Who this book is for

This computer science book is for programmers or developers who want to understand the use of algorithms for problem-solving and writing efficient code. Whether you are a beginner looking to learn the most used algorithms concisely or an experienced programmer looking to explore cutting-edge algorithms in data science, machine learning, and cryptography, you'll find this book useful. Python programming experience is a must, knowledge of data science will be helpful but not necessary.

Algorithms and data structures are much more than abstract concepts. Mastering them enables you to write code that runs faster and more efficiently, which is particularly important for today’s web and mobile apps. Take a practical approach to data structures and algorithms, with techniques and real-world scenarios that you can use in your daily production code, with examples in JavaScript, Python, and Ruby. This new and revised second edition features new chapters on recursion, dynamic programming, and using Big O in your daily work.

Use Big O notation to measure and articulate the efficiency of your code, and modify your algorithm to make it faster. Find out how your choice of arrays, linked lists, and hash tables can dramatically affect the code you write. Use recursion to solve tricky problems and create algorithms that run exponentially faster than the alternatives. Dig into advanced data structures such as binary trees and graphs to help scale specialized applications such as social networks and mapping software. You’ll even encounter a single keyword that can give your code a turbo boost. Practice your new skills with exercises in every chapter, along with detailed solutions.

Use these techniques today to make your code faster and more scalable.

PMBOK® Guide is the go-to resource for project management practitioners. The project management profession has significantly evolved due to emerging technology, new approaches and rapid market changes. Reflecting this evolution, The Standard for Project Management enumerates 12 principles of project management and the PMBOK® Guide – Seventh Edition is structured around eight project performance domains.This edition is designed to address practitioners' current and future needs and to help them be more proactive, innovative and nimble in enabling desired project outcomes.This edition of the PMBOK® Guide:

• Reflects the full range of development approaches (predictive, adaptive, hybrid, etc.);
• Provides an entire section devoted to tailoring the development approach and processes;
• Includes an expanded list of models, methods, and artifacts;•Focuses on not just delivering project outputs but also enabling outcomes; and
• Integrates with PMIstandards+™ for information and standards application content based on project type, development approach, and industry sector.

As a software engineer, you’ll encounter countless programming challenges that initially seem confusing, difficult, or even impossible. Don’t despair! Many of these “new” problems already have well-established solutions.

Advanced Algorithms and Data Structures teaches you powerful approaches to a wide range of tricky coding challenges that you can adapt and apply to your own applications. Providing a balanced blend of classic, advanced, and new algorithms, this practical guide upgrades your programming toolbox with new perspectives and hands-on techniques.

Agile ALM is a guide for Java developers who want to integrate flexible agile practices and lightweight tooling along all phases of the software development process. The book introduces a new vision for managing change in requirements and process more efficiently and flexibly. It synthesizes technical and functional elements to provide a comprehensive approach to software development.

Agile Metrics in Action is a rich resource for agile teams that aim to use metrics to objectively measure performance. You'll learn how to gather data that really counts, along with how to effectively analyze and act upon the results. Along the way, you'll pick up practical data analysis techniques, including a few emerging Big Data practices.

Agile Practice Guide has been developed as a resource to understand, evaluate, and use agile and hybrid agile approaches. This practice guide provides guidance on when, where, and how to apply agile approaches and provides practical tools for practitioners and organizations wanting to increase agility. This practice guide is aligned with other PMI standards, including A Guide to the Project Management Body of Knowledge (PMBOK® Guide) – Sixth Edition, and was developed as the result of collaboration between the Project Management Institute and the Agile Alliance.

Are you hitting a wall with data structures and algorithms? Whether you’re a student prepping for coding interviews or an independent learner, this book is your essential guide to efficient problem-solving in programming.

UNLOCK THE POWER OF DATA STRUCTURES & ALGORITHMS: Learn the intricacies of hash tables, recursion, dynamic programming, trees, graphs, and heaps. Become proficient in choosing and implementing the best solutions for any coding challenge.

REAL-WORLD, COMPETITION-PROVEN CODE EXAMPLES: The programs and challenges in this book aren’t just theoretical—they’re drawn from real programming competitions. Train with problems that have tested and honed the skills of coders around the world.

GET INTERVIEW-READY: Prepare yourself for coding interviews with practice exercises that help you think algorithmically, weigh different solutions, and implement the best choices efficiently.

WRITTEN IN C, USEFUL ACROSS LANGUAGES: The code examples are written in C and designed for clarity and accessibility to those familiar with languages like C++, Java, or Python. If you need help with the C code, no problem: We’ve got recommended reading, too.

Algorithmic Thinking is the complete package, providing the solid foundation you need to elevate your coding skills to the next level.

This fourth edition of Robert Sedgewick and Kevin Wayne’s Algorithms is the leading textbook on algorithms today and is widely used in colleges and universities worldwide. This book surveys the most important computer algorithms currently in use and provides a full treatment of data structures and algorithms for sorting, searching, graph processing, and string processing--including fifty algorithms every programmer should know. In this edition, new Java implementations are written in an accessible modular programming style, where all of the code is exposed to the reader and ready to use.

The algorithms in this book represent a body of knowledge developed over the last 50 years that has become indispensable, not just for professional programmers and computer science students but for any student with interests in science, mathematics, and engineering, not to mention students who use computation in the liberal arts.

Massive modern datasets make traditional data structures and algorithms grind to a halt. This fun and practical guide introduces cutting-edge techniques that can reliably handle even the largest distributed datasets.

In Algorithms and Data Structures for Massive Datasets you will learn:

• Probabilistic sketching data structures for practical problems
• Choosing the right database engine for your application
• Evaluating and designing efficient on-disk data structures and algorithms
• Understanding the algorithmic trade-offs involved in massive-scale systems
• Deriving basic statistics from streaming data
• Correctly sampling streaming data
• Computing percentiles with limited space resources

Algorithms and Data Structures for Massive Datasets reveals a toolbox of new methods that are perfect for handling modern big data applications. You’ll explore the novel data structures and algorithms that underpin Google, Facebook, and other enterprise applications that work with truly massive amounts of data. These effective techniques can be applied to any discipline, from finance to text analysis. Graphics, illustrations, and hands-on industry examples make complex ideas practical to implement in your projects—and there’s no mathematical proofs to puzzle over. Work through this one-of-a-kind guide, and you’ll find the sweet spot of saving space without sacrificing your data’s accuracy.

Stop dangerous threats and secure your vulnerabilities without slowing down delivery. This practical book is a one-stop guide to implementing a robust application security program.

In the Application Security Program Handbook you will learn:

• Why application security is so important to modern software
• Application security tools you can use throughout the development lifecycle
• Creating threat models
• Rating discovered risks
• Gap analysis on security tools
• Mitigating web application vulnerabilities
• Creating a DevSecOps pipeline
• Application security as a service model
• Reporting structures that highlight the value of application security
• Creating a software security ecosystem that benefits development
• Setting up your program for continuous improvement

The Application Security Program Handbook teaches you to implement a robust program of security throughout your development process. It goes well beyond the basics, detailing flexible security fundamentals that can adapt and evolve to new and emerging threats. Its service-oriented approach is perfectly suited to the fast pace of modern development. Your team will quickly switch from viewing security as a chore to an essential part of their daily work. Follow the expert advice in this guide and you’ll reliably deliver software that is free from security defects and critical vulnerabilities.

Applying UML and Patterns is the world’s #1 business and college introduction to “thinking in objects”—and using that insight in real-world object-oriented analysis and design. Building on two widely acclaimed previous editions, Craig Larman has updated this book to fully reflect the new UML 2 standard, to help you master the art of object design, and to promote high-impact, iterative, and skillful agile modeling practices.

Developers and students will learn object-oriented analysis and design (OOA/D) through three iterations of two cohesive, start-to-finish case studies. These case studies incrementally introduce key skills, essential OO principles and patterns, UML notation, and best practices. You won’t just learn UML diagrams—you’ll learn how to apply UML in the context of OO software development.

Drawing on his unsurpassed experience as a mentor and consultant, Larman helps you understand evolutionary requirements and use cases, domain object modeling, responsibility-driven design, essential OO design, layered architectures, “Gang of Four” design patterns, GRASP, iterative methods, an agile approach to the Unified Process (UP), and much more. This edition’s extensive improvements include

• A stronger focus on helping you master OOA/D through case studies that demonstrate key OO principles and patterns, while also applying the UML
• New coverage of UML 2, Agile Modeling, Test-Driven Development, and refactoring
• Many new tips on combining iterative and evolutionary development with OOA/D
• Updates for easier study, including new learning aids and graphics
• New college educator teaching resources
• Guidance on applying the UP in a light, agile spirit, complementary with other iterative methods such as XP and Scrum
• Techniques for applying the UML to documenting architectures
• A new chapter on evolutionary requirements, and much more

Applying UML and Patterns, Third Edition, is a lucid and practical introduction to thinking and designing with objects—and creating systems that are well crafted, robust, and maintainable.

Proven techniques and principles for modernizing legacy systems into new architectures that deliver serious competitive advantage.

For a business to thrive, it needs a modern software architecture that is aligned with its corporate architecture. This book presents concrete practices that sync software, product, strategy, team dynamics, and work practices. You’ll evolve your technical and social architecture together, reducing needless dependencies and achieving faster flow of innovation across your organization.

In Architecture Modernization: Socio-technical alignment of software, strategy, and structure you’ll learn how to:

• Identify strategic ambitions and challenges using listening and mapping tours
• Visualize your business landscape and crucial capabilities with Wardley Mapping
• Create a product taxonomy as a framework for your architecture
• Run big picture EventStorming workshops to map business domains
• Apply Team Topologies patterns to identify and refine value streams
• Design loosely coupled, domain-aligned software architectures
• Build internal developer platforms for rapid, reliable evolution
• Implement data mesh principles and tools to revolutionize data engineering
• Deliver compelling modernization roadmaps focused on continuous value

Architecture Modernization: Socio-technical alignment of software, strategy, and structure shows you how to turn the practice of architecting systems into a transformative process for your entire company. Chapter-by-chapter, you’ll identify the reasons and benefits of modernization, design an architecture that works for your business, and then implement your new approach in a progressive and sustainable manner. Every technique is illustrated with insightful industry examples and an interactive Miro board that lets you dig deeper.

As Python continues to grow in popularity, projects are becoming larger and more complex. Many Python developers are taking an interest in high-level software design patterns such as hexagonal/clean architecture, event-driven architecture, and the strategic patterns prescribed by domain-driven design (DDD). But translating those patterns into Python isn’t always straightforward.

With this hands-on guide, Harry Percival and Bob Gregory from MADE.com introduce proven architectural design patterns to help Python developers manage application complexity—and get the most value out of their test suites.

Each pattern is illustrated with concrete examples in beautiful, idiomatic Python, avoiding some of the verbosity of Java and C# syntax. Patterns include:

• Dependency inversion and its links to ports and adapters (hexagonal/clean architecture)
• Domain-driven design’s distinction between Entities, Value Objects, and Aggregates
• Repository and Unit of Work patterns for persistent storage
• Events, commands, and the message bus
• Command-query responsibility segregation (CQRS)
• Event-driven architecture and reactive microservices

Debugging is crucial to successful software development, but even many experienced programmers find it challenging. Sophisticated debugging tools are available, yet it may be difficult to determine which features are useful in which situations. The Art of Debugging is your guide to making the debugging process more efficient and effective.

The Art of Debugging illustrates the use three of the most popular debugging tools on Linux/Unix platforms: GDB, DDD, and Eclipse. The text-command based GDB (the GNU Project Debugger) is included with most distributions. DDD is a popular GUI front end for GDB, while Eclipse provides a complete integrated development environment.

In addition to offering specific advice for debugging with each tool, authors Norm Matloff and Pete Salzman cover general strategies for improving the process of finding and fixing coding errors, including how to:

• Inspect variables and data structures
• Understand segmentation faults and core dumps
• Know why your program crashes or throws exceptions
• Use features like catchpoints, convenience variables, and artificial arrays
• Avoid common debugging pitfalls

Real world examples of coding errors help to clarify the authors’ guiding principles, and coverage of complex topics like thread, client-server, GUI, and parallel programming debugging will make you even more proficient. You'll also learn how to prevent errors in the first place with text editors, compilers, error reporting, and static code checkers.

Whether you dread the thought of debugging your programs or simply want to improve your current debugging efforts, you'll find a valuable ally in The Art of Debugging.

If you’ve ever spent hours renaming files or updating hundreds of spreadsheet cells, you know how tedious tasks like these can be. But what if you could have your computer do them for you?

In this fully revised second edition of the best-selling classic Automate the Boring Stuff with Python, you’ll learn how to use Python to write programs that do in minutes what would take you hours to do by hand—no prior programming experience required. You'll learn the basics of Python and explore Python’s rich library of modules for performing specific tasks, like scraping data off websites, reading PDF and Word documents, and automating clicking and typing tasks.

The second edition of this international fan favorite includes a brand-new chapter on input validation, as well as tutorials on automating Gmail and Google Sheets, plus tips on automatically updating CSV files. You’ll learn how to create programs that effortlessly perform useful feats of automation to:

• Search for text in a file or across multiple files
• Create, update, move, and rename files and folders
• Search the Web and download online content
• Update and format data in Excel spreadsheets of any size
• Split, merge, watermark, and encrypt PDFs
• Send email responses and text notifications
• Fill out online forms

Step-by-step instructions walk you through each program, and updated practice projects at the end of each chapter challenge you to improve those programs and use your newfound skills to automate similar tasks.

Don't spend your time doing work a well-trained monkey could do. Even if you've never written a line of code, you can make your computer do the grunt work. Learn how in Automate the Boring Stuff with Python, 2nd Edition.

Deliver software that does what it’s supposed to do! Behavior-Driven Development guides your software projects to success with collaboration, communication techniques, and concrete requirements you can turn into automated tests.

In BDD in Action, Second Edition you’ll learn how to:

• Implement and improve BDD practices
• Prioritize features from business goals
• Facilitate an example mapping session
• Write automated acceptance tests
• Scale up your automated acceptance tests
• Deliver accurate reporting and documentation

Around half of all software projects fail to deliver on requirements. Behavior-Driven Development (BDD) helps make sure that yours isn’t one of them.

Behavior-Driven Development in Action, Second Edition teaches you how to ensure that everyone involved in a software project—from developers to non-technical stakeholders—are in agreement on goals and objectives. It lays out the communication skills, collaborative practices, and useful automation tools that will let you seamlessly succeed with BDD. Now in its second edition, this revised bestseller has been extensively updated with new techniques for incorporating BDD into large-scale and enterprise development practices such as Agile and DevOps.

Software startups make global headlines every day. As technology companies succeed and grow, so do their engineering departments. In your career, you'll may suddenly get the opportunity to lead teams: to become a manager. But this is often uncharted territory. How can you decide whether this career move is right for you? And if you do, what do you need to learn to succeed? Where do you start? How do you know that you're doing it right? What does "it" even mean? And isn't management a dirty word? This book will share the secrets you need to know to manage engineers successfully.

Going from engineer to manager doesn't have to be intimidating. Engineers can be managers, and fantastic ones at that. Cast aside the rhetoric and focus on practical, hands-on techniques and tools. You'll become an effective and supportive team leader that your staff will look up to.

Start with your transition to being a manager and see how that compares to being an engineer. Learn how to better organize information, feel productive, and delegate, but not micromanage. Discover how to manage your own boss, hire and fire, do performance and salary reviews, and build a great team. You'll also learn the psychology: how to ship while keeping staff happy, coach and mentor, deal with deadline pressure, handle sensitive information, and navigate workplace politics.

Consider your whole department. How can you work with other teams to ensure best practice? How do you help form guilds and committees and communicate effectively? How can you create career tracks for individual contributors and managers? How can you support flexible and remote working? How can you improve diversity in the industry through your own actions? This book will show you how.

Great managers can make the world a better place. Join us.

Agile principles have been a breath of fresh air to many development teams stuck in the middle of a rigid, process-driven environment. Unfortunately, it's not so easy to bring Agile into an existing organization with established people and practices. Becoming Agile shows you practical techniques and strategies to move from your existing process to an Agile process without starting from scratch.

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.

Camel in Action, Second Edition is the most complete Camel book on the market. Written by core developers of Camel and the authors of the highly acclaimed first edition, this book distills their experience and practical insights so that you can tackle integration tasks like a pro.

Learn, prepare, and practice for test day success with the Certified Associate in Project Management (CAPM)® Exam Official Cert Guide, a Project Management Institute (PMI)® authorized self-study resource. This comprehensive guide from instructors and authors Vijay Kanabar, Arthur P. Thomas, and Thomas Lechler addresses the all-new 2023 CAPM® Exam domains:

• Project management fundamentals and core concepts
• Predictive, plan-based methodologies
• Agile frameworks/methodologies
• Business analysis frameworks

CAPM is an essential first step in building your career at any stage as a project manager and a stepping-stone to the Project Management Professional (PMP)® Certification. CAPM is globally recognized as providing candidates with a solid foundation in hands-on project management skills and knowledge. The CAPM exam covers a broad range of project management approaches and prepares candidates in the skills, tools, and techniques that can be applied in the field of project management.

Nearly twenty years after the Agile Manifesto was first presented, the legendary Robert C. Martin (“Uncle Bob”) reintroduces Agile values and principles for a new generation–programmers and nonprogrammers alike. Martin, author of Clean Code and other highly influential software development guides, was there at Agile’s founding. Now, in Clean Agile: Back to Basics, he strips away misunderstandings and distractions that over the years have made it harder to use Agile than was originally intended.

Martin describes what Agile is in no uncertain terms: a small discipline that helps small teams manage small projects . . . with huge implications because every big project is comprised of many small projects. Drawing on his fifty years’ experience with projects of every conceivable type, he shows how Agile can help you bring true professionalism to software development.

• Get back to the basics–what Agile is, was, and should always be
• Understand the origins, and proper practice, of SCRUM
• Master essential business-facing Agile practices, from small releases and acceptance tests to whole-team communication
• Explore Agile team members’ relationships with each other, and with their product
• Rediscover indispensable Agile technical practices: TDD, refactoring, simple design, and pair programming
• Understand the central roles values and craftsmanship play in your Agile team’s success

If you want Agile’s true benefits, there are no shortcuts: You need to do Agile right. Clean Agile: Back to Basics will show you how, whether you’re a developer, tester, manager, project manager, or customer.

Building upon the success of best-sellers The Clean Coder and Clean Code, legendary software craftsman Robert C. "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design.

As with his other books, Martin’s Clean Architecture doesn’t merely present multiple choices and options, and say "use your best judgment": it tells you what choices to make, and why those choices are critical to your success. Martin offers direct, no-nonsense answers to key architecture and design questions like:

• What are the best high level structures for different kinds of applications, including web, database, thick-client, console, and embedded apps?
• What are the core principles of software architecture?
• What is the role of the architect, and what is he/she really trying to achieve?
• What are the core principles of software design?
• How do designs and architectures go wrong, and what can you do about it?
• What are the disciplines and practices of professional architects and designers?

Clean Architecture is essential reading for every software architect, systems analyst, system designer, and software manager -- and for any programmer who aspires to these roles or is impacted by their work.

Understand what to do at any point in developing a clean .NET architecture

Master advanced .NET techniques with a focus on actual value delivered by working within a modular, clean architecture. Microsoft Data Platform MVP Dino Esposito explains key clean architecture concepts with a mix of pragmatism and design discipline and helps you solidify your knowledge through a real-world project. Starting with an explanation of the quest for modular software architecture continuing through the methodology of domain-driven design (DDD), Esposito emphasizes the role that modularization plays in managing complexity in software development. Breaking down the layers of an architecture that is modular and maintainable, he presents a sample project that is not simply another to-do list, but an actual tool for the reader. Ultimately, an exploration of common dilemmas for both developers and operations brings together historical developments with real solutions for today.

Microsoft Data Platform MVP Dino Esposito helps you:

• Understand the relevance of modular software architecture in the history of software
• Review domain-driven design concepts both, strategic and practical
• Apply modular analysis techniques to your development
• Make the most of layered architecture
• Make the most of layered architecture that is modular and maintainable
• Explore in detail the individual layerspresentation, application, domain and infrastructure
• Make sense of domain services to separate raw persistence from persistence-related business tasks
• Make your way through a series of C# best-practices for modeling classes from real-world entities
• Understand the benefits of microservices versus modular monoliths
• Understand the analysis of technical shortcuts and benefits of long-term technical investment
• Understand client-side, server-side and other common deployment dilemmas
• Set up your architecture, test your conclusions, and find even more help

Often, software engineers and architects work with large, complex code bases that they need to scale and maintain. With this cookbook, author Maximiliano Contieri takes you beyond the concept of clean code by showing you how to identify improvement opportunities and their impact on production code. When it comes to reliability and system evolution, these techniques provide benefits that pay off over time.

Using real life examples in JavaScript, PHP, Java, Python, and many other programming languages, this cookbook provides proven recipes to help you scale and maintain large systems. Every section covers fundamental concepts including readability, coupling, testability, and extensibility, as well as code smells—symptoms of a problem that requires special attention—and the recipes to address them.

As you proceed through this book, refactoring recipes and the variety of code smells increase in complexity. You will:

• Understand the benefits of clean code and learn how to detect code smells
• Learn refactoring techniques step by step
• Gain illustrative code examples in several modern programming languages
• Get a comprehensive catalog of common code smells, their impacts, and possible solutions
• Use code that's straight to the point, favoring readability and learning

CMIS and Apache Chemistry in Action is a comprehensive guide to the CMIS standard and related ECM concepts, written by the authors of the standard. In it, you'll tackle hands-on examples for building applications on CMIS repositories from both the client and the server sides. You'll learn how to create new content-centric applications that install and run in any CMIS-compliant repository.

Widely considered one of the best practical guides to programming, Steve McConnell’s original CODE COMPLETE has been helping developers write better software for more than a decade. Now this classic book has been fully updated and revised with leading-edge practices—and hundreds of new code samples—illustrating the art and science of software construction. Capturing the body of knowledge available from research, academia, and everyday commercial practice, McConnell synthesizes the most effective techniques and must-know principles into clear, pragmatic guidance. No matter what your experience level, development environment, or project size, this book will inform and stimulate your thinking—and help you build the highest quality code.

• Discover the timeless techniques and strategies that help you:
• Design for minimum complexity and maximum creativity
• Reap the benefits of collaborative development
• Apply defensive programming techniques to reduce and flush out errors
• Exploit opportunities to refactor—or evolve—code, and do it safely
• Use construction practices that are right-weight for your project
• Debug problems quickly and effectively
• Resolve critical construction issues early and correctly
• Build quality into the beginning, middle, and end of your project

You know how to write code that works, but what about code that's well written and easy to understand? And robust and bug-free? If other programmers looked at your handiwork, would they be able to figure out the code's logic and purpose? Exceptional programmers have more than just technical know-how; they adopt the right approach and attitude to development.

Code Craft will help take your programming beyond writing correct code to writing great code, thus turning you into a true programming professional or enhancing your existing professional skills.

With language-agnostic advice that's relevant to all developers, Code Craft covers code-writing concerns such as presentation style, variable naming, error handling, and security. And it tackles broader, real-world programming issues like effective teamwork, development processes, and documentation. Each chapter ends with a Q&A section that reviews key concepts to get you thinking like an expert, making it an especially great reference for newer programmers who want to work professionally and efficiently as part of a team.

This survival guide for the software factory will show you how to:

• Write good code when the world's not helping you
• Avoid disasters and distractions in the workplace
• Assess your abilities accurately and determine ways to improve
• Adopt productive attitudes and follow best practices

There's little more valuable than the advice of a true, programming professional. You'll find Code Craft to be clear, practical, and entertaining throughout, and a great way to take your code (and your career) to the next level.

Having a great idea or design is not enough to make your software project succeed. If you want stakeholders to buy into your design and teams to collaborate and contribute to the vision, you also need to communicate effectively. In this practical book, author Jacqui Read shows you how to successfully present your architecture and get stakeholders to jump on board.

Misunderstanding and lack of buy-in leads to increasing costs, unmet requirements, and an architecture that is not what you intended. Through constructive examples and patterns, this book shows you how to create documentation and diagrams that actually get the message across to the different audiences you'll face.

This book shows you how to:

• Design diagrams and documentation appropriate to your expected audience, intended message, and project stage
• Create documentation and diagrams that are accessible to those with varying roles, needs, or disabilities
• Master written, verbal, and nonverbal communication to succeed in technical settings
• Apply the communication patterns presented in this book in real-world projects and software designs
• Communicate and collaborate with distributed teams to successfully design and document software and technical projects

Computer Architecture: A Quantitative Approach, Fifth Edition, explores the ways that software and technology in the cloud are accessed by digital media, such as cell phones, computers, tablets, and other mobile devices. The book, which became a part of Intel's 2012 recommended reading list for developers, covers the revolution of mobile computing. It also highlights the two most important factors in architecture today: parallelism and memory hierarchy.

This fully updated edition is comprised of six chapters that follow a consistent framework: explanation of the ideas in each chapter; a crosscutting issues section, which presents how the concepts covered in one chapter connect with those given in other chapters; a putting it all together section that links these concepts by discussing how they are applied in real machine; and detailed examples of misunderstandings and architectural traps commonly encountered by developers and architects. Formulas for energy, static and dynamic power, integrated circuit costs, reliability, and availability are included. The book also covers virtual machines, SRAM and DRAM technologies, and new material on Flash memory. Other topics include the exploitation of instruction-level parallelism in high-performance processors, superscalar execution, dynamic scheduling and multithreading, vector architectures, multicore processors, and warehouse-scale computers (WSCs). There are updated case studies and completely new exercises. Additional reference appendices are available online.

This book will be a valuable reference for computer architects, programmers, application developers, compiler and system software developers, computer system designers and application developers.

• Part of Intel's 2012 Recommended Reading List for Developers
• Updated to cover the mobile computing revolution
• Emphasizes the two most important topics in architecture today: memory hierarchy and parallelism in all its forms.
• Develops common themes throughout each chapter: power, performance, cost, dependability, protection, programming models, and emerging trends ("What's Next")
• Includes three review appendices in the printed text. Additional reference appendices are available online.
• Includes updated Case Studies and completely new exercises.

This practical introduction to data structures and algorithms can help every programmer who wants to write more efficient software. Building on Robert Lafores legendary Java-based guide, this book helps you understand exactly how data structures and algorithms operate. Youll learn how to efficiently apply them with the enormously popular Python language and scale your code to handle todays big data challenges.

Throughout, the authors focus on real-world examples, communicate key ideas with intuitive, interactive visualizations, and limit complexity and math to what you need to improve performance. Step-by-step, they introduce arrays, sorting, stacks, queues, linked lists, recursion, binary trees, 2-3-4 trees, hash tables, spatial data structures, graphs, and more. Their code examples and illustrations are so clear, you can understand them even if youre a near-beginner, or your experience is with other procedural or object-oriented languages.

• Build core computer science skills that take you beyond merely writing code
• Learn how data structures make programs (and programmers) more efficient
• See how data organization and algorithms affect how much you can do with todays, and tomorrows, computing resources
• Develop data structure implementation skills you can use in any language
• Choose the best data structure(s) and algorithms for each programming problemand recognize which ones to avoid

Data Structures & Algorithms in Python is packed with examples, review questions, individual and team exercises, thought experiments, and longer programming projects. It’s ideal for both self-study and classroom settings, and either as a primary text or as a complement to a more formal presentation.

An updated, innovative approach to data structures and algorithms

Written by an author team of experts in their fields, this authoritative guide demystifies even the most difficult mathematical concepts so that you can gain a clear understanding of data structures and algorithms in C++.

The unparalleled author team incorporates the object-oriented design paradigm using C++ as the implementation language, while also providing intuition and analysis of fundamental algorithms.

• Offers a unique multimedia format for learning the fundamentals of data structures and algorithms
• Allows you to visualize key analytic concepts, learn about the most recent insights in the field, and do data structure design
• Provides clear approaches for developing programs
• Features a clear, easy-to-understand writing style that breaks down even the most difficult mathematical concepts

Building on the success of the first edition, this new version offers you an innovative approach to fundamental data structures and algorithms.

The design and analysis of efficient data structures has long been recognized as a key component of the Computer Science curriculum. Goodrich, Tomassia and Goldwasser's approach to this classic topic is based on the object-oriented paradigm as the framework of choice for the design of data structures. For each ADT presented in the text, the authors provide an associated Java interface. Concrete data structures realizing the ADTs are provided as Java classes implementing the interfaces. The Java code implementing fundamental data structures in this book is organized in a single Java package, net.datastructures. This package forms a coherent library of data structures and algorithms in Java specifically designed for educational purposes in a way that is complimentary with the Java Collections Framework.

This accessible and entertaining book provides an in-depth introduction to computational thinking through the lens of data structures — a critical component in any programming endeavor. Through diagrams, pseudocode, and humorous analogies, you’ll learn how the structure of data drives algorithmic operations, gaining insight into not just how to build data structures, but precisely how and when to use them.

This book will give you a strong background in implementing and working with more than 15 key data structures, from stacks, queues, and caches to bloom filters, skip lists, and graphs. Master linked lists by standing in line at a cafe, hash tables by cataloging the history of the summer Olympics, and Quadtrees by neatly organizing your kitchen cabinets. Along with basic computer science concepts like recursion and iteration, you’ll learn:

• The complexity and power of pointers
• The branching logic of tree-based data structures
• How different data structures insert and delete data in memory
• Why mathematical mappings and randomization are useful
• How to make tradeoffs between speed, flexibility, and memory usage

Data Structures the Fun Way shows how to efficiently apply these ideas to real-world problems—a surprising number of which focus on procuring a decent cup of coffee. At any level, fully understanding data structures will teach you core skills that apply across multiple programming languages, taking your career to the next level.

Eliminate the unavoidable complexity of object-oriented designs. The innovative data-oriented programming paradigm makes your systems less complex by making it simpler to access and manipulate data.

In Data-Oriented Programming you will learn how to:

• Separate code from data
• Represent data with generic data structures
• Manipulate data with general-purpose functions
• Manage state without mutating data
• Control concurrency in highly scalable systems
• Write data-oriented unit tests
• Specify the shape of your data
• Benefit from polymorphism without objects
• Debug programs without a debugger

Data-Oriented Programming is a one-of-a-kind guide that introduces the data-oriented paradigm. This groundbreaking approach represents data with generic immutable data structures. It simplifies state management, eases concurrency, and does away with the common problems you’ll find in object-oriented code. The book presents powerful new ideas through conversations, code snippets, and diagrams that help you quickly grok what’s great about DOP. Best of all, the paradigm is language-agnostic—you’ll learn to write DOP code that can be implemented in JavaScript, Ruby, Python, Clojure, and also in traditional OO languages like Java or C#.

Dependency Injection Principles, Practices, and Patterns teaches you to use DI to reduce hard-coded dependencies between application components. You'll start by learning what DI is and what types of applications will benefit from it. Then, you'll work through concrete scenarios using C# and the .NET framework to implement DI in your own projects. As you dive into the thoroughly-explained examples, you'll develop a foundation you can apply to any of the many DI libraries for .NET and .NET Core.

Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves.

The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk.

With the immense cost savings and scalability the cloud provides, the rationale for building cloud native applications is no longer in question. The real issue is how. With this practical guide, developers will learn about the most commonly used design patterns for building cloud native applications using APIs, data, events, and streams in both greenfield and brownfield development.

You'll learn how to incrementally design, develop, and deploy large and effective cloud native applications that you can manage and maintain at scale with minimal cost, time, and effort. Authors Kasun Indrasiri and Sriskandarajah Suhothayan highlight use cases that effectively demonstrate the challenges you might encounter at each step.

• Learn the fundamentals of cloud native applications
• Explore key cloud native communication, connectivity, and composition patterns
• Learn decentralized data management techniques
• Use event-driven architecture to build distributed and scalable cloud native applications
• Explore the most commonly used patterns for API management and consumption
• Examine some of the tools and technologies you'll need for building cloud native systems

Data is at the center of many challenges in system design today. Difficult issues need to be figured out, such as scalability, consistency, reliability, efficiency, and maintainability. In addition, we have an overwhelming variety of tools, including relational databases, NoSQL datastores, stream or batch processors, and message brokers. What are the right choices for your application? How do you make sense of all these buzzwords?

In this practical and comprehensive guide, author Martin Kleppmann helps you navigate this diverse landscape by examining the pros and cons of various technologies for processing and storing data. Software keeps changing, but the fundamental principles remain the same. With this book, software engineers and architects will learn how to apply those ideas in practice, and how to make full use of data in modern applications.

• Peer under the hood of the systems you already use, and learn how to use and operate them more effectively
• Make informed decisions by identifying the strengths and weaknesses of different tools
• Navigate the trade-offs around consistency, scalability, fault tolerance, and complexity
• Understand the distributed systems research upon which modern databases are built
• Peek behind the scenes of major online services, and learn from their architectures

Designing Secure Software consolidates Loren Kohnfelder’s more than twenty years of experience into a concise, elegant guide to improving the security of technology products. Written for a wide range of software professionals, it emphasizes building security into software design early and involving the entire team in the process.

The book begins with a discussion of core concepts like trust, threats, mitigation, secure design patterns, and cryptography. The second part, perhaps this book’s most unique and important contribution to the field, covers the process of designing and reviewing a software design with security considerations in mind. The final section details the most common coding flaws that create vulnerabilities, making copious use of code snippets written in C and Python to illustrate implementation vulnerabilities.

You’ll learn how to:

• Identify important assets, the attack surface, and the trust boundaries in a system
• Evaluate the effectiveness of various threat mitigation candidates
• Work with well-known secure coding patterns and libraries
• Understand and prevent vulnerabilities like XSS and CSRF, memory flaws, and more
• Use security testing to proactively identify vulnerabilities introduced into code
• Review a software design for security flaws effectively and without judgment

Dive Into Algorithms is a wide-ranging, Pythonic tour of many of the world's most interesting algorithms. With little more than a bit of computer programming experience and basic high-school math, you'll explore standard computer science algorithms for searching, sorting, and optimization; human-based algorithms that help us determine how to catch a baseball or eat the right amount at a buffet; and advanced algorithms like ones used in machine learning and artificial intelligence. You'll even explore how ancient Egyptians and Russian peasants used algorithms to multiply numbers, how the ancient Greeks used them to find greatest common divisors, and how Japanese scholars in the age of samurai designed algorithms capable of generating magic squares.

You'll explore algorithms that are useful in pure mathematics and learn how mathematical ideas can improve algorithms. You'll learn about an algorithm for generating continued fractions, one for quick calculations of square roots, and another for generating seemingly random sets of numbers.

You'll also learn how to:

• Use algorithms to debug code, maximize revenue, schedule tasks, and create decision trees
• Measure the efficiency and speed of algorithms
• Generate Voronoi diagrams for use in various geometric applications
• Use algorithms to build a simple chatbot, win at board games, or solve sudoku puzzles
• Write code for gradient ascent and descent algorithms that can find the maxima and minima of functions
• Use simulated annealing to perform global optimization
• Build a decision tree to predict happiness based on a person's characteristics

Once you've finished this book you'll understand how to code and implement important algorithms as well as how to measure and optimize their performance, all while learning the nitty-gritty details of today's most powerful algorithms.

Software architecture—the conceptual glue that holds every phase of a project together for its many stakeholders—is widely recognized as a critical element in modern software development. Practitioners have increasingly discovered that close attention to a software system’s architecture pays valuable dividends. Without an architecture that is appropriate for the problem being solved, a project will stumble along or, most likely, fail. Even with a superb architecture, if that architecture is not well understood or well communicated the project is unlikely to succeed.

Documenting Software Architectures, Second Edition, provides the most complete and current guidance, independent of language or notation, on how to capture an architecture in a commonly understandable form. Drawing on their extensive experience, the authors first help you decide what information to document, and then, with guidelines and examples (in various notations, including UML), show you how to express an architecture so that others can successfully build, use, and maintain a system from it. The book features rules for sound documentation, the goals and strategies of documentation, architectural views and styles, documentation for software interfaces and software behavior, and templates for capturing and organizing information to generate a coherent package. New and improved in this second edition:

• Coverage of architectural styles such as service-oriented architectures, multi-tier architectures, and data models
• Guidance for documentation in an Agile development environment
• Deeper treatment of documentation of rationale, reflecting best industrial practices
• Improved templates, reflecting years of use and feedback, and more documentation layout options
• A new, comprehensive example (available online), featuring documentation of a Web-based service-oriented system
• Reference guides for three important architecture documentation languages: UML, AADL, and SySML

The software development community widely acknowledges that domain modeling is central to software design. Through domain models, software developers are able to express rich functionality and translate it into a software implementation that truly serves the needs of its users. But despite its obvious importance, there are few practical resources that explain how to incorporate effective domain modeling into the software development process.

Domain-Driven Design fills that need. This is not a book about specific technologies. It offers readers a systematic approach to domain-driven design, presenting an extensive set of design best practices, experience-based techniques, and fundamental principles that facilitate the development of software projects facing complex domains. Intertwining design and development practice, this book incorporates numerous examples based on actual projects to illustrate the application of domain-driven design to real-world software development.

Readers learn how to use a domain model to make a complex development effort more focused and dynamic. A core of best practices and standard patterns provides a common language for the development team. A shift in emphasis—refactoring not just the code but the model underlying the code—in combination with the frequent iterations of Agile development leads to deeper insight into domains and enhanced communication between domain expert and programmer. Domain-Driven Design then builds on this foundation, and addresses modeling and design for complex systems and larger organizations.Specific topics covered include:

• Getting all team members to speak the same language
• Connecting model and implementation more deeply
• Sharpening key distinctions in a model
• Managing the lifecycle of a domain object
• Writing domain code that is safe to combine in elaborate ways
• Making complex code obvious and predictable
• Formulating a domain vision statement
• Distilling the core of a complex domain
• Digging out implicit concepts needed in the model
• Applying analysis patterns
• Relating design patterns to the model
• Maintaining model integrity in a large system
• Dealing with coexisting models on the same project
• Organizing systems with large-scale structures
• Recognizing and responding to modeling breakthroughs

With this book in hand, object-oriented developers, system analysts, and designers will have the guidance they need to organize and focus their work, create rich and useful domain models, and leverage those models into quality, long-lasting software implementations.

Domain-Driven Design (DDD) software modeling delivers powerful results in practice, not just in theory, which is why developers worldwide are rapidly moving to adopt it. Now, for the first time, there’s an accessible guide to the basics of DDD: What it is, what problems it solves, how it works, and how to quickly gain value from it.

Concise, readable, and actionable, Domain-Driven Design Distilled never buries you in detail–it focuses on what you need to know to get results. Vaughn Vernon, author of the best-selling Implementing Domain-Driven Design, draws on his twenty years of experience applying DDD principles to real-world situations. He is uniquely well-qualified to demystify its complexities, illuminate its subtleties, and help you solve the problems you might encounter.

Vernon guides you through each core DDD technique for building better software. You’ll learn how to segregate domain models using the powerful Bounded Contexts pattern, to develop a Ubiquitous Language within an explicitly bounded context, and to help domain experts and developers work together to create that language. Vernon shows how to use Subdomains to handle legacy systems and to integrate multiple Bounded Contexts to define both team relationships and technical mechanisms.

Domain-Driven Design Distilled brings DDD to life. Whether you’re a developer, architect, analyst, consultant, or customer, Vernon helps you truly understand it so you can benefit from its remarkable power.

Coverage includes

• What DDD can do for you and your organization–and why it’s so important
• The cornerstones of strategic design with DDD: Bounded Contexts and Ubiquitous Language
• Strategic design with Subdomains
• Context Mapping: helping teams work together and integrate software more strategically
• Tactical design with Aggregates and Domain Events
• Using project acceleration and management tools to establish and maintain team cadence

Elastic leadership is a framework and philosophy that can help you as you manage day-to-day and long-term challenges and strive to create the elusive self-organizing team. It is about understanding that your leadership needs to change based on which phase you discover that your team is in. This book provides you with a set of values, techniques, and practices to use in your leadership role.

Electron in Action guides you, step-by-step, as you learn to build cross-platform desktop applications that run on Windows, OSX, and Linux. By the end of the book, you'll be ready to build simple, snappy applications using JavaScript, Node, and the Electron framework.

If you want to use Scrum to develop innovative products and services that delight your customers, Essential Scrum is the complete, single-source reference you’ve been searching for. Leading Scrum coach and trainer Kenny Rubin illuminates the values, principles, and practices of Scrum, and describes flexible, proven approaches that can help you implement it far more effectively.

Whether you are new to Scrum or years into your use, this book will introduce, clarify, and deepen your Scrum knowledge at the team, product, and portfolio levels. Drawing from Rubin’s experience helping hundreds of organizations succeed with Scrum, this book provides easy-to-digest descriptions enhanced by more than two hundred illustrations based on an entirely new visual icon language for describing Scrum’s roles, artifacts, and activities.

Essential Scrum will provide every team member, manager, and executive with a common understanding of Scrum, a shared vocabulary they can use in applying it, and practical knowledge for deriving maximum value from it.

Event-driven architecture in Golang is an approach used to develop applications that shares state changes asynchronously, internally, and externally using messages. EDA applications are better suited at handling situations that need to scale up quickly and the chances of individual component failures are less likely to bring your system crashing down. This is why EDA is a great thing to learn and this book is designed to get you started with the help of step-by-step explanations of essential concepts, practical examples, and more.

You'll begin building event-driven microservices, including patterns to handle data consistency and resiliency. Not only will you learn the patterns behind event-driven microservices but also how to communicate using asynchronous messaging with event streams. You'll then build an application made of several microservices that communicates using both choreographed and orchestrated messaging.

By the end of this book, you'll be able to build and deploy your own event-driven microservices using asynchronous communication.

What you will learn

• Understand different event-driven patterns and best practices
• Plan and design your software architecture with ease
• Track changes and updates effectively using event sourcing
• Test and deploy your sample software application with ease
• Monitor and improve the performance of your software architecture

Who this book is for

This hands-on book is for intermediate-level software architects, or senior software engineers working with Golang and interested in building asynchronous microservices using event sourcing, CQRS, and DDD. Intermediate-level knowledge of the Go syntax and concurrency features is necessary.

In Five Lines of Code you will learn:

• The signs of bad code
• Improving code safely, even when you don’t understand it
• Balancing optimization and code generality
• Proper compiler practices
• The Extract method, Introducing Strategy pattern, and many other refactoring patterns
• Writing stable code that enables change-by-addition
• Writing code that needs no comments
• Real-world practices for great refactoring

Improving existing code—refactoring—is one of the most common tasks you’ll face as a programmer.

Five Lines of Code teaches you clear and actionable refactoring rules that you can apply without relying on intuitive judgements such as “code smells.” Following the author’s expert perspective—that refactoring and code smells can be learned by following a concrete set of principles—you’ll learn when to refactor your code, what patterns to apply to what problem, and the code characteristics that indicate it’s time for a rework.

There have been many attempts at creating frameworks that are truly cross-platform, but most struggle to create a native-like experience at high-performance levels. Flutter achieves this with an elegant design and a wealth of third-party plugins, solidifying its status as the future of mobile app development. If you are a mobile developer who wants to create rich and expressive native apps with the latest Google Flutter framework, this book is for you.

You’ll start with the basics of cross-platform development frameworks, specifically Flutter. You’ll then explore the Dart programming language which is the foundation of the Flutter framework. Next, you’ll get a feel for Flutter and how to create your first app, followed by an exploration of the various popular plugins that supplement the Flutter framework. Finally, you’ll explore testing and app release, including some common glitches that you may experience.

By the end of this book, you’ll be well-equipped to create and release a basic Flutter app along with gaining a solid understanding of the Flutter framework and Dart language.

What you will learn

• Understand the Flutter framework and cross-platform development
• Acclimate the fundamentals of the Dart programming language
• Explore Flutter widgets, the core widget library, and stateful and stateless widgets
• Discover the complete development lifecycle, including testing and debugging
• Get familiar with both the mobile and web app release processes
• Dig deeper into more advanced Flutter concepts like animation
• Explore common Flutter plugins ad how to use them
• Discover the Flutter community and how to stay up-to-date

Who this book is for

If you are an existing mobile developer seeking a better way to develop cross-platform apps, an existing software developer looking to explore mobile app development, or someone investigating mobile apps and simply wants to know what the Flutter fuss is about, this is the book for you. Prior knowledge of Flutter and Dart is not required.

In 2017, consumers downloaded 178 billion apps, and analysts predict growth to 258 billion by 2022. Mobile customers are demanding more—and better—apps, and it’s up to developers like you to write them! Flutter, a revolutionary new cross-platform software development kit created by Google, makes it easier than ever to write secure, high-performance native apps for iOS and Android. Flutter apps are blazingly fast because this open source solution compiles your Dart code to platform-specific programs with no JavaScript bridge! Flutter also supports hot reloading to update changes instantly. And thanks to its built-in widgets and rich motion APIs, Flutter’s apps are not just highly responsive, they’re stunning!

In many systems, scalability becomes the primary driver as the user base grows. Attractive features and high utility breed success, which brings more requests to handle and more data to manage. But organizations reach a tipping point when design decisions that made sense under light loads suddenly become technical debt. This practical book covers design approaches and technologies that make it possible to scale an application quickly and cost-effectively.

Author Ian Gorton takes software architects and developers through the foundational principles of distributed systems. You'll explore the essential ingredients of scalable solutions, including replication, state management, load balancing, and caching. Specific chapters focus on the implications of scalability for databases, microservices, and event-based streaming systems.

You will focus on:

• Foundations of scalable systems: Learn basic design principles of scalability, its costs, and architectural tradeoffs
• Designing scalable services: Dive into service design, caching, asynchronous messaging, serverless processing, and microservices
• Designing scalable data systems: Learn data system fundamentals, NoSQL databases, and eventual consistency versus strong consistency
• Designing scalable streaming systems: Explore stream processing systems and scalable event-driven processing

A Practical Guide to Better, Cleaner Code with Functional Programming

In Functional Design, renowned software engineer Robert C. Martin ("Uncle Bob") explains how and why to use functional programming to build better systems for real customers. Martin compares conventional object-oriented coding structures in Java to those enabled by functional languages, identifies the best roles for each, and shows how to build better systems by judiciously using them in context.

Martin's approach is pragmatic, minimizing theory in favor of "in the-trenches" problem-solving. Through accessible examples, working developers will discover how the easy-to-learn, semantically rich Clojure language can help them improve code cleanliness, design, discipline, and outcomes. Martin examines well-known SOLID principles and Gang of Four Design Patterns from a functional perspective, revealing why patterns remain extremely valuable to functional programmers, and how to use them to achieve superior results.

• Understand functional basics: immutability, persistent data, recursion, iteration, laziness, and statefulness
• Contrast functional and object approaches through expertly crafted case studies
• Explore functional design techniques for data flow
• Use classic SOLID principles to write better Clojure code
• Master pragmatic approaches to functional testing, GUIs, and concurrency
• Make the most of design patterns in functional environments
• Walk through building an enterprise-class Clojure application

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

Practical techniques for writing code that is robust, reliable, and easy for team members to understand and adapt.

In Good Code, Bad Code you’ll learn how to:

• Think about code like an effective software engineer
• Write functions that read like well-structured sentences
• Ensure code is reliable and bug free
• Effectively unit test code
• Identify code that can cause problems and improve it
• Write code that is reusable and adaptable to new requirements
• Improve your medium and long-term productivity
• Save yourself and your team time

The difference between good code or bad code often comes down to how you apply the established practices of the software development community. In Good Code, Bad Code you’ll learn how to boost your productivity and effectiveness with code development insights normally only learned through careful mentorship and hundreds of code reviews.

As the technology leader at a small software company, you need to focus on people, products, processes, and technology as you bring your software to market, while doing your best to put out fires and minimize headaches.

Growing Software is your guide to juggling the day-to-day challenges of running a software company while managing those long-term problems and making sure that your business continues to grow. With practical, hands-on advice, Growing Software will teach you how to build and lead an effective team, define and sell your products, work with everyone from customers to CEOs, and ensure high-quality results.

Instead of learning by trial and error, you'll benefit from author Louis Testa's 20+ years of management experience. Testa combines big-picture advice, specific solutions, and real-life anecdotes to teach you how to:

• Work effectively with your CEO and executive team
• Improve development team efficiency and enthusiasm
• Evaluate your software methodology to improve effectiveness and safeguard against failure
• Use product prototypes to bridge the gap between marketing and engineering
• Defuse technology time bombs

Whether you're new to managing software or newly lost, Growing Software will help you and your growing company thrive.

Choosing the right data structure is pivotal to optimizing the performance and scalability of applications. This new edition of Hands-On Data Structures and Algorithms with Python will expand your understanding of key structures, including stacks, queues, and lists, and also show you how to apply priority queues and heaps in applications. You'll learn how to analyze and compare Python algorithms, and understand which algorithms should be used for a problem based on running time and computational complexity. You will also become confident organizing your code in a manageable, consistent, and scalable way, which will boost your productivity as a Python developer.

By the end of this Python book, you'll be able to manipulate the most important data structures and algorithms to more efficiently store, organize, and access data in your applications.

What you will learn

• Understand common data structures and algorithms using examples, diagrams, and exercises
• Explore how more complex structures, such as priority queues and heaps, can benefit your code
• Implement searching, sorting, and selection algorithms on number and string sequences
• Become confident with key string-matching algorithms
• Understand algorithmic paradigms and apply dynamic programming techniques
• Use asymptotic notation to analyze algorithm performance with regard to time and space complexities
• Write powerful, robust code using the latest features of Python

Who this book is for

This book is for developers and programmers who are interested in learning about data structures and algorithms in Python to write complex, flexible programs. Basic Python programming knowledge is expected.

At any given moment, someone struggles with the same software design problems you have. And, chances are, someone else has already solved your problem. This edition of Head First Design Patterns—now updated for Java 8—shows you the tried-and-true, road-tested patterns used by developers to create functional, elegant, reusable, and flexible software. By the time you finish this book, you’ll be able to take advantage of the best design practices and experiences of those who have fought the beast of software design and triumphed.

We think your time is too valuable to spend struggling with new concepts. Using the latest research in cognitive science and learning theory to craft a multi-sensory learning experience, Head First Design Patterns uses a visually rich format designed for the way your brain works, not a text-heavy approach that puts you to sleep.

Tired of reading Object Oriented Analysis and Design books that only makes sense after you're an expert? You've heard OOA&D can help you write great software every time-software that makes your boss happy, your customers satisfied and gives you more time to do what makes you happy.

But how?

Head First Object-Oriented Analysis & Design shows you how to analyze, design, and write serious object-oriented software: software that's easy to reuse, maintain, and extend; software that doesn't hurt your head; software that lets you add new features without breaking the old ones. Inside you will learn how to:

• Use OO principles like encapsulation and delegation to build applications that are flexible
• Apply the Open-Closed Principle (OCP) and the Single Responsibility Principle (SRP) to promote reuse of your code
• Leverage the power of design patterns to solve your problems more efficiently
• Use UML, use cases, and diagrams to ensure that all stakeholders arecommunicating clearly to help you deliver the right software that meets everyone's needs.

By exploiting how your brain works, Head First Object-Oriented Analysis & Design compresses the time it takes to learn and retain complex information. Expect to have fun, expect to learn, expect to be writing great software consistently by the time you're finished reading this!

If you're a software developer looking for a quick on-ramp to software architecture, this handy guide is a great place to start. From the authors of Fundamentals of Software Architecture, Head First Software Architecture teaches you how to think architecturally and explores the unique challenges of software architecture. You'll learn the distinction between architecture and design and the relationship between code, components, and architectural styles. You'll also learn how to work with some common architectural styles through vivid, fun examples. Quick, easy, and entertaining, this book is a valuable introduction to the world of software architecture.

Based on the latest research in cognitive science and learning theory, Head First Software Architecture uses a visually rich format to engage your mind, rather than a text-heavy approach that puts you to sleep. Why waste your time struggling with new concepts? This multisensory learning experience is designed for the way your brain really works.

How Computers Really Work is a hands-on guide to the computing ecosystem: everything from circuits to memory and clock signals, machine code, programming languages, operating systems, and the internet.

But you won’t just read about these concepts, you’ll test your knowledge with exercises, and practice what you learn with 41 optional hands-on projects. Build digital circuits, craft a guessing game, convert decimal numbers to binary, examine virtual memory usage, run your own web server, and more.

Explore concepts like how to:

• Think like a software engineer as you use data to describe a real world concept
• Use Ohm’s and Kirchhoff’s laws to analyze an electrical circuit
• Think like a computer as you practice binary addition and execute a program in your mind, step-by-step

The book’s projects will have you translate your learning into action, as you:

• Learn how to use a multimeter to measure resistance, current, and voltage
• Build a half adder to see how logical operations in hardware can be combined to perform useful functions
• Write a program in assembly language, then examine the resulting machine code
• Learn to use a debugger, disassemble code, and hack a program to change its behavior without changing the source code
• Use a port scanner to see which internet ports your computer has open
• Run your own server and get a solid crash course on how the web works

And since a picture is worth a thousand bytes, chapters are filled with detailed diagrams and illustrations to help clarify technical complexities.

We use software every day to perform all kinds of magical, powerful tasks. It's the force behind stunning CGI graphics, safe online shopping, and speedy Google searches. Software drives the modern world, but its inner workings remain a mystery to many.

How Software Works explains how computers perform common-yet-amazing tasks that we take for granted every day.

Inside you'll learn:

• How data is encrypted
• How passwords are used and protected
• How computer graphics are created
• How video is compressed for streaming and storage
• How data is searched (and found) in huge databases
• How programs can work together on the same problem without conflict
• How data travels over the Internet

How Software Works breaks down these processes with patient explanations and intuitive diagrams so that anyone can understand—no technical background is required, and you won't be reading through any code. In plain English, you'll examine the intricate logic behind the technologies you constantly use but never understood.

If you've ever wondered what really goes on behind your computer screen, How Software Works will give you fascinating look into the software all around you.

We all want people to do stuff. Whether you want your customers to buy from you, vendors to give you a good deal, your employees to take more initiative, or your spouse to make dinner—a large amount of everyday is about getting the people around you to do stuff. Instead of using your usual tactics that sometimes work and sometimes don't, what if you could harness the power of psychology and brain science to motivate people to do the stuff you want them to do - even getting people to want to do the stuff you want them to do.
 
In this book you’ll learn the 7 drives that motivate people: The Desire For Mastery, The Need To Belong, The Power of Stories, Carrots and Sticks, Instincts,  Habits, and Tricks Of The Mind. For each of the 7 drives behavioral psychologist Dr. Susan Weinschenk describes the research behind each drive, and then offers specific strategies to use. Here’s just a few things you will learn:

• The more choices people have the more regret they feel about the choice they pick. If you want people to feel less regret then offer them fewer choices.
• If you are going to use a reward, give the reward continuously at first, and then switch to giving a reward only sometimes.
• If you want people to act independently, then make a reference to money, BUT if you want people to work with others or help others, then make sure you DON’T refer to money.
• If you want people to remember something, make sure it is at the beginning or end of your book, presentation, or meeting. Things in the middle are more easily forgotten.
• If you are using feedback to increase the desire for mastery keep the feedback objective, and don’t include praise.

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

Irresistible APIs provides step-by-step guidance for designing APIs that reflect an application's core business value, delight the developers who use them, and will stand the test of time. In it, business product managers and developers learn how to treat an API as a first-class product.

Kanban in Action is a down-to-earth, no-frills, get-to-know-the-ropes introduction to kanban. It's based on the real-world experience and observations from two kanban coaches who have introduced this process to dozens of teams. You'll learn the principles of why kanban works, as well as nitty-gritty details like how to use different color stickies on a kanban board to help you organize and track your work items.

How to survive a legacy apocalypse

“Kill it with fire,” the typical first reaction to a legacy system falling into obsolescence, is a knee-jerk approach that often burns through tons of money and time only to result in a less efficient solution. This book offers a far more forgiving modernization framework, laying out smart value-add strategies and proven techniques that work equally well for ancient systems and brand-new ones.

Renowned for restoring some of the world’s oldest, messiest computer networks to operational excellence, software engineering expert Marianne Bellotti distills key lessons and insights from her experience into practical, research-backed guidance to help you determine when and how to modernize. With witty, engaging prose, Bellotti explains why new doesn’t always mean better, weaving in illuminating case studies and anecdotes from her work in the field.

You’ll learn:

• Where to focus your maintenance efforts for maximum impact and value
• How to pick the right modernization solutions for your specific needs and keep your plans on track
• How to assess whether your migrations will add value before you invest in them
• What to consider before moving data to the cloud
• How to determine when a project is finished

Packed with resources, exercises, and flexible frameworks for organizations of all ages and sizes, Kill It with Fire will give you a vested interest in your technology’s future.

LLVM was built to bridge the gap between the theoretical knowledge found in compiler textbooks and the practical demands of compiler development. With a modular codebase and advanced tools, LLVM empowers developers to build compilers with ease. This book serves as a practical introduction to LLVM, guiding you progressively through complex scenarios and ensuring that you navigate the challenges of building and working with compilers like a pro.

The book starts by showing you how to configure, build, and install LLVM libraries, tools, and external projects. You’ll then be introduced to LLVM's design, unraveling its applications in each compiler stage: frontend, optimizer, and backend. Using a real programming language subset, you'll build a frontend, generate LLVM IR, optimize it through the pipeline, and generate machine code. Advanced chapters extend your expertise, covering topics such as extending LLVM with a new pass, using LLVM tools for debugging, and enhancing the quality of your code. You'll also focus on just-in-time compilation issues and the current state of JIT-compilation support with LLVM. Finally, you’ll develop a new backend for LLVM, gaining insights into target description and how instruction selection works.

By the end of this book, you'll have hands-on experience with the LLVM compiler development framework through real-world examples and source code snippets.

What you will learn

• Configure, compile, and install the LLVM framework
• Understand how the LLVM source is organized
• Discover what you need to do to use LLVM in your own projects
• Explore how a compiler is structured, and implement a tiny compiler
• Generate LLVM IR for common source language constructs
• Set up an optimization pipeline and tailor it for your own needs
• Extend LLVM with transformation passes and clang tooling
• Add new machine instructions and a complete backend

Who this book is for

This book is for compiler developers, enthusiasts, and engineers new to LLVM. C++ software engineers looking to use compiler-based tools for code analysis and improvement, as well as casual users of LLVM libraries who want to gain more knowledge of LLVM essentials will also find this book useful. Intermediate-level experience with C++ programming is necessary to understand the concepts covered in this book.

Learning Agile is a comprehensive guide to the most popular agile methods, written in a light and engaging style that makes it easy for you to learn.

Agile has revolutionized the way teams approach software development, but with dozens of agile methodologies to choose from, the decision to "go agile" can be tricky. This practical book helps you sort it out, first by grounding you in agile’s underlying principles, then by describing four specific—and well-used—agile methods: Scrum, extreme programming (XP), Lean, and Kanban.

Each method focuses on a different area of development, but they all aim to change your team’s mindset—from individuals who simply follow a plan to a cohesive group that makes decisions together. Whether you’re considering agile for the first time, or trying it again, you’ll learn how to choose a method that best fits your team and your company.

• Understand the purpose behind agile’s core values and principles
• Learn Scrum’s emphasis on project management, self-organization, and collective commitment
• Focus on software design and architecture with XP practices such as test-first and pair programming
• Use Lean thinking to empower your team, eliminate waste, and deliver software fast
• Learn how Kanban’s practices help you deliver great software by managing flow
• Adopt agile practices and principles with an agile coach

When it comes to writing efficient code, every software professional needs to have an effective working knowledge of algorithms. In this practical book, author George Heineman (Algorithms in a Nutshell) provides concise and informative descriptions of key algorithms that improve coding. Software developers, testers, and maintainers will discover how algorithms solve computational problems creatively.

Each chapter builds on earlier chapters through eye-catching visuals and a steady rollout of essential concepts, including an algorithm analysis to classify the performance of every algorithm presented in the book. At the end of each chapter, you'll get to apply what you've learned to a novel challenge problem -- simulating the experience you might find in a technical code interview.

With this book, you will:

• Examine fundamental algorithms central to computer science and software engineering
• Learn common strategies for efficient problem solving — such as divide and conquer, dynamic programming, and greedy approaches
• Analyze code to evaluate time complexity using big O notation
• Use existing Python libraries and data structures to solve problems using algorithms
• Understand the main steps of important algorithms

Building software is harder than ever. As a developer, you not only have to chase ever-changing technological trends but also need to understand the business domains behind the software. This practical book provides you with a set of core patterns, principles, and practices for analyzing business domains, understanding business strategy, and, most importantly, aligning software design with its business needs.

Author Vlad Khononov shows you how these practices lead to robust implementation of business logic and help to future-proof software design and architecture. You'll examine the relationship between domain-driven design (DDD) and other methodologies to ensure you make architectural decisions that meet business requirements. You'll also explore the real-life story of implementing DDD in a startup company.

With this book, you'll learn how to:

• Analyze a company's business domain to learn how the system you're building fits its competitive strategy
• Use DDD's strategic and tactical tools to architect effective software solutions that address business needs
• Build a shared understanding of the business domains you encounter
• Decompose a system into bounded contexts
• Coordinate the work of multiple teams
• Gradually introduce DDD to brownfield projects

Among the text editors being used in the programming community, perhaps the most important family is vi and its derivatives. With this updated edition, Unix and Linux users will learn text editing basics for both vi and Vim ("vi improved") before moving on to advanced editing tools for each editor. Authors Arnold Robbins and Elbert Hannah cover the latest major releases of Vim, including 8.0 and 8.2.

If you're a programmer or computer analyst, or you work with browsers or command-line interfaces, using Vim can speed up your work and make complex tasks easier. You'll examine multiwindow editing, global search and replacement, and power tools for programmers, and learn how to write interactive macros and scripts to extend the editor--all in the easy-to-follow style that's made this book a classic.

• Go beyond the basics to learn which vi commands fit your specific needs
• Learn advanced vi tools that shift most of the editing burden to the computer
• Explore Vim tools that provide major improvements over vi
• Examine Vimâ??s multiwindow editing feature, a significant upgrade over vi
• Use Vim scripts to customize and tailor Vim to your needs
• Look at Vim in modern GUI environments with Graphical Vim (gvim)
• See Vim in the broader programming milieu, including usingit as an IDE

In this fourth edition of the bestselling business book Managing Humans, author Michael Lopp continues to draw leadership advice from some of the most important software companies of our modern age. Educational stories from companies such as Apple, Slack, and Pinterest detail the experiences of bright software engineers in an ever-changing industry.

This revised edition of Managing Humans expands on the previous editions’ explorations of management essentials including handling stress, building diverse teams, running inclusive meetings, and how to lead in times of crisis. The education of a great leader never stops, and Lopp applies crucial insights to help continue your never-ending leadership education. Whether it is approaching a myriad of engineering personalities or handling unexpected conflict, you will come away with the wisdom to handle any team situation.

The engineering culture of a company can determine the difference between a product’s ultimate success or failure. Managing Humans is here to guide managers and aspiring managers into the intimidating world of people and their vastly different personalities. Handle conflict, infuse innovation into your approach, and be the most confident manager you can be after reading this book.

“It is so satisfying to read the work of an author who articulates something we know, but can’t put our finger on, and then answers the excitement of fresh revelation with useful solutions or a frame to think about what we’ve just learned—all done in a breezy, knowing prose, that invites you to constantly write margin notes to capture the new thinking it invites.”

John Dickerson, author, CBS News correspondent

Most organizations with a web presence build and operate APIs; the doorway for customers to interact with the company's services. Designing, building, and managing these critical programs affect everyone in the organization, from engineers and product owners to C-suite executives. But the real challenge for developers and solution architects is creating an API platform from the ground up.

With this practical book, you'll learn strategies for building and testing REST APIs that use API gateways to combine offerings at the microservice level. Authors James Gough, Daniel Bryant, and Matthew Auburn demonstrate how simple additions to this infrastructure can help engineers and organizations migrate to the cloud; and open the opportunity to connect internal services using technologies like a service mesh.

• Learn API fundamentals and architectural patterns for building an API platform
• Use practical examples to understand how to design, build, and test API-based systems
• Deploy, operate, and configure key components of an API platform
• Use API gateways and service meshes appropriately, based on case studies
• Understand core security and common vulnerabilities in API architecture
• Secure data and APIs using threat modeling and technologies like OAuth2 and TLS
• Learn how to evolve existing systems toward API- and cloud-based architectures

To score a job in data science, machine learning, computer graphics, and cryptography, you need to bring strong math skills to the party.

Math for Programmers teaches the math you need for these hot careers, concentrating on what you need to know as a developer. Filled with lots of helpful graphics and more than 200 exercises and mini-projects, this book unlocks the door to interesting–and lucrative!–careers in some of today’s hottest programming fields.

Modeling Enterprise Architecture with TOGAF explains everything you need to know to effectively model enterprise architecture with The Open Group Architecture Framework (TOGAF), the leading EA standard. This solution-focused reference presents key techniques and illustrative examples to help you model enterprise architecture.

This book describes the TOGAF standard and its structure, from the architecture transformation method to governance, and presents enterprise architecture modeling practices with plenty of examples of TOGAF deliverables in the context of a case study.

Although widespread and growing quickly, enterprise architecture is delicate to manage across all its dimensions. Focusing on the architecture transformation method, TOGAF provides a wide framework, which covers the repository, governance, and a set of recognized best practices. The examples featured in this book were realized using the open source Modelio tool, which includes extensions for TOGAF.

• Includes intuitive summaries of the complex TOGAF standard to let you effectively model enterprise architecture
• Uses practical examples to illustrate ways to adapt TOGAF to the needs of your enterprise
• Provides model examples with Modelio, a free modeling tool, letting you exercise TOGAF modeling immediately using a dedicated tool
• Combines existing modeling standards with TOGAF

In Modern Software Engineering, continuous delivery pioneer David Farley helps software professionals think about their work more effectively, manage it more successfully, and genuinely improve the quality of their applications, their lives, and the lives of their colleagues.

Writing for programmers, managers, and technical leads at all levels of experience, Farley illuminates durable principles at the heart of effective software development. He distills the discipline into two core exercises: learning and exploration and managing complexity. For each, he defines principles that can help you improve everything from your mindset to the quality of your code, and describes approaches proven to promote success.

Farley’s ideas and techniques cohere into a unified, scientific, and foundational approach to solving practical software development problems within realistic economic constraints. This general, durable, and pervasive approach to software engineering can help you solve problems you haven’t encountered yet, using today’s technologies and tomorrow’s. It offers you deeper insight into what you do every day, helping you create better software, faster, with more pleasure and personal fulfillment.

• Clarify what you’re trying to accomplish
• Choose your tools based on sensible criteria
• Organize work and systems to facilitate continuing incremental progress
• Evaluate your progress toward thriving systems, not just more "legacy code"
• Gain more value from experimentation and empiricism
• Stay in control as systems grow more complex
• Achieve rigor without too much rigidity
• Learn from history and experience
• Distinguish "good" new software development ideas from "bad" ones

Objects are the central concept of languages like Java, Python, C#. Applying best practices for object design means that your code will be easy to read, write, and maintain.

Object Design Style Guide captures dozens of techniques for creating pro-quality OO code that can stand the test of time. Examples are in an instantly familiar pseudocode, teaching techniques you can apply to any OO language, from C++ to PHP.

More and more enterprises today are dependent on cloud services from providers like AWS, Microsoft Azure, and GCP. They also use products, such as Kafka and Kubernetes, or databases, such as YugabyteDB, Cassandra, MongoDB, and Neo4j, that are distributed by nature. Because these distributed systems are inherently stateful systems, enterprise architects and developers need to be prepared for all the things that can and will go wrong when data is stored on multiple servers--from process crashes to network delays and unsynchronized clocks.

Patterns of Distributed Systems describes a set of patterns that have been observed in mainstream open-source distributed systems. Studying the common problems and the solutions that are embodied by the patterns in this guide will give you a better understanding of how these systems work, as well as a solid foundation in distributed system design principles.

Featuring real-world code examples from systems like Kafka and Kubernetes, these patterns and solutions will prepare you to confidently traverse open-source codebases and understand implementations you encounter "in the wild."

• Review the building blocks of consensus algorithms, like Paxos and Raft, for ensuring replica consistency in distributed systems
• Understand the use of logical timestamps in databases, a fundamental concept for data versioning
• Explore commonly used partitioning schemes, with an in-depth look at intricacies of two-phase-commit protocol
• Analyze mechanisms used in implementing cluster coordination tasks, such as group membership, failure detection, and enabling robust cluster coordination
• Learn techniques for establishing effective network communication between cluster nodes.

Along with enterprise architects and data architects, software developers working with cloud services such as Amazon S3, Amazon EKS, and Azure CosmosDB or GCP Cloud Spanner will find this set of patterns to be indispensable.

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

Few books in computing have had as profound an influence on software management as Peopleware. The unique insight of this longtime best seller is that the major issues of software development are human, not technical. They're not easy issues; but solve them, and you'll maximize your chances of success.

For this third edition, the authors have added six new chapters and updated the text throughout, bringing it in line with today's development environments and challenges. For example, the book now discusses pathologies of leadership that hadn't previously been judged to be pathological; an evolving culture of meetings; hybrid teams made up of people from seemingly incompatible generations; and a growing awareness that some of our most common tools are more like anchors than propellers. Anyone who needs to manage a software project or software organization will find invaluable advice throughout the book.

Take PowerShell beyond simple scripts and build time-saving automations for your team, your users, and the world.

In Practical Automation with PowerShell you will learn how to:

• Build PowerShell functions to automate common and complex tasks
• Create smart automations that are adaptable to new challenges
• Structure your code for sharing and reusability
• Store and secure your automations
• Execute automations with Azure Automation, Jenkins, Task Scheduler, and Cron
• Share your automations with your team and non-technical colleagues
• Store and retrieve data, credentials, and variables
• Use source control solutions to maintain and test code changes
• Provide front-end UI solutions for PowerShell automations

Practical Automation in PowerShell reveals how you can use PowerShell to build automation solutions for a huge number of common admin and DevOps tasks. Author Matthew Dowst uses his decades of experience to lay out a real blueprint for setting up an enterprise scripting environment with PowerShell. The book goes beyond the basics to show you how to handle the unforeseen complexities that can keep automations from becoming reusable and resilient. From the console to the cloud, you'll learn how to manage your code, avoid common pitfalls, and create sharable automations that are adaptable to different use cases.

Practical Probabilistic Programming introduces the working programmer to probabilistic programming. In it, you'll learn how to use the PP paradigm to model application domains and then express those probabilistic models in code. Although PP can seem abstract, in this book you'll immediately work on practical examples, like using the Figaro language to build a spam filter and applying Bayesian and Markov networks, to diagnose computer system data problems and recover digital images.

Product management has become a critical function for modern organizations, from small startups to corporate enterprises. And yet, the day-to-day work of product management remains largely misunderstood. In theory, product managers are high-flying visionaries who build products that people love. In practice, they're hard-working facilitators who bring clarity and focus to their teams.

In this thoroughly revised and expanded edition, Matt LeMay provides real-world guidance for current and aspiring product managers. Updated for the era of remote and hybrid work, this book provides actionable answers to product management's most persistent and confounding questions, starting with: What exactly am I supposed to do all day?

With this book, you'll learn:

• What the day-to-day work of product management entails--and how to excel at it
• Why no job title or description will resolve the ambiguity of your role
• How to bridge the false dichotomy between "strategy" and "execution"
• Why the temptation to focus on decks and documentation can be bad for your team (and for you)
• How to prioritize your time and pick your battles

When programmers list their favourite books, Jon Bentley’s collection of programming pearls is commonly included among the classics. Just as natural pearls grow from grains of sand that irritate oysters, programming pearls have grown from real problems that have irritated real programmers. With origins beyond solid engineering, in the realm of insight and creativity, Bentley’s pearls offer unique and clever solutions to those nagging problems. Illustrated by programs designed as much for fun as for instruction, the book is filled with lucid and witty descriptions of practical programming techniques and fundamental design principles. It is not at all surprising that Programming Pearls has been so highly valued by programmers at every level of experience.

What remains the same in this edition is Bentley’s focus on the hard core of programming problems and his delivery of workable solutions to those problems. Whether you are new to Bentley’s classic or are revisiting his work for some fresh insight, the book is sure to make your own list of favourites.