Quick Reference (30 seconds)

Unified Enterprise Programming Language Expert - 25+ languages with patterns, best practices, and Context7 integration.

Auto-Triggers: Any language-specific code, files, or discussions (.py , .ts , .go , .rs , .java , .js , .cpp , .cs , .php , .swift , .kt , .scala , .ex , .rb , .r , .sql , .sh )

Core Capabilities:

• 25+ programming languages with latest versions

• Language-specific patterns and best practices

• Cross-language concepts and comparisons

• Context7 integration for latest documentation

• Progressive disclosure from basics to advanced

• Enterprise-ready patterns and deployment

Implementation Guide (5 minutes)

Features

• Multi-language support (Python, TypeScript, JavaScript, Java, C#, etc.)

• Modern language features and best practices

• Framework-specific patterns (FastAPI, React, Next.js, Spring, etc.)

• Type safety and linting standards

• Testing patterns for each language

When to Use

• Implementing backend APIs in Python (FastAPI) or TypeScript (Express)

• Building frontend UIs with React 19, Next.js 15, or Vue 3.5

• Setting up full-stack applications with type-safe communication

• Configuring linters and formatters for consistent code style

• Writing language-specific tests with appropriate frameworks

Core Patterns

Pattern 1: FastAPI Backend (Python)

from fastapi import FastAPI, HTTPException from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel): name: str price: float

@app.post("/items/") async def create_item(item: Item):

Implementation

return item

Pattern 2: Next.js 15 Frontend (TypeScript)

// app/page.tsx (App Router) export default async function Page() { const data = await fetch('https://api.example.com/data'); return <main>{/* Render data */}</main>; }

Pattern 3: Type-Safe API Integration

// Shared types between frontend/backend export interface User { id: string; name: string; email: string; }

// Backend endpoint types export type GetUserResponse = User; export type CreateUserRequest = Omit<User, 'id'>;

Language Coverage

Scripting & Dynamic Languages

• Python 3.13 - FastAPI, Django, async patterns, data science

• JavaScript ES2025 - Node.js 22 LTS, Express, browser development

• TypeScript 5.9 - React 19, Next.js 16, type safety

• PHP 8.4 - Laravel, Symfony, composer patterns

• Ruby 3.3 - Rails, Sinatra, metaprogramming

• Shell/Bash - DevOps, scripting, system automation

Systems & Performance Languages

• Go 1.23 - Concurrency, Fiber, systems programming

• Rust 1.91 - Memory safety, Tokio, async systems

• C++ - Systems programming, performance optimization

• C - Low-level programming, embedded systems

Enterprise & JVM Languages

• Java 21 LTS - Spring Boot, enterprise patterns

• Kotlin - Android, server-side, coroutines

• Scala - Functional programming, big data

Mobile & Platform Languages

• Swift - iOS development, server-side Swift

• C# (.NET 8) - Enterprise applications, game development

• Dart - Flutter, cross-platform development

Data & Domain Languages

• R - Statistical computing, data analysis

• SQL - Database queries across PostgreSQL, MySQL, etc.

• Elixir - Functional programming, Phoenix, BEAM

Quick Reference Examples

Python 3.13+ FastAPI Pattern

from fastapi import FastAPI, Depends from sqlalchemy.ext.asyncio import AsyncSession

app = FastAPI(title="API", version="1.0.0")

@app.get("/users/{user_id}") async def get_user(user_id: int, db: AsyncSession = Depends(get_db)) -> UserResponse: user = await get_user_by_id(db, user_id) return UserResponse.model_validate(user)

TypeScript 5.9+ React Pattern

// React 19 Server Component export default async function UserProfile({ userId }: { userId: string }) { const user = await getUser(userId) return <div><h1>{user.name}</h1><p>{user.email}</p></div> }

Go 1.23+ Fiber Pattern

func main() { app := fiber.New() app.Get("/users", func(c fiber.Ctx) error { return c.JSON(fiber.Map{"users": []string{"John", "Jane"}}) }) app.Listen(":3000") }

Rust 1.91+ Axum Pattern

#[tokio::main] async fn main() { let app = Router::new().route("/users/:id", get(get_user)); axum::serve(listener, app).await.unwrap() }

Java 21 LTS Spring Boot Pattern

@RestController @RequestMapping("/api/users") public class UserController { @GetMapping("/{id}") public ResponseEntity<UserDto> getUser(@PathVariable Long id) { return ResponseEntity.ok(userService.findById(id)); } }

Cross-Language Patterns

Async Programming Comparison

Language Syntax Runtime Best For

Python async/await

asyncio I/O-bound, data science

TypeScript async/await

Node.js Full-stack, real-time

Go goroutines

Go runtime Concurrent systems

Rust async/await

Tokio Performance-critical

Java virtual threads

JVM Enterprise systems

Error Handling Patterns

Python: try/except with exceptions TypeScript: try/catch with async/await Go: Multiple return values (result, err)

Rust: Result/Option types with match or ?

Java: Checked exceptions with try/catch/finally

Package Management

Language Package Manager Lock File Registry

Python pip/poetry requirements.txt/poetry.lock PyPI

TypeScript npm/yarn package-lock.json/yarn.lock npm

Go go modules go.sum Go Modules

Rust cargo Cargo.lock crates.io

Java Maven/Gradle pom.xml/build.gradle Maven Central

When to Use Each Language

Python 3.13

Use for: Data science, ML/AI, web APIs, automation Avoid: Real-time performance <1ms, embedded systems

TypeScript 5.9

Use for: Enterprise applications, full-stack, type safety Avoid: Rapid prototyping, simple scripts

Go 1.23

Use for: Microservices, CLI tools, cloud-native apps Avoid: Complex GUI, rapid prototyping

Rust 1.91

Use for: Performance-critical, systems programming Avoid: Rapid prototyping, simple CRUD

Java 21 LTS

Use for: Enterprise apps, large systems, big data Avoid: Lightweight CLI, rapid prototyping

Context7 Integration

Automatically fetches latest documentation for:

Python: FastAPI, Django, Pydantic, SQLAlchemy, pytest TypeScript: React, Next.js, Node.js, tRPC, Zod Go: Gin, Echo, GORM Rust: Tokio, Axum, Serde Java: Spring Boot, Hibernate

Usage example:

docs = await mcp__context7__get_library_docs( context7CompatibleLibraryID="/tiangolo/fastapi", topic="async dependency-injection", page=1 )

Works Well With

• moai-domain-backend — REST API, GraphQL, microservices

• moai-domain-frontend — React, Vue, Angular, UI components

• moai-domain-database — SQL, NoSQL, ORM patterns

• moai-foundation-trust — TRUST 5 quality principles

• moai-essentials-debug — AI-powered debugging

• moai-context7-integration — Latest documentation access

Troubleshooting

Python: Check venv, pip list , python -c "import sys"

TypeScript: npx tsc --noEmit , npm ls typescript

Go: go mod tidy , go mod verify

Rust: rustc --version , cargo check , cargo tree

Java: java -version , mvn/gradle build

Advanced Documentation

For comprehensive reference materials:

• reference.md - Complete language coverage, Context7 library mappings, performance characteristics

• examples.md - Multi-language code examples, REST API implementations, testing patterns, deployment configurations

Conclusion

This unified language skill replaces all individual moai-lang* skills while maintaining their expertise and functionality. It automatically detects programming context and provides relevant expertise for 25+ languages with Context7 integration and cross-language capabilities.

Last Updated: 2025-11-25 Status: Production Ready (Enterprise v1.0.0) Replaces: All moai-lang-* individual skills