For many, their only experience with that corner of computer science was a terrifying "compilers" class that they suffered through in undergrad and tried to blot from their memory as soon as they had scribbled their last NFA to DFA conversion on the final exam.That fearsome reputation belies a field that is rich with useful techniques and not so difficult as some of its practitioners might have you believe. A better understanding of how programming languages are built will make you a stronger software engineer and teach you concepts and data structures you'll use the rest of your coding days. You might even have fun.This book teaches you everything you need to know to implement a full-featured, efficient scripting language. You’ll learn both high-level concepts around parsing and semantics and gritty details like bytecode representation and garbage collection. Your brain will light up with new ideas, and your hands will get dirty and calloused.Starting from main(), you will build a language that features rich syntax, dynamic typing, garbage collection, lexical scope, first-class functions, closures, classes, and inheritance. All packed into a few thousand lines of clean, fast code that you thoroughly understand because you wrote each one yourself.

    You'll also learn design processes and how to partner with an engineering manager to get things done. Do's and Don'ts deliver information in a nutshell, and "Level Up" sections point to further reading. Real-world stories are woven in throughout to reinforce key points.This book is for you if you can answer "yes" to any one of these questions:- Do you feel like the newbie on your engineering team?- Are you wondering how to review code or write a design document?- Are you worried about breaking existing code?- Are you overwhelmed by the thought of being "on-call"?- Are you surrounded by unfamiliar acronyms like SLA, SLO, PPP, 1:1, OKR?- Are you questioning the point of sprint planning meetings, story points, and stand-ups?

    It's not that there is a lack of information out there. You can find academic papers, engineering blogs, and even books on the subject. The problem is that the available information is spread out all over the place, and if you were to put it on a spectrum from theory to practice, you would find a lot of material at the two ends, but not much in the middle.That is why I decided to write a book to teach the fundamentals of distributed systems so that you don’t have to spend countless hours scratching your head to understand how everything fits together. This is the guide I wished existed when I first started out, and it's based on my experience building large distributed systems that scale to millions of requests per second and billions of devices.If you develop the back-end of web or mobile applications (or would like to!), this book is for you. When building distributed systems, you need to be familiar with the network stack, data consistency models, scalability and reliability patterns, and much more. Although you can build applications without knowing any of that, you will end up spending hours debugging and re-designing their architecture, learning lessons that you could have acquired in a much faster and less painful way.

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

    It covers everything you need to build and maintain larger code bases, write powerful and flexible applications and libraries, and confidently expand the scope and complexity of your projects.Author Jon Gjengset takes you deep into the Rust programming language, dissecting core topics like ownership, traits, concurrency, and unsafe code. You’ll explore key concepts like type layout and trait coherence, delve into the inner workings of concurrent programming and asynchrony with async/await, and take a tour of the world of no_std programming. Gjengset also provides expert guidance on API design, testing strategies, and error handling, and will help develop your understanding of foreign function interfaces, object safety, procedural macros, and much more.You'll Learn: How to design reliable, idiomatic, and ergonomic Rust programs based on best principles Effective use of declarative and procedural macros, and the difference between them How asynchrony works in Rust – all the way from the Pin and Waker types used in manual implementations of Futures, to how async/await saves you from thinking about most of those words What it means for code to be unsafe, and best practices for writing and interacting with unsafe functions and traits How to organize and configure more complex Rust projects so that they integrate nicely with the rest of the ecosystem How to write Rust code that can interoperate with non-Rust libraries and systems, or run in constrained and embedded environments Brimming with practical, pragmatic insights that you can immediately apply, Rust for Rustaceans helps you do more with Rust, while also teaching you its underlying mechanisms.

    Aging computer systems present complex technical challenges for organizations both large and small, and Kill It with Fire provides sound strategies for spearheading modernization efforts.Kill It with Fire examines aging computer systems, the evolution of technology over time, and how organizations can modernize, maintain, and future-proof their current systems.In playful and engaging prose, Marianne Bellotti uses real-world case studies to illustrate the technical challenges of modernizing complex legacy systems, as well as the organizational challenges of time-intensive maintenance efforts. The book explains how to evaluate existing architecture, create upgrade plans, and handle communication structures. Team exercises and historical analyses of complex computer systems make this a valuable resource for those in both older and newer companies, and will help readers restore or create systems built to evolve as time goes on.

    As a developer, you not only have to chase ever-changing technological trends but you 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 Vladik 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 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:Use DDD's strategic patterns and practices as well as its tactical patterns and use casesAnalyze a client company's business domain and competitive strategyBuild a shared understanding of the business domains you encounterDecompose a system into bounded contextsCoordinate the work of multiple teams working togetherGradually start implementing domain-driven design

    At that career level, you’ll no longer be required to work towards the next promotion, and being promoted beyond it is exceptional rather than expected. At that point your career path will branch, and you have to decide between remaining at your current level, continuing down the path of technical excellence to become a Staff Engineer, or switching into engineering management. Of course, the specific titles vary by company, and you can replace “Senior Engineer” and “Staff Engineer” with whatever titles your company prefers. Over the past few years we’ve seen a flurry of books unlocking the engineering management career path, like Camille Fournier’s The Manager’s Path, Julie Zhuo’s The Making of a Manager, Lara Hogan’s Resilient Management and my own, An Elegant Puzzle. The management career isn’t an easy one, but increasingly there are maps available for navigating it. On the other hand, the transition into Staff Engineer, and its further evolutions like Principal and Distinguished Engineer, remains challenging and undocumented. What are the skills you need to develop to reach Staff Engineer? Are technical abilities alone sufficient to reach and succeed in that role? How do most folks reach this role? What is your manager’s role in helping you along the way? Will you enjoy being a Staff Engineer or you will toil for years to achieve a role that doesn’t suit you? "Staff Engineer: Leadership beyond the management track" is a pragmatic look at attaining and operating in these Staff-plus roles.

    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

    The book takes you on a journey to discover the world of backend development in Rust.You will learn by doing: we will start from scratch and build together, step by step, a fully functional email newsletter backend API.You'll learn how to:- Navigate and leverage Rust's crates ecosystem- Structure your application to make it modular and extensible- Write tests, from single units to full-blown integration tests- Model your domain and leverage the type system to enforce invariants- Collect logs, traces and metrics to observe the state of your application- Set up a robust continuous integration and continuous deployment pipeline for your Rust projects

    With Rust, you have a shiny new playground where your game ideas can flourish.Each chapter in this book presents hands-on, practical projects that take you on a journey from “Hello, World” to building a full dungeon crawler game. Start by setting up Rust and getting comfortable with your development environment. Learn the language basics with practical examples as you make your own version of Flappy Bird. Discover what it takes to randomly generate dungeons and populate them with monsters as you build a complete dungeon crawl game. Run game systems concurrently for high-performance and fast game-play, while retaining the ability to debug your program. Unleash your creativity with magical items, tougher monsters, and intricate dungeon design. Add layered graphics and polish your game with style.

    Martin ("Uncle Bob") has written every programmer's definitive guide to working well. Martin brings together the disciplines, standards, and ethics you need to deliver robust, effective code quickly and productively, and be proud of all the software you write - every single day.Martin, the best-selling author of The Clean Coder, begins with a pragmatic, technical, and prescriptive guide to five foundational disciplines of software craftsmanship: test-driven development, refactoring, simple design, collaborative programming (pairing), and acceptance tests. Next, he moves up to standards -- outlining the baseline expectations the world has of software developers, illuminating how those often differ from their own perspectives, and helping you repair the mismatch. Finally, he turns to the ethics of the programming profession, describing ten fundamental promises all software developers should make to their colleagues, their users, and above all, themselves.With Martin's guidance and advice, you can consistently write code that builds trust instead of undermining it: trust among your users, and throughout a society that depends on software for its very survival.

    In this practical book, four software engineers from VMware bring their shared experiences running Kubernetes in production and provide insight on key challenges and best practices.The brilliance of Kubernetes is how configurable and extensible the system is, from pluggable runtimes to storage integrations. For platform engineers, software developers, infosec, network engineers, storage engineers, and others, this book examines how the path to success with Kubernetes involves a variety of technology, pattern, and abstraction considerations.With this book, you will:Understand what the path to production looks like when using KubernetesExamine where gaps exist in your current Kubernetes strategyLearn Kubernetes's essential building blocks--and their trade-offsUnderstand what's involved in making Kubernetes a viable location for applicationsLearn better ways to navigate the cloud native landscape

    And you’re probably trusting a collection of tools, frameworks, and protocols to keep your data, users, and business safe. It’s important to understand these tools so you can make the best decisions about how, where, and why to use them. Real-World Cryptography teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications.

    This practical book shows you how to use Go's strengths to develop cloud native services that are scalable and resilient, even in an unpredictable environment. You'll explore the composition and construction of these applications, from lower-level features of Go to mid-level design patterns to high-level architectural considerations.Each chapter builds on the lessons of the last, walking intermediate to advanced developers through Go to construct a simple but fully featured distributed key-value store. You'll learn best practices for adopting Go as your development language for solving cloud native management and deployment issues.Learn how cloud native applications differ from other software architecturesUnderstand how Go can solve the challenges of designing scalable, distributed servicesLeverage Go's lower-level features, such as channels and goroutines, to implement a reliable cloud native serviceExplore what "service reliability" is and what it has to do with "cloud native"Apply a variety of patterns, abstractions, and tooling to build and manage complex distributed systems

    Every lesson is task-focused and covers an essential skill on the road to Kubernetes mastery. You'll learn how to smooth container management with Kubernetes, including securing your clusters, and upgrades and rollbacks with zero downtime. No development stack, platform, or background is assumed. Author Elton Stoneman describes all patterns generically, so you can easily apply them to your applications and port them to other projects! Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Create apps that perform identically on your laptop, data center, and cloud! Kubernetes provides a consistent method for deploying applications on any platform, making it easy to grow. By efficiently orchestrating Docker containers, Kubernetes simplifies tasks like rolling upgrades, scaling, and self-healing. About the book Learn Kubernetes in a Month of Lunches is your guide to getting up and running with Kubernetes. You'll progress from Kubernetes basics to essential skills, learning to model, deploy, and manage applications in production. Exercises demonstrate how Kubernetes works with multiple languages and frameworks. You'll also practice with new apps, legacy code, and serverless functions. What's inside     Deploying applications on Kubernetes clusters     Understanding the Kubernetes app lifecycle, from packaging to rollbacks     Self-healing and scalable apps     Using Kubernetes as a platform for new technologies About the reader For readers familiar with Docker and containerization. About the author Elton Stoneman is a Docker Captain, a 11-time Microsoft MVP, and the author of Learn Docker in a Month of Lunches. Table of Contents PART 1 - FAST TRACK TO KUBERNETES 1 Before you begin 2 Running containers in Kubernetes with Pods and Deployments 3 Connecting Pods over the network with Services 4 Configuring applications with ConfigMaps and Secrets 5 Storing data with volumes, mounts, and claims 6 Scaling applications across multiple Pods with controllers PART 2 - KUBERNETES IN THE REAL WORLD 7 Extending applications with multicontainer Pods 8 Running data-heavy apps with StatefulSets and Jobs 9 Managing app releases with rollouts and rollbacks 10 Packaging and managing apps with Helm 11 App development—Developer workflows and CI/CD PART 3 - PREPARING FOR PRODUCTION 12 Empowering self-healing apps 13 Centralizing logs with Fluentd and Elasticsearch 14 Monitoring applications with Kubernetes with Prometheus 15 Managing incoming traffic with Ingress 16 Securing applications with policies, contexts, and admission control PART 4 - PURE AND APPLIED KUBERNETES 17 Securing resources with role-based access control 18 Deploying Kubernetes: Multinode and multiarchitecture clusters 19 Controlling workload placement and automatic scaling 20 Extending Kubernetes with custom resources and Operators 21 Running serverless functions in Kubernetes 22 Never the end

    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 applicationsExplore key cloud native communication, connectivity, and composition patternsLearn decentralized data management techniquesUse event-driven architecture to build distributed and scalable cloud native applicationsExplore the most commonly used patterns for API management and consumptionExamine some of the tools and technologies you'll need for building cloud native systems

    In fact, it's the top feature requested. What makes this combination so compelling? In this hands-on guide, Felix Zumstein--creator of xlwings, a popular open source package for automating Excel with Python--shows experienced Excel users how to integrate these two worlds efficiently.Excel has added quite a few new capabilities over the past couple of years, but its automation language, VBA, stopped evolving a long time ago. Many Excel power users have already adopted Python for daily automation tasks. This guide gets you started.Use Python without extensive programming knowledgeGet started with modern tools, including Jupyter notebooks and Visual Studio codeUse pandas to acquire, clean, and analyze data and replace typical Excel calculationsAutomate tedious tasks like consolidation of Excel workbooks and production of Excel reportsUse xlwings to build interactive Excel tools that use Python as a calculation engineConnect Excel to databases and CSV files and fetch data from the internet using Python codeUse Python as a single tool to replace VBA, Power Query, and Power Pivot

    But that isn't always a safe assumption: in fact, in some cases, it can be disastrous, leading to architectures that serve nobody well. Strategic Microservices and Monoliths helps business decision-makers and technical team members collaborate to clearly understand their strategic problems, and identify their optimal architectural approaches, whether those turns out to be distributed microservices, well-modularized monoliths, or coarser-grade services partway between the two.Writing for executives and IT professionals alike, leading software architecture expert Vaughn Vernon and Tomasz Jaskula guide you through making balanced architecture compositional decisions based on need and purpose rather than popular opinion, so you can maximize business value and deliver systems that evolve more easily. Throughout, the authors provide realistic application examples, showing how to construct well-designed monoliths that are maintainable and extensible, and how to decompose massively tangled legacy systems into truly effective microservices.

    He has reflected deeply on the software development irritants he has encountered over his career, and this book contains 60 of his most valuable responses. -- From the Foreword by Steve McConnell, Construx Software and author of Code Complete Wouldn't it be great to gain a lifetime's experience without having to pay for the inevitable errors of your own experience? Karl Wiegers is well versed in the best techniques of business analysis, software engineering, and project management. You'll gain concise but important insights into how to recover from setbacks as well as how to avoid them in the first place. --Meilir Page-Jones, Senior Business Analyst, Wayland Systems Inc. Experience is a powerful teacher, but it's also slow and painful. You can't afford to make every mistake yourself! Software Development Pearls helps you improve faster and bypass much of the pain by learning from others who already climbed the learning curves. Drawing on 25+ years helping software teams succeed, Karl Wiegers has crystallized 60 concise, practical lessons for all your projects, regardless of your role, industry, technology, or methodology.Wiegers's insights and specific recommendations cover six crucial elements of success: requirements, design, project management, culture and teamwork, quality, and process improvement. For each, Wiegers offers First Steps for reflecting on your own experiences before you start; detailed Lessons with core insights, real case studies, and actionable solutions; and Next Steps for planning adoption in your project, team, or organization. This is knowledge you weren't taught in college or boot camp. It can boost your performance as a developer, business analyst, quality professional, or manager.Clarify requirements to gain a shared vision and understanding of your real problem Create robust designs that implement the right functionality and quality attributes and can evolve Anticipate and avoid ubiquitous project management pitfalls Grow a culture in which behaviors actually align with what people claim to value Plan realistically for quality and build it in from the outset Use process improvement to achieve desired business results, not as an end in itself Choose your next steps to get full value from all these lessons Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

    

    It's fast becoming the gold standard for modern web developers, making this book essential reading for programmers who want to stay relevant and improve their game.Readers will gain a deep understanding of what WebAssembly is, how it works under the hood, when to use it, and why it improves JavaScript run times. The book's crisp, clear prose, ample illustrations, and helpful examples easily deconstruct complex topics for programmers of all skill levels. It not only shows how to expertly optimize and compile low-level code via WebAssembly, it teaches you how to debug, evaluate, and represent your code in human-readable WebAssembly Text format - a skill set that will set users apart from their peers as WebAssembly expands into mobile and desktop apps, servers and other execution environments.

    Most projects benefit from running background tasks and processing data concurrently, but the world of OTP and various libraries can be challenging. Which Supervisor and what strategy to use? What about GenServer? Maybe you need back-pressure, but is GenStage, Flow, or Broadway a better choice? You will learn everything you need to know to answer these questions, start building highly concurrent applications in no time, and write code that’s not only fast, but also resilient to errors and easy to scale.Whether you are building a high-frequency stock trading application or a consumer web app, you need to know how to leverage concurrency to build applications that are fast and efficient. Elixir and the OTP offer a range of powerful tools, and this guide will show you how to choose the best tool for each job, and use it effectively to quickly start building highly concurrent applications.Learn about Tasks, supervision trees, and the different types of Supervisors available to you. Understand why processes and process linking are the building blocks of concurrency in Elixir. Get comfortable with the OTP and use the GenServer behaviour to maintain process state for long-running jobs. Easily scale the number of running processes using the Registry. Handle large volumes of data and traffic spikes with GenStage, using back-pressure to your advantage. Create your first multi-stage data processing pipeline using producer, consumer, and producer-consumer stages. Process large collections with Flow, using MapReduce and more in parallel. Thanks to Broadway, you will see how easy it is to integrate with popular message broker systems, or even existing GenStage producers.Start building the high-performance and fault-tolerant applications Elixir is famous for today.

    You'll learn how to refactor an existing application to Spring, how to use Spring tools to make SQL database requests and REST calls, and how to secure your projects with Spring Security. There's always more to learn, and this book will make your next steps much easier. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology For Java developers, Spring is the must-learn framework. This incredible development tool powers everything from small business ecommerce applications to enterprise-scale microservices. Mastering Spring is a long journey. Taking your first step is easy! Start here. About the book Spring Start Here teaches Java developers how to build applications using Spring framework. Informative graphics, relevant examples, and author Laurentiu Spilca's clear and lively writing make it easy to pick up the skills you need. You'll discover how to plan, write, and test applications. And by concentrating on the most important features, this no-nonsense book gives you a firm foundation for exploring Spring's rich ecosystem. What's inside     Build web applications with Spring     Minimize repetition and manual work     Persisting data in a Spring application     HTTP and REST-based web services     Testing your Spring implementations About the reader For readers with beginning to intermediate Java skills. About the author Lauren?iu Spilca is a skilled Java and Spring developer and an experienced technology instructor. Table of Contents PART 1 FUNDAMENTALS 1 Spring in the real world 2 The Spring context: Defining beans 3 The Spring context: Wiring beans 4 The Spring context: Using abstractions 5 The Spring context: Bean scopes and life cycle 6 Using aspects with Spring AOP PART 2 IMPLEMENTATION 7 Understanding Spring Boot and Spring MVC 8 Implementing web apps with Spring Boot and Spring MVC 9 Using the Spring web scopes 10 Implementing REST services 11 Consuming REST endpoints 12 Using data sources in Spring apps 13 Using transactions in Spring apps 14 Implementing data persistence with Spring Data 15 Testing your Spring app

    The tutorial-first approach to ADF taken in this book gets you working from the first chapter, explaining key ideas naturally as you encounter them. From creating your first data factory to building complex, metadata-driven nested pipelines, the book guides you through essential concepts in Microsoft's cloud-based ETL/ELT platform. It introduces components indispensable for the movement and transformation of data in the cloud. Then it demonstrates the tools necessary to orchestrate, monitor, and manage those components.The hands-on introduction to ADF found in this book is equally well-suited to data engineers embracing their first ETL/ELT toolset as it is to seasoned veterans of Microsoft's SQL Server Integration Services (SSIS). The example-driven approach leads you through ADF pipeline construction from the ground up, introducing important ideas and making learning natural and engaging. SSIS users will find concepts with familiar parallels, while ADF-first readers will quickly master those concepts through the book's steady building up of knowledge in successive chapters. Summaries of key concepts at the end of each chapter provide a ready reference that you can return to again and again.What You Will LearnCreate pipelines, activities, datasets, and linked servicesBuild reusable components using variables, parameters, and expressionsMove data into and around Azure services automaticallyTransform data natively using ADF data flows and Power Query data wranglingMaster flow-of-control and triggers for tightly orchestrated pipeline executionPublish and monitor pipelines easily and with confidenceWho This Book Is ForData engineers and ETL developers taking their first steps in Azure Data Factory, SQL Server Integration Services users making the transition toward doing ETL in Microsoft's Azure cloud, and SQL Server database administrators involved in data warehousing and ETL operations

    Pipeline as Code is a practical guide to automating your development pipeline in a cloud-native, service-driven world. You’ll use the latest infrastructure-as-code tools like Packer and Terraform to develop reliable CI/CD pipelines for numerous cloud-native applications. Follow this book's insightful best practices, and you’ll soon be delivering software that’s quicker to market, faster to deploy, and with less last-minute production bugs. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

    With more than 2,000 terms and explanations it acquaints and reunites you with the major standards and concepts of the Web, with HTML, CSS, JavaScript, accessibility, security, performance, code quality, internationalization, localization, editors and tooling and more.The glossary then goes beyond web development, touching on computer science, design, typography, usability and user experience, information as well as project management, other disciplines of interest and relevance to the modern developer. It goes beyond, inspiring the curiosity to learn more about the Web and the people creating and using it. And still it is a glossary, of a couple of thousand terms for developers, leaning on (and giving back to) Wikipedia and the MDN Web Docs.→ This is the book if you choose to extend and validate your web and software development knowledge.

    Based on the highly regarded and effective Software Guild Python course, this book teaches you the basic and advanced Python concepts you will need at any entry-level Python position.With the "Pulling It Together" sections, you'll combine and integrate the concepts and lessons taught by the book, while also benefiting from:A thorough introduction to getting set up with Python Practical discussions of the basics of the Python language, including syntax, program flow, and code organization A walk through the fundamentals of Object-Oriented Programming including Classes, Objects, Interfaces, and Inheritance, and how to leverage OOP to create elegant code A focus on data processing and data analysis with Python

    

    This book offers advice on how to avoid technical debt, how to locate its sources, and how to remove it. It focuses on the practical implications of technical debt for the entire software life cycle, with examples and case studies from companies that range from Boeing to Twitter.Technical debt is normal; it is part of most iterative development processes. But if debt is ignored, over time it may become unmanageably complex, requiring developers to spend all of their effort fixing bugs, with no time to add new features--and after all, new features are what customers really value. The authors explain how to monitor technical debt, how to measure it, and how and when to pay it down. Broadening the conventional definition of technical debt, they cover requirements debt, implementation debt, testing debt, architecture debt, documentation debt, deployment debt, and social debt. They intersperse technical discussions with Voice of the Practitioner sidebars that detail real-world experiences with a variety of technical debt issues.

    Readers learn the foundations of programming as they write code that produces creative, intriguing, and aesthetically-pleasing results.An accessible, visual, and creative approach to teaching Python programming using the Processing development environment. Readers learn the theoretical and technical workings of computer programming as they write code that produces intriguing and aesthetically-pleasing results. Based on a decade's worth of lecturing experience, the author covers what works best for those looking to learn programming fundamentals in a visual context. These skills provide an entry point into the world of code art, making video games, web development, and other creative technologies.Among the topics covered in the book, readers will learn how computers manage color, how to draw and animate with code, how to add randomness to programs, some data visualization techniques, and handling mouse and keyboard interaction.

    Using the persistent data structures built into most modern programming languages, Data-oriented programming cleanly separates code and data, which simplifies state management and eases concurrency.Data-Oriented Programming teaches you to design and implement software using the data-oriented programming paradigm. In it, you’ll learn author Yehonathan Sharvit’s unique approach to DOP that he has developed over a decade of experience. Every chapter contains a new light bulb moment that will change the way you think about programming. As you read, you’ll build a library management system using the DOP paradigm. You’ll design data models for business entities, manipulate immutable data collections, and write unit tests for data-oriented systems. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

    You'll be learning to program with JavaScript - the most popular programming language on Earth. And it runs in web browsers, making it particularly suited to creating web-based apps and games. But the principles and techniques that you'll learn will provide you with a foundation to go on and learn many other languages, too.You'll learn:Programming basics, including data types, variables and moreHow to use logic to control the flow of a programHow to use loops to repeat code over and over againHow to write functions that can be used to store code in reusable blocksHow to store data in collections such as arrays, sets and mapsHow to create objects that store properties and actionsAnd much more!Along the way, you'll build a collection of fun applications, including games and interactive web pages. Start learning to code today!

    

    Accomplished author and former P&G executive Scott Mautz walks readers through the unique challenges facing these managers, and the mindset and skillset necessary for managing up and down and influencing what happens across the organization.You'll learn the winning mindset of the best middle managers, how to develop the most important skills necessary for managing from the middle, how to create your personal Middle Action Plan (MAP), and effectively influence:Up the chain of command, to your boss and those above them Down, to your direct reports and teams who report to you Laterally, to peers and teams you have no formal authority over Anyone in an organization who reports to someone and has someone reporting to them must lead from the middle. They are the most important group in an organization and have a unique opportunity to drive impact. Leading from the Middle explains how.

    Master Scala, and you'll be well-equipped to match your programming approach to the type of problem you're dealing with. Packed with examples and exercises, Get Programming with Scala is the perfect starting point for developers with some OO knowledge who want to learn Scala and pick up a few FP skills along the way. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Scala developers are in high demand. This flexible language blends object-oriented and functional programming styles so you can write flexible, easy-to-maintain code. Because Scala runs on the JVM, your programs can interact seamlessly with Java libraries and tools. If you’re comfortable writing Java, this easy-to-read book will get you programming with Scala fast. About the book Get Programming with Scala is a fast-paced introduction to the Scala language, covering both Scala 2 and Scala 3. You’ll learn through lessons, quizzes, and hands-on projects that bring your new skills to life. Clear explanations make Scala’s features and abstractions easy to understand. As you go, you’ll learn to write familiar object-oriented code in Scala and also discover the possibilities of functional programming. What's inside     Apply object-oriented principles in Scala     Learn the core concepts of functional programming     Use types to enforce program requirements     Use abstractions to avoid code duplication     Write meaningful tests and recognize code smells About the reader For developers who know an OOP language like Java, Python, or C#. No experience with Scala or functional programming required. About the author Daniela Sfregola is a Senior Software Engineer and a Scala user since 2013. She is an active contributor to the Scala Community, a public speaker at Scala conferences and meetups, and a maintainer of open-source projects. Table of Contents Unit 0 HELLO SCALA! Unit 1 THE BASICS Unit 2 OBJECT-ORIENTED FUNDAMENTALS Unit 3 HTTP SERVER Unit 4 IMMUTABLE DATA AND STRUCTURES Unit 5 LIST Unit 6 OTHER COLLECTIONS AND ERROR HANDLING Unit 7 CONCURRENCY Unit 8 JSON (DE)SERIALIZATION

    No matter what language you use, your code should be clean, elegant, and uncluttered? With test-driven development (TDD), you'll write better code--code that's easy to understand, retains its elegance, and works for years to come.This indispensable guide will show you how TDD works in three different languages: Go, JavaScript, and Python. With Learning Test-Driven Development at your side, you'll be able to:Tame domain complexity using a divide-and-conquer approachUnderstand how TDD works across languages, testing frameworks, and domain conceptsSee how TDD enables continuous integration and continuous deliverySupport refactoring and redesign with TDDSet up a continuous integration environment with the unit tests produced during TDDWrite clean, uncluttered code using TDD in Go, JavaScript, and Python

    The essential handbook on how to build, use and improve your Continuous Delivery Pipeline.If you want to create Better Software Faster, then you need Continuous Delivery, and at the heart of Continuous Delivery is the Deployment Pipeline.You may already have one, or be thinking about building your first! Either way, this book offers a step-by-step guide to get the best Deployment Pipeline for your software.Written by the inventor of the Deployment Pipeline and author of the award-winning book "Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation", Dave Farley, shares his advice and experience in this practical handbook.Table of Contents PrefaceDeployment Pipeline FoundationsChapter 1 - Introduction to Continuous DeliveryWhat is Continuous Delivery?Three Key IdeasSeven Essential TechniquesChapter 2 - What is a Deployment Pipeline?Scope and PurposeKey Stages of a Deployment PipelineKey Practices for a Deployment PipelineWorking EfficientlySmall, Autonomous TeamsThe Deployment Pipeline is a Lean MachineSummaryChapter 3 - How to Build a Deployment PipelineGetting StartedCreate a Commit StageCreate an Artifact RepositoryCreate an Acceptance StageCreate a Simple Version of ProductionNext StepsChapter 4 - Test Driven DevelopmentWhat is TDD?Test FirstTest All the TimeThe Impact of Test-First on DesignUsing ‘Testability’ to Improve DesignChapter 5 - Automate Nearly EverythingAn Essential Element of Continuous Delivery.Test AutomationBuild and Deployment AutomationAutomate Data MigrationAutomate Monitoring and ReportingInfrastructure AutomationBenefits of AutomationTips for AutomationChapter 6 - Version ControlA Key Requirement for Deployment PipelinesWhat to Version Control?Reproducible SystemsThe Route to ProductionBranchingDeployment Pipeline AnatomyChapter 7 - The Development EnvironmentPaving the Way for the Deployment Pipeline.Chapter 8 - The Commit CycleThe Gateway to the Deployment PipelineCommit Stage TestsFeedback in Five MinutesWorking in Small StepsContinuous IntegrationGenerating Release CandidatesSummaryChapter 9 - The Artifact RepositoryThe Heart of the Deployment PipelineScope and PurposeStorage ManagementNext StepsChapter 10 - The Acceptance StageConfidence to ReleaseAims of the Acceptance StageSteps in Running Acceptance TestsWhat are Acceptance Tests?How to Write Acceptance TestsThe Four-Layer ApproachAutomating the Acceptance StageScaling UpTips for Writing Acceptance TestsChapter 11 - Manual TestingThe Role of Manual TestingWhen to Add Manual Testing?Chapter 12 - Performance TestingEvaluating the Performance of our SystemPass/Fail Performance TestsTesting UsabilityComponent-Based Performance TestingSystem-Level Performance TestingHigh-Performance, Low-Latency SystemsLong-Running TestsControl the VariablesChapter 13 - Testing Non-Functional RequirementsWhat are Non-Functional Requirements?ScalabilityTesting FailureCompliance and RegulationProvenanceAudit and TraceabilitySecurity TestingTeam ResponsibilitySummaryChapter 14 - Testing Data and Data MigrationContinuous Delivery and DataData MigrationData Migration Testing StageData ManagementLimits of Deployment-Time MigrationTesting and Test DataSummaryChapter 15 - Release Into ProductionThe Production EnvironmentWhen to Release?Release StrategiesFeedback from ProductionIn ProductionMaking Evidence-Based DecisionsWhole Pipeline ConsiderationsChapter 16 - Infrastructure As CodeWhat is Infrastructure As Code?Infrastructure Configuration ManagementRecommended PrinciplesRecommended PracticesInfrastructure As Code and the CloudChapter 17 - Regulation and ComplianceResponding to Regulatory RequirementsTechniques that Facilitate Regulatory ComplianceWhat Can Go Wrong?The Deployment Pipeline as a Tool for ComplianceContinuous ComplianceChapter 18 - Measuring SuccessMaking Evidence-Based DecisionsPurposeQualityEfficiencyThroughput and StabilityCalculating Lead TimeImproving Lead TimeFollow a Lean approachAppendicesAppendix A - More InformationThe Continuous Delivery BookThe Continuous Delivery YouTube ChannelContinuous Delivery TrainingFurther ReadingNotes

    Game systems designers plan a game's rules and balance, its characters' attributes, most of its data, and how its AI, weapons, and objects work and interact. Introduction to Game Systems Design is the first complete beginner's guide to this crucial discipline. Writing for all aspiring game professionals, even those with absolutely no experience, leading game designer and instructor Dax Gazaway presents a step-by-step, hands-on approach to designing game systems with industry-standard tools. Drawing on his experience building AAA-level game systems (including games in the Star Wars and Marvel franchises), Gazaway covers all this, and more: Exploring the essentials of game design and its emerging subdisciplines Asking the essential questions at the heart of all design Getting started with modern game system design tools, including the spreadsheets most professionals now use Creating systems and data from a blank page Populating and quantifying a world of data into a game Tuning and balancing game systems Testing game systems and data Leveraging communication, psychology, and rewards within your games Balancing game probability within systems Whether you're a college freshman entering a game design program, an indie developer using Unreal or Unity, a Dungeon Master, or anyone who wants to really understand modern games, this guide will help you get where you want to go.

    Financial Theory with Python provides relevant foundations of each discipline to give you the major tools you need to get started in the world of computational finance.Using an approach where mathematical concepts provide the common background against which financial ideas and programming techniques are learned, Financial Theory with Python teaches you the basics of financial economics. Written by the bestselling author of Python for Finance, Yves Hilpisch, this practical guide explains financial, mathematical, and Python programming concepts in an integrative manner so that the interdisciplinary concepts reinforce each other. Draw upon mathematics to learn the foundations of financial theory and Python programming Learn about financial theory, financial data modeling, and the use of Python for computational finance Leverage simple economic models to better understand basic notions of finance and Python programming concepts Utilize both static and dynamic financial modeling to address fundamental problems in finance, such as pricing, decision making, equilibrium, and asset allocation Learn the basics of Python packages useful for financial modeling, such as NumPy, pandas, matplotlib, and SymPy