Devlin Nexley (196 results)

Condition: New.

Condition: New.

Condition: New.

Paperback. Condition: new. Paperback. Autonomous AI systems are moving beyond generating text and recommendations into environments where they can plan tasks, invoke tools, access enterprise data, modify systems, and coordinate with other agents. This shift creates a fundamentally different security problem: organizations must secure not only AI models and applications, but the autonomous execution layer surrounding them.This book presents a security engineering approach to designing, deploying, governing, and operating agentic AI systems in production environments. It examines how identity, authorization, runtime policy enforcement, Zero Trust principles, threat modeling, observability, and containment must evolve when software can make decisions and initiate actions dynamically.The architecture moves from the agent runtime and its trust boundaries through the major attack surfaces created by autonomous execution. It examines prompt injection, indirect instruction attacks, memory poisoning, retrieval manipulation, tool exploitation, credential abuse, data leakage, agent impersonation, and threats emerging from multi-agent collaboration. Rather than treating these as isolated vulnerabilities, the book analyzes how individual weaknesses can combine into larger attack paths across agent workflows.Particular attention is given to secure agent identity and delegated authorization, capability-based access control, policy-as-code, tool gateways, sandboxed execution, memory isolation, retrieval security, secrets management, and continuous verification. The discussion also examines how Zero Trust architecture can be adapted for autonomous agents by separating identity, intent, authorization, execution, and trust decisions.The book then moves into operational security. Agent telemetry, behavioral analytics, security operations, decision-path monitoring, incident response, execution freezing, identity quarantine, context rollback, memory recovery, and progressive privilege restoration are examined as components of an operational model for autonomous systems. These mechanisms are considered alongside enterprise governance, auditability, accountability, risk management, and compliance requirements.Designed for security architects, AI engineers, platform engineers, DevSecOps teams, enterprise architects, security leaders, and technology executives, this book provides an architecture-first perspective on securing AI agents at enterprise scale.Topics include: - Agent runtime security and autonomous execution architectures- Threat modeling for autonomous AI systems- Agent identity, authentication, delegation, and authorization- Zero Trust architecture for AI agents- Prompt injection and indirect instruction defense- Memory security and knowledge poisoning- Secure tool and function execution- Retrieval-augmented generation security- Multi-agent trust and inter-agent communication- Secrets and sensitive-data protection- Runtime policy enforcement and capability controls- Agent observability and behavioral security analytics- Security operations for autonomous AI environments- Incident response, containment, and recovery- Enterprise AI governance, auditability, and risk management- Resilient security architectures for production agentic platformsThe central engineering challenge is not simply preventing an AI agent from behaving incorrectly. It is designing an environment in which autonomous systems can operate with useful levels of capability while their identities, permissions, decisions, data access, and external actions remain continuously controlled and observable. Autonomous AI systems are moving beyond generating text and recommendations into env Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Condition: New.

Condition: New.

Condition: New.

Condition: New.

Paperback. Condition: new. Paperback. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires more than knowing how to install applications or configure a desktop. Reliable workstation environments depend on sound architectural decisions, controlled system state, disciplined deployment practices, and a lifecycle strategy that accounts for change over time.This book takes a systems-engineering approach to Linux Mint, examining the operating system from the perspective of architecture, administration, deployment, automation, and operational reliability. Instead of presenting a collection of beginner tutorials, it explores how the major components of a Linux Mint workstation interact and how those components can be engineered into predictable and maintainable computing environments.The discussion moves from system architecture and initialization through storage, software delivery, hardware integration, desktop services, security boundaries, networking, automation, development workloads, virtualization, performance engineering, and enterprise deployment. Particular attention is given to the operational behavior of systems after deployment, where configuration drift, package dependencies, hardware differences, inconsistent policies, and uncontrolled upgrades can gradually undermine reliability.You will explore: - System architecture, initialization, service management, and desktop session lifecycle- Filesystem organization, storage design, partitioning considerations, and data persistence- APT repositories, dependency resolution, Flatpak, package governance, and software delivery- Cinnamon architecture, graphical sessions, desktop configuration, and user-environment state- Hardware detection, firmware, graphics drivers, peripheral integration, and compatibility considerations- Linux permissions, privilege boundaries, administrative controls, and workstation security architecture- NetworkManager, DNS resolution, connectivity, firewalling, and enterprise networking considerations- Shell environments, scheduled execution, scripting, and repeatable workstation automation- Developer workstation architecture for compilers, runtimes, source control, and isolated workloads- KVM/QEMU virtualization, containers, and practical workload-isolation models- CPU, memory, storage, boot, and service-level performance analysis- Corporate workstation deployment models and controlled endpoint provisioning- Imaging, cloning, identity regeneration, baseline construction, and deployment consistency- Configuration management, state reconciliation, drift detection, and policy enforcement- Upgrade rings, release transitions, recovery planning, technical debt, and long-term lifecycle managementThe central theme is operational control: how to make workstation environments reproducible without making them unnecessarily rigid, how to preserve flexibility without allowing uncontrolled divergence, and how to manage operating-system change without turning every upgrade into an emergency.Whether Linux Mint is being evaluated for professional workstations, development environments, managed desktop fleets, technical labs, or long-lived personal systems, the principles presented here provide a framework for understanding its behavior and engineering it for reliability.This is a technical reference for readers who want to move beyond desktop usage and understand the architectural and operational decisions that determine how Linux Mint systems behave in the real world. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires more than know Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Condition: New.

Condition: New.

Condition: New.

Paperback. Condition: new. Paperback. Modern software systems are no longer defined by application code alone. They are defined by the ability to store, process, replicate, coordinate, and analyze enormous volumes of data across distributed infrastructure while maintaining reliability, consistency, and performance under continuous change.As organizations move toward real-time analytics, event-driven architectures, cloud-native platforms, AI-powered applications, and globally distributed services, the complexity of managing data at scale has become one of the most challenging disciplines in modern engineering. Building these systems requires a deep understanding of storage engine internals, distributed coordination, consistency models, fault tolerance, stream processing, observability, and infrastructure behavior far beyond traditional application development.This book provides a comprehensive exploration of the architectures, principles, and implementation patterns that power today's largest and most demanding platforms. Rather than focusing on individual tools or vendor-specific technologies, it examines the underlying engineering concepts that govern how large-scale systems behave in production environments.Readers will explore the internals of distributed storage systems, transaction processing, replication architectures, partitioning strategies, consensus algorithms, event-driven systems, streaming platforms, analytical engines, and cloud-native infrastructure. The book explains not only how these systems are designed, but also how they behave under scale, contention, latency, network failures, and operational stress.The discussion extends into modern data infrastructure, including vector retrieval systems, feature stores, real-time machine learning pipelines, lakehouse architectures, and GPU-aware distributed platforms. Throughout the book, emphasis is placed on runtime behavior, performance bottlenecks, engineering tradeoffs, and the operational realities that emerge in production environments.Inside, you will learn how to: Design scalable and fault-tolerant distributed architecturesUnderstand storage engine internals, indexing structures, and persistence mechanismsImplement replication, partitioning, and consistency strategies for large-scale systemsAnalyze transactions, concurrency control, and distributed coordination protocolsBuild event-driven and stream-processing platforms capable of real-time computationEngineer resilient systems that withstand failures, outages, and unpredictable workloadsOptimize memory, storage, networking, and infrastructure utilizationDeploy and operate stateful distributed workloads in cloud-native environmentsImplement observability, tracing, monitoring, and reliability engineering practicesSecure distributed data platforms through modern governance and zero-trust principlesArchitect AI-native data infrastructure, vector retrieval systems, and machine learning pipelinesDiagnose production bottlenecks and understand failure patterns observed in real-world systemsDrawing from distributed systems engineering, database internals, cloud infrastructure, platform operations, and large-scale production architectures, this book presents a systems-focused approach to designing and operating modern data platforms. Whether building high-throughput transaction systems, real-time analytics pipelines, globally distributed services, search platforms, recommendation engines, or AI-native applications, the principles covered here provide a foundation for understanding how complex systems behave and evolve at scale. Drawing from distributed systems engineering, database internals, cloud infrastructure operations, and large-scale production architectures, th Shipping may be from multiple locations in the US or from the UK, depending on stock availability. …

Paperback. Condition: new. Paperback. Modern large language models are no longer confined to centralized cloud APIs. Advances in open-weight models, quantization, GPU acceleration, and local inference runtimes have made it possible to design AI systems that execute directly on developer workstations, private infrastructure, edge devices, and enterprise environments.LLaMA and Ollama in Production AI Systems examines the architecture behind this local AI stack, connecting the foundation-model layer represented by LLaMA with the runtime and inference layer provided by Ollama. Rather than treating local AI as a collection of command-line tools, the book approaches it as a systems-engineering problem involving model execution, memory, compute, APIs, deployment, observability, security, and operational trade-offs.The book explores how LLaMA-class transformer models are represented and executed, how Ollama manages local model execution, and how quantization and model packaging affect memory consumption, throughput, latency, and output quality. It examines the inference pipeline from tokenization and context processing through KV-cache management, sampling, streaming generation, and hardware acceleration.It also moves beyond single-machine experimentation into application and infrastructure architecture. You will examine local inference APIs, model routing, retrieval-augmented generation, tool-using applications, agentic workflows, hybrid local-cloud architectures, and deployment patterns for environments where privacy, latency, cost, availability, or data sovereignty influence where inference should occur.The book also addresses the operational realities that emerge when LLM inference becomes part of a production system: resource contention, model lifecycle management, observability, performance measurement, security boundaries, failure handling, capacity planning, and multi-node deployment.What You Will ExploreLLaMA model architecture and its role in the local LLM ecosystemOllama's runtime and model-execution architectureThe lifecycle of a local inference requestModel packaging, configuration, and runtime parametersGGUF and quantized model executionMemory requirements, KV caches, context windows, and token generationCPU, GPU, and hybrid inference trade-offsOllama's API layer and application integration patternsModel routing and multi-model local inferenceRetrieval-augmented generation with locally hosted modelsTool-using and agentic AI architecturesLocal-first application designHybrid local and cloud inference architecturesObservability and performance engineering for LLM workloadsSecurity, isolation, and data-governance considerationsEdge, on-premises, workstation, and enterprise deployment patternsCapacity planning and operational strategies for production systemsWho This Book Is ForThis book is intended for software engineers, AI engineers, ML engineers, platform engineers, DevOps and infrastructure professionals, solution architects, and technical leaders who want to understand how local LLM systems are engineered beyond basic model execution.It is particularly suited to readers who need to evaluate or build private AI infrastructure, integrate local inference into existing applications, design hybrid AI platforms, or understand the engineering consequences of moving LLM inference from centralized APIs to infrastructure they control.The goal is not simply to show how to run a model locally. It is to explain how the model, runtime, hardware, application, and infrastructure layers fit together-and how those layers behave when local LLM inference becomes a production engineering concern. Advances in open-weight models, Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback or Softback. Condition: New. Microsoft 365 Copilot Systems Design. Book.

Paperback. Condition: new. Paperback. Modern software systems are no longer defined by application code alone. They are defined by the ability to store, process, replicate, coordinate, and analyze enormous volumes of data across distributed infrastructure while maintaining reliability, consistency, and performance under continuous change.As organizations move toward real-time analytics, event-driven architectures, cloud-native platforms, AI-powered applications, and globally distributed services, the complexity of managing data at scale has become one of the most challenging disciplines in modern engineering. Building these systems requires a deep understanding of storage engine internals, distributed coordination, consistency models, fault tolerance, stream processing, observability, and infrastructure behavior far beyond traditional application development.This book provides a comprehensive exploration of the architectures, principles, and implementation patterns that power today's largest and most demanding platforms. Rather than focusing on individual tools or vendor-specific technologies, it examines the underlying engineering concepts that govern how large-scale systems behave in production environments.Readers will explore the internals of distributed storage systems, transaction processing, replication architectures, partitioning strategies, consensus algorithms, event-driven systems, streaming platforms, analytical engines, and cloud-native infrastructure. The book explains not only how these systems are designed, but also how they behave under scale, contention, latency, network failures, and operational stress.The discussion extends into modern data infrastructure, including vector retrieval systems, feature stores, real-time machine learning pipelines, lakehouse architectures, and GPU-aware distributed platforms. Throughout the book, emphasis is placed on runtime behavior, performance bottlenecks, engineering tradeoffs, and the operational realities that emerge in production environments.Inside, you will learn how to: Design scalable and fault-tolerant distributed architecturesUnderstand storage engine internals, indexing structures, and persistence mechanismsImplement replication, partitioning, and consistency strategies for large-scale systemsAnalyze transactions, concurrency control, and distributed coordination protocolsBuild event-driven and stream-processing platforms capable of real-time computationEngineer resilient systems that withstand failures, outages, and unpredictable workloadsOptimize memory, storage, networking, and infrastructure utilizationDeploy and operate stateful distributed workloads in cloud-native environmentsImplement observability, tracing, monitoring, and reliability engineering practicesSecure distributed data platforms through modern governance and zero-trust principlesArchitect AI-native data infrastructure, vector retrieval systems, and machine learning pipelinesDiagnose production bottlenecks and understand failure patterns observed in real-world systemsDrawing from distributed systems engineering, database internals, cloud infrastructure, platform operations, and large-scale production architectures, this book presents a systems-focused approach to designing and operating modern data platforms. Whether building high-throughput transaction systems, real-time analytics pipelines, globally distributed services, search platforms, recommendation engines, or AI-native applications, the principles covered here provide a foundation for understanding how complex systems behave and evolve at scale. Drawing from distributed systems engineering, database internals, cloud infrastructure operations, and large-scale production arch Shipping may be from our Sydney, NSW warehouse or from our UK or US warehouse, depending on stock availability. …

Paperback. Condition: new. Paperback. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires more than knowing how to install applications or configure a desktop. Reliable workstation environments depend on sound architectural decisions, controlled system state, disciplined deployment practices, and a lifecycle strategy that accounts for change over time.This book takes a systems-engineering approach to Linux Mint, examining the operating system from the perspective of architecture, administration, deployment, automation, and operational reliability. Instead of presenting a collection of beginner tutorials, it explores how the major components of a Linux Mint workstation interact and how those components can be engineered into predictable and maintainable computing environments.The discussion moves from system architecture and initialization through storage, software delivery, hardware integration, desktop services, security boundaries, networking, automation, development workloads, virtualization, performance engineering, and enterprise deployment. Particular attention is given to the operational behavior of systems after deployment, where configuration drift, package dependencies, hardware differences, inconsistent policies, and uncontrolled upgrades can gradually undermine reliability.You will explore: - System architecture, initialization, service management, and desktop session lifecycle- Filesystem organization, storage design, partitioning considerations, and data persistence- APT repositories, dependency resolution, Flatpak, package governance, and software delivery- Cinnamon architecture, graphical sessions, desktop configuration, and user-environment state- Hardware detection, firmware, graphics drivers, peripheral integration, and compatibility considerations- Linux permissions, privilege boundaries, administrative controls, and workstation security architecture- NetworkManager, DNS resolution, connectivity, firewalling, and enterprise networking considerations- Shell environments, scheduled execution, scripting, and repeatable workstation automation- Developer workstation architecture for compilers, runtimes, source control, and isolated workloads- KVM/QEMU virtualization, containers, and practical workload-isolation models- CPU, memory, storage, boot, and service-level performance analysis- Corporate workstation deployment models and controlled endpoint provisioning- Imaging, cloning, identity regeneration, baseline construction, and deployment consistency- Configuration management, state reconciliation, drift detection, and policy enforcement- Upgrade rings, release transitions, recovery planning, technical debt, and long-term lifecycle managementThe central theme is operational control: how to make workstation environments reproducible without making them unnecessarily rigid, how to preserve flexibility without allowing uncontrolled divergence, and how to manage operating-system change without turning every upgrade into an emergency.Whether Linux Mint is being evaluated for professional workstations, development environments, managed desktop fleets, technical labs, or long-lived personal systems, the principles presented here provide a framework for understanding its behavior and engineering it for reliability.This is a technical reference for readers who want to move beyond desktop usage and understand the architectural and operational decisions that determine how Linux Mint systems behave in the real world. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires m Shipping may be from our Sydney, NSW warehouse or from our UK or US warehouse, depending on stock availability.…

PAP. Condition: New. New Book. Shipped from UK. THIS BOOK IS PRINTED ON DEMAND. Established seller since 2000.

Paperback. Condition: new. Paperback. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires more than knowing how to install applications or configure a desktop. Reliable workstation environments depend on sound architectural decisions, controlled system state, disciplined deployment practices, and a lifecycle strategy that accounts for change over time.This book takes a systems-engineering approach to Linux Mint, examining the operating system from the perspective of architecture, administration, deployment, automation, and operational reliability. Instead of presenting a collection of beginner tutorials, it explores how the major components of a Linux Mint workstation interact and how those components can be engineered into predictable and maintainable computing environments.The discussion moves from system architecture and initialization through storage, software delivery, hardware integration, desktop services, security boundaries, networking, automation, development workloads, virtualization, performance engineering, and enterprise deployment. Particular attention is given to the operational behavior of systems after deployment, where configuration drift, package dependencies, hardware differences, inconsistent policies, and uncontrolled upgrades can gradually undermine reliability.You will explore: - System architecture, initialization, service management, and desktop session lifecycle- Filesystem organization, storage design, partitioning considerations, and data persistence- APT repositories, dependency resolution, Flatpak, package governance, and software delivery- Cinnamon architecture, graphical sessions, desktop configuration, and user-environment state- Hardware detection, firmware, graphics drivers, peripheral integration, and compatibility considerations- Linux permissions, privilege boundaries, administrative controls, and workstation security architecture- NetworkManager, DNS resolution, connectivity, firewalling, and enterprise networking considerations- Shell environments, scheduled execution, scripting, and repeatable workstation automation- Developer workstation architecture for compilers, runtimes, source control, and isolated workloads- KVM/QEMU virtualization, containers, and practical workload-isolation models- CPU, memory, storage, boot, and service-level performance analysis- Corporate workstation deployment models and controlled endpoint provisioning- Imaging, cloning, identity regeneration, baseline construction, and deployment consistency- Configuration management, state reconciliation, drift detection, and policy enforcement- Upgrade rings, release transitions, recovery planning, technical debt, and long-term lifecycle managementThe central theme is operational control: how to make workstation environments reproducible without making them unnecessarily rigid, how to preserve flexibility without allowing uncontrolled divergence, and how to manage operating-system change without turning every upgrade into an emergency.Whether Linux Mint is being evaluated for professional workstations, development environments, managed desktop fleets, technical labs, or long-lived personal systems, the principles presented here provide a framework for understanding its behavior and engineering it for reliability.This is a technical reference for readers who want to move beyond desktop usage and understand the architectural and operational decisions that determine how Linux Mint systems behave in the real world. Linux Mint provides a stable foundation for modern Linux desktop computing, but operating it effectively at a professional level requires m Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

Paperback. Condition: new. Paperback. Modern large language models are no longer confined to centralized cloud APIs. Advances in open-weight models, quantization, GPU acceleration, and local inference runtimes have made it possible to design AI systems that execute directly on developer workstations, private infrastructure, edge devices, and enterprise environments.LLaMA and Ollama in Production AI Systems examines the architecture behind this local AI stack, connecting the foundation-model layer represented by LLaMA with the runtime and inference layer provided by Ollama. Rather than treating local AI as a collection of command-line tools, the book approaches it as a systems-engineering problem involving model execution, memory, compute, APIs, deployment, observability, security, and operational trade-offs.The book explores how LLaMA-class transformer models are represented and executed, how Ollama manages local model execution, and how quantization and model packaging affect memory consumption, throughput, latency, and output quality. It examines the inference pipeline from tokenization and context processing through KV-cache management, sampling, streaming generation, and hardware acceleration.It also moves beyond single-machine experimentation into application and infrastructure architecture. You will examine local inference APIs, model routing, retrieval-augmented generation, tool-using applications, agentic workflows, hybrid local-cloud architectures, and deployment patterns for environments where privacy, latency, cost, availability, or data sovereignty influence where inference should occur.The book also addresses the operational realities that emerge when LLM inference becomes part of a production system: resource contention, model lifecycle management, observability, performance measurement, security boundaries, failure handling, capacity planning, and multi-node deployment.What You Will ExploreLLaMA model architecture and its role in the local LLM ecosystemOllama's runtime and model-execution architectureThe lifecycle of a local inference requestModel packaging, configuration, and runtime parametersGGUF and quantized model executionMemory requirements, KV caches, context windows, and token generationCPU, GPU, and hybrid inference trade-offsOllama's API layer and application integration patternsModel routing and multi-model local inferenceRetrieval-augmented generation with locally hosted modelsTool-using and agentic AI architecturesLocal-first application designHybrid local and cloud inference architecturesObservability and performance engineering for LLM workloadsSecurity, isolation, and data-governance considerationsEdge, on-premises, workstation, and enterprise deployment patternsCapacity planning and operational strategies for production systemsWho This Book Is ForThis book is intended for software engineers, AI engineers, ML engineers, platform engineers, DevOps and infrastructure professionals, solution architects, and technical leaders who want to understand how local LLM systems are engineered beyond basic model execution.It is particularly suited to readers who need to evaluate or build private AI infrastructure, integrate local inference into existing applications, design hybrid AI platforms, or understand the engineering consequences of moving LLM inference from centralized APIs to infrastructure they control.The goal is not simply to show how to run a model locally. It is to explain how the model, runtime, hardware, application, and infrastructure layers fit together-and how those layers behave when local LLM inference becomes a production engineering concern. Advances in open-w Shipping may be from our Sydney, NSW warehouse or from our UK or US warehouse, depending on stock availability.…

Paperback. Condition: new. Paperback. Autonomous AI systems are moving beyond generating text and recommendations into environments where they can plan tasks, invoke tools, access enterprise data, modify systems, and coordinate with other agents. This shift creates a fundamentally different security problem: organizations must secure not only AI models and applications, but the autonomous execution layer surrounding them.This book presents a security engineering approach to designing, deploying, governing, and operating agentic AI systems in production environments. It examines how identity, authorization, runtime policy enforcement, Zero Trust principles, threat modeling, observability, and containment must evolve when software can make decisions and initiate actions dynamically.The architecture moves from the agent runtime and its trust boundaries through the major attack surfaces created by autonomous execution. It examines prompt injection, indirect instruction attacks, memory poisoning, retrieval manipulation, tool exploitation, credential abuse, data leakage, agent impersonation, and threats emerging from multi-agent collaboration. Rather than treating these as isolated vulnerabilities, the book analyzes how individual weaknesses can combine into larger attack paths across agent workflows.Particular attention is given to secure agent identity and delegated authorization, capability-based access control, policy-as-code, tool gateways, sandboxed execution, memory isolation, retrieval security, secrets management, and continuous verification. The discussion also examines how Zero Trust architecture can be adapted for autonomous agents by separating identity, intent, authorization, execution, and trust decisions.The book then moves into operational security. Agent telemetry, behavioral analytics, security operations, decision-path monitoring, incident response, execution freezing, identity quarantine, context rollback, memory recovery, and progressive privilege restoration are examined as components of an operational model for autonomous systems. These mechanisms are considered alongside enterprise governance, auditability, accountability, risk management, and compliance requirements.Designed for security architects, AI engineers, platform engineers, DevSecOps teams, enterprise architects, security leaders, and technology executives, this book provides an architecture-first perspective on securing AI agents at enterprise scale.Topics include: - Agent runtime security and autonomous execution architectures- Threat modeling for autonomous AI systems- Agent identity, authentication, delegation, and authorization- Zero Trust architecture for AI agents- Prompt injection and indirect instruction defense- Memory security and knowledge poisoning- Secure tool and function execution- Retrieval-augmented generation security- Multi-agent trust and inter-agent communication- Secrets and sensitive-data protection- Runtime policy enforcement and capability controls- Agent observability and behavioral security analytics- Security operations for autonomous AI environments- Incident response, containment, and recovery- Enterprise AI governance, auditability, and risk management- Resilient security architectures for production agentic platformsThe central engineering challenge is not simply preventing an AI agent from behaving incorrectly. It is designing an environment in which autonomous systems can operate with useful levels of capability while their identities, permissions, decisions, data access, and external actions remain continuously controlled and observable. Autonomous AI systems are moving beyond generating text and recommendat Shipping may be from our Sydney, NSW warehouse or from our UK or US warehouse, depending on stock availability.…

Paperback. Condition: new. Paperback. Autonomous AI systems are moving beyond generating text and recommendations into environments where they can plan tasks, invoke tools, access enterprise data, modify systems, and coordinate with other agents. This shift creates a fundamentally different security problem: organizations must secure not only AI models and applications, but the autonomous execution layer surrounding them.This book presents a security engineering approach to designing, deploying, governing, and operating agentic AI systems in production environments. It examines how identity, authorization, runtime policy enforcement, Zero Trust principles, threat modeling, observability, and containment must evolve when software can make decisions and initiate actions dynamically.The architecture moves from the agent runtime and its trust boundaries through the major attack surfaces created by autonomous execution. It examines prompt injection, indirect instruction attacks, memory poisoning, retrieval manipulation, tool exploitation, credential abuse, data leakage, agent impersonation, and threats emerging from multi-agent collaboration. Rather than treating these as isolated vulnerabilities, the book analyzes how individual weaknesses can combine into larger attack paths across agent workflows.Particular attention is given to secure agent identity and delegated authorization, capability-based access control, policy-as-code, tool gateways, sandboxed execution, memory isolation, retrieval security, secrets management, and continuous verification. The discussion also examines how Zero Trust architecture can be adapted for autonomous agents by separating identity, intent, authorization, execution, and trust decisions.The book then moves into operational security. Agent telemetry, behavioral analytics, security operations, decision-path monitoring, incident response, execution freezing, identity quarantine, context rollback, memory recovery, and progressive privilege restoration are examined as components of an operational model for autonomous systems. These mechanisms are considered alongside enterprise governance, auditability, accountability, risk management, and compliance requirements.Designed for security architects, AI engineers, platform engineers, DevSecOps teams, enterprise architects, security leaders, and technology executives, this book provides an architecture-first perspective on securing AI agents at enterprise scale.Topics include: - Agent runtime security and autonomous execution architectures- Threat modeling for autonomous AI systems- Agent identity, authentication, delegation, and authorization- Zero Trust architecture for AI agents- Prompt injection and indirect instruction defense- Memory security and knowledge poisoning- Secure tool and function execution- Retrieval-augmented generation security- Multi-agent trust and inter-agent communication- Secrets and sensitive-data protection- Runtime policy enforcement and capability controls- Agent observability and behavioral security analytics- Security operations for autonomous AI environments- Incident response, containment, and recovery- Enterprise AI governance, auditability, and risk management- Resilient security architectures for production agentic platformsThe central engineering challenge is not simply preventing an AI agent from behaving incorrectly. It is designing an environment in which autonomous systems can operate with useful levels of capability while their identities, permissions, decisions, data access, and external actions remain continuously controlled and observable. Autonomous AI systems are moving beyond generating text and recommendat Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

Paperback. Condition: new. Paperback. Modern software systems are no longer defined by application code alone. They are defined by the ability to store, process, replicate, coordinate, and analyze enormous volumes of data across distributed infrastructure while maintaining reliability, consistency, and performance under continuous change.As organizations move toward real-time analytics, event-driven architectures, cloud-native platforms, AI-powered applications, and globally distributed services, the complexity of managing data at scale has become one of the most challenging disciplines in modern engineering. Building these systems requires a deep understanding of storage engine internals, distributed coordination, consistency models, fault tolerance, stream processing, observability, and infrastructure behavior far beyond traditional application development.This book provides a comprehensive exploration of the architectures, principles, and implementation patterns that power today's largest and most demanding platforms. Rather than focusing on individual tools or vendor-specific technologies, it examines the underlying engineering concepts that govern how large-scale systems behave in production environments.Readers will explore the internals of distributed storage systems, transaction processing, replication architectures, partitioning strategies, consensus algorithms, event-driven systems, streaming platforms, analytical engines, and cloud-native infrastructure. The book explains not only how these systems are designed, but also how they behave under scale, contention, latency, network failures, and operational stress.The discussion extends into modern data infrastructure, including vector retrieval systems, feature stores, real-time machine learning pipelines, lakehouse architectures, and GPU-aware distributed platforms. Throughout the book, emphasis is placed on runtime behavior, performance bottlenecks, engineering tradeoffs, and the operational realities that emerge in production environments.Inside, you will learn how to: Design scalable and fault-tolerant distributed architecturesUnderstand storage engine internals, indexing structures, and persistence mechanismsImplement replication, partitioning, and consistency strategies for large-scale systemsAnalyze transactions, concurrency control, and distributed coordination protocolsBuild event-driven and stream-processing platforms capable of real-time computationEngineer resilient systems that withstand failures, outages, and unpredictable workloadsOptimize memory, storage, networking, and infrastructure utilizationDeploy and operate stateful distributed workloads in cloud-native environmentsImplement observability, tracing, monitoring, and reliability engineering practicesSecure distributed data platforms through modern governance and zero-trust principlesArchitect AI-native data infrastructure, vector retrieval systems, and machine learning pipelinesDiagnose production bottlenecks and understand failure patterns observed in real-world systemsDrawing from distributed systems engineering, database internals, cloud infrastructure, platform operations, and large-scale production architectures, this book presents a systems-focused approach to designing and operating modern data platforms. Whether building high-throughput transaction systems, real-time analytics pipelines, globally distributed services, search platforms, recommendation engines, or AI-native applications, the principles covered here provide a foundation for understanding how complex systems behave and evolve at scale. Drawing from distributed systems engineering, database internals, cloud infrastructure operations, and large-scale production arch Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability. …

Paperback. Condition: new. Paperback. Modern large language models are no longer confined to centralized cloud APIs. Advances in open-weight models, quantization, GPU acceleration, and local inference runtimes have made it possible to design AI systems that execute directly on developer workstations, private infrastructure, edge devices, and enterprise environments.LLaMA and Ollama in Production AI Systems examines the architecture behind this local AI stack, connecting the foundation-model layer represented by LLaMA with the runtime and inference layer provided by Ollama. Rather than treating local AI as a collection of command-line tools, the book approaches it as a systems-engineering problem involving model execution, memory, compute, APIs, deployment, observability, security, and operational trade-offs.The book explores how LLaMA-class transformer models are represented and executed, how Ollama manages local model execution, and how quantization and model packaging affect memory consumption, throughput, latency, and output quality. It examines the inference pipeline from tokenization and context processing through KV-cache management, sampling, streaming generation, and hardware acceleration.It also moves beyond single-machine experimentation into application and infrastructure architecture. You will examine local inference APIs, model routing, retrieval-augmented generation, tool-using applications, agentic workflows, hybrid local-cloud architectures, and deployment patterns for environments where privacy, latency, cost, availability, or data sovereignty influence where inference should occur.The book also addresses the operational realities that emerge when LLM inference becomes part of a production system: resource contention, model lifecycle management, observability, performance measurement, security boundaries, failure handling, capacity planning, and multi-node deployment.What You Will ExploreLLaMA model architecture and its role in the local LLM ecosystemOllama's runtime and model-execution architectureThe lifecycle of a local inference requestModel packaging, configuration, and runtime parametersGGUF and quantized model executionMemory requirements, KV caches, context windows, and token generationCPU, GPU, and hybrid inference trade-offsOllama's API layer and application integration patternsModel routing and multi-model local inferenceRetrieval-augmented generation with locally hosted modelsTool-using and agentic AI architecturesLocal-first application designHybrid local and cloud inference architecturesObservability and performance engineering for LLM workloadsSecurity, isolation, and data-governance considerationsEdge, on-premises, workstation, and enterprise deployment patternsCapacity planning and operational strategies for production systemsWho This Book Is ForThis book is intended for software engineers, AI engineers, ML engineers, platform engineers, DevOps and infrastructure professionals, solution architects, and technical leaders who want to understand how local LLM systems are engineered beyond basic model execution.It is particularly suited to readers who need to evaluate or build private AI infrastructure, integrate local inference into existing applications, design hybrid AI platforms, or understand the engineering consequences of moving LLM inference from centralized APIs to infrastructure they control.The goal is not simply to show how to run a model locally. It is to explain how the model, runtime, hardware, application, and infrastructure layers fit together-and how those layers behave when local LLM inference becomes a production engineering concern. Advances in open-w Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

PAP. Condition: New. New Book. Delivered from our UK warehouse in 4 to 14 business days. THIS BOOK IS PRINTED ON DEMAND. Established seller since 2000.

Paperback. Condition: new. Paperback. Modern software organizations are moving beyond traditional automation scripts and isolated integrations toward intelligent, event-driven systems capable of coordinating complex business and technical processes. This book explores how to design and engineer production-grade automation platforms using n8n as a workflow orchestration foundation.Rather than focusing on simple task automation, this book presents a systems-oriented approach to building scalable workflow architectures that connect applications, APIs, databases, cloud services, and AI capabilities into reliable operational systems.You will learn how to design automation solutions using proven engineering principles, including event-driven architecture, workflow composition, integration patterns, distributed execution models, and platform engineering practices. The book examines how individual workflows evolve into reusable automation components and how organizations can establish internal automation platforms with governance, observability, security, and operational reliability.The book covers practical approaches for integrating large language models, building AI-powered workflows, designing retrieval-augmented generation pipelines, and creating agent-based systems where intelligent components can reason, select tools, and execute controlled actions.Key topics include: Designing scalable workflow orchestration architecturesBuilding event-driven automation systemsIntegrating APIs, webhooks, databases, and enterprise platformsCreating reusable workflow components and automation patternsEngineering reliable execution pipelines with error handling and recovery strategiesApplying AI and LLM capabilities within automation systemsDesigning agentic workflows and autonomous execution patternsImplementing security, governance, monitoring, and operational controlsScaling automation platforms for enterprise environmentsWritten for software engineers, solution architects, DevOps professionals, platform engineers, and technical leaders, this book provides an architecture-first perspective on building the next generation of intelligent automation infrastructure.By the end, readers will understand how to move beyond individual workflows and design automation ecosystems that are scalable, observable, secure, and capable of supporting the transition toward AI-native software systems. Modern software organizations are moving beyond traditional automation scripts and isolated integrations toward intelligent, event-driven systems capable of coordinating complex business and technical processes. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condition: new. Paperback. Moderm microsoft ai enterprise Mint has evolved far beyond a beginner-friendly desktop operating system. Built on the stability of Ubuntu 24.04 LTS, Linux Mint 22 provides a dependable platform for software development, IT administration, enterprise workstations, secure computing, and professional desktop deployments. This book is designed for readers who want to move beyond installation guides and gain a practical understanding of how to deploy, manage, secure, automate, and maintain Linux Mint in real-world environments.Whether you are a system administrator managing business workstations, a DevOps engineer building efficient development environments, a software developer optimizing your daily workflow, or an IT professional responsible for endpoint operations, this guide provides the technical knowledge and operational practices needed to manage Linux Mint 22 with confidence.Inside, you'll learn how to: - Understand the architecture and design principles behind Linux Mint 22 and its Ubuntu LTS foundation.- Plan, install, and provision production-ready Linux Mint systems using modern deployment strategies.- Configure users, groups, services, storage, networking, and system resources for secure and reliable operation.- Master package management with APT, repositories, Flatpak, and software lifecycle management.- Secure desktop environments through authentication controls, firewall configuration, encryption, system updates, and security hardening techniques.- Optimize system performance by monitoring processes, tuning startup behavior, managing resources, and troubleshooting complex operational issues.- Automate administrative tasks with Bash scripting, scheduled jobs, and configuration management tools to improve consistency and efficiency.- Build professional development workstations with Git, virtualization technologies, containers, and modern software engineering workflows.- Deploy Linux Mint across multiple systems using standardized configurations, fleet management practices, and enterprise operational procedures.- Implement backup, recovery, migration, documentation, and lifecycle management strategies that improve long-term reliability and reduce operational risk.Rather than focusing on isolated commands or basic desktop customization, this guide emphasizes production-grade administration, infrastructure thinking, and proven operational methodologies used in professional Linux environments. Every chapter builds practical skills through clear explanations, command-line examples, configuration guidance, and real-world scenarios that can be applied immediately.If you're looking for a comprehensive Linux Mint 22 resource that bridges desktop administration, enterprise operations, automation, security, and long-term system management, this book delivers the knowledge and best practices required to build stable, secure, and maintainable Linux workstations for today's professional computing environments. Moderm microsoft ai enterprise Mint has evolved far beyond a beginner-friendly desktop operating system. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condition: new. Paperback. Microsoft Foundry represents a shift in enterprise AI from isolated model usage to integrated systems of reasoning, retrieval, and execution. It consolidates foundation models, agent frameworks, knowledge grounding, orchestration tools, and governance controls into a unified platform for building production-grade AI systems on Azure.This book provides a technical, architecture-focused examination of Microsoft Foundry from the perspective of enterprise system design. It is intended for AI engineers, cloud architects, solution architects, and technical decision-makers responsible for designing, deploying, and operating AI systems at scale.Rather than focusing on UI workflows or introductory tutorials, the content is structured around real-world engineering problems: how to design reliable AI agents, how to build grounded knowledge systems, how to manage model diversity, and how to operationalize AI within governed enterprise environments.The book begins by establishing architectural foundations for enterprise AI workloads, including system boundaries, identity design, and multi-environment strategies. It then explores model ecosystems, evaluation frameworks, and selection methodologies for production use cases where latency, cost, and accuracy must be balanced.A significant portion of the book is dedicated to retrieval-augmented generation systems and enterprise knowledge grounding. It examines how structured and unstructured data sources are transformed into retrieval layers that support deterministic and context-aware reasoning.The book then transitions into agent engineering, covering single-agent and multi-agent systems, tool integration patterns, workflow orchestration, and state management for long-running intelligent processes. These architectures are framed in the context of enterprise constraints such as security, compliance, and operational reliability.Security and governance are treated as first-class architectural concerns rather than deployment add-ons. The book explores identity-aware agents, prompt and context security boundaries, policy enforcement models, and responsible AI frameworks required in regulated environments.Operational concerns such as observability, evaluation pipelines, performance monitoring, and cost optimization are also addressed, with emphasis on maintaining system reliability under production workloads.Finally, the book presents enterprise solution blueprints across key domains including knowledge assistants, customer service ecosystems, operational automation platforms, and decision intelligence systems. These patterns demonstrate how Microsoft Foundry components can be composed into scalable, production-ready AI systems.By the end of the book, readers will understand how to design and operate enterprise AI systems that extend beyond chat-based interfaces into fully governed, agent-driven architectures capable of executing business processes, augmenting decision-making, and integrating deeply with enterprise data ecosystems. Microsoft Foundry represents a shift in enterprise AI from isolated model usage to integrated systems of reasoning, retrieval, and execution. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condition: new. Paperback. Software development is entering a new architectural era where artificial intelligence systems are no longer limited to code completion or developer assistance. Modern engineering environments are evolving toward autonomous, agent-driven workflows where intelligent systems can plan, implement, test, validate, and continuously improve software applications.This book explores the engineering principles behind building and operating autonomous software development systems using AI agents, modern developer environments, and multi-agent workflows. It provides a deep technical examination of how organizations can integrate agent-based engineering practices into real-world software delivery processes.Rather than focusing on simple AI coding assistance, this book presents a systems-oriented approach to designing intelligent development environments. It covers agent architecture, workflow orchestration, context engineering, autonomous implementation patterns, verification strategies, security controls, governance models, and enterprise adoption practices.You will learn how to: Design AI agent workflows for software engineering tasksArchitect multi-agent development systemsBuild reliable context and memory strategies for coding agentsApply autonomous planning, implementation, testing, and review patternsIntegrate AI agents into modern DevOps and platform engineering practicesEstablish security boundaries, governance frameworks, and operational controlsManage agent behavior in large-scale enterprise environmentsCreate feedback loops for continuously improving engineering systemsUnderstand the future evolution of autonomous software factoriesThe book examines the challenges of deploying agentic engineering systems at scale, including reliability, observability, security risks, human oversight, and organizational transformation. It provides practical architectural insights for engineers building AI-native development workflows and leaders responsible for adopting emerging software engineering platforms.Designed for software engineers, architects, DevOps professionals, platform engineers, AI engineers, and technical leaders, this book provides a foundation for understanding how autonomous development systems are designed, governed, and operated in production environments.The future of software engineering will not be defined only by how quickly developers write code, but by how effectively organizations design intelligent systems that can create, maintain, and evolve software continuously. The book examines the challenges of deploying agentic engineering systems at scale, including reliability, observability, security risks, human oversight, and organizational transformation. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condition: new. Paperback. Architecting Command-Line Rust Systems is a deep technical exploration of command-line software as a systems engineering discipline. Rather than treating CLI applications as simple utilities, this book examines how modern command-line systems are designed, built, extended, and operated as production-grade infrastructure components using Rust.As organizations increasingly rely on automation, platform engineering, developer tooling, and infrastructure orchestration, command-line applications have become critical interfaces between engineers, services, operating systems, and deployment environments. Building these systems requires more than knowledge of language syntax or argument parsing libraries. It demands an understanding of process architecture, execution models, stream-oriented computing, concurrency, filesystem behavior, packaging strategies, observability, and long-term maintainability.This book takes an architecture-first approach to Rust command-line development, focusing on the internal mechanisms that govern performance, reliability, extensibility, and operational correctness. Through detailed examinations of Cargo, process management, CLI parsing systems, asynchronous execution, plugin architectures, configuration resolution, telemetry pipelines, and cross-platform distribution, readers will gain a systems-level perspective on designing robust command-line ecosystems.Topics include: Command-line systems as process-oriented execution architecturesRust's systems programming model for infrastructure toolingCargo internals, dependency orchestration, and build pipelinesProcess lifecycle management and operating system interactionCommand parsing architectures and command dispatch systemsstdin, stdout, and stream-based data processing patternsError handling, diagnostics, and resilient execution strategiesStructured logging, tracing, telemetry, and observabilityFilesystem semantics, state management, and data integrityConcurrency, asynchronous runtimes, and workload orchestrationCross-platform development and operating system compatibilityBinary optimization, packaging, and cross-compilation workflowsPlugin architectures and extensible CLI ecosystemsLong-term maintainability, versioning, and tooling evolutionWritten for experienced software engineers, systems programmers, platform engineers, infrastructure architects, and advanced Rust developers, this book emphasizes architectural reasoning, implementation tradeoffs, and production engineering practices rather than introductory tutorials. Readers will learn how to design command-line systems that scale from individual tools to large, extensible ecosystems capable of supporting modern software platforms and operational environments.Whether you are building developer tools, automation frameworks, infrastructure utilities, platform engineering workflows, or enterprise command-line ecosystems, Architecting Command-Line Rust Systems provides the technical foundations and architectural patterns required to engineer reliable, high-performance command-line software in Rust. This book examines how modern command-line systems are designed, built, extended, and operated as production-grade infrastructure components using Rust. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability. …