G# Programming Language Unlocked

From Beginner to Expert : A Complete Guide to Modern .NET Development with Go, Kotlin, and Swift Ergonomics

Introduction : Why Another Language?

Chapter 1: What Is G#? : A Modern Language for the .NET Era

1. The Problem G# Solves : Too Many Languages, Too Much Ceremony
2. Origins and Vision : David Obando, CSharp Meets Go
3. Design Principles : Small Surface, Full Power
4. Where G# Fits : Compared to C#, F#, Go, Kotlin, Swift
5. Current Status and Ecosystem : Version 0.4, Tooling Landscape
6. Who Should Read This Book : Prerequisites and Roadmap

Chapter 2: Getting Started : Installation, Tooling, and Your First Program

1. Prerequisites : .NET SDK Versions and Verification
2. Installing the MSBuild SDK and Templates
3. Setting Up Visual Studio Code with the G# Extension
4. The gsc Compiler : Direct Compilation Without Projects
5. The gsi REPL : Interactive Exploration and Scripting
6. Your First Program : Hello, World and Beyond

Chapter 3: Language Foundations : Syntax, Packages, and Basic Structure

1. Source Files and the Compilation Unit
2. Package Declarations and Organization
3. Imports : Bringing Namespaces into Scope
4. Comments : Line, Block, and Documentation Comments
5. Visibility and Access Modifiers
6. Coding Conventions and Style Guidelines

Chapter 4: Variables, Constants, Types, and Values

1. Declarations : var, let, const and When to Use Each
2. Primitive Types : Numbers, Booleans, Characters, Strings
3. Numeric Widths and Aliases : int32 vs int and Why It Matters
4. Nullability : nil, T?, and Safe Access Patterns
5. Operators and Precedence : Arithmetic, Comparison, Logical, Bitwise
6. Expressions and Statement Semantics

Chapter 5: Control Flow : Branching, Looping, and Pattern Matching

1. Conditional Statements and Expressions : if/else Rules and Patterns
2. Nullable Unwrapping : if let, guard let, while let
3. Loops : for, while, do-while, range Iteration
4. Switch Statements and Expressions : No Fallthrough Design
5. Pattern Matching : Types, Lists, Properties, Relational, Combinators
6. Smart Casts and Type Narrowing

Chapter 6: Functions : The Building Blocks of Behavior

1. Function Declarations : func Syntax and Signatures
2. Parameters : Named, Positional, Variadic, and Default Values
3. Return Values and Expression Bodies
4. Closures and Captured Variables
5. Lambdas and Arrow Functions
6. Higher-Order Functions and Functional Patterns

Chapter 7: Data Structures : Structs, Classes, and Collections

1. Structs : Value Types with Instance Methods
2. Classes : Reference Types, Identity, and Inheritance
3. Data Types : Structural Equality, Deconstruction, with-Copy
4. Interfaces : Contracts, Default Methods, Generic Constraints
5. Arrays, Slices, and Rectangular Arrays
6. Maps, Sequences, and CLR Collections

Chapter 8: Error Handling and Resource Management

1. Exceptions in G# : CLR Model and throw as Expression
2. Try/Catch/Finally : Catching Specific Types
3. Custom Exception Types : When and How to Define Them
4. Defer Statements : Guaranteed Scope Cleanup
5. Using Declarations : RAII for Disposable Resources
6. Error Handling Patterns : When to Throw vs Return nil

Chapter 9: Generics, Type Parameters, and the Advanced Type System

1. Generic Functions and Types : Syntax and Instantiation
2. Constraints : any, comparable, Interface Bounds, Base Classes
3. Variance : in/out Covariance and Contravariance
4. Inline Structs : Single-Field Value Wrappers
5. Discriminated Unions via Payload-Bearing Enums
6. Advanced Patterns : Type Tests, Conditional Logic

Chapter 10: Concurrency : From Async/Await to Structured Concurrency

1. Asynchronous Functions : async func and Task[T]
2. Await Expressions and Suspension Semantics
3. Structured Concurrency with scope
4. Async Streams : async sequence[T] and await for
5. Go-Flavored Concurrency : go, chan T, select (Opt-In)
6. Concurrency Safety : Shared State, SyncMap, Locks

Chapter 11: .NET Interoperability : Using the Full Ecosystem

1. Calling CLR APIs : Types, Constructors, Properties, Methods
2. Static Imports and Namespace Aliases
3. Extension Functions : Go-Style Receivers and LINQ
4. Events and Delegates : +=/-= Wiring Patterns
5. Attributes : Kotlin-Style Syntax and Targets
6. Native Interop : P/Invoke, LibraryImport, Function Pointers

Chapter 12: Development Workflow : Building, Testing, Debugging, and Refactoring

1. Project Structure and .gsproj Configuration
2. Build Options : Targets, TFMs, References, Deterministic Builds
3. Testing with xUnit/NUnit/MSTest from G#
4. Debugging : Breakpoints, Watch Expressions, PDBs
5. Profiling and Performance Analysis
6. The cs2gs Migration Tool : Moving C# to G#

Chapter 13: Architecture, Idioms, and Production Engineering

1. Effective G# : Idiomatic Patterns from the Official Guide
2. Package Design : Small Packages, Explicit APIs
3. Design Patterns in G# : Repository, Factory, Observer, Strategy
4. Performance Characteristics : JIT, GC, IL Generation, Profiling
5. Security Considerations : Sandboxing, Input Validation, AOT
6. Deployment : Single-File Publishing, WebAssembly, Containerization

Conclusion : The Future of G# and Your Next Steps

1. What We Have Covered : Key Takeaways
2. G# Today vs Tomorrow : Honest Assessment of Maturity
3. When to Choose G# : Decision Framework
4. Contributing and Community Engagement
5. Where to Go From Here : Resources and Next Steps

References