Some people aren’t able to think/design a software algorithm without writing the code that implements it; some other can just think/rethink at an algorithm without even writing a single line of code until it is almost totally clear in their mind, and then they code it. These are two extremes of the different approaches to designing/implementing and algorithm. Of course mixed approaches are what happen normally but let’s try to identify the extreme sides in terms of how they work.

Code-First Approach (Bottom-up or Implementation-Driven Approach):

• This approach involves thinking through the problem by immediately writing code.
• Developers using this method tend to experiment with implementations as they go.
• It’s often associated with a more hands-on, trial-and-error style of problem-solving.
• This approach can be beneficial for smaller problems or when working with familiar concepts.
• It might be referred to as “thinking with your fingers” or “coding to think.”

Design-First Approach (Top-down or Conceptual Approach):

• This approach involves thoroughly thinking through and designing the algorithm before writing any code.
• Developers using this method often use abstract thinking, mental models, or visual aids like flowcharts or pseudocode.
• It’s associated with a more theoretical or analytical style of problem-solving.
• This approach is often beneficial for complex problems or when designing large-scale systems.
• It might be referred to as “whiteboard coding” (even if no actual whiteboard is used) or “algorithmic thinking.”

Both approaches have their merits and can be effective depending on the situation, the complexity of the problem, and the individual developer’s style. Many experienced developers can switch between these approaches as needed.

It’s worth noting that in practice, many developers use a combination of both approaches, iterating between design and implementation as they work through a problem. This hybrid approach allows for both conceptual planning and practical experimentation.

Some related concepts and methodologies that incorporate aspects of these approaches include:

1. Test-Driven Development (TDD): Writing tests before implementation, which can be seen as a form of design-first thinking.
2. Rapid Prototyping: Quickly implementing ideas to test them, which aligns more with the code-first approach.
3. Model-Driven Development: Focusing on creating and analyzing domain models before implementation, which is more aligned with the design-first approach.

Understanding these different approaches can help developers recognize their own problem-solving styles and potentially expand their toolkit by practicing alternative methods when appropriate.