site:           https://treeform.github.io/devcompas/

Your Programming Philosophy
    You prefer elegant, high-level solutions that are intuitive and
    accessible to other developers. You likely favor functional
    programming, clear abstractions, and code that reads like prose.

Abstract ↔ Concrete:       +3 Abstract
Human ↔ Computer Friendly: +2 Human-Friendly

────────────────────────────────────────────────────────────────────────

My approach to learning new technologies is:    Understand the underlying principles
For testing, I believe in:                      Whatever catches bugs most effectively
When writing algorithms, I focus on:            Correctness and clarity above all
For libraries, I prefer:                        Normal libraries that everyone uses
My preferred approach to error handling is:     Using monadic error types (Result, Maybe, etc.)
Which style of programming do you prefer:       Functional style
My preferred approach to configuration is:      Type-safe configuration with validation
For making user interfaces, I believe in:       Simple, easy to edit HTML/CSS
My philosophy on software architecture is:      Optimize for team understanding and collaboration
When refactoring code, I prioritize:            Improving readability and maintainability
When writing code, I prefer:                    Whatever makes the code most maintainable
When it comes to code comments, I believe:      Comments should explain the 'why', not the 'what'
When debugging, I typically:                    Write tests to isolate the problem
For variable names, I believe in:               Short, concise names and abbreviations
For data structures, I prefer:                  Functional style with immutable data
My attitude toward code reuse is:               Optimize for readability first, reuse second
When it comes to performance optimization:      Measure first, optimize bottlenecks only
For code organization, I prefer:                Flat structures with clear file naming
My attitude toward type systems is:             I like strong static types
When designing APIs, I prioritize:              Consistency with existing patterns

────────────────────────────────────────────────────────────────────────

My approach to learning new technologies is:
    Jump in and learn by doing
  ■ Understand the underlying principles
    Read the documentation thoroughly first
    Start with tutorials and examples

For testing, I believe in:
    Comprehensive unit tests for every function
    Property-based testing and generative tests
  ■ Whatever catches bugs most effectively
    Integration tests that verify user scenarios

When writing algorithms, I focus on:
  ■ Correctness and clarity above all
    Practical performance in real scenarios
    Elegant mathematical formulation
    Optimal time and space complexity

For libraries, I prefer:
    Large, batteries-included frameworks
    Build things myself from scratch
    Small, header-only, or micro-libraries
  ■ Normal libraries that everyone uses

My preferred approach to error handling is:
    Based on the code convention of the project
  ■ Using monadic error types (Result, Maybe, etc.)
    Using return error codes
    Using exceptions

Which style of programming do you prefer:
    Object-oriented style
  ■ Functional style
    Imperative style
    Whatever the team is most comfortable with

My preferred approach to configuration is:
  ■ Type-safe configuration with validation
    Simple key-value pairs in plain text files
    Convention over configuration
    DSLs that express configuration declaratively

For making user interfaces, I believe in:
    Consistent platform conventions (SwiftUI, WinUI, etc.)
    Powerful WYSIWYG editors with rich functionality (Figma, etc.)
    Declarative UI frameworks (React, Vue, etc.)
  ■ Simple, easy to edit HTML/CSS

My philosophy on software architecture is:
    Start simple, add complexity only when needed
    Follow proven patterns and practices
  ■ Optimize for team understanding and collaboration
    Design for extensibility from the beginning

When refactoring code, I prioritize:
  ■ Improving readability and maintainability
    Optimizing performance and resource usage
    Extracting reusable abstractions
    Reducing complexity and coupling

When writing code, I prefer:
    High-level abstractions that hide implementation details
    A balance of abstraction and clarity
    Direct, explicit code that shows exactly what's happening
  ■ Whatever makes the code most maintainable

When it comes to code comments, I believe:
    Comments are only needed for complex algorithms
    Extensive documentation makes code more accessible
  ■ Comments should explain the 'why', not the 'what'
    Code should be self-documenting, comments are code smell

When debugging, I typically:
    Reason about the code logically first
  ■ Write tests to isolate the problem
    Add print statements to understand data flow
    Use a debugger to step through code systematically

For variable names, I believe in:
  ■ Short, concise names and abbreviations
    Pefixes and suffixes
    Domain-specific terminology and conventions
    Descriptive, self-documenting names even if they're long

For data structures, I prefer:
    Object-oriented with inheritance and interfaces
    Simple arrays and objects that anyone can understand
  ■ Functional style with immutable data
    What is natural for the problem domain

My attitude toward code reuse is:
    DRY (Don't Repeat Yourself) is a fundamental principle
  ■ Optimize for readability first, reuse second
    Some duplication is better than wrong abstraction
    Build reusable components from the start

When it comes to performance optimization:
    Profile and optimize the critical path
  ■ Measure first, optimize bottlenecks only
    Use high-level optimizations and let tools handle details
    Write efficient code from the beginning

For code organization, I prefer:
  ■ Flat structures with clear file naming
    Domain-driven design principles
    Layered architectures with clear boundaries
    Whatever the framework/language suggests

My attitude toward type systems is:
    I like composable types
    I like dynamic types
    I like a mix of static and dynamic types
  ■ I like strong static types

When designing APIs, I prioritize:
  ■ Consistency with existing patterns
    Minimal, orthogonal operations
    Performance and efficiency above all
    Intuitive interfaces that feel natural to use

────────────────────────────────────────────────────────────────────────

questions:      https://raw.githubusercontent.com/treeform/devcompas/refs/heads/master/questions.json

{
  "questions": [
    {
      "id": 1,
      "question": "When writing code, I prefer:",
      "options": [
        {"text": "High-level abstractions that hide implementation details", "abstract": 2, "human": 1},
        {"text": "Direct, explicit code that shows exactly what's happening", "abstract": -2, "human": 0},
        {"text": "A balance of abstraction and clarity", "abstract": 0, "human": 0},
        {"text": "Whatever makes the code most maintainable", "abstract": 1, "human": 1}
      ]
    },
    {
      "id": 2,
      "question": "For variable names, I believe in:",
      "options": [
        {"text": "Descriptive, self-documenting names even if they're long", "abstract": 2, "human": 2},
        {"text": "Short, concise names and abbreviations", "abstract": -1, "human": 0},
        {"text": "Domain-specific terminology and conventions", "abstract": 0, "human": 0},
        {"text": "Pefixes and suffixes", "abstract": 2, "human": -2}
      ]
    },
    {
      "id": 3,
      "question": "When designing APIs, I prioritize:",
      "options": [
        {"text": "Intuitive interfaces that feel natural to use", "abstract": 0, "human": 2},
        {"text": "Minimal, orthogonal operations", "abstract": 2, "human": -1},
        {"text": "Performance and efficiency above all", "abstract": -1, "human": -2},
        {"text": "Consistency with existing patterns", "abstract": 1, "human": 0}
      ]
    },
    {
      "id": 4,
      "question": "My preferred approach to error handling is:",
      "options": [
        {"text": "Using return error codes", "abstract": -1, "human": -1},
        {"text": "Using exceptions", "abstract": 1, "human": 1},
        {"text": "Using monadic error types (Result, Maybe, etc.)", "abstract": 2, "human": -1},
        {"text": "Based on the code convention of the project", "abstract": 0, "human": 0}
      ]
    },
    {
      "id": 5,
      "question": "When it comes to code comments, I believe:",
      "options": [
        {"text": "Code should be self-documenting, comments are code smell", "abstract": 1, "human": -1},
        {"text": "Comments should explain the 'why', not the 'what'", "abstract": 0, "human": 1},
        {"text": "Extensive documentation makes code more accessible", "abstract": -1, "human": 2},
        {"text": "Comments are only needed for complex algorithms", "abstract": 0, "human": -1}
      ]
    },
    {
      "id": 6,
      "question": "For data structures, I prefer:",
      "options": [
        {"text": "Simple arrays and objects that anyone can understand", "abstract": -2, "human": -2},
        {"text": "Object-oriented with inheritance and interfaces", "abstract": 2, "human": 0 },
        {"text": "Functional style with immutable data", "abstract": 2, "human": -2},
        {"text": "What is natural for the problem domain", "abstract": 0, "human": 0}
      ]
    },
    {
      "id": 7,
      "question": "Which style of programming do you prefer:",
      "options": [
        {"text": "Functional style", "abstract": 0, "human": 0},
        {"text": "Imperative style", "abstract": -2, "human": 1},
        {"text": "Object-oriented style", "abstract": 2, "human": 1},
        {"text": "Whatever the team is most comfortable with", "abstract": 0, "human": 2}
      ]
    },
    {
      "id": 8,
      "question": "My attitude toward code reuse is:",
      "options": [
        {"text": "DRY (Don't Repeat Yourself) is a fundamental principle", "abstract": 1, "human": 0},
        {"text": "Some duplication is better than wrong abstraction", "abstract": -1, "human": 1},
        {"text": "Build reusable components from the start", "abstract": 2, "human": -1},
        {"text": "Optimize for readability first, reuse second", "abstract": -1, "human": 2}
      ]
    },
    {
      "id": 9,
      "question": "For testing, I believe in:",
      "options": [
        {"text": "Comprehensive unit tests for every function", "abstract": -1, "human": -1},
        {"text": "Property-based testing and generative tests", "abstract": 2, "human": -2},
        {"text": "Integration tests that verify user scenarios", "abstract": 0, "human": 2},
        {"text": "Whatever catches bugs most effectively", "abstract": 0, "human": 0}
      ]
    },
    {
      "id": 10,
      "question": "When debugging, I typically:",
      "options": [
        {"text": "Use a debugger to step through code systematically", "abstract": -1, "human": 0},
        {"text": "Add print statements to understand data flow", "abstract": -2, "human": 1},
        {"text": "Reason about the code logically first", "abstract": 1, "human": 1},
        {"text": "Write tests to isolate the problem", "abstract": 0, "human": -1}
      ]
    },
    {
      "id": 11,
      "question": "My preferred approach to configuration is:",
      "options": [
        {"text": "Simple key-value pairs in plain text files", "abstract": -2, "human": 2},
        {"text": "Type-safe configuration with validation", "abstract": 1, "human": -1},
        {"text": "DSLs that express configuration declaratively", "abstract": 2, "human": 0},
        {"text": "Convention over configuration", "abstract": 1, "human": 1}
      ]
    },
    {
      "id": 12,
      "question": "When it comes to performance optimization:",
      "options": [
        {"text": "Measure first, optimize bottlenecks only", "abstract": 0, "human": 0},
        {"text": "Write efficient code from the beginning", "abstract": -1, "human": -2},
        {"text": "Use high-level optimizations and let tools handle details", "abstract": 2, "human": 1},
        {"text": "Profile and optimize the critical path", "abstract": -1, "human": -1}
      ]
    },
    {
      "id": 13,
      "question": "For code organization, I prefer:",
      "options": [
        {"text": "Flat structures with clear file naming", "abstract": -1, "human": 2},
        {"text": "Layered architectures with clear boundaries", "abstract": 1, "human": 0},
        {"text": "Domain-driven design principles", "abstract": 2, "human": 1},
        {"text": "Whatever the framework/language suggests", "abstract": 0, "human": 1}
      ]
    },
    {
      "id": 14,
      "question": "My approach to learning new technologies is:",
      "options": [
        {"text": "Start with tutorials and examples", "abstract": -1, "human": 2},
        {"text": "Read the documentation thoroughly first", "abstract": 0, "human": 0},
        {"text": "Understand the underlying principles", "abstract": 2, "human": -1},
        {"text": "Jump in and learn by doing", "abstract": -2, "human": 1}
      ]
    },
    {
      "id": 15,
      "question": "When writing algorithms, I focus on:",
      "options": [
        {"text": "Correctness and clarity above all", "abstract": -1, "human": 2},
        {"text": "Optimal time and space complexity", "abstract": 0, "human": -2},
        {"text": "Elegant mathematical formulation", "abstract": 2, "human": -1},
        {"text": "Practical performance in real scenarios", "abstract": -1, "human": 0}
      ]
    },
    {
      "id": 16,
      "question": "For libraries, I prefer:",
      "options": [
        {"text": "Normal libraries that everyone uses", "abstract": 0, "human": 0},
        {"text": "Build things myself from scratch", "abstract": -1, "human": -2},
        {"text": "Small, header-only, or micro-libraries", "abstract": 0, "human": 1},
        {"text": "Large, batteries-included frameworks", "abstract": 2, "human": 0}
      ]
    },
    {
      "id": 17,
      "question": "My attitude toward type systems is:",
      "options": [
        {"text": "I like strong static types", "abstract": 0, "human": -2},
        {"text": "I like dynamic types", "abstract": 0, "human": 2},
        {"text": "I like a mix of static and dynamic types", "abstract": 0, "human": 0},
        {"text": "I like composable types", "abstract": 2, "human": 0}
      ]
    },
    {
      "id": 18,
      "question": "When refactoring code, I prioritize:",
      "options": [
        {"text": "Improving readability and maintainability", "abstract": -1, "human": 2},
        {"text": "Extracting reusable abstractions", "abstract": 2, "human": 0},
        {"text": "Optimizing performance and resource usage", "abstract": 0, "human": -2},
        {"text": "Reducing complexity and coupling", "abstract": 1, "human": 1}
      ]
    },
    {
      "id": 19,
      "question": "For making user interfaces, I believe in:",
      "options": [
        {"text": "Simple, easy to edit HTML/CSS", "abstract": -1, "human": -2},
        {"text": "Powerful WYSIWYG editors with rich functionality (Figma, etc.)", "abstract": 1, "human": 2},
        {"text": "Declarative UI frameworks (React, Vue, etc.)", "abstract": 2, "human": 0},
        {"text": "Consistent platform conventions (SwiftUI, WinUI, etc.)", "abstract": 0, "human": 0}
      ]
    },
    {
      "id": 20,
      "question": "My philosophy on software architecture is:",
      "options": [
        {"text": "Start simple, add complexity only when needed", "abstract": -1, "human": 1},
        {"text": "Design for extensibility from the beginning", "abstract": 2, "human": -1},
        {"text": "Follow proven patterns and practices", "abstract": 1, "human": 0},
        {"text": "Optimize for team understanding and collaboration", "abstract": 0, "human": 2}
      ]
    }
  ]
}