Commonplace

The Progressive Complexity Principle

Commonplace is designed with the principle of progressive complexity, which means the system starts simple and gradually reveals more powerful features as you need them. This document explains this principle and how it shapes your experience with Commonplace.

What is Progressive Complexity?

Progressive complexity is a design approach that:

  • Makes the system accessible to beginners
  • Gradually introduces advanced features
  • Allows power users to access sophisticated capabilities
  • Prevents overwhelming new users with complexity
  • Supports users as they grow in expertise

This approach ensures that Commonplace can serve both casual users who need a simple note-taking system and power users who require advanced knowledge management capabilities.

How Progressive Complexity Works in Commonplace

Commonplace implements progressive complexity in several ways:

Layered Interface

The user interface reveals features in layers:

  • Basic layer: Simple card creation and organization
  • Intermediate layer: Card types, links, and collections
  • Advanced layer: Commonscript, system extensions, and federation

Features from more advanced layers are accessible but not prominent until you need them.

Automatic Inference

Commonplace reduces initial complexity through automatic inference:

  • Card Types are automatically inferred from the data you enter
  • Links can be created visually before defining formal inlets and outlets
  • Collections can start as simple groups before evolving into structured containers

This allows you to start using the system without understanding all the underlying concepts.

Contextual Guidance

The system provides guidance based on your current activities:

  • Relevant features are suggested when they might be useful
  • Documentation is accessible in context
  • Examples show how advanced features can solve specific problems

This helps you discover new capabilities when they're most relevant to your needs.

Incremental Learning Path

Commonplace supports an incremental learning path:

  1. Start with cards: Create simple cards without worrying about Types
  2. Organize with collections: Group related cards into collections
  3. Add structure with card types: Define consistent structures for your cards
  4. Create links: Establish relationships between cards
  5. Add behavior with Commonscript: Automate processes and add interactivity
  6. Extend the system: Add new capabilities through system extensions
  7. Share and collaborate: Use federation to share and collaborate

Each step builds on the previous ones, allowing you to learn at your own pace.

Examples of Progressive Complexity

Example 1: Card Creation

  • Basic: Create a card with free-form text
  • Intermediate: Use Card Types to define structured fields
  • Advanced: Add Commonscript for validation and calculated fields

Example 2: Organization

  • Basic: Group cards into simple collections
  • Intermediate: Use different collection modes (list, spatial)
  • Advanced: Create hierarchical collection structures with custom behaviors

Example 3: Links

  • Basic: Visually connect cards to show relationships
  • Intermediate: Define named inlets for structured connections
  • Advanced: Use event-driven programming with Card Type-constrained inlets

Benefits of Progressive Complexity

The progressive complexity approach provides several benefits:

  • Low entry barrier: New users can start using the system immediately
  • Sustainable learning curve: Users can learn new features gradually
  • Long-term power: The system grows with users' needs and expertise
  • Inclusive design: Both casual and power users can use the same system
  • Reduced cognitive load: Users only need to understand the features they're using

Working with Progressive Complexity

As you use Commonplace, you can take advantage of progressive complexity by:

  • Starting simple: Begin with basic features and add complexity as needed
  • Exploring gradually: Discover new features as your needs evolve
  • Learning incrementally: Focus on understanding one concept at a time
  • Building on basics: Use advanced features to enhance your existing system
  • Customizing your experience: Configure the interface to match your expertise level

Next Steps

Now that you understand progressive complexity, you might want to learn about: