10/10 - Expert Level

• Python - Deep understanding of syntax, libraries, frameworks, best practices
• JavaScript/TypeScript - Full-stack development, modern frameworks, async programming
• C++ - Advanced features, templates, STL, memory management, performance optimization

9/10 - Advanced

• Java - Enterprise development, Spring framework, JVM internals
• C - System programming, memory management, low-level operations
• Go - Concurrency, goroutines, modern language features
• Rust - Memory safety, ownership, systems programming

8/10 - Proficient

• C# - .NET ecosystem, LINQ, async/await
• PHP - Web development, frameworks like Laravel
• Ruby - Rails framework, metaprogramming
• Swift - iOS/macOS development
• Kotlin - Android development, JVM interop

7/10 - Competent

• R - Data analysis, statistics, visualization
• MATLAB - Numerical computing, signal processing
• Scala - Functional programming, JVM ecosystem
• Haskell - Functional programming concepts
• Clojure - Lisp dialect, functional programming

6/10 - Intermediate

• Assembly - x86, ARM, understanding of low-level operations
• Shell/Bash - System administration, automation
• SQL - Database design, query optimization
• Lua - Scripting, game development
• Perl - Text processing, system administration

5/10 - Basic

• Fortran - Legacy scientific computing
• COBOL - Legacy business systems
• Pascal - Educational programming
• Ada - Safety-critical systems

Specialized Knowledge

• Domain-specific languages (DSL) - Various embedded and specialized languages
• Configuration languages - YAML, JSON, TOML, etc.
• Markup languages - HTML, XML, Markdown, LaTeX

module hello_world;
import std::io;

fn void main()
{
    io::printn("Hello, world!");
}

Easy Does It
                   or...
A COMPILER FOR AN
ALGEBRAIC LANGUAGE

A compiler is always a large program. To write one from scratch, even in a pedagogical environment, is a major undertaking. Although Easy is designed to reduce the pain while providing as much enlightenment as possible, this still is the hardest problem in the book. Do not tackle it unless you (and some helpful friends) have plenty of time and energy.

THE EASY LANGUAGE

Easy is a general-purpose, procedural, algebraic programming language. Its roots lie in ALGOL, ALGOL 68, and PASCAL. Like them, it is designed to be compiled, loaded, and executed on a reasonably conventional computer (the EC-1 described in Chapter 25 is a good example). The syntax is described by a context-free grammar suitable for parsing by LR(1) techniques. The semantics are similar to the languages described above, and we will let an informal description suffice, trusting to the reader’s skill to fill any gaps. In the text below, logically connected portions of the grammar are described with the associated semantics.

begoon

git clone https://github.com/begoon/easy.git
cd easy
node easyc.ts life.easy
cc life.c -o life -I.
./life

** [ EASY LIFE ] ***************************************************************** 
*                                                      xx                        *
*                                                    xx  xx                      *
*                                          x         x  xxx                      *
*                                        xx              x   xxx                 *
*                                                     x x   x  xx                *
*                                             xx       x   x x  xx               *
*                                             xxx          x    x                *
*                                         x  xxx             xxx                 *
*                                         xxxxx    xx       xx                   *
*                                       xx   x    x  x                           *
*                                          x x     xx                            *
*                                      x   xx                                    *
*                                       xxx                                      *
*                                 x                                              *
*                               x xx         x                                   *
*                             xxx  xxx      x x                                  *
*                                    x     x  x                                  *
*                                 x  x      xx                                   *
*                                 x x                                            *
*                                                                                *
*                                                                                *
*                                                                                *
*                            xx                                                  *
*                            xx   xx                                             *
*                                 xx                                             *
********************************************************************************** 
GENERATION: 104