A More Practical Way for Developers to Learn Algorithms

Many developers assume Big-O notation and data structures are exclusively for specialists working on databases or game engines. I created Stacksmith to challenge this assumption, demonstrating how everyday algorithmic choices dramatically impact performance.

The Universal Laws of Speed

Stacksmith provides a CLI tool comparing different algorithms on identical datasets. Consider Linear Search (O(N)) versus Binary Search (O(log N)):

Dataset Size	Linear Search	Binary Search
1,000	~1,000 checks	~10 checks
10,000	~10,000 checks	~14 checks
1,000,000	~1,000,000 checks	~20 checks

If you pick an O(N) solution where O(log N) is possible, no compiler, JIT, or runtime can save you.

Hidden Performance Problems

Common patterns mask O(N^2) complexity. Consider this example:

const activeUsers = users.map(user => {
  const details = userDetails.find(d => d.id === user.id);
  return { ...user, ...details };
});

With 1,000 items in each array, this performs approximately 1,000,000 comparisons. Prebuilding a Map reduces lookups to O(1), dropping total operations from roughly 1,000,000 to a few thousand—identical functionality, dramatically different performance.

The Stacksmith Approach

The project name references blacksmiths who understand their materials’ characteristics. Developers similarly work with different data structures—arrays, maps, sets, trees, graphs—each with distinct strengths.

Stacksmith offers:

• Twenty chapters covering arrays through dynamic programming
• Solutions in both TypeScript and Go
• A CLI for running algorithms and observing timing changes
• A Knowledge Base Assistant for auditing code’s Big-O complexity

Dual Language Advantage

Examining Go implementations alongside TypeScript reveals how abstractions work. Go’s explicitness about pointers and memory allocation illuminates what TypeScript abstracts away, building mental models transferable across languages.

Practical Impact

Performance improvements deliver three benefits:

1. User experience: O(N) versus O(N^2) filtering creates noticeably smoother interactions, especially on older devices
2. Cost efficiency: More efficient algorithms reduce CPU consumption and infrastructure scaling needs
3. Foundational knowledge: Core concepts remain constant regardless of framework changes

Getting Started

1. Clone: git clone https://github.com/joachimzeelmaekers/stacksmith
2. Install and run: yarn start
3. Explore familiar chapters like arrays or maps
4. Experiment with input sizes to observe scaling behavior

Optimizing performance isn’t restricted to low-level specialists. By understanding how data structure and algorithm choices compound across applications, developers build respectful, reliable software.