Beginning Your Development

CMU601: Dissertation - Week 5

Birmingham Newman University

Lecturer: James Williams

Undergraduate Final Year Project

3-hour session • 28 slides • 2 practical tasks

Session Timeline:

10 min: Introduction & objectives
40 min: Opening slides & project planning
45 min: Task 1 - Project setup
15 min: Break/Catch up
30 min: Development practices slides
40 min: Task 2 - Initial development
Remaining: Self-directed work

Learning Objectives

Understand how to effectively begin dissertation project development
Set up a professional development environment
Establish project structure and architecture foundations
Implement good coding practices from day one
Create an initial working prototype or proof of concept
Plan iterative development cycles

⚠️ Critical Point

Starting development early and maintaining consistent progress is the single most important factor in dissertation success. Don't wait until you have a "perfect" plan - start building!

Why Start Development Now?

The earlier you start, the more time for refinement and polish

Benefits of Early Development:

Discovery of Issues: Technical problems emerge that weren't apparent during planning
Realistic Timeline: Understand how long tasks actually take versus estimates
Scope Adjustment: Time to pivot or adjust features based on feasibility
Learning Curve: Master new technologies gradually rather than cramming
Buffer Time: Handle unexpected challenges without panic
Quality Improvement: Iterate and refine your solution multiple times

                    Common Timeline:

                    Week 5-10: Initial development & core features

                    Week 11-15: Feature completion & integration

                    Week 16-20: Testing, refinement, & documentation

                    Week 21-25: Polish, final testing, & report writing

Common Mistakes to Avoid

Planning Forever Without Building

Spending months on design documents without writing code
Waiting for the "perfect" plan before starting
Over-engineering solutions before understanding the problem

Starting Too Ambitious

Trying to build everything at once
Selecting technologies you don't know for "learning experience"
Ignoring MVP (Minimum Viable Product) principles

Poor Time Management

Leaving development until the last few weeks
Not scheduling regular development time
Underestimating debugging and testing time

Setting Up Your Development Environment

Essential Components:

Code Editor/IDE: VS Code, PyCharm, IntelliJ, etc.
Version Control: Git installed locally
Language Runtime: Python, Node.js, Java, etc.
Package Manager: pip, npm, Maven, etc.
Database: PostgreSQL, MySQL, MongoDB (if needed)
Testing Framework: pytest, Jest, JUnit (language-specific)

                    # Example: Python project setup

                    python -m venv venv

                    venv\Scripts\activate  # Windows

                    source venv/bin/activate  # Mac/Linux

                    pip install -r requirements.txt

                    # Example: Node.js project setup

                    npm init -y

                    npm install express mongoose dotenv

Organizing Your Project Structure

Well-Organized Structure Benefits:

Easier to find and modify code
Clear separation of concerns
Professional presentation
Easier for others (and supervisors) to understand

                    my-dissertation-project/

                    ├── src/                    # Source code

                    │   ├── components/         # Reusable components

                    │   ├── models/             # Data models

                    │   ├── services/           # Business logic

                    │   ├── utils/              # Helper functions

                    │   └── main.py             # Entry point

                    ├── tests/                  # Test files

                    ├── docs/                   # Documentation

                    ├── config/                 # Configuration files

                    ├── .env.example            # Environment variables template

                    ├── .gitignore              # Git ignore rules

                    ├── README.md               # Project documentation

                    └── requirements.txt        # Dependencies

Creating a Professional README

Your README is often the first thing people see - make it count!

Essential README Sections:

Project Title & Description: Clear explanation of what it does
Features: Key functionality and capabilities
Installation: Step-by-step setup instructions
Usage: How to run and use the application
Technologies: List of frameworks, libraries, tools
Screenshots: Visual demonstration (if applicable)
Testing: How to run tests
License: If applicable

README.md Example

                    # Student Performance Tracking System

                    A web-based application for tracking student academic performance

                    and generating predictive analytics.

                    ## Features

                    - Student grade tracking and visualization

                    - Performance prediction using machine learning

                    - Interactive dashboards for tutors

                    - Export reports to PDF/Excel

                    ## Installation

                    ```bash

                    git clone https://github.com/username/project.git

                    cd project

                    python -m venv venv

                    source venv/bin/activate

                    pip install -r requirements.txt

                    python src/main.py

                    ```

                    ## Technologies

                    - Python 3.11

                    - Django 4.2

                    - PostgreSQL

                    - Scikit-learn

                    - Chart.js

Version Control from Day One

Start using Git immediately - it's your safety net!

Benefits of Version Control:

Track all changes to your code
Revert to previous working versions if something breaks
Document your development progress
Collaborate with supervisors or team members
Demonstrate systematic development for your report

                    # Initialize Git repository

                    git init

                    # First commit

                    git add .

                    git commit -m "Initial project setup with basic structure"

                    # Connect to GitHub

                    git remote add origin https://github.com/username/project.git

                    git branch -M main

                    git push -u origin main

Writing Good Commit Messages

❌ Bad Commit Messages:

                    git commit -m "fixed stuff"

                    git commit -m "update"

                    git commit -m "asdfasdf"

                    git commit -m "final version"

                    git commit -m "final version 2"

✅ Good Commit Messages:

                    git commit -m "Add user authentication with JWT tokens"

                    git commit -m "Fix database connection timeout issue"

                    git commit -m "Implement student grade calculation algorithm"

                    git commit -m "Refactor data validation in forms module"

                    git commit -m "Update README with installation instructions"

Format: Start with a verb, be specific, explain what and why

Task 1: Initial Project Setup

Objective:

Set up your dissertation project with proper structure and version control

Activity Steps:

Create a new project directory with appropriate folder structure
Initialize a Git repository in your project
Create a .gitignore file (use templates from gitignore.io)
Write a comprehensive README.md for your project
Set up your development environment (virtual env, dependencies)
Create a GitHub repository and push your initial commit
Add a LICENSE file if appropriate
Create an initial project roadmap or TODO.md file

Deliverable:

A well-structured, version-controlled project repository with professional documentation

Time:

45 minutes

The MVP Approach

Build the simplest working version first, then iterate

What is an MVP?

A version of your project with just enough features to be functional and demonstrate core functionality.

MVP Benefits:

Early proof of concept validates your approach
Identify technical challenges early
Something to show supervisors for feedback
Foundation to build upon systematically
Achievable milestone that builds confidence

Example MVPs:

E-commerce: Product listing + shopping cart (no payment yet)
Chat App: Text messaging between two users (no groups)
Analytics Dashboard: Display one chart type with sample data

Breaking Features into Iterations

Example: Building a Study Planner App

                    Iteration 1 (MVP - Week 5-7):

                    - Create account and login

                    - Add study tasks with title and due date

                    - Mark tasks as complete

                    - Basic list view

                    Iteration 2 (Week 8-10):

                    - Add task categories/subjects

                    - Calendar view of tasks

                    - Edit and delete tasks

                    - Basic statistics (tasks completed)

                    Iteration 3 (Week 11-13):

                    - Task priorities and reminders

                    - Study time tracking

                    - Progress visualization

                    - Export study schedule

                    Iteration 4 (Week 14-16):

                    - AI study recommendations

                    - Collaboration features

                    - Mobile responsive design

                    - Performance optimization

Establishing Coding Standards

Consistency is key to maintainable code

Essential Standards:

Naming Conventions: Consistent variable, function, class names
Indentation: 2 or 4 spaces (pick one and stick with it)
Comments: Explain complex logic, not obvious code
Function Length: Keep functions focused and concise
DRY Principle: Don't Repeat Yourself - extract common code
Error Handling: Use try-catch blocks appropriately

Style Guides by Language:

Python: PEP 8
JavaScript: Airbnb Style Guide
Java: Google Java Style Guide

Code Quality Examples

❌ Poorly Written Code:

                    def calc(a,b,c):

                        x=a+b*c #calculate result

                        return x

                    result=calc(5,10,2)

✅ Well-Written Code:

                    def calculate_total_with_tax(base_price, quantity, tax_rate):

                        """

                        Calculate total price including tax.

                        Args:

                            base_price (float): Price per item

                            quantity (int): Number of items

                            tax_rate (float): Tax rate as decimal (e.g., 0.2 for 20%)

                        Returns:

                            float: Total price including tax

                        """

                        subtotal = base_price * quantity

                        total = subtotal * (1 + tax_rate)

                        return total

                    final_price = calculate_total_with_tax(

                        base_price=50.0,

                        quantity=3,

                        tax_rate=0.2

                    )

Building in Testing from the Start

Write tests as you develop, not at the end

Types of Testing:

Unit Tests: Test individual functions/methods
Integration Tests: Test how components work together
User Acceptance Tests: Test from user perspective
Manual Testing: Explore your app like a user would

Simple Testing Example (Python):

                    # tests/test_calculator.py

                    import pytest

                    from src.calculator import calculate_total_with_tax

                    def test_calculate_total_basic():

                        result = calculate_total_with_tax(50.0, 3, 0.2)

                        assert result == 180.0

                    def test_calculate_total_no_tax():

                        result = calculate_total_with_tax(25.0, 2, 0.0)

                        assert result == 50.0

Documenting as You Develop

Why Document Early?

You'll forget implementation details later
Easier to write reports with existing documentation
Helps clarify your own thinking
Useful for supervisor meetings

What to Document:

Architecture Decisions: Why you chose certain approaches
API Documentation: How functions/endpoints work
Setup Instructions: How to run your project
Known Issues: Problems and workarounds
Development Log: Weekly progress notes

                    docs/

                    ├── architecture.md      # System design decisions

                    ├── api-reference.md     # API documentation

                    ├── development-log.md   # Weekly progress

                    └── setup-guide.md       # Installation instructions

Establishing a Development Workflow

Recommended Daily/Weekly Routine:

                    Daily (30-60 minutes minimum):

                    1. Review yesterday's progress

                    2. Pick one task from backlog

                    3. Implement feature/fix

                    4. Write tests

                    5. Commit with clear message

                    6. Push to GitHub

                    7. Update documentation

                    Weekly:

                    1. Review all commits

                    2. Update project roadmap

                    3. Test full application

                    4. Plan next week's tasks

                    5. Write development log entry

                    6. Prepare supervisor update

⏰ Time Management Tip

Schedule specific development time in your calendar. Treat it like a class - non-negotiable commitment to your project.

Environment Variables & Configuration

Never hardcode sensitive information!

What Belongs in Configuration:

Database connection strings
API keys and secrets
Email service credentials
Environment-specific settings (dev, test, production)

Example .env File:

                    # .env (DO NOT commit this file!)

                    DATABASE_URL=postgresql://user:pass@localhost/mydb

                    SECRET_KEY=your-secret-key-here

                    API_KEY=your-api-key-here

                    DEBUG=True

                    EMAIL_HOST=smtp.gmail.com

                    EMAIL_PORT=587

Example .env.example File:

                    # .env.example (commit this as a template)

                    DATABASE_URL=

                    SECRET_KEY=

                    API_KEY=

                    DEBUG=True

                    EMAIL_HOST=

                    EMAIL_PORT=

Managing Project Dependencies

Python Projects:

                    # Create requirements.txt

                    pip freeze > requirements.txt

                    # Install from requirements.txt

                    pip install -r requirements.txt

Node.js Projects:

                    # package.json automatically manages dependencies

                    npm install package-name --save

                    # Install all dependencies

                    npm install

Best Practices:

Keep dependencies updated regularly
Document why each dependency is needed
Remove unused dependencies
Use specific version numbers for stability
Test after updating dependencies

Debugging Effectively

Debugging is a skill - develop it systematically

Debugging Approaches:

Print Statements: Simple but effective for tracking values
Debugger Tools: Step through code line by line
Logging: Record application behavior
Error Messages: Read them carefully - they tell you exactly what's wrong
Rubber Duck Debugging: Explain your code to someone (or something)

Systematic Debugging Process:

Reproduce the error consistently
Read error messages and stack traces
Form hypothesis about the cause
Test hypothesis with minimal changes
Document solution for future reference

Task 2: Build Your MVP

Objective:

Create the first working version of your dissertation project

Activity Steps:

Define your MVP scope (3-5 core features maximum)
Create a basic project structure for your chosen tech stack
Implement the most fundamental feature (e.g., data entry, user auth)
Write at least 2 unit tests for your code
Test your implementation manually
Make multiple commits as you work (not one giant commit!)
Update README with what you've built
Document any challenges or decisions in a development log

Success Criteria:

Something demonstrable that runs without errors
Clear Git commit history showing progression
At least basic documentation

Time:

40 minutes

Self-Review and Refactoring

Review Your Own Code:

Read through code before committing
Check for obvious errors or improvements
Ensure naming is clear and consistent
Verify comments are helpful
Test edge cases

When to Refactor:

After getting something working
When you notice repeated code patterns
Before adding new features to messy code
After learning better approaches

⚠️ Refactoring Warning

Refactor incrementally, not all at once! Make small improvements regularly rather than massive rewrites.

Early Performance Thinking

"Premature optimization is the root of all evil" - Donald Knuth

Don't Optimize Too Early:

Get it working first, optimize later
Focus on code clarity over speed initially
Profile before optimizing (measure, don't guess)

But Do Consider:

Algorithm Choice: O(n²) vs O(n log n) matters at scale
Database Queries: Avoid N+1 query problems
Asset Loading: Don't load huge files unnecessarily
Memory Leaks: Clean up resources properly

Rule of Thumb: Write clean code first, then optimize hotspots if needed.

When You Get Stuck

Problem-Solving Strategy:

Reproduce: Can you make the problem happen consistently?
Simplify: Create minimal test case
Research: Google error messages, check documentation
Ask: Stack Overflow, forums, supervisor, peers
Take a Break: Fresh perspective helps
Alternative Approach: Sometimes need to try different solution

Good Resources:

Stack Overflow: Specific coding problems
GitHub Issues: Library-specific problems
Official Documentation: Always check first!
Reddit: r/learnprogramming, language-specific subs
Discord Communities: Real-time help

Staying Motivated Throughout Development

Strategies for Sustained Progress:

Small Wins: Celebrate completing features, no matter how small
Visual Progress: Keep screenshots/videos of your app evolving
Regular Demos: Show friends, family, supervisors
Break Tasks Down: Large tasks are overwhelming
Reward Yourself: After completing milestones
Join Communities: Connect with other dissertation students
Remember Your Why: Why did you choose this project?

💪 Persistence is Key

Every professional developer encounters frustrating bugs and challenges. The difference is they keep going. You can too!

Your Action Plan This Week

Immediate Actions (Today):

Complete Task 1: Set up your project structure
Complete Task 2: Build your first working feature
Schedule daily development time in your calendar

This Week (Days 1-7):

Expand MVP with 1-2 additional core features
Write tests for new functionality
Make daily commits
Start development log
Document any technical decisions

Next Two Weeks:

Complete MVP (all core features working)
Implement basic UI/UX
Create initial user documentation
Prepare demo for supervisor meeting

Key Takeaways

                    Remember:
                    Start development NOW, not later
Build iteratively - MVP first, then enhance
Commit code regularly with good messages
Document as you go, not at the end
Test your code continuously
Ask for help when stuck
Work on your project EVERY day or week

                

🎯 Success Formula

Consistent small progress beats sporadic heroic efforts every time!

30 minutes daily = 3.5 hours weekly = 90+ hours by submission

Contact: JWilliams@Staff.newman.ac.uk

Next Week: Using GitHub & Project Management Tools