Learn programming in 14 days - 27 serie (96 risultati)

Paperback. Condizione: new. Paperback. Fourteen days of drills that turn data structures and algorithms into something you can use under pressure.This is a book of problems. Every rule is stated in as few words as it can be, shown working in a short program with its real captured output, and then handed back as drills. Nothing is asserted that is not also demonstrated: every listing in the book was compiled and run with Rust 1.97.1, and every printed result was captured from that run.The programming problems build one real tool across the fourteen days. It is called tally, a command-line text index. It begins on Day 1 as a word counter and gains, day by day, a growing buffer, a document list, a query parser, a directory walk, a ranking, a heap, a sorted vocabulary, a hash index, a search tree, a trie, a graph of related terms and a comparison of two documents. Each day's tool is the previous day's with one structure added, so the reason for a structure arrives before it does.Rust is not a passenger here. Ownership decides how a linked list is written, why a tree is held in one vector rather than a Box per node, and what a deletion is allowed to touch. Those decisions are shown as measurements, not as opinions: an arena builds a hundred thousand nodes in two thirds of the time and half the memory of one Box per node, and the book prints both numbers.The two weeks run in three movements. Days 1 to 5 build the foundations: the cost model, arrays, linked lists, stacks and queues, and recursion with backtracking. Days 6 to 9 cover sorting, heaps and priority queues, searching and two pointers, and hash tables. Days 10 to 14 cover binary search trees, balanced trees and tries, graphs and traversal, shortest paths, and dynamic programming and greedy algorithms.Every chapter has the same shape. Numbered sections state the rules. Twenty worked examples show each rule running, each with a complete program, its real output, a figure and a short explanation. Then a fixed ladder of five problem sets: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems in both written and programming form. The review answers are at the end of the chapter; the practice problems have no answers anywhere, by design.YOUR 14-DAY PATHWEEK 1 - FOUNDATIONS AND SORTINGDay 1 - Complexity and the Cost ModelDay 2 - Arrays and Dynamic ArraysDay 3 - Linked ListsDay 4 - Stacks and QueuesDay 5 - Recursion and BacktrackingDay 6 - Elementary and Divide-and-Conquer SortingDay 7 - Heaps, Priority Queues and Linear-Time SortingWEEK 2 - SEARCHING, TREES, GRAPHS AND DESIGN METHODSDay 8 - Searching, Binary Search and Two PointersDay 9 - Hash TablesDay 10 - Binary Trees and Binary Search TreesDay 11 - Balanced Trees and TriesDay 12 - Graphs and TraversalDay 13 - Shortest Paths, Spanning Trees and Topological OrderDay 14 - Dynamic Programming and Greedy AlgorithmsWHO IT'S FORStudents taking a data structures course who want drills rather than a reference. Readers preparing for an examination or a technical interview. Working programmers who want fluency in the structures they already use by name. One programming language is assumed: loops, functions and arrays. No prior work on data structures is assumed. Rust is taught only where a structure needs it, so a reader who knows another language can follow the drills and pick up the language on the way.281 worked examples. 463 figures. 736 problems. 390 pages. Written to Rust 1.97.Fourteen days. Work them in order, and do the problems. This item is printed on Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills on JavaScript and the Node runtime it actually runs on.This is a drill manual, not a tutorial and not a reference. The programming problems build one real program across the book: pulse, a command-line task and notification scheduler. It starts as a script that runs a single job on a timer and ends as a multi-file tool that persists jobs to disk, schedules recurring work, and dispatches webhook alerts when a job fires. Every listing in the book - 414 of them - was executed on Node v24.13.1, and every printed output block, thrown errors included, is a paste from that run. A reader who works the programming problems finishes with pulse running end to end; a reader who skips them still finishes with the language.The fourteen chapters move through three arcs. The first is the language itself: values and coercion, control flow and functions, arrays and iteration, objects, JSON and destructuring, scope and closures, higher-order functions, prototypes, classes, this-binding, and the errors and modules that hold a program together. The second is the runtime that makes JavaScript worth running on a server: the event loop and callbacks, promises and async/await, the core modules, files and streams, EventEmitter, and networking. The third is shipping: the command line, npm and publishing a package, and testing, debugging and the current edition of the language.Written to ECMAScript 2026, the seventeenth edition of ECMA-262, approved 2026-06-30. ES2026 adds exactly seven things: Map.prototype.getOrInsert and getOrInsertComputed, Math.sumPrecise, Error.isError, Array.fromAsync, Uint8Array Base64 and Hex conversions, JSON.rawJSON and isRawJSON, and Iterator.concat. Only three of the seven run on Node v24.13.1. This book shows the other four throwing a real error on this Node, on the page, and then the manual equivalent a reader can use today.Every chapter has the same shape, in the same order. A short opener states what the chapter covers. Numbered sections state the rules. Each rule carries its own worked examples: complete programs, run, with the real output pasted underneath and a figure. Five problem sets close the chapter in a fixed ladder: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems.Your 14-Chapter Path1. JAVASCRIPT AND THE NODE RUNTIME2. VALUES, TYPES AND COERCION3. CONTROL FLOW AND FUNCTIONS4. ARRAYS AND ITERATION5. OBJECTS, JSON AND DESTRUCTURING6. SCOPE, CLOSURES AND HIGHER-ORDER FUNCTIONS7. PROTOTYPES, CLASSES AND THIS8. ERRORS AND MODULES9. THE EVENT LOOP AND CALLBACKS10. PROMISES AND ASYNC AWAIT11. CORE MODULES, FILES AND STREAMS12. EVENTEMITTER AND NETWORKING13. THE COMMAND LINE, NPM AND PUBLISHING14. TESTING, DEBUGGING AND ES2026 Who It's ForA reader who can already program in some language and wants fluency in modern JavaScript on Node under test conditions. Front-end developers moving to the server. Students on a web or systems course who need a vehicle beyond the browser. Readers preparing for a technical interview or an exam. Working programmers who measure a book by how many problems they can work afterward. No prior Node is assumed.312 worked examples. 312 figures. 630 numbered problems. 414 runnable listings. 378 pages. Written to ECMAScript 2026, the seventeenth edition, with every listing run on Node v24.13.1.Install Node v24.13.1, open a terminal, and start Cha Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills that turn shell scripting into something you can trust on a machine you cannot watch. This is a book of problems. Every rule is stated in as few words as it can be, shown working in a short script with its real captured output, and then handed back as drills. Nothing is asserted that is not also demonstrated: every listing in the book was run under GNU Bash 5.3.15 on Linux, and every printed result was captured from that run. The programming problems build one real tool across the fourteen days. It is called sentry, a host audit command. It begins on Day 1 as a script that refuses to run half-broken and gains, day by day, arguments that survive a space, settings with defaults, named checks chosen by option, tallies in arrays, log reading that loses no character, file discovery that survives every legal filename, a formatted report, checks that run in parallel behind a lock, and finally a dry run, a self-test, a log and an installable command. The shell is not a passenger here. Quoting decides whether a filename with a space is one argument or two. Strict mode decides whether a failed command stops the script or is ignored. A subshell decides whether a counter survives the loop that filled it. Every one of those decisions is shown as a measurement rather than an opinion, and the book prints both outcomes. The two weeks run in two movements. Days 1 to 7 cover the language: the execution model and strict mode, quoting and expansions, parameter expansion, tests and control flow, arrays, functions and scope, and reading input safely. Days 8 to 14 cover the machine: processes, pipelines and exit status, globs and awkward filenames, traps and cleanup, text processing inside the shell, concurrency and locking, the failure modes a defensive script must survive, and packaging a script an operator can run at three in the morning. Every chapter has the same shape. Numbered sections state the rules. Twenty worked examples show each rule running, each with a complete script, its real output, a figure and a short explanation. Then a fixed ladder of five problem sets: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems in both written and programming form. The review answers are at the end of the chapter; the practice problems have no answers anywhere, by design.Your 14-day pathWeek 1 - the languageDay 1 - The Shell, the Script and Strict ModeDay 2 - Words, Quoting and the Order of ExpansionsDay 3 - Parameters and Parameter ExpansionDay 4 - Tests, Conditions and Control FlowDay 5 - Arrays and Associative ArraysDay 6 - Functions, Scope and Return ValuesDay 7 - Reading Input with read, IFS and File Descriptors Week 2 - the machineDay 8 - Processes, Pipelines and Exit StatusDay 9 - Files, Globs and Awkward NamesDay 10 - Traps, Signals and CleanupDay 11 - Text Processing inside the ShellDay 12 - Concurrency, Jobs, wait and LocksDay 13 - The Failure Modes of a Shell ScriptDay 14 - Packaging a Script for Operations Who it's forSystem administrators who write the scripts a fleet depends on. Site reliability engineers who inherit them. Developers who maintain the shell that holds a deployment together. Readers preparing for a technical interview. Use of a command line is assumed. No prior scripting is assumed, and no other programming language. 280 worked examples. 462 figures. 910 pr Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills that turn data structures and algorithms into something you can use under pressure.This is a book of problems. Every rule is stated in as few words as it can be, shown working in a short program with its real captured output, and then handed back as drills. Nothing is asserted that is not also demonstrated: every listing in the book was compiled and run with Rust 1.97.1, and every printed result was captured from that run.The programming problems build one real tool across the fourteen days. It is called tally, a command-line text index. It begins on Day 1 as a word counter and gains, day by day, a growing buffer, a document list, a query parser, a directory walk, a ranking, a heap, a sorted vocabulary, a hash index, a search tree, a trie, a graph of related terms and a comparison of two documents. Each day's tool is the previous day's with one structure added, so the reason for a structure arrives before it does.Rust is not a passenger here. Ownership decides how a linked list is written, why a tree is held in one vector rather than a Box per node, and what a deletion is allowed to touch. Those decisions are shown as measurements, not as opinions: an arena builds a hundred thousand nodes in two thirds of the time and half the memory of one Box per node, and the book prints both numbers.The two weeks run in three movements. Days 1 to 5 build the foundations: the cost model, arrays, linked lists, stacks and queues, and recursion with backtracking. Days 6 to 9 cover sorting, heaps and priority queues, searching and two pointers, and hash tables. Days 10 to 14 cover binary search trees, balanced trees and tries, graphs and traversal, shortest paths, and dynamic programming and greedy algorithms.Every chapter has the same shape. Numbered sections state the rules. Twenty worked examples show each rule running, each with a complete program, its real output, a figure and a short explanation. Then a fixed ladder of five problem sets: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems in both written and programming form. The review answers are at the end of the chapter; the practice problems have no answers anywhere, by design.YOUR 14-DAY PATHWEEK 1 - FOUNDATIONS AND SORTINGDay 1 - Complexity and the Cost ModelDay 2 - Arrays and Dynamic ArraysDay 3 - Linked ListsDay 4 - Stacks and QueuesDay 5 - Recursion and BacktrackingDay 6 - Elementary and Divide-and-Conquer SortingDay 7 - Heaps, Priority Queues and Linear-Time SortingWEEK 2 - SEARCHING, TREES, GRAPHS AND DESIGN METHODSDay 8 - Searching, Binary Search and Two PointersDay 9 - Hash TablesDay 10 - Binary Trees and Binary Search TreesDay 11 - Balanced Trees and TriesDay 12 - Graphs and TraversalDay 13 - Shortest Paths, Spanning Trees and Topological OrderDay 14 - Dynamic Programming and Greedy AlgorithmsWHO IT'S FORStudents taking a data structures course who want drills rather than a reference. Readers preparing for an examination or a technical interview. Working programmers who want fluency in the structures they already use by name. One programming language is assumed: loops, functions and arrays. No prior work on data structures is assumed. Rust is taught only where a structure needs it, so a reader who knows another language can follow the drills and pick up the language on the way.281 worked examples. 463 figures. 736 problems. 390 pages. Written to Rust 1.97.Fourteen days. Work them in order, and do the problems. This item Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills on JavaScript and the Node runtime it actually runs on.This is a drill manual, not a tutorial and not a reference. The programming problems build one real program across the book: pulse, a command-line task and notification scheduler. It starts as a script that runs a single job on a timer and ends as a multi-file tool that persists jobs to disk, schedules recurring work, and dispatches webhook alerts when a job fires. Every listing in the book - 414 of them - was executed on Node v24.13.1, and every printed output block, thrown errors included, is a paste from that run. A reader who works the programming problems finishes with pulse running end to end; a reader who skips them still finishes with the language.The fourteen chapters move through three arcs. The first is the language itself: values and coercion, control flow and functions, arrays and iteration, objects, JSON and destructuring, scope and closures, higher-order functions, prototypes, classes, this-binding, and the errors and modules that hold a program together. The second is the runtime that makes JavaScript worth running on a server: the event loop and callbacks, promises and async/await, the core modules, files and streams, EventEmitter, and networking. The third is shipping: the command line, npm and publishing a package, and testing, debugging and the current edition of the language.Written to ECMAScript 2026, the seventeenth edition of ECMA-262, approved 2026-06-30. ES2026 adds exactly seven things: Map.prototype.getOrInsert and getOrInsertComputed, Math.sumPrecise, Error.isError, Array.fromAsync, Uint8Array Base64 and Hex conversions, JSON.rawJSON and isRawJSON, and Iterator.concat. Only three of the seven run on Node v24.13.1. This book shows the other four throwing a real error on this Node, on the page, and then the manual equivalent a reader can use today.Every chapter has the same shape, in the same order. A short opener states what the chapter covers. Numbered sections state the rules. Each rule carries its own worked examples: complete programs, run, with the real output pasted underneath and a figure. Five problem sets close the chapter in a fixed ladder: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems.Your 14-Chapter Path1. JAVASCRIPT AND THE NODE RUNTIME2. VALUES, TYPES AND COERCION3. CONTROL FLOW AND FUNCTIONS4. ARRAYS AND ITERATION5. OBJECTS, JSON AND DESTRUCTURING6. SCOPE, CLOSURES AND HIGHER-ORDER FUNCTIONS7. PROTOTYPES, CLASSES AND THIS8. ERRORS AND MODULES9. THE EVENT LOOP AND CALLBACKS10. PROMISES AND ASYNC AWAIT11. CORE MODULES, FILES AND STREAMS12. EVENTEMITTER AND NETWORKING13. THE COMMAND LINE, NPM AND PUBLISHING14. TESTING, DEBUGGING AND ES2026 Who It's ForA reader who can already program in some language and wants fluency in modern JavaScript on Node under test conditions. Front-end developers moving to the server. Students on a web or systems course who need a vehicle beyond the browser. Readers preparing for a technical interview or an exam. Working programmers who measure a book by how many problems they can work afterward. No prior Node is assumed.312 worked examples. 312 figures. 630 numbered problems. 414 runnable listings. 378 pages. Written to ECMAScript 2026, the seventeenth edition, with every listing run on Node v24.13.1.Install Node v24.13.1, open a terminal, Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills that turn shell scripting into something you can trust on a machine you cannot watch.This is a book of problems. Every rule is stated in as few words as it can be, shown working in a short script with its real captured output, and then handed back as drills. Nothing is asserted that is not also demonstrated: every listing in the book was run under GNU Bash 5.3.15 on Linux, and every printed result was captured from that run.The programming problems build one real tool across the fourteen days. It is called sentry, a host audit command. It begins on Day 1 as a script that refuses to run half-broken and gains, day by day, arguments that survive a space, settings with defaults, named checks chosen by option, tallies in arrays, log reading that loses no character, file discovery that survives every legal filename, a formatted report, checks that run in parallel behind a lock, and finally a dry run, a self-test, a log and an installable command.The shell is not a passenger here. Quoting decides whether a filename with a space is one argument or two. Strict mode decides whether a failed command stops the script or is ignored. A subshell decides whether a counter survives the loop that filled it. Every one of those decisions is shown as a measurement rather than an opinion, and the book prints both outcomes.The two weeks run in two movements. Days 1 to 7 cover the language: the execution model and strict mode, quoting and expansions, parameter expansion, tests and control flow, arrays, functions and scope, and reading input safely. Days 8 to 14 cover the machine: processes, pipelines and exit status, globs and awkward filenames, traps and cleanup, text processing inside the shell, concurrency and locking, the failure modes a defensive script must survive, and packaging a script an operator can run at three in the morning.Every chapter has the same shape. Numbered sections state the rules. Twenty worked examples show each rule running, each with a complete script, its real output, a figure and a short explanation. Then a fixed ladder of five problem sets: review questions, worked problems with full solutions, worked programming problems, and unassisted practice problems in both written and programming form. The review answers are at the end of the chapter; the practice problems have no answers anywhere, by design.Your 14-day pathWeek 1 - the languageDay 1 - The Shell, the Script and Strict ModeDay 2 - Words, Quoting and the Order of ExpansionsDay 3 - Parameters and Parameter ExpansionDay 4 - Tests, Conditions and Control FlowDay 5 - Arrays and Associative ArraysDay 6 - Functions, Scope and Return ValuesDay 7 - Reading Input with read, IFS and File DescriptorsWeek 2 - the machineDay 8 - Processes, Pipelines and Exit StatusDay 9 - Files, Globs and Awkward NamesDay 10 - Traps, Signals and CleanupDay 11 - Text Processing inside the ShellDay 12 - Concurrency, Jobs, wait and LocksDay 13 - The Failure Modes of a Shell ScriptDay 14 - Packaging a Script for OperationsWho it's forSystem administrators who write the scripts a fleet depends on. Site reliability engineers who inherit them. Developers who maintain the shell that holds a deployment together. Readers preparing for a technical interview. Use of a command line is assumed. No prior scripting is assumed, and no other programming language.< Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.…

Taschenbuch. Condizione: Neu. Neuware - Fourteen days of drills on the SQL a technical interview actually asks for, run through nothing but Python's own standard library. This is a drill manual, not a narrative course. Every listing was executed for real against a small SQLite database built up across the fourteen days, and every printed output block, including every EXPLAIN QUERY PLAN, is a paste from that run. Each chapter states a rule in as few words as it can, shows the rule working in a short numbered example with its captured output, and hands it straight back as problems. The vehicle is hiredb, one job-application database with four tables: applications, companies, contacts and a status-history log. Only Python 3.11 or later is required. sqlite3 ships in the standard library, so there is no server to install, no account to create, and no driver to configure. Every listing runs unchanged on Windows, macOS and Linux. The first week covers the ground a screen opens with: the table and the first query, SELECT and WHERE, every join type, GROUP BY and aggregate traps, subqueries and CTEs, window functions, and NULL and three-valued logic. The second week covers what separates a pass from a strong pass: indexes, reading a query plan, transactions and isolation, normalisation and schema design, calling SQL safely from Python, one full take-home task, and a closing chapter of forty timed questions, each worked and its own plan read. The findings are reported as they came out. A missing index turns a two-hundred-thousand-row filter from fourteen milliseconds into one tenth of one. A naive pay comparison shows remote roles earning nineteen points more than onsite ones, and the gap nearly disappears once role is held constant. Your 14-Day Path - 1. THE TABLE, THE ROW AND THE QUERY- 2. SELECT, WHERE AND THE FIRST QUESTIONS- 3. JOINS: INNER, LEFT AND THE ONE THAT LOSES ROWS- 4. GROUP BY, HAVING AND AGGREGATE TRAPS- 5. SUBQUERIES, CTEs AND READABLE SQL- 6. WINDOW FUNCTIONS- 7. NULL AND THREE-VALUED LOGIC- 8. INDEXES AND WHY YOUR QUERY IS SLOW- 9. READING A QUERY PLAN- 10. TRANSACTIONS AND ISOLATION- 11. NORMALISATION AND SCHEMA DESIGN- 12. SQL FROM PYTHON- 13. THE TAKE-HOME DATA TASK- 14. THE LIVE SQL SCREEN Who It's For Job seekers preparing a technical screen or a take-home assignment. Students learning SQL through Python's own standard library. Working developers whose SQL has stayed at a beginner's level for years. Anyone who wants every answer checked against a real database, not memorized. 284 worked examples. 286 figures. 650 numbered problems. 392 pages. Built and measured against Python 3.11 and SQLite 3.38. You need only Python and about an hour a day. Start Day 1.…

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware - Fourteen days of drills that turn design patterns from vocabulary into judgment. Most pattern books show you Java-shaped code and leave out the question C++ actually asks: who owns these objects, and how long do they live This one answers it for every pattern. That is the difference between a diagram you can recite and a design you can ship. You learn by doing, on one real project. studio is a command-line vector-drawing and report-generating application. It starts on Day 1 as a rigid hundred-line program and ends on Day 14 as a design that absorbs change. Every pattern earns its place in it rather than being bolted on. Week one builds the foundation: what a design is judged by, object lifetime and ownership in C++, and all five SOLID principles. Week two is the twenty-three classic patterns in their three groups, then the C++ forms that reach the same flexibility with no virtual function at all, then removing designs as well as adding them. Every pattern is presented the same way. First the change that breaks the rigid design. Then the rigid code, with the exact line you would have to edit. Then the hinge, the one abstraction that turns editing into adding. Then the code that changed. Then the cost, stated plainly, because a pattern that looks free gets used everywhere. Every day is self-contained: numbered rules, short worked examples with real captured output and a diagram of the mechanism, then a fixed ladder of five problem sets running from recall to unassisted building. Practice problems have no answers anywhere, by design. YOUR 14-DAY PATH Week 1 - Principles Day 1: Design, Change and Cost Day 2: Single Responsibility and Open-Closed Day 3: Substitution, Segregation and Inversion Day 4: Creating Objects by Name Day 5: Assembling, Copying and Sharing Day 6: Wrapping, Splitting and Nesting Day 7: Adding, Hiding, Deferring and Sharing Week 2 - Patterns and judgment Day 8: Interchangeable Behaviour Day 9: Objects That Talk to Each Other Day 10: Mode, Traversal and History Day 11: Operations over a Structure Day 12: Patterns without Virtual Functions Day 13: Anti-Patterns and Refactoring toward Patterns Day 14: The Assembled Application WHO IT'S FOR Working C++ programmers who can write a class but cannot yet say why one design survives a change and another does not. Students on a software design or software engineering course. Candidates preparing for a design interview, where the twenty-three patterns are asked about by name. Written to C++23. Every listing was compiled and run with g++ -std=c++23 -O2 -Wall -Wextra, and every printed output is what came back from that run. Nothing was typed from memory. Work the problems. That is what the book is for. …

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware - Fourteen days of drills on the patterns a coding interview actually asks for, run through nothing but plain Python and a harness built on Day 1. This is a drill manual, not a narrative course. Every listing was executed for real through drillkit, a small timing-and-testing harness the book builds and grows across fourteen days, and every printed output block is a paste from that run. Each chapter states a rule in as few words as it can, shows the rule working in a short numbered example with its captured output, and hands it straight back as problems. Only Python 3.11 or later is required. No package needs installing and no account needs creating. Every listing runs unchanged on Windows, macOS and Linux. The first week builds the model and the instruments: how a score is built from four axes, complexity spoken out loud, arrays and two pointers, hash maps, sliding windows, linked lists, and stacks and monotonic structures. The second week covers trees, graphs, recursion and backtracking, sorting and binary search, dynamic programming, heaps and greedy choices, and a closing mock loop of four timed interviews. The findings are reported as they came out. A heap-based merge loses to a single call to Python's own sort. A first-element quicksort pivot turns a fast sort thirty times slower on sorted input. Two candidates with identical, unfinished code cross a hiring threshold on one axis alone: the one who says what they would try next scores higher than the one who goes silent. Your 14-Day Path - 1. HOW A CODING INTERVIEW IS SCORED- 2. COMPLEXITY YOU CAN DEFEND OUT LOUD- 3. ARRAYS AND TWO POINTERS- 4. HASH MAPS AND COUNTING- 5. STRINGS AND SLIDING WINDOWS- 6. LINKED LISTS AND POINTER SURGERY- 7. STACKS, QUEUES AND MONOTONIC STRUCTURES- 8. TREES AND TRAVERSAL- 9. GRAPHS- 10. RECURSION, BACKTRACKING AND PRUNING- 11. SORTING AND BINARY SEARCH- 12. DYNAMIC PROGRAMMING WITHOUT PANIC- 13. HEAPS, INTERVALS AND GREEDY CHOICES- 14. THE MOCK LOOP Who It's For Bootcamp graduates and career changers preparing a first technical screen. Students who want every claim measured against a running program. Working developers whose interview skills have gone rusty. 280 worked examples. 336 figures. 630 numbered problems. 384 pages. Built and measured against Python 3.11. You need only Python and about an hour a day. Start Day 1.…

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Taschenbuch. Condizione: Neu. Neuware.

Paperback. Condizione: new. Paperback. Fourteen days of drills on Docker and Kubernetes, built around one real application and one real cluster that stays up the whole way through. This is a drill manual, not a narrative course. Every listing runs against a real Docker Engine and a real local Kubernetes cluster, and every printed output block is a paste from that run -- including a real crash loop caused by a liveness probe set too eager, a real registry migration that broke on the very first try, and the real VM restarts that interrupted the work more than once. Each chapter states a rule in as few words as it can, shows the rule working in a short numbered example with its captured output, and hands it straight back as problems. Every example builds one application, hiretrack, a small job-application tracker that grows a real feature every day: a SQLite file, then Postgres and Redis behind Compose, then a full Kubernetes Deployment with probes, an init container, a CI/CD pipeline, and a real container registry. The first week covers Docker: images and layers, a fast Dockerfile, multi-stage builds, volumes and bind mounts, container networking, a real Compose stack, and a systematic method for debugging a container that will not start. The second week moves the same application onto Kubernetes: Deployments, Services, ConfigMaps and Secrets, health probes and rolling updates, init containers and paused rollouts, kubectl-based debugging of planted failures, a real CI/CD pipeline against a real registry, and a closing chapter that runs the whole book back as a timed interview drill. The measurements are reported as they came out. A one-line source edit that should touch nothing costs a full nine-second dependency reinstall, because of Dockerfile order, not bad luck. A liveness probe with too short a delay kills a perfectly healthy container, repeatedly, until the delay is fixed. A registry-based deploy fails on the very first attempt with a pull-policy conflict this book's own earlier chapters caused. A book that only printed the clean successes would be easier to write and worth less to work through. Your 14-Day Path 1. IMAGES, LAYERS AND THE CONTAINER2. WRITING A DOCKERFILE THAT BUILDS FAST3. MULTI-STAGE BUILDS AND SMALL IMAGES4. VOLUMES, BIND MOUNTS AND DATA5. CONTAINER NETWORKING6. COMPOSE FOR A REAL STACK7. DEBUGGING A CONTAINER THAT WON'T START8. IMAGE SECURITY AND SUPPLY CHAIN9. FROM COMPOSE TO KUBERNETES10. DEPLOYMENTS, SERVICES AND CONFIG11. HEALTH CHECKS, PROBES AND ROLLOUTS12. LOGS, METRICS AND kubectl DEBUGGING13. CI/CD: BUILD, PUSH, DEPLOY14. THE INTERVIEW Who It's For Developers preparing for a DevOps or platform-engineering interview. Backend engineers whose team just adopted Kubernetes. Anyone who has run docker run a hundred times and still cannot explain what a Service actually routes to. No prior Kubernetes is assumed; comfort with a shell and a text editor is. 302 worked examples. 302 figures. 2,053 numbered problems. 350 pages. Measured with Docker Engine 29.6.1, kubectl v1.36.4, and a kind v0.33.0 cluster running Kubernetes v1.35.0. You need Docker Desktop or an equivalent Docker Engine, and about an hour a day. Start Chapter 1. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

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

Paperback. Condizione: new. Paperback. Fourteen days. One project. Every listing executed.This is a drill manual, not a tutorial. Every rule of the TypeScript type system is stated in as few words as it can be, shown working in a short program with its real captured output, and then handed straight back as problems. Every listing was run on TypeScript 7.0.2 and Node v24.13.1, and every printed block, diagnostics included, is a paste from that run. Nothing here is written from expectation.TypeScript 7.0 replaced the compiler with a native Go implementation. Two changes meet you on Day 1: strict is on in a new project by default, and the es5 target has been removed. Both are shown happening on the page.What you will buildOne project runs through the whole book: shiftlog, a shift-scheduling service on Node. It starts as a single typed function on Day 1 and ends on Day 14 as a package with declarations, source maps, a referenced build, and a pipeline that gates one step on another. No day uses anything an earlier day has not introduced.The fourteen daysWeek one - the type system.Day 1 - The Compiler, the Project and the First TypeDay 2 - Primitives, Literals and InferenceDay 3 - Objects, Interfaces and Structural TypingDay 4 - Unions, Narrowing and Discriminated UnionsDay 5 - Functions, Parameters and OverloadsDay 6 - Arrays, Tuples and ReadonlyDay 7 - GenericsWeek two - the type system at work.Day 8 - Conditional and Mapped TypesDay 9 - Classes, Accessibility and AbstractionDay 10 - Modules, Resolution and Declaration FilesDay 11 - Asynchronous TypesDay 12 - Validation at the BoundaryDay 13 - Strictness and MigrationDay 14 - The BuildInside398 worked examples, each a complete program with its real output and a figure398 figures, drawn to read in black and white802 numbered problems in five sets a chapter: review questions, worked problems, worked programming problems, practice problems, practice programming problems468 listings executed, every one on the versions aboveEvery diagnostic printed with its code, because the code is what you search forWho it is forProgrammers who already write JavaScript - functions, objects, promises, modules - and want the type system to become a tool rather than an obstacle. No prior TypeScript is assumed. For students, for interview and exam preparation, and for working programmers who want fluency rather than a reference.What it deliberately leaves outNo framework, no bundler, no decorators, and no test runner. A type system is easier to see without any of them in front of it. The runtime is Node and the only build tool is the compiler.372 pages. Work the problems. That is what the book is for. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

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

Paperback. Condizione: new. Paperback. Fourteen days of drills that turn data structures and algorithms into something you can use under pressure, written for C# 14 on .NET 10. This is a book of problems. Every rule is stated in as few words as it can be, shown working in a short program with its real captured output, and then handed back as drills. Nothing is asserted that is not also demonstrated: every listing is a single self-contained C# 14 file, run with dotnet run and no project file, and every printed result was captured from that run, with every timing warmed up and averaged so it measures the algorithm and not the JIT compiler or the garbage collector. The programming problems build one real tool across the fourteen days. It is called tally, a command-line text index. It begins on Day 1 as a word counter and gains, day by day, a growable buffer, a document list, a query parser, a ranking, a heap, a postings list, a hash index, an ordered vocabulary, prefix search, a co-occurrence graph, related-term search and spelling suggestions. Each day's tool is the previous day's tool with one structure added, so the reason for each structure arrives before the structure does. The two weeks run in three movements. Days 1 to 5 build the foundations: the cost model, arrays and dynamic arrays, linked lists, stacks and queues, and recursion with backtracking. Days 6 to 9 cover sorting, heaps and priority queues, searching and two pointers, and hash tables. Days 10 to 14 cover binary search trees, balanced trees and tries, graphs and traversal, shortest paths and spanning trees, and finally dynamic programming and greedy algorithms. Every chapter has the same shape. Numbered sections state the rules. Twenty worked examples show each rule running, each with a complete program, its real output, a figure and a short explanation. Then a fixed ladder of five problem sets: review questions, worked problems with full solutions, worked programming problems with complete programs, and unassisted practice problems in both written and programming form. The answers to the review questions are at the end of the chapter. The practice problems have no answers anywhere, by design. YOUR 14-DAY PATH WEEK 1 - FOUNDATIONS AND SORTING Day 1 - The Cost Model and ComplexityDay 2 - Arrays and Dynamic ArraysDay 3 - Linked ListsDay 4 - Stacks and QueuesDay 5 - Recursion and BacktrackingDay 6 - Elementary and Divide-and-Conquer SortingDay 7 - Heaps, Priority Queues and Linear-Time Sorting WEEK 2 - SEARCHING, TREES, GRAPHS AND DESIGN METHODS Day 8 - Searching, Binary Search and Two PointersDay 9 - Hash TablesDay 10 - Binary Trees and Binary Search TreesDay 11 - Balanced Trees and TriesDay 12 - Graphs and TraversalDay 13 - Shortest Paths, Spanning Trees and Topological OrderDay 14 - Dynamic Programming and Greedy Algorithms WHO IT'S FOR Students taking a data structures course who want drills rather than a reference. Readers preparing for an examination or a technical interview, where the measure is what can be produced without help. Working programmers who want fluency in the structures they already use by name. One programming language is assumed, with loops, functions and arrays. No prior work on data structures is assumed, and no mathematics beyond logarithms and summation. 290 worked examples. 346 figures. About 700 problems. 388 pages. Written to C# 14. Fourteen days. Work them in order, and do the problems. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days. One compiler. Every listing compiled, every output captured. FreeBASIC looks like the BASIC of a home computer and compiles like C. Its Integer is 8 bytes, its records carry padding and its objects carry a hidden pointer, so habits from either side give wrong answers. Day 1 builds a program from the command line and measures its types. Day 5 starts cardfile, a card index, with one record. Day 7 adds objects and virtual methods. Day 14 assembles cardfile whole: a binary store, an in-memory index, a command shell and its tests. 313 worked examples, each a whole program compiled with fbc 1.10.1. 285 output blocks, each captured from a real run. 314 figures drawn for a black-and-white press. 994 problems over five sets a chapter. YOUR 14-DAY PATH Day 1 - The Program and its Types: integer and real types, text, conversion and the three dialects of one compiler.Day 2 - Deciding and Repeating: If, Select Case, the operators, short-circuit tests and every loop form.Day 3 - Procedures: Sub and Function, ByVal against ByRef, overloading, defaults and recursion.Day 4 - Arrays and Strings: fixed and dynamic arrays, bounds, many dimensions, and text taken apart and built.Day 5 - Types of Your Own: records, the padding inside them, unions, enums, methods and properties.Day 6 - Pointers and Memory: addresses, pointer types, New and Delete, Allocate, and pointers to procedures.Day 7 - Objects: Extends, Virtual, Abstract, the vtable measured in bytes, operators and copying.Day 8 - Modules and Scope: Include, headers, namespaces, public and private, a library and the build line.Day 9 - When Things Go Wrong: runtime errors, the checks and their cost, On Error, Assert and cleaning up.Day 10 - Files: text, random-access and binary files, and what each one writes to the disk.Day 11 - The Preprocessor: Define and Macro, conditional compilation, guards and compile-time asserts.Day 12 - Testing and Measuring: a test runner in forty lines, table-driven tests, timing and a caught regression.Day 13 - Talking to C and the System: names in the object file, the C runtime, strings and bytes across it, threads.Day 14 - One Whole Program: cardfile assembled from its record, index, store, commands, reports and tests. WHO IT IS FOR. Programmers who have written a program in any language and want FreeBASIC taught as a compiled language. Students and interview candidates who need to know what the compiler actually does. Not needed: C, object-oriented programming or an IDE. A text editor and the free fbc compiler are the whole toolchain. Download book source code from: {GitHub}/{mohammadnsaqib} 450 pages, black and white. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days. One library, prkit, checked line by line against scikit-learn. By Day 14 it aligns two sequences into a complete recognizer. A classifier can look correct on paper and still be wrong in practice, because one accuracy number hides which mistakes it makes and what each one costs. Most courses teach the formulas and stop short of checking that a hand-rolled routine agrees with a trusted library. Day 1 draws the nearest-mean boundary on the Iris dataset, the simplest rule prkit builds. Day 5 fits a Gaussian's own mean and covariance straight from data instead of assuming them. Day 8 finds the widest-margin boundary, then bends it with a kernel where no line will separate the classes. Day 14 aligns two sequences by dynamic time warping into a complete recognition system. Every number here was measured, never assumed. 308 examples across 14 days, each with its captured output and a figure, and every routine in prkit is checked against scikit-learn or SciPy before it is trusted. All 14 chapters close with a review-and-practice drill, so a formula is tested twice: once by the library, once by the reader. Nothing in prkit is asserted where it can instead be run. YOUR 14-DAY PATH Day 1 - Patterns, Features and Decisions: the feature vector, the decision rule, and counting mistakes.Day 2 - Probability for Decisions: priors, likelihoods, and the posterior rule.Day 3 - Decisions That Cost Different Amounts: loss matrices, expected risk, and the option to decide nothing.Day 4 - The Gaussian and Its Boundaries: covariance, Mahalanobis distance, and the discriminants it produces.Day 5 - Learning the Density from Data: maximum likelihood, shrinkage, and naive Bayes.Day 6 - Densities Without a Formula: histograms, Parzen windows, and k nearest neighbours.Day 7 - Drawing the Boundary Directly: the perceptron, least squares, and logistic regression.Day 8 - The Widest Margin: margins, the hinge loss, and the kernel trick.Day 9 - Changing the Features: principal components, whitening, and Fisher's direction.Day 10 - Choosing the Features: filters, mutual information, and wrappers that leak.Day 11 - Measuring What Was Built: cross-validation, confusion matrices, and ROC curves.Day 12 - Many Classifiers, One Answer: voting, bagging, random forests, and boosting.Day 13 - Patterns Without Labels: k-means, mixtures, and hierarchical clustering.Day 14 - Sequences, and a Whole System: dynamic time warping, hidden states, and one measured pipeline. WHO IT IS FOR. Python developers who want to know what a classifier is deciding, not just call one from a library. You need working Python and NumPy; scikit-learn and SciPy are used only to check prkit's own answers, never to replace them. No deep learning framework and no GPU are used anywhere in the book. It does not cover neural networks, which stay outside its 14 days. Download book source code from: {GitHub}/{mohammadnsaqib} 428 pages, black and white, every output run and checked against a library. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…

Paperback. Condizione: new. Paperback. Fourteen days of drills on GPU programming, written in Python and measured on a real NVIDIA card. This is a drill manual, not a narrative course. Every one of the 463 listings was executed on a real GPU, and every printed output block and every printed timing is a paste from that run -- including the ones that came out level, and the ones that contradicted the theory. Each chapter states a rule in as few words as it can, shows the rule working in a short numbered example with its captured output, and hands it straight back as problems. The programming problems build one program across the whole book: gridsim, a grid relaxation that starts as a field of floats on the device in Chapter 1 and ends as a tuned simulation with a shared-memory stencil, a reduced convergence measure and a measured launch configuration. Most kernels here are written in Python with Numba's atcuda.jit. Where the C level is the lesson, the kernel is written in CUDA C and compiled at run time through CuPy, so a reader finishes able to read and write both and to move arrays between them without a copy. The fourteen chapters carry the whole working core. The first week covers the execution model and the first kernel, thread indexing in one and two dimensions, device memory and transfers, the CuPy array layer, honest timing and device properties, warps and divergence, and global memory access patterns. The second week covers shared memory and bank conflicts, synchronization and atomics, reduction and prefix sum, writing CUDA C kernels from Python, tiled matrix multiplication, streams and overlap, and occupancy and launch tuning. The measurements are reported as they came out. A tiled matrix multiply is 2.6 times the naive one and the library is still eight times faster than both. A pipeline in eight streams beats one stream by three per cent, not the forty the arithmetic promises. Raising occupancy by capping registers makes one kernel slower. A book that only printed the wins would be easier to write and worth less to work through. Your 14-Day Path 1. THE GPU AND THE FIRST KERNEL2. THREAD INDEXING3. DEVICE MEMORY AND TRANSFERS4. ARRAY PROGRAMMING WITH CUPY5. TIMING, ERRORS, AND DEVICE PROPERTIES6. WARPS AND DIVERGENCE7. GLOBAL MEMORY ACCESS PATTERNS8. SHARED MEMORY9. SYNCHRONIZATION AND ATOMICS10. REDUCTION AND SCAN11. WRITING CUDA C KERNELS FROM PYTHON12. MATRIX MULTIPLICATION AND TILING13. STREAMS, EVENTS, AND OVERLAP14. OCCUPANCY AND LAUNCH TUNING Who It's For Students on a parallel-computing or high-performance-computing course. Readers preparing for an examination or a technical interview. Working scientists and engineers whose NumPy code has outgrown the CPU. Python programmers who want the GPU without first learning C++. No prior CUDA is assumed; comfort with Python and NumPy is. 336 worked examples. 448 figures. 672 numbered problems. 380 pages. Measured on an RTX 4070 with CuPy 14.1 and Numba 0.67. You need an NVIDIA GPU and about an hour a day. Start Chapter 1. This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability.…