Preliminary Software Engineering
Unit 1 - Programming Fundamentals
Unit 1 - Programming Fundamentals
  • 1 - Programming Fundamentals
    • Programming Fundamentals Content
  • 2 - Python
    • Expected Python Knowledge
    • GitHub
    • Learning Python
    • Data Structures and File Management
      • Data Structures
        • Lists
        • Arrays
          • Single and Multi-Dimensional Arrays
        • Lists vs Arrays
          • Activities
        • Tuples
        • Sets
        • Dictionaries
          • Activities
      • File Handling
        • Loops, Lists, Dictionaries
        • Activities
  • 3 - Theory Content
    • Theory Content Explained
      • NESA Directional Verbs
      • Responding to Directional Verbs
  • 4 - Software Development and Management
    • Approaches to Software Development
      • Waterfall Model
      • Agile Model
      • Summary: Waterfall vs Agile
      • Activities
    • Software Development Steps
      • Sample Exam Question
      • Requirements Definition
        • Understanding the Need
        • Key Questions to Ask
        • Examples
        • Activities
        • Sample Exam Question
      • Determining Specifications
        • Functional Specifications
        • Non-Functional Specifications
        • Activities
      • Design
        • Top-Down Design Approach
        • Bottom-Up Design Approach
      • Development
        • Optimising Code
      • Integration
        • Example: Payment Program
        • Activity
        • Application Programming Interface (API)
          • Example: OpenWeather API
          • Example: WeatherAPI
          • Activity: Prepare Spells
      • Testing and Debugging
        • Test Data
          • Activities
        • Testing the System
          • Activities
        • Debugging
          • Types of Errors
            • Activities
          • Python Debugger
            • Activities
          • VS Code Debugger
            • Activities
      • Installation
        • Activities
        • Sample Exam Question
      • Maintenance
  • Charts and Algorithms
    • Example: IPO Charts and Pseudocode
      • Activities
    • Algorithms, Flowcharts, Pseudocode
      • Pseudocode Activities
      • Flowchart Activities
      • Sample Exam Questions
    • Structure Charts
      • Activities
      • Sample Exam Questions
    • Data Flow Diagrams
      • Activities
    • Data Dictionaries
      • Activities
    • Decision Trees
      • Activities
      • Sample Exam Questions
    • Gantt Chart
    • Class Diagrams
      • Sample Exam Question
    • Storyboards
      • Sample Exam Question
  • Testing and Debugging
    • Test Data
      • Activities
    • Testing the System
      • Activities
    • Debugging
      • Types of Errors
        • Activities
      • Python Debugger
        • Activities
      • VS Code Debugger
        • Activities
  • Computational Thinking
    • Decomposition
    • Abstraction
    • Activities
  • Version Control
    • Git
    • GitHub
    • Activities
  • Number Systems
    • Binary Systems
    • Hexadecimal Numbers
    • Using Two's Complement
    • Activities
  • 5 - Assessment Task 1
    • Data Science Project
      • Before we Start
        • Setting up GitHub Repository
        • Setting Up Markdown Documentation
      • Examples of API Usage
        • Starter Code: NASA Scenario
        • Starter Code: Spell Book
        • Starter: Pokédex Explorer
        • Starter Code: Weather App
        • Example: OpenWeather API
        • Example: WeatherAPI
        • Example: Prepare Spells
    • Task Guide
      • Requirements Definition
      • Determining Specifications
        • Use Cases
      • Design
        • Gantt Chart
        • Structure Chart
        • Algorithms
        • Data Dictionary
      • Development
        • Comments vs DocStrings
        • UI - main.py
        • Create Python Module
          • Example: NASA Module
          • Example: WeatherFetch Module
          • Example: SpellBook Module
      • Integration
        • Example: Pokedex
      • Testing and Debugging
        • Commit Changes
      • Installation
      • Maintenance
    • Submitting Your Task
Powered by GitBook
On this page
  • Outcomes of the Development Phase
  • Key Aspects
  1. 4 - Software Development and Management
  2. Software Development Steps

Development

The Development phase is where the actual creation of the software takes place. It's where concepts and plans become actual software that users can interact with. The Development phase is dynamic and iterative, with a focus on creating a functional and effective software product. Through coding, testing, and integration, the development team move from concept to reality, ready for deployment.

Outcomes of the Development Phase

  • Translation of design documents into executable code.

  • Building the software's core functionalities and user interface.

  • Integration of different software components and systems.

  • Conducting unit testing to ensure individual components work correctly.

Key Aspects

Writing Code: The heart of the Development phase is writing the source code. Developers use programming languages (like Python, JavaScript, HMTL, CSS) to create the software based on the previously prepared design documents.

Implementing Functionality: Developers start implementing the software's functionalities defined in the design phase. This includes the logic and user interface elements that facilitate an effective UX.

Integration: In this step, the various components of the software (such as user authentication, score tracking, challenge completion, and feedback systems) are integrated to work together seamlessly. This ensures that the software operates as a cohesive unit, providing a smooth user experience.

Testing: Unit testing is performed by developers to ensure each component or unit of the software works as intended. This involves testing individual functions and modules to catch and fix errors early. For example, a unit test might verify that the scoring system accurately calculates and updates a student's score after completing a quiz.

Version Control: Developers use version control systems to manage changes to the software codebase. This allows multiple developers to work on the game simultaneously, track changes, and revert to previous versions if necessary. It's crucial for coordinating team efforts and maintaining a history of the project's evolution.

Documentation: Throughout the development process, developers document their code and the software's architecture. This documentation is essential for future maintenance, updates, and allows new developers to understand the software's workings quickly.

Feedback Loop: Integrating feedback from test users (potentially including actual Year 11 students) can help refine the software. This might involve adjusting difficulty levels, enhancing user interfaces, or adding new features to improve the educational value and engagement of the software.

PreviousBottom-Up Design ApproachNextOptimising Code

Last updated 3 months ago