# Estándares de Lenguajes de Programación

## Java

### Convenciones de Nomenclatura
- **Clases**: `PascalCase` → `UserService`, `DatabaseConnection`
- **Métodos**: `camelCase` → `getUserById()`, `calculateTotal()`
- **Variables**: `camelCase` → `userName`, `totalAmount`
- **Constantes**: `SCREAMING_SNAKE_CASE` → `MAX_RETRY_ATTEMPTS`
- **Packages**: `lowercase.dot.notation` → `com.company.service.user`

### Mejores Prácticas
- Usar `Optional<T>` para valores que pueden ser null
- Implementar equals() y hashCode() en entidades
- Usar try-with-resources para manejo de recursos
- Aplicar principios SOLID
- Usar Streams API para operaciones de colecciones

```java
// ✅ Buenas prácticas
public class UserService {
    private final UserRepository userRepository;
    private static final int MAX_RETRY_ATTEMPTS = 3;

    public UserService(UserRepository userRepository) {
        this.userRepository = Objects.requireNonNull(userRepository);
    }

    public Optional<User> findUserById(Long id) {
        return userRepository.findById(id);
    }
}
```

## Python

### Convenciones de Nomenclatura (PEP 8)
- **Funciones/Variables**: `snake_case` → `get_user_by_id()`, `user_name`
- **Clases**: `PascalCase` → `UserService`, `DatabaseConnection`
- **Constantes**: `SCREAMING_SNAKE_CASE` → `MAX_RETRY_ATTEMPTS`
- **Módulos**: `snake_case` → `user_service.py`

### Mejores Prácticas
- Usar type hints en todas las funciones
- Implementar docstrings descriptivos
- Usar list comprehensions cuando sea apropiado
- Aplicar context managers para recursos

```python
# ✅ Buenas prácticas
from typing import Optional, List
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

class UserService:
    def __init__(self, user_repository: UserRepository) -> None:
        self.user_repository = user_repository

    def find_user_by_id(self, user_id: int) -> Optional[User]:
        """Encuentra un usuario por su ID."""
        return self.user_repository.find_by_id(user_id)
```

## JavaScript/TypeScript

### Convenciones de Nomenclatura
- **Variables/Funciones**: `camelCase` → `getUserById()`, `userName`
- **Clases**: `PascalCase` → `UserService`, `ApiClient`
- **Constantes**: `SCREAMING_SNAKE_CASE` → `MAX_RETRY_ATTEMPTS`
- **Archivos**: `kebab-case` → `user-service.js`

### Mejores Prácticas JavaScript
- Usar `const`/`let` en lugar de `var`
- Aplicar destructuring cuando sea apropiado
- Usar arrow functions para callbacks
- Implementar async/await para operaciones asíncronas

```javascript
// ✅ Buenas prácticas
const MAX_RETRY_ATTEMPTS = 3;

class UserService {
    constructor(userRepository) {
        this.userRepository = userRepository;
    }

    async findUserById(userId) {
        try {
            const user = await this.userRepository.findById(userId);
            return user;
        } catch (error) {
            console.error(`Error finding user ${userId}:`, error);
            throw error;
        }
    }
}
```

### Mejores Prácticas TypeScript
- Definir interfaces para contratos
- Usar tipos específicos en lugar de `any`
- Implementar generic types cuando sea apropiado

```typescript
interface User {
    id: number;
    name: string;
    email: string;
}

interface UserRepository {
    findById(id: number): Promise<User | null>;
    save(user: User): Promise<User>;
}

class UserService {
    constructor(private userRepository: UserRepository) {}

    async findUserById(userId: number): Promise<User | null> {
        return await this.userRepository.findById(userId);
    }
}
```

## C#

### Convenciones de Nomenclatura
- **Clases/Propiedades/Métodos**: `PascalCase` → `UserService`, `GetUserById()`
- **Variables locales**: `camelCase` → `userName`, `totalAmount`
- **Campos privados**: `_camelCase` → `_userRepository`
- **Constantes**: `PascalCase` → `MaxRetryAttempts`

### Mejores Prácticas
- Usar nullable reference types
- Implementar using statements para recursos
- Aplicar LINQ para operaciones de colecciones
- Usar async/await para operaciones I/O

```csharp
// ✅ Buenas prácticas
public class UserService
{
    private readonly IUserRepository _userRepository;
    private const int MaxRetryAttempts = 3;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
    }

    public async Task<User?> FindUserByIdAsync(int userId)
    {
        return await _userRepository.FindByIdAsync(userId);
    }
}
```

## Go

### Convenciones de Nomenclatura
- **Funciones/Variables públicas**: `PascalCase` → `GetUserById()`, `UserName`
- **Funciones/Variables privadas**: `camelCase` → `getUserById()`, `userName`
- **Constantes**: `PascalCase` → `MaxRetryAttempts`
- **Packages**: `lowercase` → `userservice`

### Mejores Prácticas
- Manejar errores explícitamente
- Usar interfaces para abstracciones
- Implementar defer para cleanup
- Seguir el principio "don't communicate by sharing memory"

```go
// ✅ Buenas prácticas
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

type UserService struct {
    userRepo UserRepository
}

func NewUserService(userRepo UserRepository) *UserService {
    return &UserService{
        userRepo: userRepo,
    }
}

func (s *UserService) FindUserByID(id int) (*User, error) {
    if id <= 0 {
        return nil, fmt.Errorf("invalid user id: %d", id)
    }

    return s.userRepo.FindByID(id)
}
```

## Rust

### Convenciones de Nomenclatura
- **Funciones/Variables**: `snake_case` → `get_user_by_id()`, `user_name`
- **Tipos/Structs**: `PascalCase` → `UserService`, `DatabaseConnection`
- **Constantes**: `SCREAMING_SNAKE_CASE` → `MAX_RETRY_ATTEMPTS`
- **Módulos**: `snake_case` → `user_service`

### Mejores Prácticas
- Aprovechar el ownership system
- Usar Result<T, E> para manejo de errores
- Implementar traits apropiadamente
- Usar pattern matching

```rust
// ✅ Buenas prácticas
use std::result::Result;

#[derive(Debug, Clone)]
pub struct User {
    pub id: u32,
    pub name: String,
    pub email: String,
}

pub trait UserRepository {
    fn find_by_id(&self, id: u32) -> Result<Option<User>, String>;
    fn save(&self, user: &User) -> Result<(), String>;
}

pub struct UserService<R: UserRepository> {
    user_repo: R,
}

impl<R: UserRepository> UserService<R> {
    pub fn new(user_repo: R) -> Self {
        Self { user_repo }
    }

    pub fn find_user_by_id(&self, id: u32) -> Result<Option<User>, String> {
        if id == 0 {
            return Err("Invalid user id".to_string());
        }

        self.user_repo.find_by_id(id)
    }
}
```

## Estándares de Documentación por Lenguaje

### JavaDoc
```java
/**
 * Servicio para gestión de usuarios.
 * Proporciona operaciones CRUD para entidades User.
 *
 * @author John Doe
 * @version 1.0
 * @since 2023-01-01
 */
public class UserService {
    /**
     * Busca un usuario por su ID único.
     *
     * @param userId ID único del usuario
     * @return Optional conteniendo el usuario si existe
     * @throws IllegalArgumentException si userId es null o negativo
     */
    public Optional<User> findUserById(Long userId) {
        // Implementation
    }
}
```

### Python Docstrings
```python
class UserService:
    """Servicio para gestión de usuarios.

    Attributes:
        user_repository: Repositorio para acceso a datos de usuarios
    """

    def find_user_by_id(self, user_id: int) -> Optional[User]:
        """Busca un usuario por su ID.

        Args:
            user_id: ID único del usuario

        Returns:
            Usuario encontrado o None si no existe

        Raises:
            ValueError: Si user_id es menor o igual a 0
        """
        pass
```

### JSDoc
```javascript
/**
 * Servicio para gestión de usuarios
 * @class UserService
 */
class UserService {
    /**
     * Busca un usuario por ID
     * @param {number} userId - ID único del usuario
     * @returns {Promise<User|null>} Usuario encontrado o null
     * @throws {Error} Error si userId es inválido
     */
    async findUserById(userId) {
        // Implementation
    }
}
```