Winner of the 2011 Jolt Excellence Award! Getting software released to users is often a painful, risky, and time-consuming process. This groundbreaking new book sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers, and operations, delivery teams can get changes released in a matter of hours- sometimes even minutes-no matter what the size of a project or the complexity of its code base. Jez Humble and David Farley begin by presenting the foundations of a rapid, reliable, low-risk delivery process. Next, they introduce the "deployment pipeline," an automated process for managing all changes, from check-in to release. Finally, they discuss the "ecosystem" needed to support continuous delivery, from infrastructure, data and configuration management to governance. The authors introduce state-of-the-art techniques, including automated infrastructure management and data migration, and the use of virtualization. For each, they review key issues, identify best practices, and demonstrate how to mitigate risks. Coverage includes * Automating all facets of building, integrating, testing, and deploying software * Implementing deployment pipelines at team and organizational levels * Improving collaboration between developers, testers, and operations * Developing features incrementally on large and distributed teams * Implementing an effective configuration management strategy * Automating acceptance testing, from analysis to implementation * Testing capacity and other non-functional requirements * Implementing continuous deployment and zero-downtime releases * Managing infrastructure, data, components and dependencies * Navigating risk management, compliance, and auditing Whether you're a developer, systems administrator, tester, or manager, this book will help your organization move from idea to release faster than ever-so you can deliver value to your business rapidly and reliably.

This book covers elementary discrete mathematics for computer science and engineering. It emphasizes mathematical definitions and proofs as well as applicable methods. Topics include formal logic notation, proof methods; induction, well-ordering; sets, relations; elementary graph theory; integer congruences; asymptotic notation and growth of functions; permutations and combinations, counting principles; discrete probability. Further selected topics may also be covered, such as recursive definition and structural induction; state machines and invariants; recurrences; generating functions.

Algorithms are the heart and soul of computer science. Their applications range from network routing and computational genomics to public-key cryptography and machine learning. Studying algorithms can make you a better programmer, a clearer thinker, and a master of technical interviews. Algorithms Illuminated is an accessible introduction to the subject for anyone with at least a little programming experience. The exposition emphasizes the big picture and conceptual understanding over low-level implementation and mathematical details---like a transcript of what an expert algorithms tutor would say over a series of one-on-one lessons. Part 1 covers asymptotic analysis and big-O notation, divide-and-conquer algorithms and the master method, randomized algorithms, and several famous algorithms for sorting and selection.

Conceptual and precise, Modern Processor Design brings together numerous microarchitectural techniques in a clear, understandable framework that is easily accessible to both graduate and undergraduate students. Complex practices are distilled into foundational principles to reveal the authors' insights and hands-on experience in the effective design of contemporary high-performance micro-processors for mobile, desktop, and server markets. Key theoretical and foundational principles are presented in a systematic way to ensure comprehension of important implementation issues.
The text presents fundamental concepts and foundational techniques such as processor design, pipelined processors, memory and I/O systems, and especially superscalar organization and implementations. Two case studies and an extensive survey of actual commercial superscalar processors reveal real-world developments in processor design and performance. A thorough overview of advanced instruction flow techniques, including developments in advanced branch predictors, is incorporated. Each chapter concludes with homework problems that will institute the groundwork for emerging techniques in the field and an introduction to multiprocessor systems.
Not-for-sale instructor resource material available to college and university faculty only; contact publisher directly.

在过去20多年的时间里，本书一直是计算机领域的教师、学生和体系结构设计人员的必读之作。两位作者Hennessy和Patterson于2017年荣获图灵奖，肯定了他们对计算机领域持久而重要的技术贡献。随着处理器和系统架构的最新发展，第6版进行了全面修订。这一版采用RISC-V指令集体系结构，这是一个现代的RISC指令集，被设计为免费且可公开采用的标准。书中还增加了一个关于领域特定体系结构的新章节，并更新了关于仓储级计算的章节，其中介绍了谷歌最新的WSC。与本书之前版本的目标一样，本书致力于揭开计算机体系结构的神秘面纱，关注那些令人兴奋的技术创新，同时强调良好的工程设计。

From the stock market to genomics laboratories, census figures to marketing email blasts, we are awash with data. But as anyone who has ever opened up a spreadsheet packed with seemingly infinite lines of data knows, numbers aren’t enough: we need to know how to make those numbers talk. In The Model Thinker, social scientist Scott E. Page shows us the mathematical, statistical, and computational models–from linear regression to random walks and far beyond–that can turn anyone into a genius. At the core of the book is Page’s “many-model paradigm,” which shows the reader how to apply multiple models to organize the data, leading to wiser choices, more accurate predictions, and more robust designs. The Model Thinker provides a toolkit for business people, students, scientists, pollsters, and bloggers to make them better, clearer thinkers, able to leverage data and information to their advantage.

You’ve completed a basic Python programming tutorial or finished Al Sweigart’s best selling Automate the Boring Stuff with Python. What’s the next step toward becoming a capable, confident software developer?
Welcome to Beyond the Basic Stuff with Python. More than a mere collection of advanced syntax and masterful tips for writing clean code, you’ll learn how to advance your Python programming skills by using the command line and other professional tools like code formatters, type checkers, linters, and version control. Sweigart takes you through best practices for setting up your development environment, naming variables, and improving readability, then tackles documentation, organization and performance measurement, as well as object-oriented design and the Big-O algorithm analysis commonly used in coding interviews. The skills you learn will boost your ability to program—not just in Python but in any language.
You’ll learn:
Coding style, and how to use Python’s Black auto-formatting tool for cleaner code
Common sources of bugs, and how to detect them with static analyzers
How to structure the files in your code projects with the Cookiecutter template tool
Functional programming techniques like lambda and higher-order functions
How to profile the speed of your code with Python’s built-in timeit and cProfile modules
The computer science behind Big-O algorithm analysis
How to make your comments and docstrings informative, and how often to write them
How to create classes in object-oriented programming, and why they’re used to organize code
Toward the end of the book you’ll read a detailed source-code breakdown of two classic command-line games, the Tower of Hanoi (a logic puzzle) and Four-in-a-Row (a two-player tile-dropping game), and a breakdown of how their code follows the book’s best practices. You’ll test your skills by implementing the program yourself.
Of course, no single book can make you a professional software developer. But Beyond the Basic Stuff with Python will get you further down that path and make you a better programmer in the process as you learn to write readable code that’s easy to debug and perfectly Pythonic.

If you last saw algorithms in a university course or at a job interview, you’re missing out on what they can do for your code. Learn different sorting and searching techniques, and when to use each. Find out how to use recursion effectively. Discover structures for specialized applications, such as trees and graphs. Use Big O notation to decide which algorithms are best for your production environment. Beginners will learn how to use these techniques from the start, and experienced developers will rediscover approaches they may have forgotten.

This comprehensive guide helps developers and architects understand current cloud-native technologies, with recommendations that explain when you need to use each one. Authors Boris Scholl, Trent Swanson, and Peter Jausovec describe the patterns you need for building cloud-native applications, and provide best practices for the most common tasks such as messaging, eventing, and DevOps.
This practical book also delivers an architectural blueprint for a modern cloud-native application. You’ll learn about microservices, containers, serverless computing, storage types, data considerations, portability, and the use of functions.
Differentiate between containers and functions, and understand when to use which technology
Leverage Service Meshes to move complexity, such as distributed tracing and mutual TLS handshakes, away from the developer
Use messaging and eventing as the glue for the cloud-native composite applications
Handle state-in distributed applications
Understand what makes your application portable

The essentials of communication for professionals, educators, students, and entrepreneurs, from organizing your thoughts to inspiring your audience.
Do you give presentations at meetings? Do you ever have to explain a complicated subject to audiences unfamiliar with your field? Do you make pitches for ideas or products? Do you want to interest a lecture hall of restless students in subjects that you find fascinating? Then you need this book. Make It Clear explains how to communicate—how to speak and write to get your ideas across. Written by an MIT professor who taught his students these techniques for more than forty years, the book starts with the basics—finding your voice, organizing your ideas, making sure what you say is remembered, and receiving critiques (“do not ask for brutal honesty”)—and goes on to cover such specifics as preparing slides, writing and rewriting, and even choosing a type family.
The book explains why you should start with an empowerment promise and conclude by noting you delivered on that promise. It describes how a well-crafted, explicitly identified slogan, symbol, salient idea, surprise, and story combine to make you and your work memorable. The book lays out the VSN-C (Vision, Steps, News–Contributions) framework as an organizing structure and then describes how to create organize your ideas with a “broken–glass” outline, how to write to be understood, how to inspire, how to defeat writer's block—and much more. Learning how to speak and write well will empower you and make you smarter. Effective communication can be life-changing—making use of just one principle in this book can get you the job, make the sale, convince your boss, inspire a student, or even start a revolution.

Accelerate your organization to win in the marketplace.
How can we apply technology to drive business value? For years, we’ve been told that the performance of software delivery teams doesn’t matter―that it can’t provide a competitive advantage to our companies. Through four years of groundbreaking research to include data collected from the State of DevOps reports conducted with Puppet, Dr. Nicole Forsgren, Jez Humble, and Gene Kim set out to find a way to measure software delivery performance―and what drives it―using rigorous statistical methods. This book presents both the findings and the science behind that research, making the information accessible for readers to apply in their own organizations.
Readers will discover how to measure the performance of their teams, and what capabilities they should invest in to drive higher performance. This book is ideal for management at every level.

本书是一个非音乐专业人士写的音乐随笔，但是不同凡响，不是声音振天响，而是平凡、安静和孤迥，还有悠远，有从音乐“沾取一点恩泽”的感觉。这样的随笔集不光是懂音乐的人可能找到知音，不懂音乐的人仅凭这些文字，也会爱上巴赫，享受到某种境界，或者从此,开始有音乐作为自己的朋友。
不管这个世界上发生什么，有多少游戏、厌倦和绝望，都有那么一种音乐，温暖得持久而真实，与人不弃不离。
不论你是不是听很多古典音乐，读了这本书，你都可能找到一种新的方式或者态度，接受生活，感谢生活。
听音乐是需要勇气的，你把自己的情感交出去，任它给喂养的茁壮而陌生，这中间会有多少孤独和挣扎。
这个世界有它的秩序，就像音乐里宿命的“必然”。在音乐绽放的伤口里放进心悸，放进骄傲，于是音乐吸取血气变得动荡，动荡得能撕毁。
用“道路”去感觉音乐，简直就是把音乐“种”在自己的记忆和生活里哪。
我在各种生活里观看过那些音乐被不同的心情照出的凹凸。
这些音乐无论多么寂寞，多么少有人知，他们仍然“是一种贴近皮肤的温润的渗透，你要相信他们终将抵达心脏。”请相信，我用时间和生活诚实地验证过。

Accident investigation and risk assessment have for decades focused on the human factor, most notably in the form of 'human error'. Countless books and papers have been written about how to identify, classify, eliminate, prevent and compensate for 'human error'. This preoccupation with failure is near universal and can be found in all fields of application. One consequence of this has been a bias towards the study of performance failures, leading to a neglect of normal or 'error-free' performance. The common, unspoken assumption is that failures and successes have different origins and that there therefore is little to be gained from studying the latter. Erik Hollnagel argues strongly that this assumption is incorrect and that it is impossible to attain safety by eliminating risks and failures. Instead it is better to study why things go right, and to find ways to support and amplify that. The aim of this book is to present a single, simple but powerful principle for human performance that can be used to understand both positive and negative outcomes. The ETTO Principle reflects the common trait that people in their work naturally adjust what they do to match the conditions - to what has happened, to what happens, and to what may happen. It proposes that it is normal for people in work situations to adjust their performance by means of an efficiency-thoroughness trade-off (ETTO) - usually by sacrificing thoroughness for efficiency. The trade-off can be due to a lack of time, lack of resources, work and company pressures, lack of information, etc. The ability of people mutually to adjust their performance is the reason why things go right. Yet in some cases the adjustments may combine in an unforeseen way and lead to adverse outcomes. These outcomes are nevertheless due to the very same processes that produce successes, rather than to errors and malfunctions. The ETTO Principle obviates the need for specialised theories and models of failure and 'human error' and offers instead a viable basis for more effective and just approaches to both reactive and proactive safety management.

Level up your C++, get the tools working for you, eliminate common problems, and move on to more exciting things! This version is printed with full color syntax highlighted examples. A black and white only edition is available for less.As a C++ developer and trainer for 20 years, I have learned that there are many common mistakes that C++ developers of all experience levels make. This book distills that experience down into the most important things to address to make your code faster, easier to maintain, and more portable.Most sections have one or more exercises that help you apply what is discussed in a practical way in the code you are currently working onThis book is intentionally concise! Expect short sections for each item! I use as few words as possible to get across the point and get you applying what you learned to your code.If you follow me and watch all of my talks this book will present little new information to you. Why should you buy it then? Because I've consolidated the most important items and given you exercises to apply the rules in your code.

Ansible is a simple, but powerful, server and configuration management tool (with a few other tricks up its sleeve). This book will help those familiar with the command line and basic shell scripting start using Ansible to provision and manage anywhere from one to thousands of servers.

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

The system design interview is considered to be the most complex and most difficult technical job interview by many. Those questions are intimidating, but don’t worry. It's just that nobody has taken the time to prepare you systematically.
We take the time.
We go slow.
We draw lots of diagrams and use lots of examples.
You'll learn step-by-step, one question at a time.
Don’t miss out.
What’s inside?
- An insider’s take on what interviewers really look for and why.
- A 4-step framework for solving any system design interview question.
- 16 real system design interview questions with detailed solutions.
- 188 diagrams to visually explain how different systems work.

"Digital Design and Computer Architecture" takes a unique and modern approach to digital design. Beginning with digital logic gates and progressing to the design of combinational and sequential circuits, Harris and Harris use these fundamental building blocks as the basis for what follows: the design of an actual MIPS processor. SystemVerilog and VHDL are integrated throughout the text in examples illustrating the methods and techniques for CAD-based circuit design. By the end of this book, readers will be able to build their own microprocessor and will have a top-to-bottom understanding of how it works. Harris and Harris have combined an engaging and humorous writing style with an updated and hands-on approach to digital design. This second edition has been updated with new content on I/O systems in the context of general purpose processors found in a PC as well as microcontrollers found almost everywhere. The new edition provides practical examples of how to interface with peripherals using RS232, SPI, motor control, interrupts, wireless, and analog-to-digital conversion. High-level descriptions of I/O interfaces found in PCs include USB, SDRAM, WiFi, PCI Express, and others. In addition to expanded and updated material throughout, SystemVerilog is now featured in the programming and code examples (replacing Verilog), alongside VHDL. This new edition also provides additional exercises and a new appendix on C programming to strengthen the connection between programming and processor architecture. It covers the fundamentals of digital logic design and reinforces logic concepts through the design of a MIPS microprocessor. It features side-by-side examples of the two most prominent Hardware Description Languages (HDLs)-SystemVerilog and VHDL - which illustrate and compare the ways each can be used in the design of digital systems. It includes examples throughout the text that enhance the reader's understanding and retention of key concepts and techniques. Companion Web site includes links to CAD tools for FPGA design from Altera and Mentor Graphics, lecture slides, laboratory projects, and solutions to exercises. Updated based on instructor feedback with more exercises and new examples of parallel and advanced architectures, practical I/O applications, embedded systems, and heterogeneous computing. It presents digital system design examples in both VHDL and SystemVerilog (updated for the second edition from Verilog), shown side-by-side to compare and contrast their strengths. It includes a new chapter on C programming to provide necessary prerequisites and strengthen the connection between programming and processor architecture. Instructors can also register at textbooks.elsevier.com for access to: solutions to all exercises (PDF); lab materials with solutions; HDL for textbook examples and exercise solutions; Lecture slides (PPT); Sample exams\ Sample course syllabus; and figures from the text (JPG, PPT).