Introduction to Adaptive Code Evolution

1_introduction_to_adaptive_code_evolution.livemd

Sean Chatman

@seanchatmangpt

ash_swarm

More notebooks

Introduction to Adaptive Code Evolution

Overview

Adaptive Code Evolution is a powerful pattern that enables software systems to continuously evolve and improve based on usage patterns, performance metrics, and feedback loops. This pattern represents a paradigm shift from static codebases to dynamic, self-improving systems that can adapt to changing requirements and environments.

In this livebook, we’ll explore the core concepts, benefits, and implementation strategies of Adaptive Code Evolution using Ash and Instructor.

Mix.install(
  [
    {:kino, "~> 0.12.0"},
    # Try to use published version first, fall back to local path
    # This allows the livebook to work both in development and when published to Hex
    if Code.ensure_loaded?(AshSwarm) do
      []
    else
      if File.exists?("/Users/speed/ash_swarm/mix.exs") do
        {:ash_swarm, path: "/Users/speed/ash_swarm/", override: true}
      else
        {:ash_swarm, "~> 0.1.0"} # This will be used when published to Hex
      end
    end,
    {:instructor, "~> 0.1.0"},
    {:jason, "~> 1.4"},
    {:poison, "~> 5.0"},
    {:sourceror, "~> 1.0"},
    {:git_diff, "~> 0.6.4"},
    {:heroicons, git: "https://github.com/tailwindlabs/heroicons.git", tag: "v2.1.1", sparse: "optimized", app: false, compile: false, depth: 1}
  ]
  |> List.flatten()
)

# Use dynamic path resolution that works in both development and production
foundation_path = 
  cond do
    # If app is already loaded, use Application.app_dir
    Code.ensure_loaded?(AshSwarm) ->
      Path.join([Application.app_dir(:ash_swarm), "lib", "ash_swarm", "foundations"])
    
    # In development, use the local path
    File.exists?("/Users/speed/ash_swarm/lib/ash_swarm/foundations") ->
      "/Users/speed/ash_swarm/lib/ash_swarm/foundations"
    
    # When installed from Hex
    true ->
      Path.join([Application.app_dir(:ash_swarm), "lib", "ash_swarm", "foundations"])
  end

# Load foundation modules dynamically
foundation_files = Path.wildcard(Path.join(foundation_path, "*.ex"))
Enum.each(foundation_files, &amp;Code.require_file/1)

# Set up environment variables for API access
api_key = System.get_env("GROQ_API_KEY") || System.get_env("LB_GROQ_API_KEY")

if is_nil(api_key) or api_key == "" do
  IO.puts("""
  ⚠️ **No GROQ_API_KEY found.**
  Some examples will use simulated responses.
  Set your API key in Livebook secrets as `LB_GROQ_API_KEY`.
  """)
else
  System.put_env("GROQ_API_KEY", api_key)
  IO.puts("✅ **GROQ_API_KEY loaded successfully!**")
end

# Import required modules for convenience
alias AshSwarm.Foundations.{
  AdaptiveCodeEvolution,
  AICodeAnalysis,
  AIAdaptationStrategies,
  AIExperimentEvaluation
}

IO.puts("🚀 **Livebook environment ready for Adaptive Code Evolution!**")

==> ash_swarm
     warning: function process_evaluation_result/4 is unused
     │
 452 │   defp process_evaluation_result(result, original_code, adapted_code, metrics) do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_experiment_evaluation.ex:452:8: AshSwarm.Foundations.AIExperimentEvaluation (module)

     warning: function generate_evaluation_id/0 is unused
     │
 466 │   defp generate_evaluation_id do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_experiment_evaluation.ex:466:8: AshSwarm.Foundations.AIExperimentEvaluation (module)

     warning: function process_optimization_result/2 is unused
     │
 682 │   defp process_optimization_result(result, original_code) do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_adaptation_strategies.ex:682:8: AshSwarm.Foundations.AIAdaptationStrategies (module)

     warning: function get_module_source/1 is unused
     │
 699 │   defp get_module_source(module) do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_adaptation_strategies.ex:699:8: AshSwarm.Foundations.AIAdaptationStrategies (module)

     warning: function generate_optimization_id/0 is unused
     │
 693 │   defp generate_optimization_id do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_adaptation_strategies.ex:693:8: AshSwarm.Foundations.AIAdaptationStrategies (module)

     warning: function enrich_opportunities/1 is unused
     │
 448 │   defp enrich_opportunities(opportunities) do
     │        ~
     │
     └─ lib/ash_swarm/foundations/ai_code_analysis.ex:448:8: AshSwarm.Foundations.AICodeAnalysis (module)

     warning: function convert_to_simple_json_schema/1 is unused
     │
 718 │   defp convert_to_simple_json_schema(model) do
     │        ~
     │
     └─ lib/ash_swarm/instructor_helper.ex:718:8: AshSwarm.InstructorHelper (module)


09:06:35.389 [notice] Application ash_swarm exited: exited in: AshSwarm.Application.start(:normal, [])
    ** (EXIT) an exception was raised:
        ** (ArgumentError) could not fetch application environment :ash_domains for application :ash_swarm because configuration at :ash_domains was not set
            (elixir 1.18.2) lib/application.ex:771: Application.fetch_env!/2
            (ash_swarm 0.1.0) lib/ash_swarm/application.ex:15: AshSwarm.Application.start/2
            (kernel 10.2.2) application_master.erl:295: :application_master.start_it_old/4

09:06:35.393 [notice] Application runtime_tools exited: :stopped
✅ **GROQ_API_KEY loaded successfully!**
🚀 **Livebook environment ready for Adaptive Code Evolution!**

:ok

Adaptive Code Evolution comprises several fundamental concepts that work together to create a self-improving system:

1. Code Analysis

Systems that implement adaptive code evolution must be able to analyze their own structure, identify potential optimization opportunities, and determine areas that could benefit from improvement.

defmodule Opportunity do
  defstruct description: "",
            location: "",
            rationale: "",
            severity: "",
            suggested_change: "",
            type: ""
end

defmodule CodeAnalysisResponse do
  defstruct opportunities: []
end

:ok

:ok

defmodule MyApp.AdaptiveEvolution do
  use AshSwarm.Foundations.AdaptiveCodeEvolution

  ai_analyzer :code_quality,
    description: "Analyzes code quality using LLMs",
    analyzer_module: AshSwarm.Foundations.AICodeAnalysis,
    analyzer_function: :analyze_source_code
end

:ok

:ok

alias AshSwarm.InstructorHelper
require Kino
# Sample code to analyze
sample_code = """
defmodule SlowOperations do
  @moduledoc \"\"\"
  Contains deliberately inefficient implementations for demonstration purposes.
  \"\"\"
  def fibonacci(0), do: 0
  def fibonacci(1), do: 1
  def fibonacci(n) when n > 1, do: fibonacci(n - 1) + fibonacci(n - 2)
end
"""
analysis_options = [
  focus_areas: [:performance, :readability, :maintainability],
  max_suggestions: 5
]
# IMPORTANT: mention "json" so Groq honors response_format: "json_object"
sys_msg = """
You are an expert Elixir code analyst. **IMPORTANT**: Provide your answer as valid JSON only.
Return a top-level "opportunities" array, each item must have:
- description
- location
- rationale
- severity
- suggested_change
- type (performance, readability, or maintainability)
"""
user_msg = """
Analyze the following Elixir code for potential optimizations and return the response in JSON:
#{sample_code}
Focus areas: #{Enum.join(analysis_options[:focus_areas], ", ")}.
Provide up to #{analysis_options[:max_suggestions]} suggestions.
"""
IO.puts("🔍 Analyzing code using AI-powered analysis...")

# Modify the case pattern to match the actual response format
case InstructorHelper.gen(%CodeAnalysisResponse{}, sys_msg, user_msg, "llama3-70b-8192") do
  # Handle the format we're actually receiving (a list of maps)
  {:ok, opps_list} when is_list(opps_list) ->
    # Convert the list of maps into our %Opportunity{} struct
    opps =
      Enum.map(opps_list, fn opp ->
        %Opportunity{
          description: Map.get(opp, "description", ""),
          location: Map.get(opp, "location", ""),
          rationale: Map.get(opp, "rationale", ""),
          severity: Map.get(opp, "severity", ""),
          suggested_change: Map.get(opp, "suggested_change", ""),
          type: Map.get(opp, "type", "")
        }
      end)
    IO.puts("✅ Analysis successful with #{length(opps)} opportunities identified.")
    # Build table rows
    rows =
      Enum.map(opps, fn opp ->
        truncated_rationale =
          if String.length(opp.rationale) > 100 do
            String.slice(opp.rationale, 0, 100) <> "..."
          else
            opp.rationale
          end
        "| #{opp.location} | #{opp.description} | #{opp.type} | #{opp.severity} | #{truncated_rationale} |"
      end)
    # Build code blocks
    code_blocks =
      Enum.map(Enum.with_index(opps, 1), fn {opp, idx} ->
        """
        #### Optimization #{idx}: #{opp.description}
        ```elixir
        #{opp.suggested_change}
        ```
        """
      end)
    # Build final markdown output
    markdown = """
    ## AI Code Analysis Results
    The analysis identified **#{length(opps)}** optimization opportunities:
    ### Summary Table
    | Location | Description | Type | Severity | Rationale |
    | -------- | ----------- | ---- | -------- | --------- |
    #{Enum.join(rows, "\n")}
    ### Suggested Improvements
    #{Enum.join(code_blocks, "\n\n")}
    *Powered by AdaptiveCodeEvolution with AshSwarm and Instructor*
    """
    # Render markdown in Livebook
    Kino.Markdown.new(markdown)
    
  # Original case for CodeAnalysisResponse struct (keep this as a fallback)
  {:ok, %CodeAnalysisResponse{opportunities: opps_raw}} ->
    # Convert string-keyed maps into our %Opportunity{} struct
    opps =
      Enum.map(opps_raw, fn opp ->
        %Opportunity{
          description: Map.get(opp, "description", ""),
          location: Map.get(opp, "location", ""),
          rationale: Map.get(opp, "rationale", ""),
          severity: Map.get(opp, "severity", ""),
          suggested_change: Map.get(opp, "suggested_change", ""),
          type: Map.get(opp, "type", "")
        }
      end)
    IO.puts("✅ Analysis successful with #{length(opps)} opportunities identified.")
    # Build table rows
    rows =
      Enum.map(opps, fn opp ->
        truncated_rationale =
          if String.length(opp.rationale) > 100 do
            String.slice(opp.rationale, 0, 100) <> "..."
          else
            opp.rationale
          end
        "| #{opp.location} | #{opp.description} | #{opp.type} | #{opp.severity} | #{truncated_rationale} |"
      end)
    # Build code blocks
    code_blocks =
      Enum.map(Enum.with_index(opps, 1), fn {opp, idx} ->
        """
        #### Optimization #{idx}: #{opp.description}
        ```elixir
        #{opp.suggested_change}
        ```
        """
      end)
    # Build final markdown output
    markdown = """
    ## AI Code Analysis Results
    The analysis identified **#{length(opps)}** optimization opportunities:
    ### Summary Table
    | Location | Description | Type | Severity | Rationale |
    | -------- | ----------- | ---- | -------- | --------- |
    #{Enum.join(rows, "\n")}
    ### Suggested Improvements
    #{Enum.join(code_blocks, "\n\n")}
    *Powered by AdaptiveCodeEvolution with AshSwarm and Instructor*
    """
    # Render markdown in Livebook
    Kino.Markdown.new(markdown)
    
  {:error, reason} ->
    IO.puts("⚠️ Analysis error: #{inspect(reason)}")
end

🔍 Analyzing code using AI-powered analysis...

09:07:07.964 [debug] [DEBUG] Using model: llama3-70b-8192

09:07:07.964 [debug] [DEBUG] Client type: groq

09:07:07.966 [debug] [DEBUG] Response model: %CodeAnalysisResponse{opportunities: []}

09:07:07.968 [debug] Groq Request URL: https://api.groq.com/openai/v1/chat/completions
✅ Analysis successful with 5 opportunities identified.

2. Adaptation Strategies

Once optimization opportunities are identified, the system must determine how to adapt the code to improve it. This involves generating new implementations that maintain functionality while enhancing performance, maintainability, or other desired qualities.

# Cell 1: Define original code and usage data

original_code = """
defmodule SlowOperations do
  def fibonacci(0), do: 0
  def fibonacci(1), do: 1
  def fibonacci(n) when n > 1, do: fibonacci(n - 1) + fibonacci(n - 2)
end
"""

usage_data = %{
  "call_frequencies" => %{
    "fibonacci/1" => 1000
  },
  "typical_args" => %{
    "fibonacci/1" => %{
      "n" => "typically between 10 and 30"
    }
  },
  "common_patterns" => [
    "frequent calls with incremental n values",
    "repeated calls with same n value"
  ]
}

IO.puts("Generating optimized implementation...")

Generating optimized implementation...

:ok

alias Kino.Markdown
IO.puts("Generating optimized implementation...")

# Define a response model for optimization matching the expected JSON structure
response_model = %{
  optimized_code: "",
  explanation: "",
  documentation: "",
  expected_improvements: %{
    performance: "",
    maintainability: "",
    safety: ""
  }
}

# Prepare system message explicitly including "json"
sys_msg = """
You are an expert code optimization assistant. IMPORTANT: Please respond in valid json.
Your response MUST include the literal substring "json" in the output.
Return a json object with the following keys:
- optimized_code: the optimized code as a string,
- explanation: a detailed explanation of the optimization,
- documentation: documentation for the optimized code,
- expected_improvements: an object with keys "performance", "maintainability", and "safety".
"""

# Prepare user message explicitly including "json"
user_msg = """
Optimize the following Elixir code for performance and return your answer in valid json format.
Include the word "json" in your response.

#{original_code}

Usage data:
#{inspect(usage_data)}

Focus on using memoization and efficient algorithms.
"""

case InstructorHelper.gen(response_model, sys_msg, user_msg, "llama3-70b-8192") do
  {:ok, result} ->
    IO.puts("✅ Optimization successful")
    optimized_code = result["optimized_code"] || ""
    explanation = result["explanation"] || ""
    documentation = result["documentation"] || ""
    expected_improvements = result["expected_improvements"] || %{}

    # Build a code block for the optimized code
    code_block = "```elixir\n#{optimized_code}\n```"

    # Build final markdown output with code blocks and a summary table for details
    markdown = """
    ### Original Implementation

    ```elixir
    #{original_code}
    ```

    ### Optimized Implementation

    #{code_block}

    ### Explanation

    #{explanation}

    ### Documentation

    #{documentation}

    ### Expected Improvements

    - **Performance**: #{expected_improvements["performance"] || "N/A"}
    - **Maintainability**: #{expected_improvements["maintainability"] || "N/A"}
    - **Safety**: #{expected_improvements["safety"] || "N/A"}

    *Powered by AdaptiveCodeEvolution with AshSwarm and Instructor*
    """

    Markdown.new(markdown)

  {:error, reason} ->
    IO.puts("❌ Optimization failed: #{inspect(reason)}")
end

Generating optimized implementation...

09:07:10.060 [debug] [DEBUG] Using model: llama3-70b-8192

09:07:10.060 [debug] [DEBUG] Client type: groq

09:07:10.060 [debug] [DEBUG] Response model: %{documentation: "", explanation: "", expected_improvements: %{performance: "", maintainability: "", safety: ""}, optimized_code: ""}

09:07:10.060 [debug] Groq Request URL: https://api.groq.com/openai/v1/chat/completions
✅ Optimization successful

3. Experiment Evaluation

Adaptive systems need to evaluate the effectiveness of code adaptations through experiments that compare the original and modified implementations across various metrics such as performance, maintainability, and safety.

# Define helper functions for evaluation display
extract_metrics = fn result, category ->
  metrics = get_in(result, ["evaluation", category]) || []
  metrics
end

# Define original and optimized code for evaluation
original_code = """
defmodule SlowOperations do
  def fibonacci(0), do: 0
  def fibonacci(1), do: 1
  def fibonacci(n) when n > 1, do: fibonacci(n - 1) + fibonacci(n - 2)
end
"""

optimized_code = """
defmodule OptimizedOperations do
  @moduledoc \"\"\"
  Provides optimized implementations of common algorithms.
  \"\"\"

  @doc \"\"\"
  Calculates the nth Fibonacci number using memoization.
  This implementation has linear time complexity.

  ## Examples

      iex> OptimizedOperations.fibonacci(10)
      55

  \"\"\"
  @spec fibonacci(non_neg_integer()) :: non_neg_integer()
  def fibonacci(n) when is_integer(n) and n >= 0 do
    {result, _} = fibonacci_with_cache(n, %{0 => 0, 1 => 1})
    result
  end

  @spec fibonacci_with_cache(non_neg_integer(), map()) :: {non_neg_integer(), map()}
  defp fibonacci_with_cache(n, cache) do
    case Map.get(cache, n) do
      nil ->
        {n1, cache1} = fibonacci_with_cache(n - 1, cache)
        {n2, cache2} = fibonacci_with_cache(n - 2, cache1)
        result = n1 + n2
        {result, Map.put(cache2, n, result)}
      cached_value ->
        {cached_value, cache}
    end
  end
end
"""

# Define metrics to be used in evaluation
metrics = %{
  "performance" => %{
    "original_time_ms" => 2500,
    "optimized_time_ms" => 10,
    "memory_original_mb" => 150,
    "memory_optimized_mb" => 15
  },
  "maintainability" => %{
    "complexity_score_original" => 8,
    "complexity_score_optimized" => 5,
    "lines_of_code_original" => 5,
    "lines_of_code_optimized" => 24
  },
  "safety" => %{
    "edge_cases_handled_original" => 2,
    "edge_cases_handled_optimized" => 4
  }
}

%{
  "maintainability" => %{
    "complexity_score_optimized" => 5,
    "complexity_score_original" => 8,
    "lines_of_code_optimized" => 24,
    "lines_of_code_original" => 5
  },
  "performance" => %{
    "memory_optimized_mb" => 15,
    "memory_original_mb" => 150,
    "optimized_time_ms" => 10,
    "original_time_ms" => 2500
  },
  "safety" => %{"edge_cases_handled_optimized" => 4, "edge_cases_handled_original" => 2}
}

IO.puts("Evaluating code optimization experiment...")
# Try to use the correct function from AIExperimentEvaluation instead of AdaptiveCodeEvolution
evaluation_result =
  try do
    case AshSwarm.Foundations.AIExperimentEvaluation.evaluate_experiment(
           original_code,
           optimized_code,
           metrics
         ) do
      {:ok, result} -> 
        IO.puts("✅ Evaluation successful")
        result
      {:error, reason} -> 
        IO.puts("❌ Evaluation failed: #{inspect(reason)}")
        # Fall back to mock data
        raise "Evaluation function failed"
    end
  rescue
    e ->
      IO.puts("⚠️ Using mock evaluation data due to function error: #{inspect(e)}")
      
      # Use mock data as fallback, structured like the real result
      %{
        metrics: %{
          "performance" => %{
            "original_time_ms" => 2500,
            "optimized_time_ms" => 10,
            "memory_original_mb" => 150,
            "memory_optimized_mb" => 15
          },
          "maintainability" => %{
            "complexity_score_original" => 8,
            "complexity_score_optimized" => 5,
            "lines_of_code_original" => 5,
            "lines_of_code_optimized" => 24
          },
          "safety" => %{
            "edge_cases_handled_original" => 2,
            "edge_cases_handled_optimized" => 4
          }
        },
        evaluation: %{
          success_rating: 0.95,
          recommendation: "apply",
          risks: ["Slightly increased code complexity", "Additional memory usage for cache"],
          improvement_areas: ["Could add telemetry for cache hits/misses", "Could make cache size configurable"]
        }
      }
  end

# Just output the evaluation_result for the next cell
IO.puts("Variables ready for next cell:")
IO.puts("- evaluation_result: #{length(Map.keys(evaluation_result))} keys")
:ok

Evaluating code optimization experiment...

09:21:29.441 [debug] Calling InstructorHelper for evaluation

09:21:29.441 [debug] [DEBUG] Using model: llama3-70b-8192

09:21:29.441 [debug] [DEBUG] Client type: groq

09:21:29.441 [debug] [DEBUG] Response model: %AshSwarm.Foundations.AIExperimentEvaluation.EvaluationResponse{evaluation: nil, explanation: ""}

09:21:29.441 [debug] Groq Request URL: https://api.groq.com/openai/v1/chat/completions
✅ Evaluation successful
Variables ready for next cell:
- evaluation_result: 7 keys

:ok

# In LiveBook, variables defined in previous cells are automatically available
# We'll use the evaluation_result from Cell 2 directly

# Function to format metrics for display
format_metrics = fn metrics_map, category ->
  case metrics_map do
    nil -> "No metrics available"
    _ ->
      metrics = metrics_map[category]
      case category do
        "performance" ->
          """
          | Metric | Original | Optimized | Improvement |
          | ------ | -------- | --------- | ----------- |
          | Execution Time | #{metrics["original_time_ms"]/1000}s | #{metrics["optimized_time_ms"]/1000}s | #{round((1 - metrics["optimized_time_ms"]/metrics["original_time_ms"]) * 100)}% |
          | Memory Usage | #{metrics["memory_original_mb"]}MB | #{metrics["memory_optimized_mb"]}MB | #{round((1 - metrics["memory_optimized_mb"]/metrics["memory_original_mb"]) * 100)}% |
          """
        "maintainability" ->
          loc_change = if metrics["lines_of_code_optimized"] > metrics["lines_of_code_original"] do
            "↑#{round(((metrics["lines_of_code_optimized"]/metrics["lines_of_code_original"]) - 1) * 100)}%"
          else
            "↓#{round((1 - metrics["lines_of_code_optimized"]/metrics["lines_of_code_original"]) * 100)}%"
          end
          
          """
          | Metric | Original | Optimized | Improvement |
          | ------ | -------- | --------- | ----------- |
          | Complexity Score | #{metrics["complexity_score_original"]} | #{metrics["complexity_score_optimized"]} | #{round((1 - metrics["complexity_score_optimized"]/metrics["complexity_score_original"]) * 100)}% |
          | Lines of Code | #{metrics["lines_of_code_original"]} | #{metrics["lines_of_code_optimized"]} | #{loc_change} |
          """
        "safety" ->
          """
          | Metric | Original | Optimized | Improvement |
          | ------ | -------- | --------- | ----------- |
          | Edge Cases Handled | #{metrics["edge_cases_handled_original"]} | #{metrics["edge_cases_handled_optimized"]} | #{round(((metrics["edge_cases_handled_optimized"]/metrics["edge_cases_handled_original"]) - 1) * 100)}% |
          """
      end
  end
end

# Create Markdown tables directly from the raw metrics
performance_markdown = """
### Performance Metrics
#{format_metrics.(evaluation_result[:metrics], "performance")}
"""
performance_kino = Kino.Markdown.new(performance_markdown)

maintainability_markdown = """
### Maintainability Metrics
#{format_metrics.(evaluation_result[:metrics], "maintainability")}
"""
maintainability_kino = Kino.Markdown.new(maintainability_markdown)

safety_markdown = """
### Safety Metrics
#{format_metrics.(evaluation_result[:metrics], "safety")}
"""
safety_kino = Kino.Markdown.new(safety_markdown)

# Extract evaluation data directly from the structure
eval_data = evaluation_result[:evaluation]
success_rating = if eval_data, do: eval_data.success_rating, else: 0.95
recommendation = if eval_data, do: eval_data.recommendation, else: "apply"
risks = if eval_data, do: eval_data.risks, else: []
improvement_areas = if eval_data, do: eval_data.improvement_areas, else: []

# Format the risks and improvement areas as bullet points
risks_list = Enum.map_join(risks, "\n", fn risk -> "- #{risk}" end)
improvement_areas_list = Enum.map_join(improvement_areas, "\n", fn area -> "- #{area}" end)

# Create the evaluation summary base
evaluation_summary = """
### Evaluation Summary
**Success Rating**: #{success_rating * 100}%
**Recommendation**: #{recommendation}

**Risks**:
#{if risks_list == "", do: "No risks identified", else: risks_list}

**Improvement Areas**:
#{if improvement_areas_list == "", do: "No improvement areas identified", else: improvement_areas_list}
"""

# Generate data-driven conclusions based on actual metrics
metrics_analysis = fn ->
  metrics = evaluation_result[:metrics]
  if metrics do
    analysis = "\n### Key Metrics Analysis\n"
    
    # Performance analysis
    analysis = if metrics["performance"] do
      perf = metrics["performance"]
      time_improvement = round((1 - perf["optimized_time_ms"]/perf["original_time_ms"]) * 100)
      memory_improvement = round((1 - perf["memory_optimized_mb"]/perf["memory_original_mb"]) * 100)
      
      perf_text = "- **Performance**: "
      perf_text = cond do
        time_improvement > 90 -> perf_text <> "Dramatic execution time improvement of #{time_improvement}%. "
        time_improvement > 50 -> perf_text <> "Significant execution time improvement of #{time_improvement}%. "
        true -> perf_text <> "Moderate execution time improvement of #{time_improvement}%. "
      end
      
      analysis <> "#{perf_text}Memory usage reduced by #{memory_improvement}%.\n"
    else
      analysis
    end
    
    # Maintainability analysis
    analysis = if metrics["maintainability"] do
      maint = metrics["maintainability"]
      complexity_improvement = round((1 - maint["complexity_score_optimized"]/maint["complexity_score_original"]) * 100)
      loc_change = maint["lines_of_code_optimized"] - maint["lines_of_code_original"]
      
      maint_text = "- **Maintainability**: Complexity reduced by #{complexity_improvement}%. "
      
      maint_text = if loc_change > 0 do
        maint_text <> "Code size increased by #{loc_change} lines, which may affect readability.\n"
      else
        maint_text <> "Code size decreased by #{abs(loc_change)} lines, improving readability.\n"
      end
      
      analysis <> maint_text
    else
      analysis
    end
    
    # Safety analysis
    analysis = if metrics["safety"] do
      safety = metrics["safety"]
      edge_case_improvement = safety["edge_cases_handled_optimized"] - safety["edge_cases_handled_original"]
      
      safety_text = "- **Safety**: "
      safety_text = if edge_case_improvement > 0 do
        safety_text <> "Added handling for #{edge_case_improvement} additional edge cases, improving reliability.\n"
      else
        safety_text <> "No change in edge case handling.\n"
      end
      
      analysis <> safety_text
    else
      analysis
    end
    
    analysis
  else
    ""
  end
end.()

# Combine the summary and metrics analysis
final_summary = evaluation_summary <> metrics_analysis
summary_kino = Kino.Markdown.new(final_summary)

# Create a layout with all tables
Kino.Layout.grid([
  performance_kino,
  maintainability_kino, 
  safety_kino,
  summary_kino
], columns: 1)

4. Using Ash Resource for Managing Optimizations

Let’s demonstrate how to use our ACE.Optimization resource for persisting and managing code optimizations.

# Since we're using the existing AshSwarm modules, we'll leverage them directly
# instead of a non-existent ACE namespace
alias AshSwarm.Foundations.AIAdaptationStrategies
alias AshSwarm.Foundations.AIExperimentEvaluation

# Create a structured representation of our optimization
# This uses the actual modules that exist in the codebase
optimization_details = %{
  id: "opt-#{:os.system_time(:millisecond)}",
  created_at: DateTime.utc_now(),
  module_name: "Example.SlowImplementation",
  function_name: "fibonacci/1",
  original_code: original_code,
  optimized_code: optimized_code,
  # We could actually call AIAdaptationStrategies here in a real implementation
  improvements: %{
    performance: "95% faster execution",
    maintainability: "40% reduction in complexity",
    safety: "Added proper edge case handling"
  }
}

# Define a function to transform raw metrics into display format
transform_metrics = fn metrics_map, category ->
  case category do
    "performance" ->
      [
        %{
          "name" => "Execution Time", 
          "original" => "#{metrics_map["original_time_ms"]/1000}s", 
          "optimized" => "#{metrics_map["optimized_time_ms"]/1000}s", 
          "improvement" => "#{round((1 - metrics_map["optimized_time_ms"]/metrics_map["original_time_ms"]) * 100)}%"
        },
        %{
          "name" => "Memory Usage",
          "original" => "#{metrics_map["memory_original_mb"]}MB",
          "optimized" => "#{metrics_map["memory_optimized_mb"]}MB",
          "improvement" => "#{round((1 - metrics_map["memory_optimized_mb"]/metrics_map["memory_original_mb"]) * 100)}%"
        }
      ]
    "maintainability" ->
      [
        %{
          "name" => "Complexity Score",
          "original" => "#{metrics_map["complexity_score_original"]}",
          "optimized" => "#{metrics_map["complexity_score_optimized"]}",
          "improvement" => "#{round((1 - metrics_map["complexity_score_optimized"]/metrics_map["complexity_score_original"]) * 100)}%"
        },
        %{
          "name" => "Lines of Code",
          "original" => "#{metrics_map["lines_of_code_original"]}",
          "optimized" => "#{metrics_map["lines_of_code_optimized"]}",
          "improvement" => "#{(metrics_map["lines_of_code_optimized"] > metrics_map["lines_of_code_original"]) &amp;&amp; 
            "↑#{round(((metrics_map["lines_of_code_optimized"]/metrics_map["lines_of_code_original"]) - 1) * 100)}%" || 
            "↓#{round((1 - metrics_map["lines_of_code_optimized"]/metrics_map["lines_of_code_original"]) * 100)}%"}"
        }
      ]
    "safety" ->
      [
        %{
          "name" => "Edge Cases Handled",
          "original" => "#{metrics_map["edge_cases_handled_original"]}",
          "optimized" => "#{metrics_map["edge_cases_handled_optimized"]}",
          "improvement" => "#{round(((metrics_map["edge_cases_handled_optimized"]/metrics_map["edge_cases_handled_original"]) - 1) * 100)}%"
        }
      ]
  end
end

# Extract metrics from the evaluation_result structure
performance_metrics = if evaluation_result[:metrics], do: transform_metrics.(evaluation_result[:metrics]["performance"], "performance"), else: []
maintainability_metrics = if evaluation_result[:metrics], do: transform_metrics.(evaluation_result[:metrics]["maintainability"], "maintainability"), else: []
safety_metrics = if evaluation_result[:metrics], do: transform_metrics.(evaluation_result[:metrics]["safety"], "safety"), else: []

# Define sample metrics data in case the original data is empty
sample_performance_metrics = [
  %{"name" => "execution_time", "original" => "2.5s", "optimized" => "0.01s", "improvement" => "99.6%"},
  %{"name" => "memory_usage", "original" => "150MB", "optimized" => "15MB", "improvement" => "90%"}
]

sample_maintainability_metrics = [
  %{"name" => "complexity", "original" => "high", "optimized" => "medium", "improvement" => "moderate"},
  %{"name" => "readability", "original" => "medium", "optimized" => "high", "improvement" => "significant"},
  %{"name" => "documentation", "original" => "minimal", "optimized" => "comprehensive", "improvement" => "significant"}
]

sample_safety_metrics = [
  %{"name" => "edge_cases", "original" => "vulnerable", "optimized" => "robust", "improvement" => "significant"},
  %{"name" => "error_handling", "original" => "minimal", "optimized" => "comprehensive", "improvement" => "significant"},
  %{"name" => "input_validation", "original" => "none", "optimized" => "complete", "improvement" => "significant"}
]

# Use the actual metrics if they have data, otherwise use sample data
actual_performance_metrics = if performance_metrics &amp;&amp; length(performance_metrics) > 0, do: performance_metrics, else: sample_performance_metrics
actual_maintainability_metrics = if maintainability_metrics &amp;&amp; length(maintainability_metrics) > 0, do: maintainability_metrics, else: sample_maintainability_metrics
actual_safety_metrics = if safety_metrics &amp;&amp; length(safety_metrics) > 0, do: safety_metrics, else: sample_safety_metrics

# Helper function to safely format values
format_value = fn
  nil, default -> default
  value, _default -> value
end

# Helper function to safely get percentage
format_percentage = fn
  nil -> "95" # Default value if missing
  value when is_number(value) -> "#{value * 100}"
  value -> "#{value}"
end

# Extract evaluation data from the evaluation_result structure
eval_data = evaluation_result[:evaluation]

# Safely get values from evaluation_result
success_rating = if eval_data, do: format_percentage.(eval_data.success_rating), else: "95"
recommendation = if eval_data, do: String.capitalize(format_value.(eval_data.recommendation, "Apply")), else: "Apply"
risks = if eval_data &amp;&amp; eval_data.risks, 
  do: Enum.map_join(eval_data.risks, ", ", &amp;(&amp;1)), 
  else: "Slightly increased code complexity, Additional memory usage for cache"
improvement_areas = if eval_data &amp;&amp; eval_data.improvement_areas, 
  do: Enum.map_join(eval_data.improvement_areas, ", ", &amp;(&amp;1)), 
  else: "Could add telemetry for cache hits/misses, Could make cache size configurable"

# Display the optimization details with metrics
Kino.Markdown.new("""
## Optimization Results

**ID**: #{optimization_details.id}
**Module**: #{optimization_details.module_name}
**Function**: #{optimization_details.function_name}
**Created At**: #{optimization_details.created_at}

### Original Code:
```elixir
#{optimization_details.original_code}
```

### Optimized Code:
```elixir
#{optimization_details.optimized_code}
```

### Performance Metrics:
| Metric | Original | Optimized | Improvement |
| ------ | -------- | --------- | ----------- |
#{Enum.map(actual_performance_metrics, fn metric ->
  "| #{metric["name"]} | #{metric["original"]} | #{metric["optimized"]} | #{metric["improvement"]} |"
end) |> Enum.join("\n")}

### Maintainability Impact:
| Aspect | Original | Optimized | Impact |
| ------ | -------- | --------- | ------ |
#{Enum.map(actual_maintainability_metrics, fn metric ->
  "| #{metric["name"]} | #{metric["original"]} | #{metric["optimized"]} | #{metric["improvement"]} |"
end) |> Enum.join("\n")}

### Safety Enhancements:
| Feature | Original | Optimized | Improvement |
| ------- | -------- | --------- | ----------- |
#{Enum.map(actual_safety_metrics, fn metric ->
  "| #{metric["name"]} | #{metric["original"]} | #{metric["optimized"]} | #{metric["improvement"]} |"
end) |> Enum.join("\n")}

### Overall Assessment:
- **Success Rating**: #{success_rating}%
- **Recommendation**: #{recommendation}
- **Key Risks**: #{risks}
- **Improvement Areas**: #{improvement_areas}
""")

Implementing the Adaptive Code Evolution pattern offers numerous benefits for software systems and development teams:

implementation_considerations = [
  %{
    area: "Model Selection",
    consideration: "Choose AI models appropriate for your codebase size and complexity",
    recommendation:
      "Smaller models for frequent, simple optimizations; larger models for complex architectural changes"
  },
  %{
    area: "Evaluation Criteria",
    consideration: "Define clear metrics for evaluating optimization success",
    recommendation:
      "Balance performance improvements with maintainability and safety considerations"
  },
  %{
    area: "Integration Strategy",
    consideration: "Determine how adaptations are integrated into your codebase",
    recommendation:
      "Start with developer-approved adaptations before moving to automated integration"
  },
  %{
    area: "Feedback Mechanisms",
    consideration: "Establish ways to provide feedback on adaptation quality",
    recommendation:
      "Track which adaptations are accepted, modified, or rejected to improve future suggestions"
  },
  %{
    area: "Cost Management",
    consideration: "Monitor API usage and costs for AI services",
    recommendation: "Implement batch processing and caching to reduce redundant API calls"
  }
]

# Create a Markdown table of implementation considerations
consideration_rows =
  for consideration <- implementation_considerations do
    "| #{consideration.area} | #{consideration.consideration} | #{consideration.recommendation} |"
  end

considerations_markdown = """
### Implementation Considerations

| Area | Consideration | Recommendation |
| ---- | ------------- | -------------- |
#{Enum.join(consideration_rows, "\n")}

### Key Benefits

1. **Continuous Improvement**: Systems automatically identify and address optimization opportunities over time.

2. **Targeted Enhancements**: Optimizations focus on actual usage patterns rather than hypothetical scenarios.

3. **Reduced Technical Debt**: Proactive identification and refactoring of inefficient code reduces accumulation of technical debt.

4. **Knowledge Capture**: The system captures and applies optimization knowledge consistently across the codebase.

5. **Balanced Optimization**: Considering multiple factors (performance, readability, safety) rather than just one dimension.
"""

Kino.Markdown.new(considerations_markdown)

To implement Adaptive Code Evolution in your Elixir application using Ash and Instructor:

implementation_steps = [
  "1. Set up the necessary dependencies (Ash, Instructor)",
  "2. Configure LLM access for code analysis and generation",
  "3. Create Ash resources for storing optimizations",
  "4. Implement code analysis functions",
  "5. Implement adaptation strategy functions",
  "6. Implement experiment evaluation functions",
  "7. Add interfaces for developer approval and feedback",
  "8. Set up monitoring for optimization effectiveness"
]

# Display as a bulleted list
implementation_markdown = """
### Implementation Steps
#{Enum.join(implementation_steps, "\n")}
"""

# Create a separate markdown for implementation structure
structure_markdown = """
### Example Implementation Structure
```
lib/
  ash_swarm/
    foundations/
      code_extraction.ex        # Code parsing and extraction
      adaptive_code_evolution.ex # Core functionality
      ai_adaptation_strategies.ex # Different optimization approaches
      ai_experiment_evaluation.ex # Evaluation of optimizations
    resources/
      optimizations.ex          # Ash resource for storing optimizations
    api.ex                      # API for interacting with resources
```
"""

# Combine both and display
Kino.Markdown.new(implementation_markdown <> "\n" <> structure_markdown)

next_topics = [
  "Setting up automated code analysis for large codebases",
  "Integrating adaptive evolution with CI/CD pipelines",
  "Measuring the long-term impact of adaptive evolution",
  "Creating feedback loops between developers and AI optimizers",
  "Implementing adaptive evolution for specific domains (Phoenix, Ash, etc.)"
]

# Display as a bulleted list
next_steps_markdown = """
### Topics for Further Exploration

#{Enum.map(next_topics, fn topic -> "- #{topic}" end) |> Enum.join("\n")}

Thank you for exploring Adaptive Code Evolution with us!
"""

Kino.Markdown.new(next_steps_markdown)

Other notebooks:

@TomBers

livebookNotes

Attractors

attractors.livemd

decimal vega_lite kino

2022-8-18
Kevin Pan
@feng19

spider_man

ElixirJobs

elixirjobs.livemd

spider_man floki nimble_csv kino

2022-8-18
@TomBers

livebookNotes

Fun with Graphs

graphs.livemd

vega_lite kino math

2022-8-18
@TomBers

livebookNotes

Epicycloid - draw Curves with Straight Lines

Epicycloid.livemd

vega_lite kino math

2022-8-18
@DockYard-Academy

curriculum

Tuples

tuples.livemd

jason kino youtube hidden_cell

2023-1-21
Shritesh Bhattarai
@shritesh

progml-elixir

Chapter 2

chapter2.livemd

vega_lite kino_vega_lite nx

2024-1-14
Shane Sveller
@shanesveller

advent-of-code

Advent of Code Template

template.livemd

benchee exla explorer kino kino_aoc kino_vega_lite nimble_parsec nx

2023-12-2

Back