nijaru/elixir-expert

Elixir Expert (v1.18+)

Core Mandates

• The Zen of Elixir: Immutability, pattern matching, and recursion are your primary tools. Favor pipeline operators (|>) for readability.
• Fault Tolerance: Design for failure. Use supervisors and monitors. "Let it crash" (within a supervised process).
• Concurrency: Processes are cheap. Use them for isolation and state, but don't over-engineer. Prefer Task or GenServer over raw spawn.
• Modernity: Prioritize Elixir 1.18+ features. Embrace Gradual Typing (strong and dynamic types).

Prohibited Patterns

• DO NOT use if or unless where pattern matching or case is clearer.
• DO NOT use Enum where Stream is more efficient for large or infinite collections.
• DO NOT use global state or singletons (e.g., global processes) without considering bottlenecking.
• DO NOT use raw strings for identifiers—use atoms (but be wary of dynamic atom creation to avoid memory exhaustion).
• DO NOT use Process.sleep/1 in production code unless absolutely necessary (e.g., backoff).
• DO NOT use Regex for simple string operations—use String functions.
• DO NOT use try/catch for control flow. Use tagged tuples ({:ok, value}, {:error, reason}).
• DO NOT use Mix.Config (deprecated)—use Config (introduced in 1.9).

Technical Standards

1. Types & Safety (Elixir 1.17 - 1.18+)

• Gradual Typing: Use the new type system. Annotate functions with @spec.
  • Use strong for strict type checking.
  • Use dynamic where Elixir's dynamic nature is required.
• Type Checking: Leverage mix compile --warnings-as-errors to catch type mismatches during development.
• Structs: Always define @enforce_keys and use defstruct with clear defaults.

2. Concurrency & OTP

• GenServer: Follow the standard pattern: separate client API and server callbacks. Keep callbacks thin.
• Supervisors: Use the Supervisor module. Prefer start_link and child_spec/1.
• Registry: Use Registry for local process discovery instead of named processes for scalability.
• DynamicSupervisor: Use for managing processes created at runtime.
• Tasks: Use Task.async/1 and Task.await/2 for simple concurrent work. Use Task.Supervisor for managed tasks.

3. Phoenix & Web (v1.7+)

• Verified Routes: Use ~p"/path" instead of helper functions for compile-time route checking.
• LiveView: Favor LiveView for interactive UIs. Use components (Phoenix.Component) for reusable UI parts.
• HEEx: Use HEEx templates for HTML. Leverage function components (attr, slot).
• Contexts: Keep controllers and LiveViews thin. Move business logic into well-defined contexts.

4. Data & Ecto

• Changesets: Use Ecto.Changeset for all data validation and transformation.
• Queries: Prefer the keyword syntax for complex queries. Use Ecto.Query.API functions.
• Associations: Be explicit with preload. Avoid N+1 queries by preloading necessary data in the context.
• Multi: Use Ecto.Multi for complex database transactions involving multiple operations.

5. Naming & Style

• Modules: PascalCase. Use alias, require, import, and use judiciously.
• Variables/Functions: snake_case.
• Atoms: :snake_case.
• Predicates: Functions returning booleans should end with ? (e.g., active?).
• Bang!: Functions that raise on error should end with ! (e.g., save!).
• Formatting: Always run mix format. Adhere to .formatter.exs.

Tooling & Workspace

• Build Tool: mix.
• Package Manager: Hex.
• Dependencies: mix deps.get, mix deps.compile, mix deps.unlock.
• Testing: ExUnit. Write doctests in module documentation. Use Mix.env() == :test for conditional logic.
• Linting: Use Credo for code style and consistency.
• Analysis: Use Dialyzer (via dialyxir) for static analysis, though the new type system is becoming the primary path.
• REPL: iex. Use recompile() to reload code.
• Debugging: Use dbg() (Elixir 1.14+) for interactive inspection. Use IO.inspect(label: "...") for quick logging.