Books

Este es un libro sobre nuestra Panadería, nuestra gastronomía, nuestra cultura panadera, es fin, sobre lo nuestro. Nuestros panes nos acompañan en cada comida y la hacen más deliciosa y memorable. Si deseas hacer tus propios panes en casa y reproducir nuestros aromas para compartirlo con tus afectos, entonces Haz Panes Venezolanos en Casa.

Si eres Venezolano y extrañas los buenos panes de antes, este es el libro para tí. No importa donde estés, en cualquier lugar del mundo vas a poder preparar los 10 PANES …que te regresarán a Venezuela.

A local model returns the expected answer. How do we know which layers ran on the GPU? In Local AI on RTX Spark Laptops, we investigate questions like this through 251 hands-on WSL2 exercises, following the evidence from model-loader logs down to individual CUDA kernels.

A Deep Systems Engineering Guide to ELF64 Internals, Dynamic Linking, Kernel Loading, Binary Instrumentation, and Executable Runtime ArchitectureEvery executable binary contains more than machine instructions. It encodes the structural information, symbol relationships, relocation rules, memory mappings, and runtime metadata required to transform compiled code into a functioning process. Understanding this transformation requires looking beyond compiler output and examining the mechanisms that connect binary formats, operating-system loaders, dynamic linkers, virtual memory, and processor execution.Mastering ELF: From Bytes to Execution is a comprehensive, implementation-focused engineering reference to the Executable and Linkable Format (ELF), with a particular emphasis on ELF64 internals and low-level runtime behavior. Across 50 chapters, it follows the complete execution pipeline from raw binary structures and defensive parsing to kernel-space loading, dynamic symbol resolution, thread-local storage, exception unwinding, executable modification, and custom loader architecture.

وصفات موروث الروهينجا العريق | Authentic Rohingya Heritage Sweets

A Comprehensive Engineering Guide to Low-Precision AI, Quantized Inference, GPU Kernels, and Production DeploymentQuantization is one of the key techniques for making large language models more efficient. By representing weights, activations, and other model data at reduced precision, engineers can lower memory requirements, improve hardware utilization, and potentially increase inference throughput. Achieving these benefits, however, requires careful trade-offs between numerical accuracy, computational cost, memory bandwidth, and hardware support. Mastering LLM Quantization: Architecture and Code is a 44-chapter engineering reference covering the mathematics, algorithms, implementation techniques, GPU kernels, evaluation methods, and deployment systems behind quantized language models. It connects theoretical foundations with practical approaches to building and optimizing low-precision inference pipelines.

Build a Deep Technical Understanding of How Modern Browsers Reveal Device IdentityBrowser fingerprinting has evolved far beyond traditional cookies and persistent tracking identifiers. Modern websites can derive identifying signals from browser internals, graphics hardware, JavaScript runtimes, network protocols, rendering engines, media subsystems, and operating system characteristics. When combined, these signals can help distinguish devices and correlate browsing sessions even when conventional tracking mechanisms are unavailable.Modern Browser Fingerprinting: Techniques and Code is a comprehensive technical guide to the architecture, mathematics, implementation, and practical applications of browser fingerprinting. It examines how individual signals are generated, how their identifying value can be measured, and how multiple observations can be combined to construct probabilistic device profiles.Combining technical explanations with source code, controlled experiments, telemetry analysis, and statistical methods, the book explores browser fingerprinting across security research, fraud prevention, bot detection, web analytics, and digital privacy. It also examines the limitations of fingerprint-based identification, including measurement noise, browser updates, hardware changes, signal instability, and privacy-preserving countermeasures.

Are you looking for something to eat that is off the beaten path? Something deep fried and something savory that reminds you of a tropical breeze? You have come to the right place, La Buena Vida: Puerto Rican Finger Foods is your ticket to my culinary delights.

A Comprehensive Engineering Guide to Autonomous Agent Architectures, Multi-Agent Systems, Memory, Tool Execution, Reliability, Observability, and Production DeploymentAutonomous AI agents represent a fundamental shift from conventional conversational applications toward software systems capable of executing multi-step tasks, interacting with external tools, maintaining persistent state, coordinating specialized components, and adapting their behavior to changing conditions. Building such systems requires considerably more than connecting a language model to a prompt. It demands a disciplined approach to execution control, memory architecture, workflow orchestration, security, evaluation, and production infrastructure.Mastering AI Agents: Hands-On Production Code is a practical, implementation-focused engineering reference to designing, building, and deploying autonomous AI agent systems. Across 38 chapters, it progresses from low-level LLM runtime primitives and a zero-dependency Python agent loop to cognitive architectures, persistent memory, stateful workflows, multi-agent coordination, secure tool execution, production observability, and enterprise deployment.

Build, Train, Optimize, Secure, and Deploy Large Language Models Under Full Infrastructure ControlLarge language models are increasingly treated as hosted services, but organizations seeking genuine control over their AI capabilities must understand and engineer the infrastructure behind them. Data ownership, compute resources, model weights, training pipelines, inference runtimes, security boundaries, and operational telemetry all contribute to the independence and reliability of an AI system.

Explore the Software, Computing Architectures, Data Pipelines, and High-Performance Systems Behind Modern High-Energy PhysicsCERN is more than a particle physics laboratory. It operates one of the world's most demanding scientific computing environments, bringing together extreme data rates, heterogeneous hardware, distributed storage, high-performance networking, real-time processing, large-scale simulation, machine learning, and advanced software engineering.Coding CERN: A Technical Developer's Guide explores the computing architecture behind experiments at the Large Hadron Collider (LHC), connecting detector electronics and real-time trigger systems with modern C++, ROOT, distributed computing, GPU acceleration, machine learning, high-performance computing, and global scientific infrastructure.The book takes a developer-oriented approach to the complete scientific computing pipeline, examining how physical events become digital signals, how those signals are filtered and reconstructed, and how the resulting data is stored, distributed, simulated, and analyzed across geographically dispersed computing facilities.

Engineering ultra-low-latency, high-throughput real-time systems with .NET, WebSockets, SignalR, Kestrel, and distributed architectures.Modern real-time applications must maintain persistent connections, process massive event streams, synchronize distributed state, and deliver predictable latency under extreme concurrency.High-Performance Real-Time Systems in .NET is a deep technical guide to designing, optimizing, profiling, and operating real-time systems built on the modern .NET ecosystem.Rather than treating real-time communication as a simple framework feature, this book examines the entire engineering stack, from memory management and network transports to WebSockets, SignalR internals, distributed messaging, Kubernetes, observability, and large-scale load testing.

An Engineering Reference for Resilient, Scalable, and Autonomous Enterprise InfrastructureEnterprise automation is no longer limited to scheduled scripts and isolated administrative tasks. Reliable infrastructure requires coordinated systems that can detect failures, manage changing state, enforce security policies, and recover from operational problems with minimal manual intervention. Advanced Automation: 50-Chapter Master Script Package is a 50-chapter technical reference for DevOps engineers, Site Reliability Engineers (SREs), cloud architects, and platform engineers.

Cloud GPU rental costs more than compute time. It can also introduce recurring expenses, external dependencies, and additional questions about where your prompts, datasets, and model artifacts are processed. A local machine learning workstation gives you direct control over the hardware, software stack, and data workflows. The Local AI Stack is a technical engineering reference for building a Windows-based machine learning workstation with Linux environments, NVIDIA GPU acceleration, and virtualization. Across 140 pages, it follows the stack from firmware configuration and Windows virtualization features to CUDA-enabled containers, model inference, storage optimization, and system recovery.

An advanced technical reference to Qiskit architecture, IBM Quantum hardware, pulse-level control, error mitigation, quantum algorithms, and scalable quantum-classical computing.Quantum computing is moving beyond the construction of theoretical circuits toward the practical challenge of executing workloads on noisy, hardware-constrained quantum processors. This transition requires a detailed understanding of quantum algorithms, compiler architecture, device topology, calibration, error mitigation, and the classical infrastructure that supports quantum execution. Advanced IBM Quantum Computing and Qiskit Architecture is an 80-chapter technical reference exploring the engineering principles behind modern Qiskit development and IBM Quantum systems. It connects quantum programming abstractions with hardware-aware compilation, runtime execution, performance analysis, and the challenges of building reproducible quantum-classical workflows.