{"id":15076110,"url":"https://github.com/getvmio/free-programming-resources","last_synced_at":"2025-10-26T11:38:19.917Z","repository":{"id":251137268,"uuid":"822446363","full_name":"getvmio/free-programming-resources","owner":"getvmio","description":"Programming Free Resources | This repo collects 232 of free resources for Programming. 🧰 Sharpen your programming skills across multiple languages with our Coder's Toolkit repository! Featuring a comprehensive collection of free programming resources, online courses, and a user-friendly playgroun...","archived":false,"fork":false,"pushed_at":"2025-05-01T01:36:17.000Z","size":63,"stargazers_count":2,"open_issues_count":1,"forks_count":1,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-10-24T15:21:54.724Z","etag":null,"topics":["awesome-list","free-resources","getvm","playground","programming"],"latest_commit_sha":null,"homepage":"https://getvm.io/tutorials/category/programming","language":null,"has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/getvmio.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2024-07-01T07:07:37.000Z","updated_at":"2025-09-27T10:22:37.000Z","dependencies_parsed_at":"2024-08-01T04:55:06.115Z","dependency_job_id":"9feb145d-e26d-4d21-a4ce-c22d62d39796","html_url":"https://github.com/getvmio/free-programming-resources","commit_stats":null,"previous_names":["getvmio/free-programming-resources"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/getvmio/free-programming-resources","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/getvmio%2Ffree-programming-resources","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/getvmio%2Ffree-programming-resources/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/getvmio%2Ffree-programming-resources/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/getvmio%2Ffree-programming-resources/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/getvmio","download_url":"https://codeload.github.com/getvmio/free-programming-resources/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/getvmio%2Ffree-programming-resources/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":281098557,"owners_count":26443530,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-26T02:00:06.575Z","response_time":61,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["awesome-list","free-resources","getvm","playground","programming"],"created_at":"2024-09-25T03:57:52.938Z","updated_at":"2025-10-26T11:38:19.870Z","avatar_url":"https://github.com/getvmio.png","language":null,"funding_links":[],"categories":["More","Other Lists"],"sub_categories":["TeX Lists"],"readme":"# Programming Free Resources\n\n🧰 Sharpen your programming skills across multiple languages with our Coder's Toolkit repository! Featuring a comprehensive collection of free programming resources, online courses, and a user-friendly playground, this is your one-stop-shop for becoming a versatile and proficient developer.\n\n## Resources\n\n|   Index | Name                                                                                                                                                                                                                 | Category            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n|       1 | [Rust Tutorials](https://getvm.io/tutorials/rust-tutorials)                                                                                                                                                          | Technical Tutorials | Explore Rust's unique features like ownership, memory safety, and concurrency. Practice hands-on coding through interactive tutorials and master the powerful Rust language.                                                                                                                                                                                                                                                                                   |\n|       2 | [Python Tutorials](https://getvm.io/tutorials/python-tutorials)                                                                                                                                                      | Technical Tutorials | Comprehensive Python tutorials covering basic programming concepts, command-line usage, and advanced topics. Includes hands-on exercises and practical examples to reinforce learning.                                                                                                                                                                                                                                                                         |\n|       3 | [Go Tutorials](https://getvm.io/tutorials/go-tutorials)                                                                                                                                                              | Technical Tutorials | Dive into the world of Go programming with our comprehensive tutorials. Learn the basics of syntax, types, and object-oriented programming to become a proficient Go developer.                                                                                                                                                                                                                                                                                |\n|       4 | [Software Construction](https://getvm.io/tutorials/6-005-software-construction-fall-2016-mit)                                                                                                                        | University Courses  | Dive into the fundamental principles and techniques of software development at MIT. Learn to write high-quality, maintainable code through topics like testing, state machines, and concurrent programming.                                                                                                                                                                                                                                                    |\n|       5 | [6.001 Structure and Interpretation of Computer Programs - MIT](https://getvm.io/tutorials/6-001-structure-and-interpretation-of-computer-programs-mit)                                                              | University Courses  | Teaches big-picture computing concepts using the Scheme programming language. Students will implement programs in a variety of different programming paradigms (functional, object-oriented, logical). Heavy emphasis on function composition, code-as-data, control abstraction with continuations, and syntactic abstraction through macros. An excellent course if you are looking to build a mental framework on which to hang your programming knowledge. |\n|       6 | [Computer Science](https://getvm.io/tutorials/cs-for-all-cs-for-all-harvey-mudd-college)                                                                                                                             | University Courses  | Explore computer science as an engaging field beyond just programming. Emphasis on concepts and problem-solving over syntax. Unique course for diverse backgrounds.                                                                                                                                                                                                                                                                                            |\n|       7 | [Programming Foundations I](https://getvm.io/tutorials/csce-2004-programming-foundations-i-university-of-oxford)                                                                                                     | University Courses  | Comprehensive introduction to programming, covering fundamental concepts and techniques. Develop problem-solving skills and algorithmic thinking through hands-on assignments.                                                                                                                                                                                                                                                                                 |\n|       8 | [Object-Oriented Programming](https://getvm.io/tutorials/cs-2110-object-oriented-programming-and-data-structures-cornell-university)                                                                                 | University Courses  | Comprehensive computer science course covering program design, object-oriented programming, data structures, and more. Suitable for students with prior programming experience.                                                                                                                                                                                                                                                                                |\n|       9 | [Computer Science I and II for Hackers](https://getvm.io/tutorials/cs-1410-2-computer-science-i-and-ii-for-hackers-university-of-utah)                                                                               | University Courses  | Introductory computer science course focused on Racket, C, and Java programming with a functional programming perspective, designed by a lead Racket designer.                                                                                                                                                                                                                                                                                                 |\n|      10 | [Transition to Python](https://getvm.io/tutorials/cs-1133-transition-to-python-cornell-university)                                                                                                                   | University Courses  | Comprehensive Python programming course for students with prior coding experience in Java, MATLAB, C, C++, or Fortran. Covers fundamental Python constructs and provides a smooth transition to the language.                                                                                                                                                                                                                                                  |\n|      11 | [Transition to OO Programming](https://getvm.io/tutorials/cs-1130-transition-to-oo-programming-cornell-university)                                                                                                   | University Courses  | Explore object-oriented programming concepts using Java. Ideal for students with prior coding experience in other languages seeking to expand their skills.                                                                                                                                                                                                                                                                                                    |\n|      12 | [Computational Science and Engineering Using MATLAB GUI](https://getvm.io/tutorials/cs-1115-introduction-to-computational-science-and-engineering-using-matlab-graphical-user-interfaces-cornell-university)         | University Courses  | Explore the practical applications of computational science and engineering with a focus on MATLAB GUI development. Suitable for students with programming experience.                                                                                                                                                                                                                                                                                         |\n|      13 | [CS 1112](https://getvm.io/tutorials/cs-1112-introduction-to-computing-using-matlab-cornell-university)                                                                                                              | University Courses  | Comprehensive MATLAB programming course covering fundamental concepts, data structures, and algorithms. Hands-on projects and experienced Cornell faculty.                                                                                                                                                                                                                                                                                                     |\n|      14 | [Fundamental Programming Concepts](https://getvm.io/tutorials/cs-1109-fundamental-programming-concepts-cornell-university)                                                                                           | University Courses  | Gain a solid foundation in programming and problem-solving skills with this introductory course from Cornell University.                                                                                                                                                                                                                                                                                                                                       |\n|      15 | [Programming Practice Using Scala](https://getvm.io/tutorials/cs-109-programming-practice-using-scala-kaist)                                                                                                         | University Courses  | Dive into the fundamentals of programming and computer science with this Scala-based course from KAIST. Build a strong coding foundation and prepare for advanced CS studies.                                                                                                                                                                                                                                                                                  |\n|      16 | [Advanced Programming Paradigms](https://getvm.io/tutorials/cs-107-programming-paradigms-stanford-university)                                                                                                        | University Courses  | Explore the nuances of imperative, object-oriented, functional, and concurrent programming through hands-on experience with C, C++, LISP, and Python.                                                                                                                                                                                                                                                                                                          |\n|      17 | [Programming Abstractions](https://getvm.io/tutorials/cs-106b-programming-abstractions-stanford-university)                                                                                                          | University Courses  | Advance your programming skills with CS 106B: Programming Abstractions at Stanford University, covering recursion, algorithmic analysis, and data abstraction using C++.                                                                                                                                                                                                                                                                                       |\n|      18 | [Programming Methodology](https://getvm.io/tutorials/cs-106a-programming-methodology-stanford-university)                                                                                                            | University Courses  | Comprehensive introduction to computer science and programming using Java, focusing on modern software engineering principles like object-oriented design, decomposition, and testing.                                                                                                                                                                                                                                                                         |\n|      19 | [CS 61AS: Structure \u0026 Interpretation of Computer Programs](https://getvm.io/tutorials/cs-61as-structure-interpretation-of-computer-programs-racket-uc-berkeley)                                                      | University Courses  | Explore the fundamentals of computer science with this self-paced course from UC Berkeley, using the classic \"Structure and Interpretation of Computer Programs\" textbook.                                                                                                                                                                                                                                                                                     |\n|      20 | [CS50: Introduction to Computer Science](https://getvm.io/tutorials/cs-50-introduction-to-computer-science-harvard-university)                                                                                       | University Courses  | Explore the intellectual enterprises of computer science and the art of programming with Harvard's renowned CS50 course. Develop problem-solving skills, learn fundamental programming concepts, and apply your knowledge in a final project.                                                                                                                                                                                                                  |\n|      21 | [The Beauty and Joy of Computing](https://getvm.io/tutorials/cs-10-the-beauty-and-joy-of-computing-uc-berkeley)                                                                                                      | University Courses  | Explore the fundamentals of computer science, its history, social impact, and future in this beginner-friendly UC Berkeley course.                                                                                                                                                                                                                                                                                                                             |\n|      22 | [Great Ideas in Theoretical Computer Science](https://getvm.io/tutorials/6-045-great-ideas-in-theoretical-computer-science-mit)                                                                                      | University Courses  | Explore the central ideas of theoretical computer science, from finite automata to quantum computing, in this challenging MIT online course.                                                                                                                                                                                                                                                                                                                   |\n|      23 | [Programming Paradigms](https://getvm.io/tutorials/csce-3193-programming-paradigms-university-of-arkansas-fayetteville)                                                                                              | University Courses  | Explore multiple programming paradigms including object-oriented, network, and functional programming in this comprehensive course at the University of Arkansas.                                                                                                                                                                                                                                                                                              |\n|      24 | [Advanced Functional Programming](https://getvm.io/tutorials/l28-advanced-functional-programming-university-of-cambridge)                                                                                            | University Courses  | Explore advanced functional programming concepts and their practical applications to design and implement robust, efficient software systems.                                                                                                                                                                                                                                                                                                                  |\n|      25 | [Functional Design and Programming](https://getvm.io/tutorials/cs-696-functional-design-and-programming-san-diego-state-university)                                                                                  | University Courses  | Explore the fundamentals of functional programming with Clojure, a powerful Lisp dialect running on the Java Virtual Machine. Gain hands-on experience in practical software development.                                                                                                                                                                                                                                                                      |\n|      26 | [Advanced Symbolic Programming](https://getvm.io/tutorials/6-945-adventures-in-advanced-symbolic-programming-mit)                                                                                                    | University Courses  | Explore advanced concepts and techniques for designing and implementing large, adaptable software systems like compilers, computer-algebra, and AI applications with this MIT course.                                                                                                                                                                                                                                                                          |\n|      27 | [Practical Concurrent \u0026 Parallel Programming](https://getvm.io/tutorials/pcpp-practical-concurrent-and-parallel-programming-it-university-of-copenhagen)                                                             | University Courses  | Learn to write correct and efficient concurrent and parallel software using Java on shared-memory multicore hardware. Covers basic and advanced concepts, performance, and debugging tools.                                                                                                                                                                                                                                                                    |\n|      28 | [Discrete Mathematics and Functional Programming](https://getvm.io/tutorials/dmfp-discrete-mathematics-and-functional-programming-wheaton-college)                                                                   | University Courses  | Comprehensive course combining discrete mathematics and functional programming, featuring videos, source code, and supplementary materials for independent study and classroom use.                                                                                                                                                                                                                                                                            |\n|      29 | [Compiler Construction](https://getvm.io/tutorials/cse-p-501-compiler-construction-university-of-washington)                                                                                                         | University Courses  | Learn the inner workings of modern compilers and gain practical experience in compiler construction. Covers major algorithms and techniques, implemented in Java.                                                                                                                                                                                                                                                                                              |\n|      30 | [Programming Languages](https://getvm.io/tutorials/cse-341-programming-languages-university-of-washington)                                                                                                           | University Courses  | Explore non-imperative programming paradigms and languages like Ruby, Racket, and ML. Gain a comprehensive understanding of programming language fundamentals.                                                                                                                                                                                                                                                                                                 |\n|      31 | [Types and Semantics](https://getvm.io/tutorials/cs-6118-types-and-semantics-cornell-university)                                                                                                                     | University Courses  | Explore the design and understanding of programming languages with a focus on types and semantics. Develop custom languages for your needs through a project-based approach.                                                                                                                                                                                                                                                                                   |\n|      32 | [Compilers](https://getvm.io/tutorials/cs-5470-compilers-university-of-utah)                                                                                                                                         | University Courses  | Dive deep into the world of compilers with CS 5470 at the University of Utah. Explore fundamental concepts, hands-on projects, and expert instruction from a renowned professor.                                                                                                                                                                                                                                                                               |\n|      33 | [Scripting Languages](https://getvm.io/tutorials/cs-5142-scripting-languages-cornell-university)                                                                                                                     | University Courses  | Learn rapid prototyping, web programming, data processing, and application extension using popular scripting languages like Perl, PHP, JavaScript, and VisualBasic.                                                                                                                                                                                                                                                                                            |\n|      34 | [Network Programming Languages](https://getvm.io/tutorials/cs-5114-network-programming-languages-cornell-university)                                                                                                 | University Courses  | Comprehensive course on the programming languages used in computer networks, including logic, functional, and distributed languages, as well as tools for verifying program correctness.                                                                                                                                                                                                                                                                       |\n|      35 | [Programming Languages](https://getvm.io/tutorials/cs-4400-programming-languages-northeastern-university)                                                                                                            | University Courses  | Explore the fundamentals of programming languages at Northeastern University. Gain expertise in language design, implementation, and applications.                                                                                                                                                                                                                                                                                                             |\n|      36 | [Purely Functional Data Structures in Elm](https://getvm.io/tutorials/cs-223-purely-functional-data-structures-in-elm-university-of-chicago)                                                                         | University Courses  | Learn functional reactive programming and purely functional data structures using the Elm programming language in this hands-on course from the University of Chicago.                                                                                                                                                                                                                                                                                         |\n|      37 | [Programming Languages](https://getvm.io/tutorials/cs-173-programming-languages-brown-university)                                                                                                                    | University Courses  | Explore programming language design and concepts with renowned professor Shriram Krishnamurthi's CS 173 course at Brown University, featuring the custom-built Pyret language.                                                                                                                                                                                                                                                                                 |\n|      38 | [Programming Languages](https://getvm.io/tutorials/cs-164-hack-your-language-uc-berkeley)                                                                                                                            | University Courses  | Explore programming languages through the design and implementation of domain-specific languages at UC Berkeley's CS 164 course.                                                                                                                                                                                                                                                                                                                               |\n|      39 | [Principles of Programming Languages](https://getvm.io/tutorials/corsopl-principles-of-programming-languages-politecnico-di-milano)                                                                                  | University Courses  | Explore the key programming language concepts and paradigms, including functional, object-oriented, and concurrent programming, through an in-depth analysis of Scheme, Haskell, and Erlang.                                                                                                                                                                                                                                                                   |\n|      40 | [Introduction to Programming Languages](https://getvm.io/tutorials/cs-91-introduction-to-programming-languages-swathmore-college)                                                                                    | University Courses  | Gain a fundamental understanding of programming languages with Pyret and the PAPL book in this Swarthmore College CS 91 course.                                                                                                                                                                                                                                                                                                                                |\n|      41 | [Tiny Package Manager: Learns how npm or Yarn works](https://getvm.io/tutorials/tiny-package-manager-learns-how-npm-or-yarn-works)                                                                                   | Technical Tutorials | Explore a simple package manager demo and understand the core functionality of NPM or Yarn v1, including package downloads, dependency resolution, and more.                                                                                                                                                                                                                                                                                                   |\n|      42 | [Writing a URL Shortening Service](https://getvm.io/tutorials/writing-a-url-shortening-service)                                                                                                                      | Technical Tutorials | Learn how to build a URL shortening service using the Nim programming language. Covers web development and practical programming topics.                                                                                                                                                                                                                                                                                                                       |\n|      43 | [Learn JavaScript Promises by Building a Promise from Scratch](https://getvm.io/tutorials/learn-javascript-promises-by-building-a-promise-from-scratch)                                                              | Technical Tutorials | Step-by-step tutorial to fully understand JavaScript Promises by building a Promise from scratch. Ideal for beginners to intermediate developers.                                                                                                                                                                                                                                                                                                              |\n|      44 | [Lets Create a Simple Load Balancer](https://getvm.io/tutorials/lets-create-a-simple-load-balancer)                                                                                                                  | Technical Tutorials | Learn how to build a basic load balancer using the Go programming language, including networking, load balancing techniques, and practical implementation.                                                                                                                                                                                                                                                                                                     |\n|      45 | [Building a Spell-Checker](https://getvm.io/tutorials/building-a-spell-checker)                                                                                                                                      | Technical Tutorials | Explore the development of a spell-checker using Clojure programming language, with insights into building efficient and accurate spell-checking algorithms for text processing tasks.                                                                                                                                                                                                                                                                         |\n|      46 | [Writing a Linux Debugger](https://getvm.io/tutorials/writing-a-linux-debugger)                                                                                                                                      | Technical Tutorials | Learn how to build a Linux debugger from scratch, covering core features like breakpoints, single stepping, and variable inspection. Ideal for developers interested in low-level systems programming.                                                                                                                                                                                                                                                         |\n|      47 | [How X Window Managers work and how to write one](https://getvm.io/tutorials/how-x-window-managers-work-and-how-to-write-one)                                                                                        | Technical Tutorials | Comprehensive guide to understanding the inner workings of X Window Managers and learning how to develop one from scratch. Dive into the low-level details of modern desktop environments.                                                                                                                                                                                                                                                                     |\n|      48 | [The very basics of a terminal emulator](https://getvm.io/tutorials/the-very-basics-of-a-terminal-emulator)                                                                                                          | Technical Tutorials | Explore the inner workings of terminal emulators, from beginner to advanced developers. Learn about pseudoterminals, master-slave file descriptors, and more.                                                                                                                                                                                                                                                                                                  |\n|      49 | [How to Write a Video Player in Less Than 1000 Lines](https://getvm.io/tutorials/how-to-write-a-video-player-in-less-than-1000-lines)                                                                                | Technical Tutorials | Learn to build a complete video player using FFmpeg and SDL libraries. Covers digital video and audio processing, with step-by-step tutorials and downloadable source code.                                                                                                                                                                                                                                                                                    |\n|      50 | [Designing a Simple Text Editor](https://getvm.io/tutorials/designing-a-simple-text-editor)                                                                                                                          | Technical Tutorials | Comprehensive guide to designing a FLTK-based text editor with features like menus, text editing, search and replace functionality. Suitable for beginner and experienced developers.                                                                                                                                                                                                                                                                          |\n|      51 | [Build Your Own Text Editor](https://getvm.io/tutorials/build-your-own-text-editor)                                                                                                                                  | Technical Tutorials | Learn to build a text editor from scratch in C with features like syntax highlighting and search. Gain a deeper understanding of text editor functionality and low-level programming concepts.                                                                                                                                                                                                                                                                 |\n|      52 | [Building a LISP from scratch with Swift](https://getvm.io/tutorials/building-a-lisp-from-scratch-with-swift)                                                                                                        | Technical Tutorials | Build a LISP programming language from scratch using Swift. Learn how to create a REPL and implement a minimal LISP interpreter - a rewarding weekend project.                                                                                                                                                                                                                                                                                                 |\n|      53 | [Writing a Lisp, the series](https://getvm.io/tutorials/writing-a-lisp-the-series)                                                                                                                                   | Technical Tutorials | Comprehensive guide to building your own Lisp programming language, covering fundamental concepts and practical implementation details.                                                                                                                                                                                                                                                                                                                        |\n|      54 | [Writing a C Compiler](https://getvm.io/tutorials/writing-a-c-compiler)                                                                                                                                              | Technical Tutorials | Comprehensive guide to writing a C compiler, covering topics like abstract syntax trees, assembly, and low-level computer architecture. Ambitious project to gain valuable insights into computer systems.                                                                                                                                                                                                                                                     |\n|      55 | [Build a Little Lisp Interpreter](https://getvm.io/tutorials/little-lisp-interpreter)                                                                                                                                | Technical Tutorials | Learn the fundamentals of Lisp programming and how to build a simple Lisp interpreter in just 116 lines of JavaScript code.                                                                                                                                                                                                                                                                                                                                    |\n|      56 | [The Super Tiny Interpreter](https://getvm.io/tutorials/the-super-tiny-interpreter)                                                                                                                                  | Technical Tutorials | Build a super tiny interpreter for programming languages and learn about closures. A hands-on approach to understanding the inner workings of a programming language interpreter.                                                                                                                                                                                                                                                                              |\n|      57 | [The Super Tiny Compiler](https://getvm.io/tutorials/the-super-tiny-compiler)                                                                                                                                        | Technical Tutorials | Dive into programming languages, compilers, and build a super tiny compiler from scratch with this comprehensive guide.                                                                                                                                                                                                                                                                                                                                        |\n|      58 | [Creating JVM Language](https://getvm.io/tutorials/creating-jvm-language)                                                                                                                                            | Technical Tutorials | Discover the process of building a custom programming language that runs on the Java Virtual Machine (JVM). Learn language design, parsing, code generation, and Java integration.                                                                                                                                                                                                                                                                             |\n|      59 | [Write You A Scheme](https://getvm.io/tutorials/write-you-a-scheme)                                                                                                                                                  | Technical Tutorials | Explore the fundamentals of Scheme programming, including functional programming, syntax, and language implementation. Build a Scheme interpreter in Haskell.                                                                                                                                                                                                                                                                                                  |\n|      60 | [Write Yourself a Scheme in 48 Hours](https://getvm.io/tutorials/write-yourself-a-scheme-in-48-hours)                                                                                                                | Technical Tutorials | Comprehensive guide to learning Scheme, with a focus on functional programming and hands-on practice within 48 hours.                                                                                                                                                                                                                                                                                                                                          |\n|      61 | [Compiler Design](https://getvm.io/tutorials/how-to-create-a-compiler)                                                                                                                                               | Technical Tutorials | Comprehensive guide to understanding compiler design and implementation, covering lexing, parsing, optimization, and code generation. Practical techniques for building compilers from scratch.                                                                                                                                                                                                                                                                |\n|      62 | [A journey explaining how to build a compiler from scratch](https://getvm.io/tutorials/a-journey-explaining-how-to-build-a-compiler-from-scratch)                                                                    | Technical Tutorials | Embark on a hands-on journey to build a compiler from scratch, covering lexical scanning, parsing, operator precedence, and assembly generation. Suitable for beginners and experienced developers.                                                                                                                                                                                                                                                            |\n|      63 | [Build Your Own Lisp: Learn C and build your own programming language in 1000 lines of code](https://getvm.io/tutorials/build-your-own-lisp-learn-c-and-build-your-own-programming-language-in-1000-lines-of-code)   | Technical Tutorials | Learn C programming and build your own programming language in just 1000 lines of code. Develop a real-world project and write beautiful code.                                                                                                                                                                                                                                                                                                                 |\n|      64 | [Write your own Operating System](https://getvm.io/tutorials/write-your-own-operating-system)                                                                                                                        | Technical Tutorials | Comprehensive guide to designing and implementing an operating system from scratch. Covers fundamental concepts in computer science and programming with a hands-on approach.                                                                                                                                                                                                                                                                                  |\n|      65 | [Python for Beginners](https://getvm.io/tutorials/python-tutorial-python-for-beginners-full-course)                                                                                                                  | Video Courses       | Learn Python programming from scratch with this in-depth course. Build real-world projects and automate repetitive tasks. Ideal for complete beginners.                                                                                                                                                                                                                                                                                                        |\n|      66 | [Python Programming From Scratch With Practicals](https://getvm.io/tutorials/python-programming-from-scratch-with-practicals)                                                                                        | Video Courses       | Comprehensive guide to learning Python programming from the basics to practical applications, including problem-solving, programming constructs, and fundamental concepts.                                                                                                                                                                                                                                                                                     |\n|      67 | [Python Learn Course](https://getvm.io/tutorials/python-learn-course)                                                                                                                                                | Video Courses       | Comprehensive Python programming course for beginners, covering syntax, variables, functions, data structures, and more. Build a strong foundation in Python.                                                                                                                                                                                                                                                                                                  |\n|      68 | [Python Course From Scratch](https://getvm.io/tutorials/python-course-from-scratch)                                                                                                                                  | Video Courses       | Comprehensive Python course from scratch by experienced instructor Olaf Paulson. Learn essential programming concepts and Python language features.                                                                                                                                                                                                                                                                                                            |\n|      69 | [Learn Python For Free](https://getvm.io/tutorials/learn-python-for-free)                                                                                                                                            | Video Courses       | Comprehensive guide to learning Python programming language, covering fundamental concepts, practical examples, and exercises for beginners.                                                                                                                                                                                                                                                                                                                   |\n|      70 | [Learn Lua Programming](https://getvm.io/tutorials/learn-lua-in-15-minutes)                                                                                                                                          | Video Courses       | Dive into the Lua programming language with this concise 15-minute tutorial, perfect for beginners looking to quickly grasp the fundamentals.                                                                                                                                                                                                                                                                                                                  |\n|      71 | [Learn Java Programming](https://getvm.io/tutorials/learn-java-programming-java-for-testers-and-developers)                                                                                                          | Video Courses       | Comprehensive Java programming course covering fundamentals and advanced concepts. Suitable for beginners and experienced developers. Hands-on exercises and real-world applications.                                                                                                                                                                                                                                                                          |\n|      72 | [Java Tutorial for Complete Beginners](https://getvm.io/tutorials/java-tutorial-for-complete-beginners)                                                                                                              | Video Courses       | Learn Java programming from scratch with this comprehensive beginner's course. Covers the fundamentals of Java language with step-by-step guidance.                                                                                                                                                                                                                                                                                                            |\n|      73 | [Java Programming](https://getvm.io/tutorials/java-programming)                                                                                                                                                      | Video Courses       | Comprehensive Java Programming course by Angie Jones, a certified Java Programmer with 18+ years of experience. Suitable for complete beginners, covers Java language in-depth with relatable examples.                                                                                                                                                                                                                                                        |\n|      74 | [Game Development](https://getvm.io/tutorials/cs50s-introduction-to-game-development)                                                                                                                                | Video Courses       | Dive into the fundamentals of game design and development with CS50's comprehensive course. Learn 2D/3D graphics, animation, sound, and more.                                                                                                                                                                                                                                                                                                                  |\n|      75 | [Game Development](https://getvm.io/tutorials/cs50-2019-games-track)                                                                                                                                                 | Video Courses       | Comprehensive course on game development, covering programming, design, and implementation. Taught by David J. Malan.                                                                                                                                                                                                                                                                                                                                          |\n|      76 | [Essential Dart](https://getvm.io/tutorials/essential-dart)                                                                                                                                                          | Video Courses       | Comprehensive guide to the Dart programming language, covering essential concepts for programming and development. Authored by an experienced Dart programmer.                                                                                                                                                                                                                                                                                                 |\n|      77 | [Design of Computer Programs](https://getvm.io/tutorials/design-of-computer-programs)                                                                                                                                | Video Courses       | Explore the principles and techniques for designing effective computer programs, including algorithm design, problem-solving, and software engineering practices.                                                                                                                                                                                                                                                                                              |\n|      78 | [CS50's Introduction To Computer Science](https://getvm.io/tutorials/cs50s-introduction-to-computer-science)                                                                                                         | Video Courses       | Comprehensive introduction to computer science covering programming, algorithms, and computational thinking. Taught by renowned Harvard professor David J. Malan.                                                                                                                                                                                                                                                                                              |\n|      79 | [C++ Tutorial for Beginners](https://getvm.io/tutorials/c-tutorial-for-beginners-full-course)                                                                                                                        | Video Courses       | Learn C++ from the basics, including setting up the development environment, writing your first program, and working with variables and data. Dive into advanced programming structures and develop a solid understanding of core programming concepts.                                                                                                                                                                                                        |\n|      80 | [C++ Programming Course](https://getvm.io/tutorials/c-programming-course-beginner-to-advanced)                                                                                                                       | Video Courses       | Comprehensive C++ programming course from beginner to advanced level, taught by an experienced instructor. Includes hands-on coding exercises and projects.                                                                                                                                                                                                                                                                                                    |\n|      81 | [C++ For Programmers 1](https://getvm.io/tutorials/c-for-programmers-1)                                                                                                                                              | Video Courses       | Learn C++ programming with practical projects and hands-on experience. Designed for developers with prior programming knowledge.                                                                                                                                                                                                                                                                                                                               |\n|      82 | [C Programming Tutorial](https://getvm.io/tutorials/c-programming-tutorial-for-beginners)                                                                                                                            | Video Courses       | Comprehensive C Programming Tutorial for Beginners. Learn the fundamentals of C language, from basic syntax to advanced concepts. Ideal for aspiring developers.                                                                                                                                                                                                                                                                                               |\n|      83 | [C Programming 2021: Master The Basics!](https://getvm.io/tutorials/c-programming-2021-master-the-basics)                                                                                                            | Video Courses       | Comprehensive guide to learning C programming, covering fundamentals and essential concepts for mastering the basics of programming in C.                                                                                                                                                                                                                                                                                                                      |\n|      84 | [Scratch Programming Playground](https://getvm.io/tutorials/scratch-programming-playground)                                                                                                                          | Technical Tutorials | A comprehensive guide to learning computer programming through the Scratch platform, focusing on creating interactive games and projects. Ideal for kids and beginners.                                                                                                                                                                                                                                                                                        |\n|      85 | [Learn to Code with Scratch](https://getvm.io/tutorials/learn-to-code-with-scratch)                                                                                                                                  | Technical Tutorials | Learn to code with Scratch, a beginner-friendly programming language. Create animations, interactive elements, and your first games and applications with step-by-step guidance.                                                                                                                                                                                                                                                                               |\n|      86 | [The Rust Programming Language](https://getvm.io/tutorials/the-rust-programming-language)                                                                                                                            | Technical Tutorials | Discover the power of the Rust programming language with this comprehensive guide covering memory safety, concurrency, and performance. Ideal for software developers and programming enthusiasts.                                                                                                                                                                                                                                                             |\n|      87 | [Learning Rust Ebook](https://getvm.io/tutorials/learning-rust-ebook)                                                                                                                                                | Technical Tutorials | Comprehensive Rust programming language ebook covering core features, error handling, concurrency, and more. Valuable for beginner and intermediate Rust developers.                                                                                                                                                                                                                                                                                           |\n|      88 | [Easy Rust](https://getvm.io/tutorials/easy-rust)                                                                                                                                                                    | Technical Tutorials | Learn Rust programming with Easy Rust, a comprehensive and approachable guide covering syntax, concepts, and advanced topics. Ideal for beginners.                                                                                                                                                                                                                                                                                                             |\n|      89 | [Using Blocks in Ruby](https://getvm.io/tutorials/using-blocks-in-ruby)                                                                                                                                              | Technical Tutorials | Explore the usage of blocks and functions in Ruby programming with this insightful book by Jay McGavren. Valuable resource for Ruby developers and programmers.                                                                                                                                                                                                                                                                                                |\n|      90 | [Ruby Notes for Professionals](https://getvm.io/tutorials/ruby-notes-for-professionals)                                                                                                                              | Technical Tutorials | Comprehensive guide to Ruby programming, covering syntax, concepts, and practical examples from StackOverflow Documentation. Ideal for beginners and experienced developers.                                                                                                                                                                                                                                                                                   |\n|      91 | [Ruby Best Practices](https://getvm.io/tutorials/ruby-best-practices)                                                                                                                                                | Technical Tutorials | Comprehensive guide to writing clean, efficient, and maintainable Ruby code. Covers essential programming practices, design patterns, and development strategies for Ruby developers.                                                                                                                                                                                                                                                                          |\n|      92 | [The Python Handbook](https://getvm.io/tutorials/the-python-handbook)                                                                                                                                                | Technical Tutorials | The Python Handbook by Flavio Copes is a comprehensive guide to Python programming, covering syntax, data structures, and best practices. Suitable for beginners and experienced developers.                                                                                                                                                                                                                                                                   |\n|      93 | [The Python Coding Book](https://getvm.io/tutorials/the-python-coding-book)                                                                                                                                          | Technical Tutorials | Comprehensive guide to Python programming, covering data structures, algorithms, and software development. Focuses on real understanding of programming concepts.                                                                                                                                                                                                                                                                                              |\n|      94 | [The Coders Apprentice: Learning Programming with Python 3](https://getvm.io/tutorials/the-coders-apprentice-learning-programming-with-python-3)                                                                     | Technical Tutorials | Learn Python 3 programming from scratch with The Coder's Apprentice, a beginner-friendly book that covers coding concepts and language basics through hands-on exercises.                                                                                                                                                                                                                                                                                      |\n|      95 | [Python Tutorial](https://getvm.io/tutorials/python-tutorial)                                                                                                                                                        | Technical Tutorials | Comprehensive Python tutorial covering basic to advanced concepts, suitable for beginners to become software engineers. Learn Python's applications in ML, AI, web development, and more.                                                                                                                                                                                                                                                                      |\n|      96 | [Python Programming Exercises, Gently Explained](https://getvm.io/tutorials/python-programming-exercises-gently-explained)                                                                                           | Technical Tutorials | Comprehensive Python programming course with practical exercises and step-by-step guidance for beginners.                                                                                                                                                                                                                                                                                                                                                      |\n|      97 | [Python Programming](https://getvm.io/tutorials/python-programming)                                                                                                                                                  | Technical Tutorials | Comprehensive Python Programming book covering Python 3.x and 2.x, with information on different Python implementations. Suitable for beginners to experienced developers.                                                                                                                                                                                                                                                                                     |\n|      98 | [Python Notes for Professionals](https://getvm.io/tutorials/python-notes-for-professionals)                                                                                                                          | Technical Tutorials | Comprehensive Python programming guide covering data types, web development, parallel computing and more. Practical examples and code snippets for learners and professionals.                                                                                                                                                                                                                                                                                 |\n|      99 | [Python 101](https://getvm.io/tutorials/python-101)                                                                                                                                                                  | Technical Tutorials | Discover the fundamentals of Python programming with Python 101, a beginner-friendly book covering Python 3 from start to finish.                                                                                                                                                                                                                                                                                                                              |\n|     100 | [Pro Python Advanced coding techniques and tools](https://getvm.io/tutorials/pro-python-advanced-coding-techniques-and-tools)                                                                                        | Technical Tutorials | Comprehensive guide to advanced Python programming, covering techniques, tools, and best practices for experienced developers.                                                                                                                                                                                                                                                                                                                                 |\n|     101 | [Practical Programming in Python](https://getvm.io/tutorials/practical-programming-in-python)                                                                                                                        | Technical Tutorials | Learn Python programming with a focus on practical applications and problem-solving. Suitable for beginners and intermediate programmers.                                                                                                                                                                                                                                                                                                                      |\n|     102 | [Non-Programmers Tutorial for Python 3](https://getvm.io/tutorials/non-programmers-tutorial-for-python-3)                                                                                                            | Technical Tutorials | Learn Python 3 programming from scratch with this beginner-friendly guide. Covers fundamental concepts, syntax, and practical examples for hands-on learning.                                                                                                                                                                                                                                                                                                  |\n|     103 | [Learn Python Programming, Second Edition](https://getvm.io/tutorials/learn-python-programming-second-edition)                                                                                                       | Technical Tutorials | Comprehensive introduction to Python programming for beginners and those with some coding experience. Covers Python's characteristics, ecosystem, and fundamental programming concepts.                                                                                                                                                                                                                                                                        |\n|     104 | [Learn Python in Y minutes](https://getvm.io/tutorials/learn-python-in-y-minutes)                                                                                                                                    | Technical Tutorials | Quickly learn the fundamentals of Python programming with this concise and easy-to-understand introduction to the language. Ideal for beginners looking to start coding.                                                                                                                                                                                                                                                                                       |\n|     105 | [Introduction to Python](https://getvm.io/tutorials/introduction-to-python)                                                                                                                                          | Technical Tutorials | Comprehensive Python course for beginners, covering fundamentals like variables, data structures, and programming concepts. Hands-on coding and practical examples make it easy to start writing Python.                                                                                                                                                                                                                                                       |\n|     106 | [Introduction to Programming Using Python](https://getvm.io/tutorials/introduction-to-programming-using-python)                                                                                                      | Technical Tutorials | Comprehensive Python programming course for beginners, covering the fundamentals of Python syntax and concepts with hands-on exercises and examples.                                                                                                                                                                                                                                                                                                           |\n|     107 | [Intermediate Python](https://getvm.io/tutorials/intermediate-python)                                                                                                                                                | Technical Tutorials | Comprehensive guide to intermediate-level Python programming, covering advanced topics and techniques for Python development. Suitable for beginners, intermediate, and advanced programmers.                                                                                                                                                                                                                                                                  |\n|     108 | [Learn Python 3 Programming](https://getvm.io/tutorials/how-to-code-in-python-3)                                                                                                                                     | Technical Tutorials | Comprehensive Python 3 programming course for beginners, covering fundamentals, hands-on examples, and object-oriented programming.                                                                                                                                                                                                                                                                                                                            |\n|     109 | [Fundamentals of  Python Programming](https://getvm.io/tutorials/fundamentals-of-python-programming)                                                                                                                 | Technical Tutorials | Master the fundamentals of Python programming and build a strong foundation in coding. Ideal for beginners, this course covers essential concepts and practical applications.                                                                                                                                                                                                                                                                                  |\n|     110 | [Dive Into Python 3](https://getvm.io/tutorials/dive-into-python-3)                                                                                                                                                  | Technical Tutorials | Dive into Python 3 is a comprehensive guide to Python 3 programming, covering a wide range of topics from basic syntax to advanced features. Ideal for beginners and experienced programmers.                                                                                                                                                                                                                                                                  |\n|     111 | [Building Skills in Python](https://getvm.io/tutorials/building-skills-in-python)                                                                                                                                    | Technical Tutorials | Comprehensive Python programming course covering syntax, techniques, and practical examples to build strong Python foundations.                                                                                                                                                                                                                                                                                                                                |\n|     112 | [Beyond the Basic Stuff with Python](https://getvm.io/tutorials/beyond-the-basic-stuff-with-python)                                                                                                                  | Technical Tutorials | Comprehensive guide to intermediate Python topics and programming techniques, offering deeper understanding of Python development.                                                                                                                                                                                                                                                                                                                             |\n|     113 | [Beejs Guide to Python Programming - For Beginners](https://getvm.io/tutorials/beejs-guide-to-python-programming-for-beginners)                                                                                      | Technical Tutorials | Comprehensive guide on Python Programming for Absolute Beginners, covering a wide range of topics and providing valuable resources.                                                                                                                                                                                                                                                                                                                            |\n|     114 | [A Practical Introduction to Python Programming](https://getvm.io/tutorials/a-practical-introduction-to-python-programming)                                                                                          | Technical Tutorials | Comprehensive Python programming guide covering basics to advanced topics, with hands-on examples and exercises for efficient learning.                                                                                                                                                                                                                                                                                                                        |\n|     115 | [PHP Handbook](https://getvm.io/tutorials/php-handbook)                                                                                                                                                              | Technical Tutorials | Comprehensive PHP programming guide by Flavio Copes, covering a wide range of topics and available for free as part of a collection of 16 books.                                                                                                                                                                                                                                                                                                               |\n|     116 | [Perl Notes for Professionals](https://getvm.io/tutorials/perl-notes-for-professionals)                                                                                                                              | Technical Tutorials | Comprehensive Perl programming guide covering syntax, data structures, OOP, and more. Compiled from StackOverflow, a must-have resource for Perl developers.                                                                                                                                                                                                                                                                                                   |\n|     117 | [Higher-Order Perl](https://getvm.io/tutorials/higher-order-perl)                                                                                                                                                    | Technical Tutorials | Comprehensive guide to advanced and higher-order programming techniques in Perl, covering recursion, callbacks, dispatch tables, caching, memoization, and more.                                                                                                                                                                                                                                                                                               |\n|     118 | [Learn Markdown](https://getvm.io/tutorials/learn-markdown)                                                                                                                                                          | Technical Tutorials | Comprehensive guide to learning Markdown, create engaging, interactive content for teams and projects. Improve your technical documentation skills.                                                                                                                                                                                                                                                                                                            |\n|     119 | [Comprehensive Lua Tutorial](https://getvm.io/tutorials/lua-tutorial)                                                                                                                                                | Technical Tutorials | Learn Lua programming from basics to advanced with this comprehensive tutorial. Suitable for beginners and experienced developers alike.                                                                                                                                                                                                                                                                                                                       |\n|     120 | [Comprehensive Lua Programming](https://getvm.io/tutorials/learning-lua-ebook)                                                                                                                                       | Technical Tutorials | Dive into Lua programming and scripting with this comprehensive guide, suitable for beginners and experienced developers alike.                                                                                                                                                                                                                                                                                                                                |\n|     121 | [Notes On Programming in TeX](https://getvm.io/tutorials/notes-on-programming-in-tex)                                                                                                                                | Technical Tutorials | Comprehensive guide covering TeX programming, including variables, arithmetic, expansion control, and more. Suitable for beginners and experienced TeX programmers.                                                                                                                                                                                                                                                                                            |\n|     122 | [LaTex Notes for Professionals](https://getvm.io/tutorials/latex-notes-for-professionals)                                                                                                                            | Technical Tutorials | Comprehensive guide to the LaTeX typesetting system, covering a wide range of topics from basic formatting to advanced features. Compiled from the Stack Overflow Documentation.                                                                                                                                                                                                                                                                               |\n|     123 | [Kotlin Quick Reference](https://getvm.io/tutorials/kotlin-quick-reference)                                                                                                                                          | Technical Tutorials | Kotlin Quick Reference is a concise guide that provides a fast reference to the Kotlin programming language, covering syntax and features with examples for developers.                                                                                                                                                                                                                                                                                        |\n|     124 | [Julia language: a concise tutorial](https://getvm.io/tutorials/julia-language-a-concise-tutorial)                                                                                                                   | Technical Tutorials | A comprehensive and regularly updated tutorial on the Julia programming language, perfect for beginners looking to start coding in Julia.                                                                                                                                                                                                                                                                                                                      |\n|     125 | [Julia By Example](https://getvm.io/tutorials/julia-by-example)                                                                                                                                                      | Technical Tutorials | Learn the Julia programming language with practical examples and tutorials. Suitable for both beginners and experienced programmers interested in Julia.                                                                                                                                                                                                                                                                                                       |\n|     126 | [The Code Challenge Book](https://getvm.io/tutorials/the-code-challenge-book)                                                                                                                                        | Technical Tutorials | Comprehensive guide to coding, programming, and algorithms. Prepare for coding bootcamps and technical interviews with problem-solving techniques and algorithm analysis skills.                                                                                                                                                                                                                                                                               |\n|     127 | [JavaScript Challenges Book](https://getvm.io/tutorials/javascript-challenges-book)                                                                                                                                  | Technical Tutorials | Dive deep into JavaScript with this challenging book filled with practical exercises and exercises to improve your programming skills.                                                                                                                                                                                                                                                                                                                         |\n|     128 | [Introduction to Programming Using Java (5th Edition - final version, 2010 Jun)](https://getvm.io/tutorials/introduction-to-programming-using-java-5th-edition-final-version-2010-jun)                               | Technical Tutorials | Comprehensive Java programming introduction covering fundamental concepts and practical applications in computer science. Includes Java 5.0 and later versions, with downloadable formats.                                                                                                                                                                                                                                                                     |\n|     129 | [The Haskell Road to Logic, Math and Programming](https://getvm.io/tutorials/the-haskell-road-to-logic-math-and-programming)                                                                                         | Technical Tutorials | Explore the intersection of programming, logic, and mathematics with The Haskell Road to Logic, Math and Programming - an excellent resource for beginners and experienced programmers.                                                                                                                                                                                                                                                                        |\n|     130 | [Gradle User Guide](https://getvm.io/tutorials/gradle-user-guide)                                                                                                                                                    | Technical Tutorials | Comprehensive documentation and tutorials on Gradle, a powerful build automation tool for JVM, Android, and Kotlin Multi-Platform projects.                                                                                                                                                                                                                                                                                                                    |\n|     131 | [The Little Go Book](https://getvm.io/tutorials/the-little-go-book)                                                                                                                                                  | Technical Tutorials | Discover the power of Google's Go programming language with The Little Go Book, a concise and beginner-friendly guide written by an experienced author.                                                                                                                                                                                                                                                                                                        |\n|     132 | [How To Code In Go](https://getvm.io/tutorials/how-to-code-in-go)                                                                                                                                                    | Technical Tutorials | Comprehensive guide to learning the Go programming language, authored by experienced Go developers. Covers basic syntax to advanced concepts.                                                                                                                                                                                                                                                                                                                  |\n|     133 | [Go Programming](https://getvm.io/tutorials/go-tutorial)                                                                                                                                                             | Technical Tutorials | Learn Go programming language from scratch with this comprehensive tutorial by Tutorials Point. Covers syntax, features, and standard library for software developers.                                                                                                                                                                                                                                                                                         |\n|     134 | [Go Handbook](https://getvm.io/tutorials/go-handbook)                                                                                                                                                                | Technical Tutorials | A comprehensive guide to the Go programming language, covering essential concepts, best practices, and practical examples for software developers.                                                                                                                                                                                                                                                                                                             |\n|     135 | [Essentials of Go Programming](https://getvm.io/tutorials/essentials-of-go-programming)                                                                                                                              | Technical Tutorials | Comprehensive guide to learning the Go programming language, covering fundamental concepts, best practices, and practical examples for software development.                                                                                                                                                                                                                                                                                                   |\n|     136 | [Modern Fortran Tutorial](https://getvm.io/tutorials/modern-fortran-tutorial)                                                                                                                                        | Technical Tutorials | Comprehensive tutorial on modern Fortran programming, covering basics, advanced concepts, and practical programming techniques. Suitable for beginners and experienced developers.                                                                                                                                                                                                                                                                             |\n|     137 | [Hands-on Elixir \u0026 OTP: Cryptocurrency trading bot](https://getvm.io/tutorials/hands-on-elixir-otp-cryptocurrency-trading-bot)                                                                                       | Technical Tutorials | Learn how to build a cryptocurrency trading bot using Elixir and OTP. Gain practical experience in designing process supervision trees and leveraging Elixir's parallelization capabilities.                                                                                                                                                                                                                                                                   |\n|     138 | [Expert Delphi](https://getvm.io/tutorials/expert-delphi)                                                                                                                                                            | Technical Tutorials | Comprehensive guide to mastering Delphi programming and software development, authored by Pawe_ G_owacki. Covers Delphi platform features and capabilities.                                                                                                                                                                                                                                                                                                    |\n|     139 | [The Rook's Guide to C++: Beginner's Programming Manual](https://getvm.io/tutorials/the-rooks-guide-to-c)                                                                                                            | Technical Tutorials | Dive into the world of C++ programming with The Rook's Guide, a comprehensive beginner's guide that covers the basics with practical examples and clear explanations.                                                                                                                                                                                                                                                                                          |\n|     140 | [Learn C++ Programming Language](https://getvm.io/tutorials/learn-c-programming-language)                                                                                                                            | Technical Tutorials | Comprehensive C++ programming language tutorial for beginners. Covers basic to advanced concepts, runs on various platforms, and is an ideal choice to expand your coding skills.                                                                                                                                                                                                                                                                              |\n|     141 | [Fundamentals of C++ Programming](https://getvm.io/tutorials/fundamentals-of-c-programming)                                                                                                                          | Technical Tutorials | Comprehensive guide to the C++ programming language, covering core concepts and features. Suitable for beginners and experienced programmers.                                                                                                                                                           ","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgetvmio%2Ffree-programming-resources","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgetvmio%2Ffree-programming-resources","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgetvmio%2Ffree-programming-resources/lists"}