{"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,"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.                                                                                                                                                                                                                                                                                                                  |\n|     142 | [The New C Standard - An Economic and Cultural commentary (2009)](https://getvm.io/tutorials/the-new-c-standard-an-economic-and-cultural-commentary-2009)                                                            | Technical Tutorials | Comprehensive analysis of the C programming language, covering its history, evolution, and cultural impact. Invaluable resource for C developers of all levels.                                                                                                                                                                                                                                                                                                |\n|     143 | [The C Programming Language Handbook](https://getvm.io/tutorials/the-c-programming-language-handbook)                                                                                                                | Technical Tutorials | Comprehensive guide to learning and mastering the C programming language, covering key concepts, syntax, and best practices for writing efficient C code.                                                                                                                                                                                                                                                                                                      |\n|     144 | [The C Book](https://getvm.io/tutorials/the-c-book)                                                                                                                                                                  | Technical Tutorials | The C Book is a comprehensive guide to C programming, covering language syntax, software development, and programming techniques. Highly recommended for beginners and experienced programmers.                                                                                                                                                                                                                                                                |\n|     145 | [The Basics of C Programming](https://getvm.io/tutorials/the-basics-of-c-programming)                                                                                                                                | Technical Tutorials | Comprehensive introduction to C programming for beginners and intermediate learners, covering essential topics like data types, control structures, and functions.                                                                                                                                                                                                                                                                                             |\n|     146 | [Essential C](https://getvm.io/tutorials/essential-c)                                                                                                                                                                | Technical Tutorials | Comprehensive guide to learning the essentials of C programming, including concepts, syntax, and best practices. Ideal for software developers and programming enthusiasts.                                                                                                                                                                                                                                                                                    |\n|     147 | [C Notes for Professionals](https://getvm.io/tutorials/c-notes-for-professionals)                                                                                                                                    | Technical Tutorials | Comprehensive C programming guide from StackOverflow Documentation, covering essential topics for beginners and experienced developers.                                                                                                                                                                                                                                                                                                                        |\n|     148 | [Beejs Guide to C Programming](https://getvm.io/tutorials/beejs-guide-to-c-programming)                                                                                                                              | Technical Tutorials | Comprehensive and beginner-friendly guide to learning C programming, covering fundamentals, best practices, and efficient coding techniques.                                                                                                                                                                                                                                                                                                                   |\n|     149 | [Conquer The Command Line](https://getvm.io/tutorials/conquer-the-command-line)                                                                                                                                      | Technical Tutorials | Comprehensive guide to mastering the command line interface, covering Linux, programming, and system administration. Hands-on experience and practical examples.                                                                                                                                                                                                                                                                                               |\n|     150 | [Web API Design](https://getvm.io/tutorials/web-api-design)                                                                                                                                                          | Technical Tutorials | Explore proven design principles and best practices for crafting Web APIs that developers will love. Covers naming conventions, error handling, versioning, and more.                                                                                                                                                                                                                                                                                          |\n|     151 | [Code Simplicity: The Fundamentals of Software](https://getvm.io/tutorials/code-simplicity-the-fundamentals-of-software)                                                                                             | Technical Tutorials | Comprehensive guide to software engineering, focusing on simplicity and efficiency in code development. Valuable resource for developers and engineers.                                                                                                                                                                                                                                                                                                        |\n|     152 | [Solr for newbies workshop (2019)](https://getvm.io/tutorials/solr-for-newbies-workshop-2019)                                                                                                                        | Technical Tutorials | Hands-on tutorial on Solr, a popular open-source search platform, suitable for beginners looking to get started with Solr's core concepts and functionality.                                                                                                                                                                                                                                                                                                   |\n|     153 | [Structure and Interpretation of Computer Programs 246](https://getvm.io/tutorials/structure-and-interpretation-of-computer-programs-246)                                                                            | Technical Tutorials | Comprehensive introduction to computer science and programming, covering essential algorithms and data structures. Developed by MIT faculty, highly recommended for beginners and experienced programmers.                                                                                                                                                                                                                                                     |\n|     154 | [UNIX Application and System Programming, lecture notes](https://getvm.io/tutorials/unix-application-and-system-programming-lecture-notes)                                                                           | Technical Tutorials | Comprehensive lecture notes on Unix application and system programming, covering key concepts and providing a thorough introduction to the topic.                                                                                                                                                                                                                                                                                                              |\n|     155 | [The Art of Unix Programming](https://getvm.io/tutorials/the-art-of-unix-programming)                                                                                                                                | Technical Tutorials | Comprehensive guide to Unix programming and open source principles, covering Unix history, key concepts, and techniques for developers and programmers.                                                                                                                                                                                                                                                                                                        |\n|     156 | [OOP _ Learn Object Oriented Thinking and Programming](https://getvm.io/tutorials/oop-learn-object-oriented-thinking-and-programming)                                                                                | Technical Tutorials | Dive into the world of object-oriented programming with this comprehensive guide by experienced author Rudolf Pecinovský. Includes detailed concepts, practical examples, and downloadable PDF.                                                                                                                                                                                                                                                                |\n|     157 | [Object Oriented Programming](https://getvm.io/tutorials/object-oriented-programming)                                                                                                                                | Technical Tutorials | Dive into the fundamentals of Object-Oriented Programming with this comprehensive course, covering key concepts like encapsulation, inheritance, and polymorphism.                                                                                                                                                                                                                                                                                             |\n|     158 | [Networking! ACK!](https://getvm.io/tutorials/networking-ack)                                                                                                                                                        | Technical Tutorials | Explore networking fundamentals like TCP/IP, DNS, and routing in a fun, comic-style format. Suitable for beginners and experienced programmers.                                                                                                                                                                                                                                                                                                                |\n|     159 | [Kafka: The Definitive Guide](https://getvm.io/tutorials/kafka-the-definitive-guide)                                                                                                                                 | Technical Tutorials | Comprehensive guide to Apache Kafka, covering data streaming, big data, and real-time processing applications. Authored by industry expert Neha Narkhede.                                                                                                                                                                                                                                                                                                      |\n|     160 | [Beejs Guide to Network Programming - Using Internet Sockets](https://getvm.io/tutorials/beejs-guide-to-network-programming-using-internet-sockets)                                                                  | Technical Tutorials | Comprehensive guide to network programming, focusing on the use of internet sockets. Written by experienced author Brian \"Beej Jorgensen\" Hall, offering in-depth coverage and practical examples.                                                                                                                                                                                                                                                             |\n|     161 | [Pointers And Memory](https://getvm.io/tutorials/pointers-and-memory)                                                                                                                                                | Technical Tutorials | Comprehensive guide to understanding pointers, memory allocation, and optimization techniques for computer science students and software developers.                                                                                                                                                                                                                                                                                                           |\n|     162 | [Foundations of Programming](https://getvm.io/tutorials/foundations-of-programming)                                                                                                                                  | Technical Tutorials | Comprehensive guide to the core principles of programming, including algorithms, data structures, and software development best practices. Suitable for beginners and experienced developers.                                                                                                                                                                                                                                                                  |\n|     163 | [The Craft of Text Editing or A Cookbook for an Emacs](https://getvm.io/tutorials/the-craft-of-text-editing-or-a-cookbook-for-an-emacs)                                                                              | Technical Tutorials | Comprehensive guide to text editing and Emacs, offering practical insights and techniques for software development and programming.                                                                                                                                                                                                                                                                                                                            |\n|     164 | [Comprehensive Guide to GNU Emacs](https://getvm.io/tutorials/gnu-emacs-manual)                                                                                                                                      | Technical Tutorials | The GNU Emacs Manual is a comprehensive guide to the powerful GNU Emacs text editor, covering features, customization, and programming. Authored by the Free Software Foundation, it's an essential resource for Emacs users and developers.                                                                                                                                                                                                                   |\n|     165 | [CI/CD for Monorepos: Effectively building, testing, and deploying code with monorepos](https://getvm.io/tutorials/ci-cd-for-monorepos-effectively-building-testing-and-deploying-code-with-monorepos)               | Technical Tutorials | Comprehensive guide to effectively building, testing, and deploying code with monorepos using CI/CD practices. Optimize productivity, reliability, and scalability for monorepo-based projects.                                                                                                                                                                                                                                                                |\n|     166 | [Let's Build a Compiler](https://getvm.io/tutorials/lets-build-a-compiler)                                                                                                                                           | Technical Tutorials | Comprehensive guide to understanding and building compilers, covering parsing, code generation, and language implementation. Practical insights for beginners and experienced programmers.                                                                                                                                                                                                                                                                     |\n|     167 | [Introduction to Compilers and Language Design](https://getvm.io/tutorials/introduction-to-compilers-and-language-design)                                                                                            | Technical Tutorials | Comprehensive course on compiler design principles and techniques, including scanning, parsing, semantic analysis, code generation, and optimization. Hands-on experience in building a complete compiler.                                                                                                                                                                                                                                                     |\n|     168 | [EXPL NITC: Build your own Compiler](https://getvm.io/tutorials/expl-nitc-build-your-own-compiler)                                                                                                                   | Technical Tutorials | Dive into the practical development of a compiler with the EXPL NITC: Build Your Own Compiler book. Gain hands-on experience in programming languages and compiler construction.                                                                                                                                                                                                                                                                               |\n|     169 | [Matters Computational: Ideas, Algorithms, Source Code](https://getvm.io/tutorials/matters-computational-ideas-algorithms-source-code)                                                                               | Technical Tutorials | Comprehensive book covering computational algorithms, source code, and programming concepts. Recommended for programmers and computer scientists.                                                                                                                                                                                                                                                                                                              |\n|     170 | [CS50 Labs](https://getvm.io/tutorials/cs50-labs)                                                                                                                                                                    | University Courses  | Explore the intellectual enterprises of computer science and the art of programming with CS50 Labs, Harvard University's renowned introduction to computer science for beginners and experienced learners alike.                                                                                                                                                                                                                                               |\n|     171 | [Python Tutorial For Beginners](https://getvm.io/tutorials/python-tutorial-for-beginners)                                                                                                                            | Video Courses       | Learn Python fundamentals, installation, and setup for beginners. Explore the interactive prompt, create and run your first Python script. Ideal for new programmers.                                                                                                                                                                                                                                                                                          |\n|     172 | [Learn Python Basics](https://getvm.io/tutorials/learn-python-basics)                                                                                                                                                | Technical Tutorials | Dive into the world of programming with Python, a beginner-friendly language. Explore its readability, versatility, and robust community support.                                                                                                                                                                                                                                                                                                              |\n|     173 | [C++ Language Tutorial](https://getvm.io/tutorials/c-language-tutorial)                                                                                                                                              | Technical Tutorials | Learn C++ programming from the ground up, including practical examples and the latest features. Ideal for beginners and experienced developers.                                                                                                                                                                                                                                                                                                                |\n|     174 | [Programming, Data Structures \u0026 Algorithms](https://getvm.io/tutorials/programming-data-structures-and-algorithms-iit-madras)                                                                                        | University Courses  | Comprehensive NPTEL course from IIT Madras covering programming, data structures, and algorithms. Develop strong coding and problem-solving skills.                                                                                                                                                                                                                                                                                                            |\n|     175 | [Data Structures](https://getvm.io/tutorials/data-structures-pepperdine-university)                                                                                                                                  | University Courses  | Comprehensive course on essential data structures, algorithms, and problem-solving techniques. Ideal for software engineers, computer scientists, and data professionals.                                                                                                                                                                                                                                                                                      |\n|     176 | [Introduction to Computer Graphics](https://getvm.io/tutorials/introduction-to-computer-graphics-iit-delhi)                                                                                                          | University Courses  | Comprehensive course on computer graphics principles and techniques, with hands-on projects and experienced faculty from IIT Delhi.                                                                                                                                                                                                                                                                                                                            |\n|     177 | [Software Engineering](https://getvm.io/tutorials/software-engineering-bauhaus-uni-weimar)                                                                                                                           | University Courses  | Comprehensive software engineering course covering object-oriented programming, best practices, development paradigms, and design patterns. Ideal for students and professionals seeking a solid foundation in building maintainable and reusable software.                                                                                                                                                                                                    |\n|     178 | [Software Architecture Design](https://getvm.io/tutorials/cs-411-software-architecture-design-bilkent-university)                                                                                                    | University Courses  | Comprehensive course on software architecture design, covering concepts, methods, and techniques for designing complex software systems.                                                                                                                                                                                                                                                                                                                       |\n|     179 | [Multiprocessor Synchronization](https://getvm.io/tutorials/cs176-multiprocessor-synchronization-brown-university)                                                                                                   | University Courses  | Explore the technical and practical aspects of blockchain technology, including consensus, distributed computing, smart contracts, and more in this comprehensive course at Brown University.                                                                                                                                                                                                                                                                  |\n|     180 | [Developing iPad Apps for Data Visualization](https://getvm.io/tutorials/developing-ipad-applications-for-visualization-and-insight-carnegie-mellon-university)                                                      | University Courses  | Learn to create interactive, data-driven iPad apps that communicate insights and drive decision-making. Developed by experienced instructors at Carnegie Mellon University.                                                                                                                                                                                                                                                                                    |\n|     181 | [Software Engineering](https://getvm.io/tutorials/cs-5150-software-engineering-fall-2014-cornell-university)                                                                                                         | University Courses  | Comprehensive software engineering course covering development processes, feasibility, requirements, design, and usability. Hands-on project experience and exposure to industry best practices.                                                                                                                                                                                                                                                               |\n|     182 | [The Beauty and Joy of Computing](https://getvm.io/tutorials/cs-10-the-beauty-and-joy-of-computing-spring-2015-dan-garcia-uc-berkeley-infocobuild)                                                                   | University Courses  | Explore the fundamental concepts and principles of computer science, including abstraction, design, recursion, and more. Suitable for both CS majors and non-majors.                                                                                                                                                                                                                                                                                           |\n|     183 | [Android Development](https://getvm.io/tutorials/csse490-android-development-rose-hulman-winter-2010-2011-dave-fisher)                                                                                               | University Courses  | Comprehensive introduction to Android development, covering fundamentals of building mobile apps. Hands-on experience, expert instruction, and university-level learning.                                                                                                                                                                                                                                                                                      |\n|     184 | [Object-Oriented Software Engineering](https://getvm.io/tutorials/oose-object-oriented-software-engineering-dr-tim-lethbridge)                                                                                       | University Courses  | Comprehensive overview of object-oriented software engineering principles, techniques, and methodologies. Practical, hands-on approach taught by renowned expert Dr. Tim Lethbridge.                                                                                                                                                                                                                                                                           |\n|     185 | [Intro to Computing](https://getvm.io/tutorials/cs-1301-intro-to-computing-gatech)                                                                                                                                   | University Courses  | Explore the fundamentals of computing and programming with Python in Georgia Tech's collaborative CS 1301 course, featuring hands-on activities and team-based learning.                                                                                                                                                                                                                                                                                       |\n|     186 | [Software Engineering](https://getvm.io/tutorials/cs-164-software-engineering-harvard)                                                                                                                               | University Courses  | Explore the fundamental principles and best practices of software engineering, including object-oriented programming, source control, and design patterns.                                                                                                                                                                                                                                                                                                     |\n|     187 | [Building Mobile Apps](https://getvm.io/tutorials/cs-s-76-building-mobile-applications-harvard)                                                                                                                      | University Courses  | Learn to develop mobile apps for iOS and Android platforms. Gain hands-on experience with popular frameworks and tools. Create innovative mobile applications.                                                                                                                                                                                                                                                                                                 |\n|     188 | [Introduction to Programming with R](https://getvm.io/tutorials/cs50r-introduction-to-programming-with-r)                                                                                                            | University Courses  | Explore the popular R language for data science and statistical computing. Learn to use RStudio, represent real-world data, and create visualizations.                                                                                                                                                                                                                                                                                                         |\n|     189 | [CS50's Understanding Technology](https://getvm.io/tutorials/cs50s-understanding-technology)                                                                                                                         | University Courses  | Explore the fundamental concepts and technologies that shape the digital world with CS50's Understanding Technology, a free online course from Harvard University.                                                                                                                                                                                                                                                                                             |\n|     190 | [System Analysis and Design](https://getvm.io/tutorials/system-analysis-and-design-iisc-bangalore)                                                                                                                   | University Courses  | Comprehensive understanding of system analysis and design principles, covering all stages of the system development life cycle.                                                                                                                                                                                                                                                                                                                                |\n|     191 | [Software Engineering](https://getvm.io/tutorials/software-engineering-iit-bombay)                                                                                                                                   | University Courses  | Comprehensive overview of software engineering principles, methods, and tools for developing reliable and efficient software systems.                                                                                                                                                                                                                                                                                                                          |\n|     192 | [Introduction to Problem Solving and Programming](https://getvm.io/tutorials/introduction-to-problem-solving-and-programming-iit-kanpur)                                                                             | University Courses  | Comprehensive Python programming course covering problem-solving, data types, control structures, functions, and object-oriented programming. Suitable for beginners with no prior experience.                                                                                                                                                                                                                                                                 |\n|     193 | [Introduction to Programming in C](https://getvm.io/tutorials/introduction-to-programming-in-c-iit-kanpur)                                                                                                           | University Courses  | Comprehensive C programming course from IIT Kanpur, suitable for beginners and experienced programmers. Develop strong programming foundations and problem-solving skills.                                                                                                                                                                                                                                                                                     |\n|     194 | [Programming in C++](https://getvm.io/tutorials/programming-in-c-iit-kharagpur)                                                                                                                                      | University Courses  | Comprehensive C++ programming course from IIT Kharagpur experts, covering core concepts, syntax, and hands-on projects to develop proficient programming skills.                                                                                                                                                                                                                                                                                               |\n|     195 | [Object-Oriented Analysis and Design](https://getvm.io/tutorials/object-oriented-analysis-and-design-iit-kharagpur)                                                                                                  | University Courses  | Comprehensive course on object-oriented analysis and design, covering essential concepts, UML, design patterns, and hands-on experience for software developers and engineers.                                                                                                                                                                                                                                                                                 |\n|     196 | [Software Testing](https://getvm.io/tutorials/software-testing-iit-kharagpur)                                                                                                                                        | University Courses  | Comprehensive software testing course from IIT Kharagpur covering techniques, methodologies, and best practices to improve software quality and reliability.                                                                                                                                                                                                                                                                                                   |\n|     197 | [Mobile Computing](https://getvm.io/tutorials/mobile-computing-iit-madras)                                                                                                                                           | University Courses  | Comprehensive coverage of mobile computing concepts and technologies, hands-on experience with mobile app development, and insights from experts at IIT Madras.                                                                                                                                                                                                                                                                                                |\n|     198 | [C++ for Java Programmers](https://getvm.io/tutorials/uw-madison-cs-368-c-for-java-programmers-fall-2020-by-michael-doescher)                                                                                        | University Courses  | Comprehensive C++ course designed for Java programmers, taught by experienced instructor Michael Doescher. Covers data types, control structures, functions, classes, and more.                                                                                                                                                                                                                                                                                |\n|     199 | [UW Madison CS 354](https://getvm.io/tutorials/uw-madison-cs-354-machine-organization-and-programming-spring-2020-2021-by-michael-doescher)                                                                          | University Courses  | Comprehensive course covering computer architecture, assembly language, and low-level programming. Gain in-depth understanding of how computers work at the hardware level.                                                                                                                                                                                                                                                                                    |\n|     200 | [Computational \u0026 Software Engineering](https://getvm.io/tutorials/cornell-ece-4960-computational-and-software-engineering-spring-2017-by-edwin-kan)                                                                  | University Courses  | Comprehensive course on algorithm design, data structures, and software development, taught by an experienced professor at Cornell University.                                                                                                                                                                                                                                                                                                                 |\n|     201 | [Introduction to Computer Science and Programming in Python](https://getvm.io/tutorials/60001-introduction-to-computer-science-and-programming-in-python-mit-ocw)                                                    | University Courses  | Explore fundamental computer science and programming concepts with this comprehensive MIT OpenCourseWare course on Python.                                                                                                                                                                                                                                                                                                                                     |\n|     202 | [Structure and Interpretation of Computer Programs](https://getvm.io/tutorials/6001-structure-and-interpretation-of-computer-programs-mit)                                                                           | University Courses  | Comprehensive introduction to computer programming fundamentals, problem-solving skills, and programming paradigms. Suitable for beginners and experienced learners.                                                                                                                                                                                                                                                                                           |\n|     203 | [Introduction to Computational Thinking](https://getvm.io/tutorials/introduction-to-computational-thinking-mit)                                                                                                      | University Courses  | Explore computational thinking and apply mathematical concepts to real-world problems with this interactive MIT online course.                                                                                                                                                                                                                                                                                                                                 |\n|     204 | [Electrical Engineering \u0026 Computer Science I](https://getvm.io/tutorials/601sc-introduction-to-electrical-engineering-and-computer-science-i-mit-ocw)                                                                | University Courses  | Explore the fundamentals of electrical engineering and computer science with MIT OpenCourseWare's comprehensive course. Develop programming skills and gain insights from expert instructors.                                                                                                                                                                                                                                                                  |\n|     205 | [Java](https://getvm.io/tutorials/cs3-design-in-computing-richard-buckland-unsw)                                                                                                                                     | University Courses  | Explore fundamental programming concepts in Java, object-oriented design principles, and algorithm design with this comprehensive course from UNSW's Richard Buckland.                                                                                                                                                                                                                                                                                         |\n|     206 | [Introduction to Parallel Programming for Scientists \u0026 Engineers](https://getvm.io/tutorials/uiuc-cs-420-ece-492-cse-402-introduction-to-parallel-programming-for-scientists-and-engineers-fall-2015-by-sanjay-kale) | University Courses  | Learn the fundamentals of parallel computing, including parallel architectures, programming models, and algorithms from an expert instructor. Suitable for beginners and experienced programmers.                                                                                                                                                                                                                                                              |\n|     207 | [Parallel Computing Course](https://getvm.io/tutorials/stanford-cme-213-introduction-to-parallel-computing-using-mpi-openmp-and-cuda-winter-2020-by-eric-darve)                                                      | University Courses  | Comprehensive introduction to parallel computing using MPI, OpenMP, and CUDA. Taught by an expert, with hands-on exercises and practical applications.                                                                                                                                                                                                                                                                                                         |\n|     208 | [Introduction to Programming with Arcade Games](https://getvm.io/tutorials/cmsc-150-introduction-to-programming-with-arcade-games-simpson-college)                                                                   | University Courses  | Learn to create your own arcade games with Python and Pygame. Covers programming fundamentals, game development techniques, and more.                                                                                                                                                                                                                                                                                                                          |\n|     209 | [Standard C++ Programming](https://getvm.io/tutorials/cs-106l-standard-c-programming)                                                                                                                                | University Courses  | Dive deeper into the modern C++ language with CS 106L, a companion course to CS106B/CS106X. Learn exciting features and practice with hands-on assignments.                                                                                                                                                                                                                                                                                                    |\n|     210 | [Programming Abstractions in C++](https://getvm.io/tutorials/cs-106x-programming-abstractions-in-c)                                                                                                                  | University Courses  | Learn the fundamentals of programming with C++ language, including data structures, algorithms, and object-oriented programming. Taught by experienced instructors at Stanford University.                                                                                                                                                                                                                                                                     |\n|     211 | [Developing Applications for iOS](https://getvm.io/tutorials/cs-193p-developing-applications-for-ios-stanford-university)                                                                                            | University Courses  | Comprehensive iOS development course from Stanford University, covering SwiftUI, hands-on projects, and expert instruction.                                                                                                                                                                                                                                                                                                                                    |\n|     212 | [Android App Development for Beginners](https://getvm.io/tutorials/android-app-development-for-beginners-playlist-thenewboston)                                                                                      | University Courses  | Comprehensive guide for beginners to learn Android app development, covering Java, Android Studio, UI design, and app deployment.                                                                                                                                                                                                                                                                                                                              |\n|     213 | [Android Application Development Tutorials](https://getvm.io/tutorials/android-application-development-tutorials-thenewboston)                                                                                       | University Courses  | Comprehensive Android app development tutorials covering layouts, activities, user interfaces, databases, services, and more. Taught by the popular YouTube instructor, thenewboston.                                                                                                                                                                                                                                                                          |\n|     214 | [Introduction to Functional Programming](https://getvm.io/tutorials/fp-101x-introduction-to-functional-programming-tu-delft)                                                                                         | University Courses  | Learn the fundamentals of functional programming and the Haskell language with this comprehensive course from TU Delft Open CourseWare.                                                                                                                                                                                                                                                                                                                        |\n|     215 | [Structure \u0026 Interpretation of Computer Programs](https://getvm.io/tutorials/cs-61a-structure-and-interpretation-of-computer-programs)                                                                               | University Courses  | Discover the fundamental concepts of computer programming with CS 61A, covering Python, functions, control structures, and more. Ideal for beginners and experienced learners.                                                                                                                                                                                                                                                                                 |\n|     216 | [Software Engineering](https://getvm.io/tutorials/computer-science-169-software-engineering-spring-2015-ucberkeley)                                                                                                  | University Courses  | Comprehensive software engineering course covering design, testing, and project management. Hands-on projects and case studies for building high-quality software systems.                                                                                                                                                                                                                                                                                     |\n|     217 | [Software Engineering](https://getvm.io/tutorials/computer-science-169-software-engineering-fall-2019-ucberkeley)                                                                                                    | University Courses  | Comprehensive software engineering course covering design, testing, project management, and teamwork. Hands-on projects and industry-standard tools.                                                                                                                                                                                                                                                                                                           |\n|     218 | [CS 101](https://getvm.io/tutorials/cs-101-introduction-to-computer-science-udacity)                                                                                                                                 | University Courses  | Comprehensive online course covering fundamental computer science concepts, including algorithms, data structures, and programming languages. Taught by experienced Udacity instructors.                                                                                                                                                                                                                                                                       |\n|     219 | [Software Testing - Udacity](https://getvm.io/tutorials/software-testing-udacity-course-cs258-2015)                                                                                                                  | University Courses  | Dive into the fundamentals of software testing, including unit, integration, and end-to-end testing. Learn test-driven development and automated testing with JUnit and Selenium.                                                                                                                                                                                                                                                                              |\n|     220 | [Software Debugging - Udacity](https://getvm.io/tutorials/software-debugging-udacity-course-cs259-2015)                                                                                                              | University Courses  | Comprehensive guide to software debugging, covering essential techniques and strategies for identifying and resolving issues in software applications.                                                                                                                                                                                                                                                                                                         |\n|     221 | [Software Architecture \u0026 Design](https://getvm.io/tutorials/mooc-software-architecture-design-udacity)                                                                                                               | University Courses  | Enhance your software design skills with Udacity's MOOC on Software Architecture \u0026 Design. Learn modular design, design patterns, and architectural styles for building robust, scalable, and maintainable software systems.                                                                                                                                                                                                                                   |\n|     222 | [Developing Android Apps](https://getvm.io/tutorials/mooc-developing-android-apps-udacity)                                                                                                                           | University Courses  | Learn the fundamentals of Android app development, including UI design, user input, and Android components like activities and services.                                                                                                                                                                                                                                                                                                                       |\n|     223 | [Advanced Android App Development](https://getvm.io/tutorials/mooc-advanced-android-app-development-udacity)                                                                                                         | University Courses  | Expand your Android development skills with Udacity's advanced course covering complex UI, databases, multimedia, and security for feature-rich mobile apps.                                                                                                                                                                                                                                                                                                   |\n|     224 | [Systematic Program Design](https://getvm.io/tutorials/cpsc-110-systematic-program-design)                                                                                                                           | University Courses  | Explore the fundamentals of systematic program design, including problem decomposition, data representation, algorithm design, and testing. Suitable for beginners and experienced programmers.                                                                                                                                                                                                                                                                |\n|     225 | [Android Mobile App Development](https://getvm.io/tutorials/mooc-programming-mobile-applications-for-android-handheld-systems-university-of-maryland)                                                                | University Courses  | Learn to develop mobile applications for the Android platform with this comprehensive MOOC from the University of Maryland. Hands-on projects, expert insights, and a solid foundation in Android development.                                                                                                                                                                                                                                                 |\n|     226 | [Introduction to Service Design](https://getvm.io/tutorials/introduction-to-service-design-and-engineering-university-of-trento-italy)                                                                               | University Courses  | Explore innovative user-centric services through this introductory course on service design and engineering from the University of Trento, Italy.                                                                                                                                                                                                                                                                                                              |\n|     227 | [Concurrency](https://getvm.io/tutorials/cse-p-506-concurrency-spring-2011-university-of-washington)                                                                                                                 | University Courses  | Explore the fundamental concepts and techniques of concurrent programming at the University of Washington. Gain practical skills for building robust and efficient concurrent systems.                                                                                                                                                                                                                                                                         |\n|     228 | [Parallel Computation](https://getvm.io/tutorials/csep-524-parallel-computation-university-of-washington)                                                                                                            | University Courses  | Explore the principles and techniques of parallel programming, including parallel architectures, algorithms, and models, in the renowned CSEP 524 course at the University of Washington.                                                                                                                                                                                                                                                                      |\n|     229 | [Manycore Parallel Algorithms](https://getvm.io/tutorials/uiuc-ece-508-cs-508-manycore-parallel-algorithms-spring-2019-by-wen-mei-hwu)                                                                               | University Courses  | In-depth course on algorithm techniques for programming massively parallel processors, especially GPUs, taught by renowned expert Wen-mei Hwu.                                                                                                                                                                                                                                                                                                                 |\n|     230 | [Applied Parallel Programming](https://getvm.io/tutorials/uiuc-ece-408-cs-408-applied-parallel-programming-spring-2018-fall-2022-by-wen-mei-hwu-sanjay-patel)                                                        | University Courses  | Master parallel programming with CUDA, OpenMP, and other frameworks in this hands-on course covering parallel hardware, programming models, and algorithm design.                                                                                                                                                                                                                                                                                              |\n|     231 | [How to Build Robots and Make Them Move](https://getvm.io/tutorials/rob-311-how-to-build-robots-and-make-them-move-university-of-michigan)                                                                           | University Courses  | Gain practical experience in building and programming robots through this hands-on robotics course from the University of Michigan.                                                                                                                                                                                                                                                                                                                            |\n|     232 | [CS1](https://getvm.io/tutorials/cs1-higher-computing-richard-buckland-unsw)                                                                                                                                         | University Courses  | Comprehensive computer science and programming course taught by renowned professor Richard Buckland at UNSW. Engage with real-world examples and hands-on projects.                                                                                                                                                                                                                                                                                            |\n\n## More\n\n- [Free JavaScript Resources](https://github.com/getvmio/free-javascript-resources)\n- [Free HTML Resources](https://github.com/getvmio/free-html-resources)\n- [Free R Resources](https://github.com/getvmio/free-r-resources)\n- [Free Java Resources](https://github.com/getvmio/free-java-resources)\n- [Free Neural Networks Resources](https://github.com/getvmio/free-neural-networks-resources)\n- [Free Natural Language Processing Resources](https://github.com/getvmio/free-natural-language-processing-resources)\n- [Free Computer Science Resources](https://github.com/getvmio/free-computer-science-resources)\n- [Free React Resources](https://github.com/getvmio/free-react-resources)\n- [Free Security Resources](https://github.com/getvmio/free-security-resources)\n- [Free Node.js Resources](https://github.com/getvmio/free-node-js-resources)\n- [Free PyTorch Resources](https://github.com/getvmio/free-pytorch-resources)\n- [Free Computer Architecture Resources](https://github.com/getvmio/free-computer-architecture-resources)\n- [Free Functional Programming Resources](https://github.com/getvmio/free-functional-programming-resources)\n- [Free Operating System Resources](https://github.com/getvmio/free-operating-system-resources)\n- [Free Cryptography Resources](https://github.com/getvmio/free-cryptography-resources)\n- [Free Compiler Resources](https://github.com/getvmio/free-compiler-resources)\n- [Free Blockchain Resources](https://github.com/getvmio/free-blockchain-resources)\n- [Free SQL Resources](https://github.com/getvmio/free-sql-resources)\n- [Free Python Resources](https://github.com/getvmio/free-python-resources)\n- [Free Unix Resources](https://github.com/getvmio/free-unix-resources)\n- [Free Object-Oriented Programming Resources](https://github.com/getvmio/free-object-oriented-programming-resources)\n- [Free CSS Resources](https://github.com/getvmio/free-css-resources)\n- [Free Machine Learning Resources](https://github.com/getvmio/free-machine-learning-resources)\n- [Free Web Development Resources](https://github.com/getvmio/free-web-development-resources)\n- [Free Shell Scripting Resources](https://github.com/getvmio/free-shell-scripting-resources)\n- [Free Rust Resources](https://github.com/getvmio/free-rust-resources)\n- [Free Haskell Resources](https://github.com/getvmio/free-haskell-resources)\n- [Free Software Development Resources](https://github.com/getvmio/free-software-development-resources)\n- [Free Data Science Resources](https://github.com/getvmio/free-data-science-resources)\n- [Free Git Resources](https://github.com/getvmio/free-git-resources)\n- [Free Networking Resources](https://github.com/getvmio/free-networking-resources)\n- [Free Game Development Resources](https://github.com/getvmio/free-game-development-resources)\n- [Free TensorFlow Resources](https://github.com/getvmio/free-tensorflow-resources)\n- [Free Distributed Systems Resources](https://github.com/getvmio/free-distributed-systems-resources)\n- [Free Embedded Systems Resources](https://github.com/getvmio/free-embedded-systems-resources)\n- [Free DevOps Resources](https://github.com/getvmio/free-devops-resources)\n- [Free Docker Resources](https://github.com/getvmio/free-docker-resources)\n- [Free Robotics Resources](https://github.com/getvmio/free-robotics-resources)\n- [Free Computer Vision Resources](https://github.com/getvmio/free-computer-vision-resources)\n- [Free Deep Learning Resources](https://github.com/getvmio/free-deep-learning-resources)\n- [Free Cloud Computing Resources](https://github.com/getvmio/free-cloud-computing-resources)\n- [Free Go Resources](https://github.com/getvmio/free-go-resources)\n- [Free Data Structures Resources](https://github.com/getvmio/free-data-structures-resources)\n- [Free Control Systems Resources](https://github.com/getvmio/free-control-systems-resources)\n- [Free Artificial Intelligence Resources](https://github.com/getvmio/free-artificial-intelligence-resources)\n- [Free Data Analysis Resources](https://github.com/getvmio/free-data-analysis-resources)\n- [Free Ruby Resources](https://github.com/getvmio/free-ruby-resources)\n- [Free C++ Resources](https://github.com/getvmio/free-cpp-resources)\n- [Free Bash Resources](https://github.com/getvmio/free-bash-resources)\n- [Free Cybersecurity Resources](https://github.com/getvmio/free-cybersecurity-resources)\n- [Free Algorithm Resources](https://github.com/getvmio/free-algorithm-resources)\n- [Free Database Resources](https://github.com/getvmio/free-database-resources)\n- [Free C Resources](https://github.com/getvmio/free-c-resources)\n- [Free Version Control Resources](https://github.com/getvmio/free-version-control-resources)\n- [Free Linux Resources](https://github.com/getvmio/free-linux-resources)\n- [Free Computer Graphics Resources](https://github.com/getvmio/free-computer-graphics-resources)\n","funding_links":[],"categories":["More","Other Lists"],"sub_categories":["TeX Lists"],"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"}