Although salary surveys worldwide regularly identify software architect as one of the top ten best jobs, no decent guides exist to help developers become architects. Until now. This practical guide provides the first comprehensive overview of software architecture’s many aspects. You’ll examine architectural characteristics, architectural patterns, component determination, diagramming and presenting architecture, evolutionary architecture, and many other topics. Authors Neal Ford and Mark Richards help you learn through examples in a variety of popular programming languages, such as Java, C#, JavaScript, and others. You’ll focus on architecture principles with examples that apply across all technology stacks.

If you’re among the Python developers put off by Asyncio’s complexity, it’s time to take another look. Asyncio is complicated because it aims to solve problems in concurrent network programming for both framework developers and end-user developers like you. The features you need to consider are a small subset of the whole Asyncio API, but picking out the right features is the tricky part. That’s where this practical book comes in. Veteran Python developer Caleb Hattingh helps end-user developers gain a basic understanding of Asyncio’s building blocks—enough to get you started writing simple event-based programs. You’ll learn why Asyncio offers a safer alternative to preemptive multitasking (threading) and how this API provides a simple way to support thousands of simultaneous socket connections. Get a critical comparison of Asyncio and threading for concurrent network programming Take an Asyncio walkthrough, including a quickstart guide to help you hit the ground looping with event-based programming Learn the difference between Asyncio features for end-user developers and those for framework developers Understand Asyncio’s new async/await language syntax, including coroutines and task and future APIs Get detailed case studies (with code) of some popular Asyncio-compatible third-party libraries

Gain insight into how hexagonal architecture can help to keep the cost of development low over the complete lifetime of an application Key Features Explore ways to make your software flexible, extensible, and adaptable Learn new concepts that you can easily blend with your own software development style Develop the mindset of building maintainable solutions instead of taking shortcuts Book Description We would all like to build software architecture that yields adaptable and flexible software with low development costs. But, unreasonable deadlines and shortcuts make it very hard to create such an architecture. Get Your Hands Dirty on Clean Architecture starts with a discussion about the conventional layered architecture style and its disadvantages. It also talks about the advantages of the domain-centric architecture styles of Robert C. Martin's Clean Architecture and Alistair Cockburn's Hexagonal Architecture. Then, the book dives into hands-on chapters that show you how to manifest a hexagonal architecture in actual code. You'll learn in detail about different mapping strategies between the layers of a hexagonal architecture and see how to assemble the architecture elements into an application. The later chapters demonstrate how to enforce architecture boundaries. You'll also learn what shortcuts produce what types of technical debt and how, sometimes, it is a good idea to willingly take on those debts. After reading this book, you'll have all the knowledge you need to create applications using the hexagonal architecture style of web development. What you will learn Identify potential shortcomings of using a layered architecture Apply methods to enforce architecture boundaries Find out how potential shortcuts can affect the software architecture Produce arguments for when to use which style of architecture Structure your code according to the architecture Apply various types of tests that will cover each element of the architecture Who this book is for This book is for you if you care about the architecture of the software you are building. To get the most out of this book, you must have some experience with web development. The code examples in this book are in Java. If you are not a Java programmer but can read object-oriented code in other languages, you will be fine. In the few places where Java or framework specifics are needed, they are thoroughly explained.

As the digital economy changes the rules of the game for enterprises, it’s also changing the role of architects. In addition to making technical decisions, architects can help change the organization’s structure and processes to support this transition. To do that, architects need to take the express elevator from the engine room to the penthouse, where business strategy resides. Brimming with anecdotes from actual IT transformations, this book prepares software architects, senior developers, and other IT professionals for a more complex but rewarding role in the enterprise. This book is ideal for: Architects and senior developers looking to shape the company’s technology direction or assist in an organizational transformation Enterprise architects and senior technologists looking for practical advice on how to navigate technical and organizational topics CTOs and senior technical architects who want to learn what’s worked and what hasn’t in large-scale architecture and transformation IT managers seeking to understand how architecture can support their technical transformation agenda

Want to be a better developer? This books collects the personal habits, ideas, and approaches of successful agile software developers and presents them in a series of short, easy-to-digest tips. This isn't academic fluff; follow these ideas and you'll show yourself, your teammates, and your managers real results. These are the proven and effective agile practices that will make you a better developer. This book will help you improve five areas of your career: The Development Process What to Do While Coding Developer Attitudes Project and Team Management Iterative and Incremental Learning These practices provide guidelines that will help you succeed in delivering and meeting your user's expectations, even if the domain is unfamiliar. You'll be able to keep normal project pressure from turning into disastrous stress while writing code, and see how to effectively coordinate mentors, team leads, and developers in harmony. You can learn all this stuff the hard way, but this book can save you time and pain. Read it, and you'll be a better developer.

Practical Software Architecture Solutions from the Legendary Robert C. Martin (“Uncle Bob”) By applying universal rules of software architecture, you can dramatically improve developer productivity throughout the life of any software system. Now, building upon the success of his best-selling books Clean Code and The Clean Coder, legendary software craftsman Robert C. Martin (“Uncle Bob”) reveals those rules and helps you apply them. Martin’s Clean Architecture doesn’t merely present options. Drawing on over a half-century of experience in software environments of every imaginable type, Martin tells you what choices to make and why they are critical to your success. As you’ve come to expect from Uncle Bob, this book is packed with direct, no-nonsense solutions for the real challenges you’ll face—the ones that will make or break your projects. Learn what software architects need to achieve—and core disciplines and practices for achieving it Master essential software design principles for addressing function, component separation, and data management See how programming paradigms impose discipline by restricting what developers can do Understand what’s critically important and what’s merely a “detail” Implement optimal, high-level structures for web, database, thick-client, console, and embedded applications Define appropriate boundaries and layers, and organize components and services See why designs and architectures go wrong, and how to prevent (or fix) these failures Clean Architecture is essential reading for every current or aspiring software architect, systems analyst, system designer, and software manager—and for every programmer who must execute someone else’s designs. Register your product at informit.com/register for convenient access to downloads, updates, and/or corrections as they become available.

AI is complicated, but cloud providers have stepped in to make it easier, offering free (or affordable) state-of-the-art models and training tools to get you started. In this book, AI novices will learn how to use Google’s AI-powered cloud services to do everything from analyzing text, images, and video to creating a chatbot. Author Micheal Lanham takes you step-by-step through building models, training them, and then expanding on them to accomplish increasingly complex tasks. If you have a good grasp of math and the Python language, this book will get you up and running with Google Cloud Platform, whether you’re looking to build a simple business AI application or an AI assistant. Learn key concepts for data science, machine learning, and deep learning Explore tools like Video AI, AutoML Tables, the Cloud Inference API, the Recommendations AI API, and BigQuery ML Perform image recognition using CNNs, transfer learning, and GANs Build a simple language processor using embeddings, RNNs, and Bidirectional Encoder Representations from Transformers (BERT) Use Dialogflow to build a chatbot Analyze video with automatic video indexing, face detection, and TF Hub

The Rust programming language offers the rare and valuable combination of statically verified memory safety and low-level control. Imagine C++ but without dangling pointers, null pointer dereferences, leaks, or buffer overruns. With this practical guide, systems programmers will understand Rust’s rules clearly and economically. You’ll learn how to express programs that Rust can prove are free of a broad class of common errors. Rust brings the benefits of an expressive modern type system to systems programming. Authors Jim Blandy and Jason Orendorff demonstrate how Rust’s features put programmers in control over memory consumption and processor use, combining predictable performance with memory safety and trustworthy concurrency. You’ll learn: How to write fast, safe, concurrent programs in Rust Rust’s rules for managing memory efficiently, including ownership, borrowing, moves, and lifetimes How to design interfaces that fit well into the Rust ecosystem Rust’s all-purpose Cargo tool for building, testing, and managing Rust packages High-level features like traits, generics, closures, and iterators that make Rust productive and flexible

Microservices can be complicated and difficult to manage, but there’s a ready solution to this problem. With this practical guide, Lin Sun and Daniel Berg explain how service meshes can help you control interactions between the services in your application. You’ll explore what a service mesh is and how it works using Istio, an open source service mesh for managing and securing microservices. Ideal for application developers, DevOps engineers, SecOps engineers, and others responsible for the delivery of containers and microservices, this guide takes an incremental adoption approach with Istio so you can adopt various features gradually and still reap the benefits. You’ll learn Istio’s architecture and explore its capabilities for observing microservices and dealing with their interactions. Learn how a service mesh manages microservices and helps you innovate faster Explore Istio’s observability, traffic management, and security capabilities Add services to a mesh incrementally in a brownfield application Use Istio to manage secure communication between services Control how traffic flows into and out of the mesh and between services

NOTE: Although the book refers to the web site www.OnJava8.com, that site is not yet live. The examples are freely available at https://github.com/BruceEckel/OnJava8-Examples. On Java 8 is only available as an eBook, and only via Google Play Books. Any other source or delivery mechanism is illegitimate. This book is far too large to publish as a single print volume, and my intent has always been to only publish it as an eBook. Color syntax highlighting for code listings is, alone, worth the cost of admission. Searchability, font resizing or text-to-voice for the vision-impaired, the fact you can always keep it with you---there are so many benefits to eBooks it's hard to name them all. Anyone buying this book needs a computer to run the programs and write code, and the eBook reads nicely on a computer (I was also surprised to discover that it even reads tolerably well on a phone). However, the best reading experience is on a tablet computer. Tablets are inexpensive enough you can now buy one for less than you'd pay for an equivalent print version of this book (which, note, does not exist). It's much easier to read a tablet in bed (for example) than trying to manage the pages of a physical book, especially one this big. When working at your computer, you don't have to hold the pages open when using a tablet at your side. It might feel different at first, but I think you'll find the benefits far outweigh the discomfort of adapting. I've done the research, and Google Play Books provides a very nice reading experience on every platform, including Linux and iOS devices. As an experiment, I've decided to try publishing exclusively through Google Books. The free sample includes a complete table of contents.

《数学女孩4：随机算法》以“随机算法”为主题，从纯粹的数学和计算机程序设计两个角度对随机算法进行了细致的讲解。内容涉及排列组合、概率、期望、线性法则、矩阵、顺序查找算法、二分查找算法、冒泡排序算法和快速排序算法等。整本书一气呵成，非常适合对数学和算法感兴趣的初高中生以及成人阅读。

Java continues to grow and evolve, and this Cookbook continues to evolve in tandem. This book helps to get you up to speed right away with hundreds of hands-on recipes across a broad range of Java topics. You’ll learn useful techniques for everything from string handling and functional programming to network communication. Each recipe includes self-contained code solutions that you can freely use, along with a discussion of how and why they work. If you are familiar with the basics of the Java language, this cookbook will bolster your knowledge of the language in general and its many recent changes and how to apply them in your day-to-day development. Recipes include: Methods for compiling, running, and debugging “Packaging” Java classes and building applications Manipulating, comparing, and rearranging text Regular expressions for string- and pattern-matching Handling numbers, dates, and times Structuring data with collections, arrays, and other types Object-oriented and functional programming techniques Input/Output, Directory and filesystem operations Network programming on both client and server Processing JSON for data interchange Multithreading and concurrency Using Java in Big Data applications Interfacing Java with other languages The 4th Edition of this book has been updated to cover changes through Java 12 and includes new recipes for Big Data and data science.

AWS Security is an invaluable guide that you’ll want to have on hand when you’re facing any cloud security problem. With a cookbook-style delivery, it’s filled with well-documented examples and procedures you can apply to common AWS security issues. This book covers best practices for access policies, data protection, auditing, continuous monitoring, and incident response. You’ll also explore several deliberately insecure applications, including a social media site and a mobile app, learning the exploits and vulnerabilities commonly used to attack them and the security practices to counter those attacks. With this practical primer, you’ll be well prepared to evaluate your system’s security, detect threats, and respond with confidence. what's inside Securely grant access to AWS resources to coworkers and customers Develop policies for ensuring proper access controls Lock-down network controls using VPCs Record audit logs and use them to identify attacks Track and assess the security of an AWS account Common attacks and vulnerabilities

Written by leading authorities in database and Web technologies, this book is essential reading for students and practitioners alike. The popularity of the Web and Internet commerce provides many extremely large datasets from which information can be gleaned by data mining. This book focuses on practical algorithms that have been used to solve key problems in data mining and can be applied successfully to even the largest datasets. It begins with a discussion of the MapReduce framework, an important tool for parallelizing algorithms automatically. The authors explain the tricks of locality-sensitive hashing and stream-processing algorithms for mining data that arrives too fast for exhaustive processing. Other chapters cover the PageRank idea and related tricks for organizing the Web, the problems of finding frequent itemsets, and clustering. This third edition includes new and extended coverage on decision trees, deep learning, and mining social-network graphs.

AI is complicated, but cloud providers have stepped in to make it easier, offering free (or affordable) state-of-the-art models and training tools to get you started. In this book, AI novices will learn how to use Google’s AI-powered cloud services to do everything from analyzing text, images, and video to creating a chatbot. Author Micheal Lanham takes you step-by-step through building models, training them, and then expanding on them to accomplish increasingly complex tasks. If you have a good grasp of math and the Python language, this book will get you up and running with Google Cloud Platform, whether you’re looking to build a simple business AI application or an AI assistant. Learn key concepts for data science, machine learning, and deep learning Explore tools like Video AI, AutoML Tables, the Cloud Inference API, the Recommendations AI API, and BigQuery ML Perform image recognition using CNNs, transfer learning, and GANs Build a simple language processor using embeddings, RNNs, and Bidirectional Encoder Representations from Transformers (BERT) Use Dialogflow to build a chatbot Analyze video with automatic video indexing, face detection, and TF Hub

In this fully updated and new edition, you'll get hands-on practice with the basics, including setting up cloud-based virtual machines, deploying web servers, and using hosted data stores. As you work through the book's 21 carefully planned lessons, you'll explore big-picture concerns like security, scaling, and automation. Learn Azure in a Month of Lunches, Second Edition teaches you the most important skills you'll need to write, deploy, and run cloud-based applications in Azure.

Organizations today often struggle when trying to balance business requirements with ever-increasing volumes of data. Yet the need to take advantage of real-time data continues to grow among the most competitive digital industries. Conventional system architectures may not be up to the task. With this practical guide, you’ll learn how to leverage large-scale data usage across the business units in your organization using the principles of event-driven microservices. Author Adam Bellemare from Flipp takes you through the process of building a complete microservice-powered organization. You’ll reconsider how data is produced, accessed, and used across your organization. Discover powerful yet simple patterns for unlocking the value of this data. Incorporate event-driven design and architectural principles into your own systems. And completely rethink how your organization delivers value by unlocking real-time access to data at scale. You’ll learn: How to leverage event-driven architectures to deliver exceptional business value The role of microservices in supporting event-driven design Architectural patterns to ensure success both within and between teams in your organization Application patterns for developing powerful event-driven microservices

Improve the performance of relational databases with indexes designed for today's hardware Over the last few years, hardware and software have advanced beyond all recognition, so it's hardly surprising that relational database performance now receives much less attention. Unfortunately, the reality is that the improved hardware hasn't kept pace with the ever-increasing quantity of data processed today. Although disk packing densities have increased enormously, making storage costs extremely low and sequential read very fast, random reads are still painfully slow. Many of the old design recommendations are therefore no longer valid-the optimal point of indexing has come a long way. Consequently many of the old problems haven't actually gone away-they have simply changed their appearance. This book provides an easy but effective approach to the design of indexes and tables. Using lots of examples and case studies, the authors describe how the DB2, Oracle, and SQL Server optimizers determine how to access data, and how CPU and response times for the resulting access paths can be quickly estimated. This enables comparisons to be made of the various designs, and helps you choose available choices for the most appropriate design. This book is intended for anyone who wants to understand the issues of SQL performance or how to design tables and indexes effectively. With this title, readers with many years of experience of relational systems will be able to better grasp the implications that have been brought into play by the introduction of new hardware. An Instructor's Manual presenting detailed solutions to all the problems in the book is available online from the Wiley editorial department. An Instructor Support FTP site is also available.

对于嵌入式工程师来说，进入更高阶段后，学习Linux设备驱动开发无疑就是职业生涯的一次“重生”。这是因为Linux设备驱动开发不仅仅涉及操作系统的转换，开发方式的转换，更重要的是思维上的转变。对于Linux这样一个复杂系统，如何从复杂的代码中抓住设备驱动开发的关键是任何一个Linux设备驱动开发者入门时需要面对的挑战。除了知识、工具之外，往往还需要思路上的指导。本书不但帮助Linux设备驱动开发的初学者厘清必要的概念，还从具体的实例、设备驱动开发的指导原则循序渐进地引导读者渐入学习佳境。为了让读者能够达到Linux设备驱动开发的至臻境界，作者更是从软件工程的角度抽象出设备驱动开发的一般思想。毫无疑问，本书将成为读者学习Linux设备驱动开发过程中的一座“灯塔”。

As computation continues to move into the cloud, the computing platform of interest no longer resembles a pizza box or a refrigerator, but a warehouse full of computers. These new large datacenters are quite different from traditional hosting facilities of earlier times and cannot be viewed simply as a collection of co-located servers. Large portions of the hardware and software resources in these facilities must work in concert to efficiently deliver good levels of Internet service performance, something that can only be achieved by a holistic approach to their design and deployment. In other words, we must treat the datacenter itself as one massive warehouse-scale computer (WSe. We describe the architecture of WSCs, the main factors influencing their design, operation, and cost structure, and the characteristics of their software base. We hope it will be useful to architects and programmers of today's WSCs, as well as those of future many-core platforms which may one day implement the equivalent of today's WSCs on a single board. Table of Contents: Introduction / Workloads and Software Infrastructure / Hardware Building Blocks / Datacenter Basics / Energy and Power Efficiency / Modeling Costs / Dealing with Failures and Repairs / Closing Remarks