Lab Project Guides
These guides help you develop the critical thinking skills needed to transform abstract programming problems into working code. Rather than jumping straight into implementation, these resources walk you through the systematic problem decomposition and program design process that experienced developers use.
The Problem-to-Code Journey
Most students see a lab assignment and immediately start coding. This often leads to:
- Confusion about where to start
- Incomplete solutions that miss edge cases
- Brittle code that breaks with minor changes
- Poor design that’s hard to extend or debug
Professional developers follow a different process: Think first, code second.
What These Guides Provide
1. Problem Decomposition Framework
Each guide breaks down complex problems into manageable pieces:
- Real-world context: Understanding what you’re modeling
- Core operations: Identifying the essential behaviors
- Data relationships: Mapping how information flows
- Edge cases: Anticipating what could go wrong
2. Design Decision Analysis
Programming is about making informed choices. These guides help you:
- Compare alternative approaches with pros and cons
- Understand trade-offs between different data structures
- Plan for future requirements and extensibility
- Apply design principles like encapsulation and abstraction
3. Implementation Strategy
Rather than diving into code randomly, learn to:
- Phase your development from simple to complex
- Plan your testing approach before writing methods
- Anticipate common pitfalls and how to avoid them
- Connect local decisions to larger software engineering concepts
How to Use These Guides
Before You Code
- Read the entire guide for your lab
- Work through the thinking exercises to understand the problem space
- Sketch your approach on paper or whiteboard
- Decide on your data structures and class design
- Plan your testing strategy and edge cases
While You Code
- Implement in phases as suggested in the guide
- Test frequently to catch issues early
- Refer back to design principles when making decisions
- Use the pitfall warnings to avoid common mistakes
After You Code
- Reflect on your choices using the guide’s questions
- Consider alternative approaches you didn’t try
- Think about extensions and how your design supports them
- Connect your experience to the larger concepts discussed
The Meta-Skill: Learning to Think Like a Developer
These guides teach you more than just how to solve specific problems. They develop your ability to:
Systematic Problem Analysis
- Break complex requirements into simple components
- Identify the core abstractions and relationships
- Recognize patterns that apply across different domains
Design Thinking
- Consider multiple solutions before committing to one
- Evaluate trade-offs between different approaches
- Plan for maintainability and extensibility
Strategic Implementation
- Develop incrementally with frequent testing
- Anticipate and handle edge cases systematically
- Write code that expresses intent clearly
Available Lab Guides
Numbers, Triangles, and Tables
Master loop fundamentals through practical exercises in number generation, pattern creation, and table formatting. This beginner-friendly lab builds your foundation in iteration patterns you’ll use for the rest of your career.
- Python Version - Using Python loops, range(), and string operations
- Java Version - Using Java for loops, StringBuilder, and formatting
Key Topics: Loops, iteration, string manipulation, formatting
Difficulty: Beginner
Reading Time: 12 minutes
WordGuess Game
Learn object-oriented programming by building a word-guessing game from scratch. This guide teaches you incremental development, interface-driven design, state management, and test-driven development through a fun, interactive project.
- Python Version - Using Python classes, sets, and abstract base classes
- Java Version - Using Java classes, HashSet, and interfaces
Key Topics: OOP, interfaces, game development, state management, testing
Difficulty: Intermediate
Reading Time: 15 minutes
DiceyLab
Problem decomposition guide for building a dice simulation with statistical tracking. Learn to separate concerns, design classes with single responsibilities, and verify results through testing.
Key Topics: Class design, statistical simulation, data collection
Difficulty: Intermediate
Reading Time: 10 minutes
Note: Language-agnostic guide focusing on problem decomposition
PhoneBook Lab
Your first meaningful abstraction—building a phone book that supports bidirectional lookup. Learn about data structure choices, abstraction design, and managing synchronized state.
Key Topics: Data structures, abstraction, bidirectional mapping
Difficulty: Intermediate
Reading Time: 8 minutes
Note: Language-agnostic guide focusing on design decisions
Hamurabi Game
Build a turn-based strategy game while learning state management, user interaction, and game loop patterns. Practice decomposing complex requirements into manageable methods.
Key Topics: State management, game loops, user input validation
Difficulty: Intermediate
Reading Time: 7 minutes
Note: Language-agnostic guide focusing on problem solving
Group Casino Week 5
A comprehensive 6-day team project plan for building a collaborative casino simulation. Master team collaboration, version control workflows, and integration strategies while building multiple games.
- Python Version - Using Python with pytest, abstract base classes
- Java Version - Using Java with JUnit, Maven, interfaces
Key Topics: Team collaboration, object-oriented design, testing, integration
Difficulty: Advanced
Reading Time: 20 minutes
UML Diagrams for Program Decomposition
Learn to use UML class diagrams to discover entities and design object-oriented programs. Master the “nouns and verbs” technique for transforming problem descriptions into working code structure.
Key Topics: UML diagrams, program design, entity discovery
Difficulty: Intermediate
Reading Time: 15 minutes
Note: Language-agnostic guide focusing on design methodology
Lab Guides Summary and Resources
Cross-cutting analysis of problem-solving patterns across all labs. Includes peer programming checklists, common patterns guide, and connections to industry practices.
Key Topics: Meta-learning, patterns, code review, industry connections
Difficulty: All levels
Reading Time: 25 minutes
Beyond the Lab: Real-World Connections
Each guide connects your lab work to real-world software development:
- Numbers, Triangles, Tables → Data formatting, report generation, batch processing
- WordGuess → State management, user interaction, interface contracts
- PhoneBook → Database design, caching systems, user management
- DiceyLab → Random number generation, statistical modeling, game design
- Hamurabi → State management, user interaction, simulation systems
- Group Casino → Team collaboration, continuous integration, multi-developer workflows
By mastering these fundamental patterns, you’re building skills that apply to enterprise software, mobile apps, web services, and any other programming domain.
Getting the Most Value
Active Engagement
Don’t just read these guides—actively work through them:
- Answer the reflection questions honestly
- Draw diagrams of your data structures and relationships
- Discuss approaches with classmates and compare solutions
- Experiment with the suggested alternatives
Iterative Learning
Use these guides multiple times:
- First pass: Get the big picture and overall approach
- Second pass: Focus on implementation details and testing
- Third pass: Reflect on design decisions and alternatives
- Later reviews: See how your understanding has evolved
Building Habits
The goal is to internalize this thinking process so you automatically:
- Question requirements before coding
- Consider alternatives when making design decisions
- Plan for testing and edge cases
- Think about maintainability and future changes
Remember: Process Over Product
While these guides will help you complete your labs successfully, their real value is in developing your problem-solving process. The specific solutions matter less than learning to think systematically about transforming problems into elegant, maintainable code.
The best developers aren’t those who code fastest—they’re those who think most clearly about what they’re building and why.