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.

    By scale, we mean having numbers of users in the millions and being built by large engineering teams.For mobile engineers, this book is a blueprint for modern app engineering approaches. For non-mobile engineers and managers, it is a resource with which to build empathy and appreciation for the complexity of world-class mobile engineering.

    While there are plenty of tutorials available that teach Go's syntax to developers with experience in other programming languages, tutorials aren't enough. They don't teach Go's idioms, so developers end up recreating patterns that don't make sense in a Go context. This practical guide provides the essential background you need to write clear and idiomatic Go.No matter your level of experience, you'll learn how to think like a Go developer. Author Jon Bodner introduces the design patterns experienced Go developers have adopted and explores the rationale for using them. You'll also get a preview of Go's upcoming generics support and how it fits into the language.Learn how to write idiomatic code in Go and design a Go projectUnderstand the reasons for the design decisions in GoSet up a Go development environment for a solo developer or teamLearn how and when to use reflection, unsafe, and cgoDiscover how Go's features allow the language to run efficientlyKnow which Go features you should use sparingly or not at all

    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 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.

    Designed for readers who don't care for academic formalities, it's a fast and easy guide. It teaches the foundations programmers and knowledge workers need to maximize their effectiveness. It explains how the Internet works from the ground up, how to analyse and derive knowledge from data, and how computers are able to predict the future with machine learning.

    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

    The 100+ short programs in Big Book of Small Python Projects are designed to help beginning-to-intermediate programmers expand their knowledge of how to deploy Python creatively and effectively by offering coding examples that will help them to tackle their own coding challenges.The 100+ short, complete Python programs in this book are designed to help beginning-to-intermediate Python programmers broaden their skills by providing a diverse set of coding examples they can study, emulate, and draw inspiration from. The programs range from classic card and board games and mazes, to math and probability demos, and mad libs. The author includes the complete code for each program, as well as commentary and suggestions for how to modify and experiment with code.

    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.

    

    It demonstrates practical techniques that you will recognize from popular sites where visitors can:Register as a member and log in Create articles, posts and profiles that are saved in a database Upload their own images and files Automatically receive email notifications Like and comment on posts. To show you how to apply the skills you learn, you will build a complete content management system, enhanced with features that are commonly seen on social networks.Written by best-selling HTML & CSS and JavaScript & jQuery author Jon Duckett, this book uses a unique visual approach, with step-by-step instructions, practical code examples and pro tips that will teach you how to build modern database-driven websites using PHP.

    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 unique book teaches you concrete techniques rooted in cognitive science that will improve the way you learn and think about code.In The Programmer’s Brain: What every programmer needs to know about cognition you will learn:* Fast and effective ways to master new programming languages* Speed reading skills to quickly comprehend new code* Techniques to unravel the meaning of complex code* Ways to learn new syntax and keep it memorized* Writing code that is easy for others to read* Picking the right names for your variables* Making your codebase more understandable to newcomers* Onboarding new developers to your teamLearn how to optimize your brain’s natural cognitive processes to read code more easily, write code faster, and pick up new languages in much less time. This book will help you through the confusion you feel when faced with strange and complex code, and explain a codebase in ways that can make a new team member productive in days!about the technologyUnderstanding the cognitive functions that govern the way your brain thinks about coding will help you work smarter, not harder. You’ll improve your productivity, reduce your need for constant rewrites, and say goodbye to spending late nights struggling with new languages.about the bookThe Programmer’s Brain explores the way your brain works when it’s thinking about code. In it, you’ll master practical ways to apply these cognitive principles to your daily programming life. You’ll improve your code comprehension by turning confusion into a learning tool, and pick up awesome techniques for reading code and quickly memorizing syntax. This practical guide includes tips for creating your own flashcards and study resources that can be applied to any new language you want to master. By the time you’re done, you’ll not only be better at teaching yourself—you’ll be an expert at bringing new colleagues and junior programmers up to speed.

    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

    The Gherkin format is supported by many BDD tools, including the different flavors of Cucumber, Behat or SpecFlow, but the ideas described in the book are also suitable for other BDD tools, like JBehave or Robot Framework.This book is written for everyone involved in the specification and delivery of software: product owners, business analysts, developers, and testers.This is the second in the BDD Books series that will guide you through the entire development process, including specific technical practices needed to successfully drive development using collaboratively-authored specifications and living documentation.

    In Good Code, Bad Code you’ll learn how to boost your effectiveness and productivity with code development insights normally only learned through years of experience, careful mentorship, and hundreds of code reviews.In Good Code, Bad Code you’ll learn how to:+ Think about code like an effective software engineer+ Write functions that read like a well-structured sentence+ 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 you and your team’s time

    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.

    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

    Systems design could be seen as the application of systems theory to product development. As a result, there is some overlap with the disciplines of systems analysis, systems architecture, and systems engineering.Designing software systems is a vast topic, and even a software engineer having years of experience at a top software company may not claim to be an expert on system design. Companies spend not weeks but months and hire a big team of software engineers to build such systems in real life.While this book is oriented towards Software Developers and Architects, this book can be helpful for any working in the High-Tech industry. In this, we will understand how popular products such as Instagram, Facebook Messenger, Dropbox, TinyURL, and Pastebin are designed. No prior technical knowledge is required before picking up this book.As a Product Manager or Startup Founder, having a high-level understanding of the various technologies being used in you as well as popular products across the industry would be a handy tool in your toolkit. As a Venture Capitalist, you can better analyze the capabilities of the tech teams of the startups you are investing in as well as understand how their tech stands apart from the competition.Even if you are not working directly in the Tech industry, everyone uses these products on a daily basis. Therefore, having an understanding of how these products work could help you improve your digital life and make use of these products in a better way.

    But adopting a new language can be daunting, especially when you're working with business-critical Java code that must meet changing requirements.This book takes a novel approach to introducing Kotlin to Java programmers: showing you how to gradually refactor Java code to idiomatic Kotlin while continuing to evolve its functionality. But converting Java to Kotlin is just the starting point. Kotlin has many features beyond Java.Using worked examples, authors Duncan McGregor and Nat Pryce guide you through honing the converted code to make it simpler, more efficient, more expressive, and easier to change. You'll learn how to take advantage of functional constructs to improve program structure, reliability, and error handling.Once you finish this book, you'll be confident writing Kotlin from scratch, converting your existing Java when appropriate, and managing a mixed Java-Kotlin codebase as it evolves over time.

    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.

    To start, you'll find the steps for installing Visual Studio Code on Windows, Mac and Linux platforms, along with an introduction to the editing features of the workspace. Coverage of more advanced functionality includes managing source code, debugging, unit testing, and Jupyter Notebook support. The book finishes with a walk-through of real-world projects which utilize Visual Studio Code features introduced in the book.For developers, the choice of an editor is a very personal one. You have idiosyncratic needs and wants that are unique to you as a developer. This book will help you learn how to customize Visual Studio Code to meet your needs and Python development workflow.Introduces you to the features of the Visual Studio Code workspace and how those features can be customized Demonstrates how Visual Studio Code allows you to choose your structure according to your needs Covers editing code in Python, including syntax highlighting, code completion, object definition, refactoring, and code navigation Describes Git integration and how to perform common Git functions (commits, checkouts, branches, and merges) from within Visual Studio Code Highlights debugging features for Python developers A final section on Real World Applications will step you through several examples (and features integration with Django, Flask, Jupyter Notebook, Docker, and Azure), so you can hit the ground running with Visual Studio Code.

    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.

    You'll learn how to combine small yet powerful command-line tools to quickly obtain, scrub, explore, and model your data. To get you started, author Jeroen Janssens provides a Docker image packed with over 80 tools--useful whether you work with Windows, macOS, or Linux.You'll quickly discover why the command line is an agile, scalable, and extensible technology. Even if you're comfortable processing data with Python or R, you'll learn how to greatly improve your data science workflow by leveraging the command line's power. This book is ideal for data scientists, analysts, and engineers; software and machine learning engineers; and system administrators.Obtain data from websites, APIs, databases, and spreadsheetsPerform scrub operations on text, CSV, HTM, XML, and JSON filesExplore data, compute descriptive statistics, and create visualizationsManage your data science workflowCreate reusable command-line tools from one-liners and existing Python or R codeParallelize and distribute data-intensive pipelinesModel data with dimensionality reduction, clustering, regression, and classification algorithms

    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

    

    Nearly all online forum posts, books, online documentation, and libraries refer to the language as single threaded. Thanks to recent advancements in the language--such as the Atomics and SharedArrayBuffers objects and Web Workers in the browser--JavaScript is now a multi-threaded language. These features will go down as being the biggest paradigm shift for the world's most popular programming language.Multithreaded JavaScript explores the various features that JavaScript runtimes have at their disposal for implementing multithreaded programming, providing both practical real-world examples, as well as reference material.Learn what multithreaded programming is and how you can benefit from itUnderstand the differences between a web worker, a service worker, and a worker threadKnow when and when not to use threads in an applicationOrchestrate communication between threads by leveraging the Atomics objectBuild high-performance applications using the knowledge you gain from this bookBenchmark performance to learn if you'll benefit from multithreading

    C# is a language of unusual flexibility and breadth, but with its continual growth there's so much more to learn. In the tradition of O'Reilly's Nutshell guides, this thoroughly updated edition is simply the best one-volume reference to the C# language available today.Organized around concepts and use cases, C# 9.0 in a Nutshell provides intermediate and advanced programmers with a concise map of C# and .NET that also plumbs significant depths.Get up to speed on C#, from syntax and variables to advanced topics such as pointers, records, closures, and patternsDig deep into LINQ with three chapters dedicated to the topicExplore concurrency and asynchrony, advanced threading, and parallel programmingWork with .NET features, including regular expressions, networking, spans, reflection, and cryptographyJoseph Albahari is author of C# 8.0 in a Nutshell, C# 8.0 Pocket Reference, and LINQ Pocket Reference (all from O'Reilly). He also wrote LINQPad, the popular code scratchpad and LINQ querying utility.

    With this book, you will learn how to write more idiomatic and performant code with a focus on micro-level engineering decisions. This notebook has been designed to provide a reference to everything mentioned in class, as if they were your own personal notes.Our classes challenge every student to think about what they are doing and why and so does this book. The first chapter helps you prepare your mind by establishing the mental models and design philosophy for the material you are about to review. You will learn about the mechanics and semantics behind types, decoupling, error handling, concurrency, and more. GENERICS! Learn about the new syntax coming to Go 1.18 for writing generic functions and types. Four chapters on profiling, tracing, and stack traces help you learn critical debugging skills that will make you a more productive Go developer. The last chapter features the many blog posts that are referenced throughout the book.If you have taken the class before, this notebook will be an invaluable resource for reminders on the content. If you have never taken the class, there is still tremendous value in this book as it covers more advanced topics not found in other books today.“If you want to be a better Go developer, code reviewer, designer and architect, this is the book you want.”When coming from another language, developers often struggle to grasp the fundamentals that make Go useful and unique. This book builds layers of foundational knowledge that will give you a deeper understanding into data semantics, decoupling, concurrency and tooling that is provided with the language.

    It covers technical terms found in modern software analysis, such as block cipher, while providing important context for historical references like the crypto wars, sharing amusing anecdotes (ever hear of the Hasty Pudding Cipher?), and describing major conferences in the field, including Eurocrypt and Real World Crypto.Crypto Dictionary describes the field's most innovative techniques, like threshold cryptography, as well as those developed in the context of blockchain applications, in a broadly approachable way.

    

    This practical book shows ML engineers and data scientists how to solve a variety of image problems including classification, object detection, autoencoders, image generation, counting, and captioning with proven ML techniques.Google engineers Valliappa Lakshmanan, Martin Garner, and Ryan Gillard show you how to develop accurate and explainable computer vision ML models and put them into large-scale production using robust ML architecture in a flexible and maintainable way. You'll learn how to design, train, evaluate, and predict with models written in TensorFlow/Keras. This book also covers best practices to improve the operationalization of the models using end-to-end ML pipelines.You'll learn how to:Design ML architecture for computer vision tasksSelect a model (such as ResNet, SqueezeNet, or EfficientNet) appropriate to your taskCreate an end-to-end ML pipeline to train, evaluate, deploy, and explain your modelPreprocess images for data augmentation and to support learnabilityIncorporate explainability and responsible AI best practicesDeploy image models as web services or on edge devicesMonitor and manage ML models

    Exploring 12 different themes - from the Olympics to Presidents & Royals and from Movies to Myths & Legends - each pair of visualizations explores different technologies and forms, blurring the boundary between visualization as an exploratory tool and an artform in its own right. This beautiful book provides an intimate, behind-the-scenes account of all 24 projects and shares the authors' personal notes and drafts every step of the way.The book features:Detailed information on data gathering, sketching, and coding data visualizations for the web, with screenshots of works-in-progress and reproductions from the authors' notebooks Never-before-published technical write-ups, with beginner-friendly explanations of core data visualization concepts Practical lessons based on the data and design challenges overcome during each project Full-color pages, showcasing all 24 final data visualizations This book is perfect for anyone interested or working in data visualization and information design, and especially those who want to take their work to the next level and are inspired by unique and compelling data-driven storytelling.

    Through communication, we transfer information to produce a greater shared understanding. Communication is multi-faceted. You can share information verbally or through written media, such as books, websites, and documents. You can enrich your communication visually using graphs, charts, images, and maps. Finally, you can complement the message with non-verbal communication such as body language, gestures, tone, and voice pitch.As software engineers, we care a lot about our code. It defines us. We study the programming languages we use in great detail. We become experts in the tools we deploy. We argue with other engineers who are not using the same editors we use. In college, we learn how to write compilers. We learn multiple programming languages, frameworks, and design patterns. A large majority of our formal education draws our focus on these technical topics. We see the same in informal discussions between software engineers.However, "softer" skills get less attention. Some examples: How to collaborate, how to achieve consensus on an idea, how to articulate our thoughts, how to make meetings effective, and how to listen to others. The more senior you become, the larger your scope of influence, and the less you can communicate effectively just by talking with others.Stand-ups, planning meetings, and peer programming sessions all have their physical limits. This effect applies to you sooner than you think. At that point, you need to pivot to asynchronous communication: you need to switch to writing. Those who can write well suddenly have a significant advantage. Through well-written communication, your words and thoughts can influence hundreds or even thousands of people.If writing is a superpower, I am not sure what we would call reading. Perhaps, a hyperpower. To become excellent at writing, you need to read a lot. Reading provides you with different perspectives and insights. Reading faster helps you process information faster, allowing you to make more informed decisions. Most successful people are voracious readers. If there is any advice I can give you as a fellow engineer, read more. This book gives the same advice.The communication in a company naturally forms a graph, with people as the nodes and interactions (emails, meetings, documents, code) as edges. In the communication graph, highly productive individuals look like "supernodes," with many edges: lots of information flows through them and from them. The supernodes bridge different clusters in the graph and allow information to reach otherwise disconnected parts. What enables these exceptional individuals to become so successful? Exceptional communication skills.A few years ago, visiting Google NYC, Chris pulled me aside to meet his team for a demo. He was working on a new prototype version of Google Meet. His team showed me a setup using transparent OLED displays with a camera behind the screen. With this setup, you can maintain excellent, natural eye contact because the camera is not offset from the screen, so the other person sees you looking at them. The demo was very compelling. I saw the problem the team was trying to solve. I understood how they were experimenting to come up with a better solution. Like written materials, good demos tell a story and focus on the user problem. Communication is not just about writing; it is about conveying something effectively, using various tools such as a demo, code, text, or speech.By now, it should be clear that, as an engineer, you should invest in your communication skills. This book provides an excellent plan, combined with a methodical approach and actionable advice. No single book can turn you into an expert (remember "voracious reader?") but reading this concise book can put you on a path to becoming a more successful and impactful engineer. Most importantly, you will be a happier engineer. Enjoy reading!Urs Hölzle is a Senior Vice President of Engineering at Google

    

    If you're a data scientist who lacks a math or scientific background or a developer who wants to add data domains to your skillset, this is your book. Author Hadrien Jean provides you with a foundation in math for data science, machine learning, and deep learning.Through the course of this book, you'll learn how to use mathematical notation to understand new developments in the field, communicate with your peers, and solve problems in mathematical form. You'll also understand what's under the hood of the algorithms you're using.Learn how to:Use Python and Jupyter notebooks to plot data, represent equations, and visualize space transformationsRead and write math notation to communicate ideas in data science and machine learningPerform descriptive statistics and preliminary observation on a datasetManipulate vectors, matrices, and tensors to use machine learning and deep learning libraries such as TensorFlow or KerasExplore reasons behind a broken model and be prepared to tune and fix itChoose the right tool or algorithm for the right data problem

    But its power comes at a cost: longer load times, sluggish pages, and inaccessible content. The more we rely on client-side rendering, the more likely we are to exclude visitors with older devices, slower connections, or those who have disabled JavaScript altogether.If we want people to fully experience the sites we have worked so hard to craft, then we must be judicious in our use of JavaScript. In thoughtful detail, Jeremy Wagner shows how JavaScript can be used to progressively enhance server-side functionality, while improving speed and access for more visitors. By centering user needs every step of the way—from toolchains to metrics to testing—we can all contribute to a more inclusive, accessible, and resilient web.

    Authored by accomplished cloud consultant and technology professional Brett McLaughlin, Programming Kotlin Applications provides readers with the pragmatic and practical advice they need to build their very first Kotlin applications. Designed to give readers a thorough understanding of Kotlin that goes beyond mere mobile programming, this book will help you: Learn how to develop your first Kotlin project Understand how Kotlin securely protects and stores information Advocate for using Kotlin in your own professional and personal environments Understand Kotlin's goals and how to use it as its best Know when to avoid using Kotlin Programming Kotlin Applications is written in a highly approachable and accessible way without the fluff and unrealistic samples that characterize some of its competitor guides. Perfect for developers familiar with another object-oriented programming language like Java or Ruby, or for people who want to advance their skillset in the Kotlin environment, this book is an indispensable addition to any programmer's library.

    

    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

    Tools and techniques are presented in the context of a framework and life cycle, taking a problem or idea through logical steps to design a holistic, evidence-based solution. There is a focus on collaboration with the business as well as with disciplines such as enterprise architecture.

    Until recently, programs got faster by themselves as CPUs were upgraded, but that doesn't happen anymore. The clock frequency of new processors has almost peaked. New architectures provide small improvements to existing programs, but this only helps slightly. Processors do get larger and more powerful, but most of this new power is consumed by the increased number of processing cores and other "extra" computing units. To write efficient software, you now have to know how to program by making good use of the available computing resources, and this book will teach you how to do that.The book covers all the major aspects of writing efficient programs, such as using CPU resources and memory efficiently, avoiding unnecessary computations, measuring performance, and how to put concurrency and multithreading to good use. You'll also learn about compiler optimizations and how to use the programming language (C++) more efficiently. Finally, you'll understand how design decisions impact performance.By the end of this book, you'll not only have enough knowledge of processors and compilers to write efficient programs, but you'll also be able to understand which techniques to use and what to measure while improving performance. At its core, this book is about learning how to learn.What You Will Learn: Discover how to use the hardware computing resources in your programs effectivelyUnderstand the relationship between memory order and memory barriersFamiliarize yourself with the performance implications of different data structures and organizationsAssess the performance impact of concurrent memory accessed and how to minimize itDiscover when to use and when not to use lock-free programming techniquesExplore different ways to improve the effectiveness of compiler optimizationsDesign APIs for concurrent data structures and high-performance data structures to avoid inefficienciesWho this book is for: This book is for experienced developers and programmers who work on performance-critical projects and want to learn different techniques to improve the performance of their code. Programmers who belong to algorithmic trading, gaming, bioinformatics, computational genomics, or computational fluid dynamics communities can learn various techniques from this book and apply them in their domain of work.Although this book uses the C++ language, the concepts demonstrated in the book can be easily transferred or applied to other compiled languages such as C, Java, Rust, Go, and more.

    You’ll start with Pulsar’s fundamentals, each illustrated by real-world examples, as you get to grips with Pulsar’s unique architecture. Pulsar contributor David Kjerrumgaard teaches the skills you need to deploy a Pulsar server, ingest data from third-party systems, and deploy lightweight computing logic with simple functions. You’ll learn to employ Pulsar’s seamless scalability through relatable case studies, including an IOT analytics application that can be deployed within a resource constrained environment and a microservices application based on Pulsar functions. At the end of this practical book, you’ll be ready to fully take advantage of Pulsar to create high-traffic message-driven applications.

    TypeScript combines the typing features of C# or Java with the flexibility of JavaScript, reducing typing errors and providing an easier path to JavaScript development.Author Adam Freeman explains how to get the most from TypeScript 4 in this second edition of his best-selling book. He begins by describing the TypeScript language and the benefits it offers and then shows you how to use TypeScript in real-world scenarios, including development with the DOM API, and popular frameworks such as Angular and React. He starts from the nuts-and-bolts and builds up to the most advanced and sophisticated features.Each topic is covered clearly and concisely, and is packed with the details you need to be effective. The most important features are given a no-nonsense, in-depth treatment and chapters include common problems and teach you how to avoid them.What You Will LearnGain a solid understanding of the TypeScript language and toolsUse TypeScript for client- and server-side developmentExtend and customize TypeScriptTest your TypeScript codeApply TypeScript with the DOM API, Angular, React, and Vue.jsWho This Book Is For JavaScript developers who want to use TypeScript to create client-side or server-side applications

    

    

    A list of keyboard shortcuts for Windows and macOS is also included.

    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

    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.

    In its many hands-on labs, you’ll explore crucial skills for any aspiring penetration tester, security researcher, or malware analyst.You’ll begin with the basics: capturing a victim’s network traffic with an ARP spoofing attack and then viewing it in Wireshark. From there, you’ll deploy reverse shells that let you remotely run commands on a victim’s computer, encrypt files by writing your own ransomware in Python, and fake emails like the ones used in phishing attacks. In advanced chapters, you’ll learn how to fuzz for new vulnerabilities, craft trojans and rootkits, exploit websites with SQL injection, and escalate your privileges to extract credentials, which you’ll use to traverse a private network.You’ll work with a wide range of professional penetration testing tools—and learn to write your own tools in Python—as you practice tasks like:• Deploying the Metasploit framework’s reverse shells and embedding them in innocent-seeming files• Capturing passwords in a corporate Windows network using Mimikatz• Scanning (almost) every device on the internet to find potential victims• Installing Linux rootkits that modify a victim’s operating system• Performing advanced Cross-Site Scripting (XSS) attacks that execute sophisticated JavaScript payloadsAlong the way, you’ll gain a foundation in the relevant computing technologies. Discover how advanced fuzzers work behind the scenes, learn how internet traffic gets encrypted, explore the inner mechanisms of nation-state malware like Drovorub, and much more.Developed with feedback from cybersecurity students, Ethical Hacking addresses contemporary issues in the field not often covered in other books and will prepare you for a career in penetration testing. Most importantly, you’ll be able to think like an ethical hacker⁠: someone who can carefully analyze systems and creatively gain access to them.

    A major use of these inexpensive 8-bit machines--including the TRS System 80s and the Sinclair, Atari, Microbee, and Commodore ranges--was the development of homebrew games. Users with often self-taught programming skills devised the graphics, sound, and coding for their self-created games. In this book, Melanie Swalwell offers a history of this era of homebrew game development, arguing that it constitutes a significant instance of the early appropriation of digital computing technology.Drawing on interviews and extensive archival research on homebrew creators in 1980s Australia and New Zealand, Swalwell explores the creation of games on microcomputers as a particular mode of everyday engagement with new technology. She discusses the public discourses surrounding microcomputers and programming by home coders; user practices; the development of game creators' ideas, with the game Donut Dilemma as a case study; the widely practiced art of hardware hacking; and the influence of 8-bit aesthetics and gameplay on the contemporary game industry. With Homebrew Gaming and the Beginnings of Vernacular Digitality, Swalwell reclaims a lost chapter in video game history, connecting it to the rich cultural and media theory around everyday life and to critical perspectives on user-generated content.

    We cover a wide variety of topics related to decision making, introducing the underlying mathematical problem formulations and the algorithms for solving them.

    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. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Every codebase includes mistakes and inefficiencies that you need to find and fix. Refactor the right way, and your code becomes elegant, easy to read, and easy to maintain. In this book, you’ll learn a unique approach to refactoring that implements any method in five lines or fewer. You’ll also discover a secret most senior devs know: sometimes it’s quicker to hammer out code and fix it later! About the book Five Lines of Code is a fresh look at refactoring for developers of all skill levels. In it, you’ll master author Christian Clausen’s innovative approach, learning concrete rules to get any method down to five lines—or less! You’ll learn when to refactor, specific refactoring patterns that apply to most common problems, and characteristics of code that should be deleted altogether. What's inside     The signs of bad code     Improving code safely, even when you don’t understand it     Balancing optimization and code generality     Proper compiler practices About the reader For developers of all skill levels. Examples use easy-to-read Typescript, in the same style as Java and C#. About the author Christian Clausen works as a Technical Agile Coach, teaching teams how to refactor code. Table of Contents 1 Refactoring refactoring 2 Looking under the hood of refactoring PART 1 LEARN BY REFACTORING A COMPUTER GAME 3 Shatter long function 4 Make type codes work 5 Fuse similar code together 6 Defend the data PART 2 TAKING WHAT YOU HAVE LEARNED INTO THE REAL WORLD 7 Collaborate with the compiler 8 Stay away from comments 9 Love deleting code 10 Never be afraid to add code 11 Follow the structure in the code 12 Avoid optimizations and generality 13 Make bad code look bad 14 Wrapping up

    Throughout the work hands-on examples walk through mitigating threats and the areas of concern that need to be addressed. The book contains the information that professionals need in order to build a diverse mix of the niche knowledge required to harden Cloud Native estates.The book begins with more accessible content about understanding Linux containers and container runtime protection before moving on to more advanced subject matter like advanced attacks on Kubernetes. You'll also learn about:Installing and configuring multiple types of DevSecOps tooling in CI/CD pipelines Building a forensic logging system that can provide exceptional levels of detail, suited to busy containerized estates Securing the most popular container orchestrator, Kubernetes Hardening cloud platforms and automating security enforcement in the cloud using sophisticated policies Perfect for DevOps engineers, platform engineers, security professionals and students, Cloud Native Security will earn a place in the libraries of all professionals who wish to improve their understanding of modern security challenges.

    Reading the official documentation or entry-level books is important, but it's not enough to grasp the true power of the language.Expert Swift is here to help, by showing you how to harness the full power of Swift. You'll learn about advanced usages of protocols, generics, functional reactive programming, API design and more.

    Avoid logical errors that usually go undetected by Python linters and code formatters, such as frequent data look-ups in long lists, improper use of local and global variables, and mishandled user input. Discover rare language features, like rational numbers, set comprehensions, counters, and pickling, that may boost your productivity. Discover how to apply general programming patterns, including caching, in your Python code. Become a better-than-average Python programmer, and develop self-documented, maintainable, easy-to-understand programs that are fast to run and hard to break.Python is one of the most popular and rapidly growing modern programming languages. With more than 200 standard libraries and even more third-party libraries, it reaches into the software development areas as diverse as artificial intelligence, bioinformatics, natural language processing, and computer vision. Find out how to improve your understanding of the spirit of the language by using one hundred pythonic tips to make your code safer, faster, and better documented.This programming style manual is a quick reference of helpful hints and a random source of inspiration. Choose the suitable data structures for searching and sorting jobs and become aware of how a wrong choice may cause your application to be completely ineffective. Understand global and local variables, class and instance attributes, and information-hiding techniques. Create functions with flexible interfaces. Manage intermediate computation results by caching them in files and memory to improve performance and reliability. Polish your documentation skills to make your code easy for other programmers to understand. As a bonus, discover Easter eggs cleverly planted in the standard library by its developers.Polish, secure, and speed-up your Python applications, and make them easier to maintain by following pythonic programming tips.What You Need: You will need a Python interpreter (ideally, version 3.4 or above) and the standard Python library that usually comes with the interpreter.

    Written by NASA JPL Deputy CTO and Principal Data Scientist Chris Mattmann, all examples are accompanied by downloadable Jupyter Notebooks for a hands-on experience coding TensorFlow with Python. New and revised content expands coverage of core machine learning algorithms, and advancements in neural networks such as VGG-Face facial identification classifiers and deep speech classifiers. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Supercharge your data analysis with machine learning! ML algorithms automatically improve as they process data, so results get better over time. You don’t have to be a mathematician to use ML: Tools like Google’s TensorFlow library help with complex calculations so you can focus on getting the answers you need. About the book Machine Learning with TensorFlow, Second Edition is a fully revised guide to building machine learning models using Python and TensorFlow. You’ll apply core ML concepts to real-world challenges, such as sentiment analysis, text classification, and image recognition. Hands-on examples illustrate neural network techniques for deep speech processing, facial identification, and auto-encoding with CIFAR-10. What's inside     Machine Learning with TensorFlow     Choosing the best ML approaches     Visualizing algorithms with TensorBoard     Sharing results with collaborators     Running models in Docker About the reader Requires intermediate Python skills and knowledge of general algebraic concepts like vectors and matrices. Examples use the super-stable 1.15.x branch of TensorFlow and TensorFlow 2.x. About the author Chris Mattmann is the Division Manager of the Artificial Intelligence, Analytics, and Innovation Organization at NASA Jet Propulsion Lab. The first edition of this book was written by Nishant Shukla with Kenneth Fricklas. Table of Contents PART 1 - YOUR MACHINE-LEARNING RIG 1 A machine-learning odyssey 2 TensorFlow essentials PART 2 - CORE LEARNING ALGORITHMS 3 Linear regression and beyond 4 Using regression for call-center volume prediction 5 A gentle introduction to classification 6 Sentiment classification: Large movie-review dataset 7 Automatically clustering data 8 Inferring user activity from Android accelerometer data 9 Hidden Markov models 10 Part-of-speech tagging and word-sense disambiguation PART 3 - THE NEURAL NETWORK PARADIGM 11 A peek into autoencoders 12 Applying autoencoders: The CIFAR-10 image dataset 13 Reinforcement learning 14 Convolutional neural networks 15 Building a real-world CNN: VGG-Face ad VGG-Face Lite 16 Recurrent neural networks 17 LSTMs and automatic speech recognition 18 Sequence-to-sequence models for chatbots 19 Utility landscape

    Juggling all of these different mechanisms can be somewhat overwhelming. Does it have to be this hard? Not anymore!In this book, you'll learn about Combine - Apple's framework to work with asynchronous events in a unified and reactive way that ensures your app is always up to date based on the latest state of its data.Who This Book Is ForThis book is for intermediate iOS developers who already know the basics of iOS and Swift development but are interested in learning declarative/reactive programming and take their app and state management to the next level.You'll also find this book interesting if you're interested in SwiftUI - as many of the reactive capabilities keeping your SwiftUI views up-to-date are built on top of Combine.Topics Covered in Combine: Asynchronous Programming with SwiftWhat & Why: Learn what is Combine and reactive programming and the problems they solve, and how you can unify all of your asynchronous piece of work.Operators: Learn how to compose, transform, filter and otherwise manipulate different pieces of asynchronous work using operators.In Practice: You'll gain knowledge on various topics and techniques you'll leverage when writing your own real-life apps, as well as practice these techniques with actual hands-on apps and projects.SwiftUI: You'll learn about how Combine is deeply rooted within SwiftUI and provides it with the ability to reactively update its views based on the state of your app.Advanced Combine: Once you've got a handle on the basics, you'll dive into advanced Combine topics such as Error Handling, Schedulers, and Custom Publishers.By the end of this book, you'll be a pro in building full-fledged applications using Combine's various abilities.

    

    Learn everything you need to create safe, performant and predictable asynchronous apps by leveraging the new modern concurrency features introduced in Swift 5.5, such as async/await, tasks, actors and more.

    If it doesn't, customers are unhappy--and sometimes lives are put at risk. When complex software underperforms or fails, software engineers need to identify and address the root causes. This is difficult and, historically, few tools have been available to help.In Understanding Software Dynamics , performance expert Richard L. Sites tackles the problem head on, offering expert methods and advanced tools for understanding complex, time-constrained software dynamics, improving reliability and troubleshooting challenging performance problems.Sites draws on several decades of experience pioneering software performance optimization, as well as extensive experience teaching graduate-level developers. He introduces principles and techniques for use in any environment, from embedded devices to datacenters, illuminating them with examples based on x86 or ARM processors running Linux and linked by Ethernet. He also guides readers through building and applying a powerful, new, extremely low-overhead open-source software tool, KUtrace, to precisely trace executions on every CPU core. Using insights gleaned from this tool, readers can apply nuanced solutions--not merely brute-force techniques such as turning off caches or cores. Measure and address issues associated with CPUs, memory, disk/SSD, networks, and their interactions Fix programs that are always too slow, and those that sometimes lag for no apparent reason Design useful observability, logging, and time-stamping capabilities into your code Reason more effectively about performance data to see why reality differs from expectations Identify problems such as excess execution, slow instruction execution, waiting for resources, and software locks Understanding Software Dynamics will be valuable to experienced software professionals, including application and OS developers, hardware and system architects, real-time system designers, and game developers, as well as advanced students.Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

    

    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