moai-lang-unified

## 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)
```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)
```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
```typescript
// 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
```python
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
```typescript
// 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
```go
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
```rust
#[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
```java
@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:
```python
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](reference.md) - Complete language coverage, Context7 library mappings, performance characteristics
- [examples.md](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