Browse / Developer Tools / Smalltalk Implementation Finder

Smalltalk Implementation Finder

Finds and analyzes method implementations across Pharo Smalltalk class hierarchies to understand code patterns and assess refactoring impact.

SkillDeveloper ToolsCode QualityCode Search

The source repository doesn't declare a license. Check its terms before reusing the code.

Key features

  • Discovers common Smalltalk implementation patterns and idioms.
  • Assesses the impact of method signature changes by counting implementors and references.
  • Filters method references by the specific implementation being called.
  • Identifies duplicate or similar code to find refactoring opportunities.
  • Traces method implementations across entire class hierarchies.

Use cases

  • Learn how to implement a common method (e.g., 'printOn:') by studying existing examples.
  • Determine the risk and effort required before refactoring a core method's signature.
  • Find and consolidate duplicated code from multiple subclasses into a single superclass method.

FAQ

What core capabilities does it provide?

It can trace method implementations across entire class hierarchies, count implementors and references to assess refactoring impact, discover common coding idioms, identify duplicate code, and filter method usage by the specific implementation being called.

How does this skill improve my workflow?

It automates the tedious process of manually searching for implementations. This saves time, helps you make informed refactoring decisions with impact analysis, and enables you to write more idiomatic Smalltalk code by learning from existing patterns.

What does the Smalltalk Implementation Finder skill do?

This skill helps you find, trace, and analyze method implementations across Pharo Smalltalk class hierarchies. It's designed to understand how code is structured, discover common patterns, and assess the impact of changes.

When should I use this skill?

Use it when you need to understand an abstract method, learn Smalltalk idioms, assess the risk of a method signature change, or find duplicate code for refactoring. It answers questions like "who implements this method?" and "how is it implemented?".