Oreilly - Rust in Action, video edition

seeders: 5
leechers: 6
updated:
Download torrent
Added by freecoursewb in Other > Tutorials
Download Fast Safe Anonymous
movies, software, shows...
  • Downloads: 44
  • Language: English

Files

[ TutPig.com ] Oreilly - Rust in Action, video edition
  • Get Bonus Downloads Here.url (0.2 KB)
    • ~Get Your Files Here !
    • 01 - Chapter 1. Introducing Rust .mp4 (50.9 MB)
    • 02 - Chapter 1. A taste of the language .mp4 (32.4 MB)
    • 03 - Chapter 1. What does Rust look and feel like .mp4 (60.2 MB)
    • 04 - Chapter 1. Goal of Rust Safety .mp4 (51.6 MB)
    • 05 - Chapter 1. Rust’s big features .mp4 (46.2 MB)
    • 06 - Chapter 1. Where does Rust fit best .mp4 (67.5 MB)
    • 07 - Part 1 Rust language distinctives .mp4 (1.8 MB)
    • 08 - Chapter 2. Language Foundations .mp4 (48.2 MB)
    • 09 - Chapter 2. Numbers .mp4 (44.7 MB)
    • 10 - Chapter 2. Floating-point hazards .mp4 (49.4 MB)
    • 11 - Chapter 2. Flow control .mp4 (39.4 MB)
    • 12 - Chapter 2. Defining functions .mp4 (58.6 MB)
    • 13 - Chapter 2. Creating grep-lite .mp4 (35.5 MB)
    • 14 - Chapter 2. Making lists of things with arrays, slices, and vectors .mp4 (40.1 MB)
    • 15 - Chapter 2. Including third-party code .mp4 (45.5 MB)
    • 16 - Chapter 3. Compound data types .mp4 (56.1 MB)
    • 17 - Chapter 3. Adding methods to a struct with impl .mp4 (49.2 MB)
    • 18 - Chapter 3. Making use of the Result return type .mp4 (58.8 MB)
    • 19 - Chapter 3. Implementing std fmt Display for your own types .mp4 (42.7 MB)
    • 20 - Chapter 4. Lifetimes, ownership, and borrowing .mp4 (61.4 MB)
    • 21 - Chapter 4. What is an owner Does it have any responsibilities .mp4 (51.5 MB)
    • 22 - Chapter 4. Duplicate the value .mp4 (50.7 MB)
    • 23 - Part 2 Demystifying systems programming .mp4 (2.4 MB)
    • 24 - Chapter 5. Data in depth .mp4 (54.2 MB)
    • 25 - Chapter 5. Understanding endianness .mp4 (41.7 MB)
    • 26 - Chapter 5. Isolating the exponent .mp4 (42.0 MB)
    • 27 - Chapter 5. Fixed-point number formats .mp4 (53.4 MB)
    • 28 - Chapter 5. Implementing a CPU to establish that functions are also data .mp4 (60.5 MB)
    • 29 - Chapter 5. CPU RIA 3 The Caller .mp4 (48.1 MB)
    • 30 - Chapter 6. Memory .mp4 (36.4 MB)
    • 31 - Chapter 6. Exploring Rust’s reference and pointer types .mp4 (48.4 MB)
    • 32 - Chapter 6. Rust’s pointer ecosystem .mp4 (40.4 MB)
    • 33 - Chapter 6. The stack .mp4 (29.3 MB)
    • 34 - Chapter 6. The heap .mp4 (35.8 MB)
    • 35 - Chapter 6. What is dynamic memory allocation .mp4 (42.1 MB)
    • 36 - Chapter 6. Virtual memory .mp4 (47.8 MB)
    • 37 - Chapter 6. Translating virtual addresses to physical addresses .mp4 (69.1 MB)
    • 38 - Chapter 7. Files and storage .mp4 (48.7 MB)
    • 39 - Chapter 7. File operations in Rust .mp4 (49.0 MB)
    • 40 - Chapter 7. Actionkv v1 The front-end code .mp4 (56.8 MB)
    • 41 - Chapter 7. Validating I O errors with checksums .mp4 (55.4 MB)
    • 42 - Chapter 7. Creating a HashMap and populating it with values .mp4 (48.8 MB)
    • 43 - Chapter 8. Networking .mp4 (49.6 MB)
    • 44 - Chapter 8. Trait objects .mp4 (29.3 MB)
    • 45 - Chapter 8. TCP .mp4 (47.9 MB)
    • 46 - Chapter 8. Ergonomic error handling for libraries .mp4 (53.5 MB)
    • 47 - Chapter 8. MAC addresses .mp4 (57.6 MB)
    • 48 - Chapter 9. Time and timekeeping .mp4 (66.5 MB)
    • 49 - Chapter 9. Encoding time .mp4 (51.1 MB)
    • 50 - Chapter 9. clock v0.1.2 Setting the time .mp4 (38.2 MB)
    • 51 - Chapter 9. clock v0.1.3 Resolving differences between clocks with the Network Time Protocol (NTP) .mp4 (68.2 MB)
    • 52 - Chapter 10. Processes, threads, and containers .mp4 (53.0 MB)
    • 53 - Chapter 10. Reproducing the results .mp4 (40.4 MB)
    • 54 - Chapter 10. Single-threaded render-hex overview .mp4 (45.0 MB)
    • 55 - Chapter 10. Using a thread pool and task queue .mp4 (51.9 MB)
    • 56 - Chapter 10. Concurrency and task virtualization .mp4 (63.3 MB)
    • 57 - Chapter 11. Kernel .mp4 (47.2 MB)
    • 58 - Chapter 11. Source code listings .mp4 (60.1 MB)
    • 59 - Chapter 11. Writing to the screen with VGA-compatible text mode .mp4 (52.0 MB)
    • 60 - Chapter 11. fledgeos-3 Text output .mp4 (49.0 MB)
    • 61 - Chapter 12. Signals, interrupts, and exceptions .mp4 (54.0 MB)
    • 62 - Chapter 12. Signal handling .mp4 (38.0 MB)
    • 63 - Chapter 12. Global variables in Rust .mp4 (53.1 MB)
    • 64 - Chapter 12. Shutting down from deeply nested call stacks .mp4 (44.6 MB)
    • 65 - Chapter 12. Casting a pointer to another type .mp4 (33.6 MB)
    • Bonus Resources.txt (0.3 KB)

Description

Rust in Action, video edition



https://TutPig.com

MP4 | Video: h264, 1276x716 | Audio: AAC, 44.1 KHz, 2 Ch
Genre: eLearning | Language: English | Duration: 65 Lessons (10h 31m) | Size: 829.2 MB
Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. Filled to the brim with real-life use cases and scenarios, you'll go beyond the Rust syntax and see what Rust has to offer in real-world use cases.

about the technology
Rust is the perfect language for systems programming. It delivers the low-level power of C along with rock-solid safety features that let you code fearlessly. Ideal for applications requiring concurrency, Rust programs are compact, readable, and blazingly fast. Best of all, Rust’s famously smart compiler helps you avoid even subtle coding errors.

about the book
Rust in Action is a hands-on guide to systems programming with Rust. Written for inquisitive programmers, it presents real-world use cases that go far beyond syntax and structure. You’ll explore Rust implementations for file manipulation, networking, and kernel-level programming and discover awesome techniques for parallelism and concurrency. Along the way, you’ll master Rust’s unique borrow checker model for memory management without a garbage collector.

what's inside
Elementary to advanced Rust programming
Practical examples from systems programming
Command-line, graphical and networked applications
about the audience
For intermediate programmers. No previous experience with Rust required.



Download torrent
3 GB
seeders:5
leechers:6
Oreilly - Rust in Action, video edition

Trackers

tracker name
udp://tracker.torrent.eu.org:451/announce
udp://tracker.tiny-vps.com:6969/announce
http://tracker.foreverpirates.co:80/announce
udp://tracker.cyberia.is:6969/announce
udp://exodus.desync.com:6969/announce
udp://explodie.org:6969/announce
udp://tracker.opentrackr.org:1337/announce
udp://9.rarbg.to:2780/announce
udp://tracker.internetwarriors.net:1337/announce
udp://ipv4.tracker.harry.lu:80/announce
udp://open.stealth.si:80/announce
udp://9.rarbg.to:2900/announce
udp://9.rarbg.me:2720/announce
udp://opentor.org:2710/announce
µTorrent compatible trackers list

Download torrent
3 GB
seeders:5
leechers:6
Oreilly - Rust in Action, video edition

Torrent hash: E720F106402C07731FB1130DFEDD2502BA8A4BD5