Crossley Ethan (71 results)

Paperback. Condition: New.

Paperback. Condition: New.

Paperback. Condition: New.

Paperback. Condition: New.

Paperback. Condition: New.

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingMemory-Safe Machine Learning: Rust Frameworks is a comprehensive guide to building fast, reliable, secure ML systems without the runtime pitfalls of traditional languages. At its core, this book shows how Rust's ownership model, fearless concurrency, and zero-cost abstractions unlock a new generation of machine-learning architectures designed for safety, performance, and long-term scalability.You will learn how to design end-to-end ML pipelines in Rust, integrate existing Rust ML ecosystems, build custom kernels, optimize inference engines, and leverage Rust's type system to eliminate entire classes of memory bugs before they occur. From GPU acceleration to distributed training, this book walks through practical patterns and production-grade workflows used by engineers who are pushing ML workloads beyond Python's limits.Inside you'll find: - Foundations of memory-safe ML design- Rust crates for tensors, autograd, and numerical computing- Building training loops and custom layers in pure Rust- Hybrid workflows that integrate Rust with Python and C++- Performance tuning, SIMD, GPU kernels, and deployment strategies- Architecting robust ML services using async Rust, axum, and WebAssembly- Testing, benchmarking, and reproducibility in Rust-based ML systemsWhether you are an ML engineer seeking more predictable performance or a Rust developer exploring machine learning, this book provides the tools, frameworks, and design patterns to build next-generation AI systems that are both safe and blazing fast.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingArtificial intelligence is moving from experimental research into performance-critical, real-world systems. As models grow larger and deployment environments become more constrained, traditional high-level tooling alone is no longer enough. Teams need software that is fast, memory-efficient, and reliable under production workloads. Rust is emerging as one of the most powerful languages for building the next generation of AI infrastructure.Rust for AI and Applied Machine Learning: Engineering High-Performance Systems provides a practical, engineering-focused guide to building AI and machine learning systems using Rust. Instead of focusing only on theory or model training, this book shows how to design, build, and optimize the software layer that makes modern AI usable at scale.You will learn how to integrate Rust into machine learning pipelines, accelerate inference workloads, and build safe, concurrent systems that support real-time AI applications. The book bridges the gap between data science and systems engineering, making it ideal for teams building production AI platforms, trading systems, robotics software, or large-scale data processing engines.Inside, you will explore: - Rust fundamentals tailored for AI and ML workloads- High-performance data processing and numerical computing patterns- Interfacing Rust with Python, C++, and existing ML ecosystems- Memory safety and concurrency for real-time AI systems- Building inference engines, data pipelines, and model serving infrastructure- Performance profiling and low-latency optimization techniques- Designing reliable AI services for production environmentsWhether you are a machine learning engineer looking to improve system performance, a backend engineer moving into AI infrastructure, or a quantitative developer building intelligent trading systems, this book provides a clear roadmap for using Rust to build fast, reliable, and scalable intelligent software.Rust is not just another language in the AI stack. It is becoming a foundation layer for teams that need performance, safety, and long-term maintainability in intelligent systems. This book shows you how to apply it where it matters most. …

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingThe Rust HFT Handbook is a practical, implementation-focused guide to building ultra-low-latency trading engines with Rust for modern electronic markets. Combining systems-level design, exchange microstructure, and execution engineering, this handbook shows how to architect deterministic, failure-resistant pipelines that can reliably ingest market data, make decisions, and route orders at sub-millisecond speeds.Readers learn how to structure end-to-end HFT systems, including market data capture, order book construction, strategy logic, risk checks, and exchange connectivity, while navigating the performance constraints and concurrency challenges of real-time trading.Topics include: - Modern market structure, matching, and microsecond realities- Deterministic code paths, scheduling, and memory management in Rust- Order flow analytics and stateful event processing for fast decision-making- Multi-venue connectivity, FIX/OUCH/ITCH protocols, and exchange adapters- Optimizing latency through zero-copy design, lock-free data structures, and efficient I/O- Strategy evaluation, risk controls, throttles, and kill-switch mechanisms- Benchmarking, profiling, and simulation environments for continuous improvement- Deployment considerations for co-lo environments and cross-venue executionDesigned for quants, engineers, and trading technologists, The Rust HFT Handbook offers a rigorous blueprint for building institutional-grade HFT engines that balance speed, stability, and safety. Rust's memory model enables precise control over performance while reducing runtime failures, making it an emerging language of choice for modern execution systems.Whether you are migrating legacy stacks away from C]+/Java or architecting a greenfield platform, this guide provides the tooling, mental models, and implementation techniques required to compete in today's ultra-fast markets.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingEvent-Driven Trading Architecture in Rust is a technical guide to building reliable, deterministic, and fault-tolerant systems for modern market infrastructure.Written for developers, quantitative engineers, fintech builders, and technically minded traders, this book explores how event-driven architecture can be applied to trading systems where latency, correctness, recoverability, and operational discipline matter. Rather than focusing on trading signals or speculative strategies, it examines the engineering foundations behind systems that process market data, manage orders, coordinate state, and respond to high-volume event flows.Inside, readers will explore how Rust can be used to design robust trading infrastructure with strong type safety, predictable performance, and memory-safe concurrency. The book covers architectural patterns for event streams, message routing, state machines, order workflows, risk controls, replayability, logging, persistence, testing, and failure recovery.Topics include: Event-driven design for trading and market systemsRust's role in safe, high-performance financial infrastructureDeterministic state management and reproducible workflowsOrder lifecycle modeling and execution system architectureFault tolerance, recovery, and operational resilienceMarket data pipelines, event sourcing, and message-driven componentsTesting, simulation, logging, and observability for trading platformsClear, structured, and implementation-oriented, Event-Driven Trading Architecture in Rust provides a practical foundation for readers who want to understand how professional-grade trading systems are designed from the inside out.This book is for educational and technical purposes only. It does not provide financial advice, investment recommendations, or trading signals.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingHigh-Performance Systems with Rust is a practical guide to designing and operating software where latency, throughput, and memory behavior are first-class constraints.This book is written for engineers building real systems under pressure: trading infrastructure, distributed services, game engines, embedded platforms, data pipelines, and performance-critical backends where milliseconds matter and abstractions have a cost.Rather than teaching Rust from first principles, the focus is on how to think in Rust when performance is the objective. You'll learn how Rust's ownership model, lifetimes, and zero-cost abstractions can be deliberately shaped to produce predictable memory layouts, cache-efficient data flows, and stable low-latency execution paths.Inside, you'll explore: - Designing low-latency architectures that minimize allocation, contention, and tail latency- Precise control of memory, lifetimes, and data ownership for cache-aware performance- Throughput engineering techniques for high-load, multi-core systems- Lock-free and low-lock concurrency patterns in Rust- Profiling, benchmarking, and performance diagnostics that actually surface bottlenecks- When to trust abstractions, and when to break them intentionallyThe emphasis is on engineering judgment: understanding trade-offs between safety, ergonomics, and raw speed, and making those decisions consciously rather than accidentally.If you're already comfortable with systems programming concepts and want to push Rust to its limits in production environments, this book will give you the mental models, patterns, and performance instincts to do it with confidence.Rust doesn't just make systems safer. Used correctly, it makes them faster, more predictable, and easier to reason about at scale. …

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingDiscover how to build reliable, memory-safe embedded systems using Rust, the modern programming language that is transforming firmware development.'Rust for Embedded Systems and IoT: Memory-Safe Firmware Development with Embassy, RTIC, and Tock' provides a practical guide to developing embedded applications and IoT devices with Rust's powerful ownership model and fearless concurrency.You'll learn how to leverage three of the most respected Rust frameworks in the embedded space: - Embassy - for building efficient async applications and drivers- RTIC - for real-time, interrupt-driven concurrency done right- Tock - for secure, capability-based operating systems on microcontrollersThis book focuses on real-world patterns for writing production-grade firmware, including memory safety techniques, hardware abstraction, device driver development, sensor integration, and asynchronous runtimes tailored for resource-constrained environments.Whether you are an embedded systems engineer transitioning from C/C++, a firmware developer exploring modern alternatives, or an IoT specialist looking to reduce bugs and improve reliability, this book offers clear explanations and hands-on guidance for using Rust effectively in embedded projects.What You'll Gain: - Strong understanding of Rust's memory safety guarantees in bare-metal and RTOS environments- Practical experience with Embassy, RTIC, and Tock- Techniques for building robust device drivers and sensor networks- Best practices for real-time systems and low-level hardware interactionWritten for developers with basic Rust knowledge who want to apply it to embedded and IoT development.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingThis book explores the implementation of database and storage engine components using Rust. It covers the design and development of key-value stores, log-structured merge (LSM) trees, write-ahead logs (WALs), and query engines.Readers will follow the step-by-step construction of these core systems, starting from fundamental data structures and moving through persistence, indexing, and query processing. The focus is on practical Rust code and systems programming concepts involved in building storage engines.Topics include: - In-memory and on-disk data structures- Write-ahead logging and durability- LSM tree implementation and compaction- Basic query execution and optimizationThe content is intended for developers with prior experience in Rust and interest in systems programming and database internals. All implementations are built from foundational principles.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingRust has emerged as the most compelling language for robotics, embedded systems, and cyber-physical platforms that demand low-latency, high-reliability, and strict memory safety. As autonomous machines grow in complexity, the need for deterministic execution, strong type guarantees, and concurrency without data races is transforming how engineers build real-world robotic systems.Rust for Robotics & Embedded Systems is a comprehensive guide to designing intelligent machines with Rust from the firmware up. This book shows engineers how to interface sensors, actuators, and microcontrollers; build motion control primitives; and implement safety-critical mechanisms for robots that must operate without failure in real time. Through practical examples and executable code, readers learn how to combine embedded Linux, no_std environments, RTOS integration, and robotics middleware to deliver deterministic performance without compromising safety.Key topics include: - Deterministic execution and concurrency without data races- Microcontrollers, embedded Linux, and no_std Rust environments- Real-time motion control, path planning, and servo coordination- Sensor integration for IMUs, lidar, encoders, cameras, and depth sensors- Safety-critical design patterns for robotics & embedded systems- Rust for ROS2, PX4, and other robotics middleware ecosystems- Firmware architecture, messaging, and scheduling- Testing, verification, and simulation frameworks for robot software- Deploying to drones, manipulators, autonomous vehicles, and industrial machines- Memory safety, performance engineering, and resource constraintsRust for Robotics & Embedded Systems is written for robotics engineers, embedded developers, systems programmers, and researchers who want to leverage Rust to build machines that are safe, intelligent, and reliable. Whether you are prototyping motion control on a microcontroller or building large-scale autonomous systems, this book delivers a unified technical foundation for the next generation of robotics software.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingDiscover how to build high-performance cross-platform mobile applications using Rust, one of the most powerful and memory-safe programming languages available today.This practical guide explores modern approaches to mobile development with Rust at the core. You'll learn to leverage Tauri for lightweight, secure apps that utilize the system's native webview, integrate Rust with Flutter for rich user interfaces and rapid development, and achieve near-native performance across iOS and Android from a shared codebase.What You'll Learn- Setting up Rust-powered mobile projects with Tauri for mobile targets- Bridging Rust backends with Flutter frontends for optimal performance and developer experience- Designing efficient, cross-platform architectures that minimize bundle size while maximizing speed and security- Implementing native capabilities, handling platform-specific code, and optimizing for real-world mobile constraints- Best practices for state management, testing, deployment, and maintaining high-performance Rust code in mobile environmentsWhether you're a Rust enthusiast looking to expand into mobile, a Flutter developer seeking better performance and safety, or an experienced engineer evaluating modern toolchains, this book provides clear explanations, working examples, and actionable insights for building production-ready mobile applications.Perfect for developers who want to combine Rust's performance and reliability with popular cross-platform frameworks.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingIn the world of modern web development, speed, reliability, and memory safety aren't optional, they're essential. Rust Web Development is your complete guide to harnessing Rust's legendary performance and rock-solid concurrency model to build scalable APIs, microservices, and full-featured web applications.What You'll Learn- Deep dives into the Rust async ecosystem with Tokio, the backbone of high-concurrency Rust applications- Practical, real-world web frameworks: Build robust applications with both Axum (the ergonomic, tower-powered framework from the Tokio team) and Actix Web (the battle-tested, actor-based framework)- How to structure large-scale Rust projects with clean architecture, proper error handling, and modular design- Database integration, authentication & authorization, testing strategies, logging, observability, and deployment- Performance optimization, graceful shutdowns, rate limiting, and production hardening techniques- Comparing Axum vs Actix Web, when to choose each and how to migrate between themWhether you're a seasoned Rustacean looking to level up your web skills or a backend developer curious about Rust's power for server-side development, this book provides clear explanations, practical examples, and battle-tested patterns you can apply immediately.Build the fast, secure, and reliable backends the industry increasingly demands, with Rust.Perfect for intermediate to advanced developers ready to move beyond 'hello world' and ship production-grade Rust web services with confidence.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingBuilding a Complete Trading Stack in Rust: From Market Data to Order Execution is a practical, systems-level guide to designing and implementing professional-grade trading infrastructure using Rust.Modern trading is no longer about isolated strategies or toy backtests. Real edge comes from building an end-to-end stack that handles market data ingestion, normalization, strategy evaluation, risk controls, and ultra-reliable order execution under real-world constraints. This book walks you through that entire pipeline with Rust as the foundation.Designed for developers, quants, and engineers who want performance, safety, and control, this book focuses on how real trading systems are architected-not academic abstractions or copy-paste scripts. You'll learn how to structure a modular trading stack that can evolve from research to production without collapsing under latency, concurrency, or operational risk.Inside, you'll explore: - Architecting a full trading stack from raw market feeds to execution gateways- Designing low-latency market data pipelines with deterministic performance- Modeling instruments, orders, and portfolios safely using Rust's type system- Building strategy engines that scale across symbols and venues- Implementing risk checks, position limits, and execution safeguards- Managing concurrency, async workflows, and fault tolerance- Structuring systems for simulation, paper trading, and live deploymentRather than focusing on a single exchange or strategy, the book teaches transferable architectural patterns used in professional trading environments. The emphasis is on clarity, correctness, and performance-so your system behaves predictably when markets do not.Whether you're building an automated trading platform, a proprietary execution engine, or a research-to-production pipeline, Building a Complete Trading Stack in Rust gives you the mental models and system designs needed to build trading infrastructure that actually survives contact with live markets.This is not a beginner's introduction to trading or Rust. It's a blueprint for engineers who want to build serious, end-to-end trading systems with modern tooling and production-grade discipline.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingMarket volatility does not move in a straight line. It clusters, snaps, compresses, explodes, then settles into deceptive calm. Traders who fail to detect these regime shifts early end up trading the wrong playbook at the wrong time. This book shows you how to build systems that never make that mistake again.Designed for serious quants, developers, and systematic traders, this book blends market microstructure theory with Rust's high-performance, low-latency capabilities. You'll learn how to architect engines that sense market state transitions in real time and adapt position sizing, risk allocation, and execution logic on the fly.This is a handbook for building self-correcting, adaptive, and future-proof trading systems. Systems that don't just react they anticipate.Inside you'll learn: - How volatility clusters and regime shifts emerge across equities, FX, crypto, and derivatives- Rust patterns for designing ultra-fast market state detection engines- Real-time signal construction using realized vol, entropy, kurtosis bursts, microstructure noise, and structural breaks- How to build adaptive trading logic that switches execution, risk, and exposure models based on detected regimes- Techniques for modeling calm, trending, choppy, and explosive volatility environments- Frameworks for building machine learning driven state classifiers in Rust- When to scale exposure, when to cut, and when to go flat- Complete, ready-to-use Rust modules for regime detection and adaptive strategy controlWhether you're building a new systematic strategy or upgrading legacy models, this book hands you the tools to operate in the real world the world where conditions change in seconds, and only adaptive systems survive.If you want your trading engine to think, react, and evolve at market speed, this is the blueprint.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingBuild High-Performance, Production-Grade AI Pipelines That Scaling Systems Can Actually Depend On.Moving AI models from research to production is where most modern software systems break down. While training a model or making an API call is easy, building reliable infrastructure that processes high-throughput data with predictable performance, minimal latency, and zero non-deterministic failure is a massive engineering challenge.In Engineering AI at Scale, Ethan Crossley delivers a practical, blueprint-driven guide to architecting deterministic, resilient AI infrastructure behind modern applications.Whether you are scaling LLM workflows, handling real-time inference pipelines, or managing distributed data orchestration, this book bridges the gap between machine learning concepts and rigorous software engineering practices.Inside, you will discover: - Deterministic Pipeline Design: How to eliminate unpredictable race conditions, unhandled edge cases, and non-deterministic behavior in complex AI systems.- Latency & Throughput Optimization: Strategies for building low-latency, high-availability pipelines that handle massive concurrent requests without crashing under load.- Scalable Data Orchestration: Practical patterns for chunking, streaming, caching, and processing large datasets efficiently across distributed environments.- Observability & Error Recovery: How to set up effective logging, trace execution flows, and build automated fallbacks for brittle third-party APIs and model failures.- Production-Ready Architecture: Real-world architectural blueprints for integrating vector stores, queuing systems, and asynchronous workers into existing backend systems.Stop relying on brittle scripts and fragile API wrappers. Learn how to design, build, and deploy AI infrastructure that scales seamlessly with your business.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingDiscover the inner workings of modern AI-powered search with Building Vector Search Engines from Scratch.As vector embeddings transform how we store, retrieve, and interact with data, building a high-performance vector search system has become an essential skill for AI engineers, machine learning practitioners, and backend developers. This book takes you step-by-step through the complete process of designing and implementing your own vector search engine, starting from fundamental concepts and progressing to production-ready architectures.What You'll Learn: - Core Storage Strategies: Explore efficient data structures and databases optimized for high-dimensional vector data, including flat indexes, graph-based methods, and quantization techniques.- Indexing Techniques: Master inverted files, product quantization, hierarchical navigable small world (HNSW) graphs, and other state-of-the-art indexing approaches that balance speed, memory usage, and accuracy.- High-Performance Retrieval: Implement approximate nearest neighbor (ANN) search, similarity metrics, reranking, and hybrid search systems that deliver sub-millisecond query times at scale.- AI System Integration: Learn how to integrate vector search into real-world applications such as semantic search, recommendation engines, retrieval-augmented generation (RAG) for LLMs, and multimodal AI systems.- Performance Optimization and Scaling: Address challenges in distributed systems, hardware acceleration (CPU/GPU), monitoring, and maintaining relevance as your data grows.Written with clear explanations, practical code examples in Python, and architectural diagrams, this hands-on guide emphasizes building systems that are both theoretically sound and practically deployable. Whether you're developing the next generation of search infrastructure or enhancing existing AI applications, you'll gain the deep technical foundation needed to move beyond off-the-shelf solutions.Ideal for intermediate to advanced developers familiar with machine learning concepts who want to understand vector search at a systems level.Start building robust, scalable vector search engines today.…

Taschenbuch. Condition: Neu. Neuware - Reactive PublishingTraditional analytical pipelines often hit a performance ceiling in high-stakes, low-latency environments. Rust for Predictive Analytics and Reliability Engineering bridges the critical gap between high-performance computing and uncompromising system safety.Designed for engineers moving beyond basic syntax, this guide focuses on applied architectures. Whether you are migrating legacy Python workflows, constructing zero-copy data pipelines, or designing fault-tolerant predictive models, this book provides the practical mechanics to build systems that scale without crashing.Core Concepts Covered- Zero-Copy Data Pipelines: Engineer low-latency analytical engines that process massive datasets without unnecessary memory allocation.- Time-Series Processing: Build highly concurrent, thread-safe systems optimized for quantitative modeling, algorithmic evaluation, and real-time data streams.- Memory-Safe Reliability: Leverage Rust's ownership model to eliminate data races and segmentation faults in mission-critical environments.- Ecosystem Integration: Connect high-performance Rust backends with existing Python data science workflows for seamless, cross-language deployment.Who This Book Is ForWritten for systems architects, data engineers, and quantitative analysts who need to deploy production-grade predictive models that demand both absolute speed and mathematical stability.…

Paperback. Condition: New.

Paperback. Condition: New.

Paperback. Condition: New.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

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

Condition: New. Print on Demand.

Condition: New. Print on Demand.