Learning a general-purpose language

Beginner

Theory

Quick Starts, Tutorials, Walk-throughs, User Guides, Beginner Books, etc

  1. Basic data types and operators

  2. Basic data structures

  3. Variable definition

  4. Function definition

  5. Loops

  6. Branching

  7. Some Std library

    1. Data manipulation
    2. File
    3. OS
    4. Network
    5. Datetime
    6. Math
    7. Extended data structures

Grok the lexicon, sementics and syntax!

Many languages have different ways of doing the same thing; many even do the same thing the same way but under a different name!

Practical

  1. Very simple (usually single file) problems like:

    1. Fibonacci, Primes Sieve, etc
    2. Pull data from a public api and store in a file
    3. Read data from file into language-specific data structure
    4. Convert and write data into json/csv file as original backup
    5. Store data into a database
    6. Create web server routes that GET and POST a row of data in db

  2. Syntactically challenging yet still easy to solve problems like:

    1. A simple game (guess the number, hangman etc)
    2. A simple management system (orders, employees, library etc)
    3. A simple data processing pipeline (calculate statistics from a transaction sheet, etc)
    4. A simple web scraper
    5. A simple to-do app
    6. A simple chat app

Yes, we must keep in mind that the solutions need to be SIMPLE, else we miss the forest for the trees.

Intermediate

Theory

Documentations, User Manuals, API References, More Books etc

  1. Simple Project Structure (with tooling)
    1. Linters
    2. Test Runners
    3. Formatters
    4. Package Managers
  2. Concurrent/Parallel (Async) Model
  3. Exception Handling
  4. Modules/Packages Handling
  5. Higher Level Concepts (Inheritance, Protocols, Dispatchers, Composition, Type classes etc)
  6. Scope/Context Model
  7. Common Gotchas (Haskell string, JS falsy, Python GIL, etc)
  8. Simple Macros (if they exist)
  9. Pattern Matching (if it exists)
  10. Regular Expression Support
  11. Memory Allocation/Deallocation (if required)
  12. Value/Reference/Address Passing Support
  13. More from std library
  14. Popular packages from public repository
  15. Best practices, conventions

Practical

  1. 6 small projects
  2. 3 medium projects
  3. 1 large project
  4. Contribute to open source projects

Expert

Everything, everywhere but not all at once

  1. Idiomatic Code
  2. Complex Project Structure (with embedded DSLs, advanced config, CI/CD, container images etc)
  3. Development/Testing/Deployment workflows
  4. Foreign Function Interface
  5. Memory Management Models (with different GC mechanisms)
  6. Performance Gotchas (tail-call recursion, lazy evaluation, etc)
  7. Complex Macros and Language extension
  8. When to overrule best practices and conventions

Ideally, should spend as little time as possible in Beginner phase. An experience programmer can pick up the basics in less than a week.

Spend most of the time in Intermediate phase, working on different projects. This is where you'll learn much of what the language has to offer.

There will be a stark contrast to moving from beginner to intermediate, as you change the scale of your projects. The same cannot be said for intermediate to expert. It could take years, and it is a very gradual process.