Module 2 Projects - Engineering the Core

You have studied:

• Name binding and memory references
• Object identity and equality
• Dynamic typing and runtime dispatch
• Truthiness and boolean protocol
• Operator mechanics
• Interning and object caching
• Input and output behavior

Now you apply them.

These projects are not toy exercises.

They are controlled environments designed to force you to reason about:

• Object identity
• Mutability vs reassignment
• Type behavior
• Boolean evaluation
• Operator semantics
• Runtime execution flow

The goal is not to “practice syntax”.

The goal is to build execution awareness.

Why Projects Matter at This Stage

Most beginners write programs without understanding:

• How values are stored
• When objects are reused
• Why equality behaves differently from identity
• Why logical operators return objects
• Why certain bugs occur in mutable defaults

These projects are engineered to surface those behaviors.

You will encounter:

• Shared references
• Subtle truth evaluation
• Operator chaining side effects
• Runtime type ambiguity
• Identity pitfalls

This is intentional.

Engineering Mindset Required

Before starting:

Adopt these rules:

1. Always reason about object identity.
2. Print id values when debugging.
3. Inspect type explicitly when confused.
4. Avoid assumptions about caching behavior.
5. Test edge cases deliberately.

The purpose is to train mental models, not just produce output.

Project Design Philosophy

Each project will:

• Be small in surface area
• Be deep in conceptual requirements
• Force runtime reasoning
• Encourage defensive thinking
• Expose hidden Python behaviors

Projects are layered.

Basic implementation is required.

Advanced extensions are optional but recommended.

What You Will Strengthen

After completing these projects, you should:

• Understand when objects are shared
• Predict truthiness behavior
• Safely compare identity and equality
• Avoid common mutability bugs
• Design robust input handling
• Use operators intentionally
• Think in terms of runtime semantics

If you cannot explain why something behaves a certain way, you do not yet understand it.

Debugging Rule for This Module

When something behaves unexpectedly:

1. Print the object
2. Print its type
3. Print its id
4. Check equality
5. Check identity

This systematic approach builds runtime intuition.

Output Expectations

Your solutions should demonstrate:

• Clean structure
• Clear variable naming
• Proper use of equality vs identity
• Defensive input handling
• Correct truth evaluation
• Explicit reasoning about object behavior

Do not write clever code.

Write correct, understandable code.

Depth Over Speed

Do not rush these.

Read behavior carefully.

Modify values intentionally.

Test unusual inputs.

Break things deliberately.

Engineering maturity develops through deliberate stress-testing.

Reflection Before You Begin

Ask yourself:

• Can I explain how Python stores this value?
• Do I know whether this object is shared?
• What happens if I mutate this structure?
• What type is actually being returned?
• What exactly does this operator return?

If you cannot answer these confidently, the project will expose it.

That is the point.

You are no longer learning syntax.

You are learning execution semantics.

Proceed carefully.