# Programming

> Provides recipes for programming tasks. Use when executing programming tasks like creating code, creating tests, reactoring code, reviewing code.

- Skill: `wesleyegberto/programming` (Agent Skill, multi-file: 10 files)
- Install (CLI): `npx skillmds@latest add wesleyegberto/programming`
- Raw SKILL.md: https://api.skillmd.com/api/skills/wesleyegberto/programming/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: wesleyegberto (https://skillmd.com/u/wesleyegberto)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/wesleyegberto/programming

---


# Programming Recipes

This skill provides a collection of recipes to solve common programming tasks, focusing on refactoring, optimization, and best practices.

## Available Recipes

### 1. Decouple Business Logic from UI
- **Goal**: Separate business logic from UI components to improve maintainability, reusability, and testability.
- **Technique**: Extract business logic into services, state management solutions (e.g., Redux), or hooks.
- **Example**: Refactoring a React `Counter` component by moving state management to Redux, separating actions, reducers, and the store from the component's view.

### 2. Fix Lint Errors
- **Goal**: Improve code quality, catch bugs early, and ensure consistency by addressing linter warnings.
- **Common Fixes**:
  - Managing imports (adding missing, removing unused).
  - Adhering to style guidelines (naming conventions, spacing, indentation).
  - Removing unused variables and unreachable code.
  - Adding docstrings and replacing `print` statements with proper logging.

### 3. Handle Cross-Cutting Concerns
- **Goal**: Centralize logic for concerns that affect multiple parts of an application (e.g., logging, security, validation).
- **Technique**: Use Aspect-Oriented Programming (AOP), decorators, or middleware to avoid code duplication.
- **Example**: Refactoring a Python application to use `aspectlib` to handle logging for multiple service methods, keeping the logging logic in one place.

### 4. Improve Code Readability and Maintainability
- **Goal**: Make code easier to understand, maintain, and extend.
- **Techniques**:
  - **Use Descriptive Variable Names**: Replace abstract names (`a`, `b`) with meaningful ones (`name`, `age`).
  - **Avoid Sequential Conditionals**: Replace long `if/else` chains with dictionaries or switch statements.
  - **Reduce Nested Logic**: Use guard clauses to flatten deeply nested `if` statements.
  - **Split Large Methods**: Break down long methods into smaller, single-responsibility functions.

### 5. Refactor Data Access Layers
- **Goal**: Abstract database interactions to make the application more modular, scalable, and secure.
- **Technique**: Implement a repository pattern to separate data access logic from business logic.
- **Example**: Refactoring a Python function with a hardcoded, insecure SQL query into a `UserRepository` with a `Database` class that uses parameterized queries and a context manager.

### 6. Implement Design Patterns
- **Goal**: Solve common software design problems using established, reusable patterns.
- **Technique**: Identify areas where patterns like Singleton, Factory, or Module can improve code structure.
- **Example**: Refactoring JavaScript code to use the **Module Pattern** to encapsulate related functions and data, preventing global namespace pollution.

### 7. Optimize for Performance
- **Goal**: Identify and resolve performance bottlenecks in inefficient code.
- **Techniques**:
  - Optimize algorithms and data structures (e.g., using a sieve for prime generation instead of trial division).
  - Reduce redundant computations and memory allocation.
  - Introduce caching or parallelize operations where appropriate.

### 8. Refactor for Environmental Sustainability
- **Goal**: Reduce the energy consumption and environmental impact of software.
- **Technique**: Identify and refactor resource-intensive operations to be more efficient in terms of CPU and memory usage.
- **Example**: Improving a Python script that counts lines in a large file by reading it line-by-line instead of loading the entire file into memory.

### 9. Translate Between Programming Languages
- **Goal**: Port code from one language to another to leverage different features, improve performance, or standardize a codebase.
- **Process**: Translate the logic, syntax, and standard library calls from the source language to the target language, ensuring functional equivalence.
- **Example**: Converting a Perl script for file analysis into a modern TypeScript equivalent using Node.js modules.