Course Content
KM-01- Introduction to Java Programming
Module Code: 900102-000-00-KM-01 Credits: 2 Summary: This module introduces learners to the fundamentals of Java programming and basic computing concepts. It builds a strong foundation by covering essential topics such as how computers work, the Java environment, development tools, and core programming principles. Learners are also introduced to version control and the structure of Java programs, preparing them to begin writing, compiling, and managing simple applications.
0/13
KM-02- Principles of Programming with Java
Module Code: 900102-000-00-KM-02 NQF Level : NQF Level 4 Credits: 6 Credits This module builds the learner’s understanding of the principles of programming with the Java programming language. It covers Java program structure, variables, data types, arrays, strings, classes, conditionals, loops, algorithms, exception handling, file systems, multithreading, and the programming life cycle.
0/29
KM-03: Principles of Object-Oriented Programming with Java
his module introduces learners to the core principles and structure of Object-Oriented Programming (OOP) using Java. Learners will explore how object-oriented concepts are used to design scalable, reusable, and maintainable software applications in modern software development environments. The module covers the foundational concepts of OOP, including classes, objects, methods, inheritance, abstraction, encapsulation, polymorphism, aggregation, association, and composition. Learners will also examine the advantages of applying object-oriented principles in real-world software projects and enterprise application development. Through theoretical understanding and contextual programming examples, learners will develop the ability to analyse object-oriented structures, identify relationships between objects, and apply OOP principles to solve programming problems effectively. This module supports learner progression into intermediate and advanced Java development by building strong foundational knowledge required for application development, GUI systems, REST APIs, enterprise systems, and software engineering workflows.
0/4
KM-04- Principles of Intermediate Programming with Java
Module Code: 900102-000-00-KM-04 NQF Level: 4 Credits: 6 Curriculum Title: Java Programmer Curriculum Code: 900102-000-00-00 Module Summary This module focuses on building an understanding of the principles of intermediate programming with Java. Learners are introduced to more advanced Java concepts, including collections, generics, functional programming, concurrency, concurrent collections, and atomic operations.
0/9
KM-05- REST API and Modularization
Module Code: 900102-000-00-KM-05 NQF Level: 4 Credits: 2 Module Summary The main focus of this knowledge module is to build an understanding of the functionalities of REST API and modularization and when to use them. Learners will develop knowledge of REST API concepts, functions, features, and implementation approaches used in Java applications. The module also introduces Java modularization concepts, including module structures, dependency management, encapsulation, and modern Java features such as Local Variable Type Inference, Switch Expressions, Text Blocks, and Records. The module prepares learners to understand modern Java application development practices and modular software design.
0/5
PM-01- Getting Started with Java
Module Code: 900102-000-00-PM-01 NQF Level: 4 Credits: 3 Module Summary The main focus of this practical module is to introduce learners to the practical application of basic computer skills, Java installation and setup, Integrated Development Environments (IDEs), Java class creation, and Git commands. Learners will perform practical activities that involve setting up Java development environments, creating and running Java programs, navigating IDEs, and applying basic source code management practices using Git. The module prepares learners for practical Java software development activities in modern programming environments.
0/10
PM-02- Programming with Java
Module code: 900102-000-00-PM-02 NQF Level: 4 Credits: 8 Module Summary This module introduces learners to practical Java programming skills used in software development. Learners develop the ability to create and run Java programs, work with variables and data types, use arrays and ArrayLists, create and manage classes and objects, and apply core programming concepts such as loops, conditionals, algorithms, exception handling, and multithreading. The module also covers string manipulation, file handling, wrapper classes, and the programming lifecycle used to develop complete software solutions. By the end of the module, learners will be able to design, write, test, and troubleshoot Java applications using structured programming techniques and object-oriented programming principles.
0/44
PM-03- Object-Oriented Programming with Java
Module code: 900102-000-00-PM-03 NQF Level: 4 Credits: 4 Module Summary This practical module introduces learners to Object-Oriented Programming (OOP) using Java. Learners will apply practical Java programming skills to design classes, create objects, apply inheritance, use constructors, manage object state, and develop reusable Java applications. The module focuses on practical implementation of OOP principles including: * encapsulation, * inheritance, * polymorphism, * and abstraction. Learners will also compile, execute, and organize Java programs correctly within Java file systems and directories. The module prepares learners for real-world Java software development environments through hands-on practical activities and problem-solving scenarios.
0/2
PM-04- Intermediate Programming with Java
Module code: 900102-000-00-PM-04 NQF Level: 4 Credits: 6 Module Summary This practical module introduces learners to intermediate Java programming concepts and practical software development techniques using modern Java functionalities. Learners will apply Java collections, generics, functional programming concepts, and concurrency techniques to create efficient and scalable Java applications. The module focuses on practical implementation of: * Java collections and data structures, * generics and type safety, * functional programming using lambda expressions and streams, * and concurrent programming using synchronization and concurrent collections. Learners will develop hands-on Java applications that manage collections, process data functionally, and handle concurrent operations safely within multi-threaded environments. The module prepares learners for real-world Java software development by strengthening problem-solving abilities, improving software performance, and introducing enterprise-level programming techniques commonly used in modern Java applications.
0/8
PM-05- Getting Started with REST API and Modularization
Module code: 900102-000-00-PM-05 NQF Level: 4 Credits: 4 Module Summary This practical module introduces learners to REST API development and Java modularization using modern Java technologies and frameworks. Learners will develop practical skills in connecting Java applications to databases, creating RESTful web services, implementing CRUD operations, and deploying databases using Docker. The module focuses on practical implementation of: * JDBC database connectivity, * REST API development using Java and Spring Boot, * CRUD operations using HTTP methods, * Docker containerization, * Java modularization, * and modern Java APIs. Learners will build practical Java applications that connect to MySQL databases, manage data using REST APIs, split applications into Java modules, and apply modern Java functionalities for cleaner and more scalable code. The module prepares learners for enterprise-level Java software development environments where REST APIs, modular applications, and containerized systems are widely used in modern software engineering.
0/4
PM-06- Keystone Project with Java
Module code:900102-000-00-PM-06 NQF Level: 4 Credits: 8 Module Summary This practical module provides learners with the opportunity to complete a comprehensive Keystone Project using the Java programming language. Learners will apply all the programming knowledge and practical skills acquired throughout the qualification to design, develop, test, and execute real-world Java applications. The module focuses on practical implementation of: * core Java programming, * arrays and objects, * conditions and loops, * GUI development, * game development, * and complete Java application solutions using frameworks and environments of the learner’s choice. Learners will complete practical exercises, build an operable Java game, and develop a contextual GUI-based solution within a selected sector such as: * retail, * healthcare, * IoT, * cloud computing, * mobile development, * or network systems. The module prepares learners for real-world software development environments by strengthening problem-solving abilities, practical development experience, creativity, and application deployment skills using Java technologies and frameworks.
0/6
Java Programmer Skills Programme

📘LESSON 6

3.1 Lesson Outcomes

After completing this lesson, learners will be able to:

  • Explain the purpose of Git.
  • Define version control and source code control.
  • Explain collaboration using Git.
  • Define repositories and branches.
  • Explain pull requests and changes in Git.
  • Use basic Git commands in software development workflows.

3.2 Overview

Modern software development requires tools that help developers track changes, collaborate efficiently, and manage source code safely. Git is one of the world’s most widely used version control systems and is commonly used in enterprise and collaborative software development environments.

This lesson introduces learners to Git and explains version control, repositories, branches, collaboration workflows, and Git commands used in source code management.

Git is widely used in:

  • enterprise software development,
  • web development,
  • cloud platforms,
  • DevOps environments,
  • and collaborative programming projects.

Understanding Git is important because software developers rely on version control systems to manage code and collaborate effectively.


KT0601 — Overview of Git

Git is a distributed version control system used to track changes in source code during software development.

Git helps developers:

  • manage code,
  • track changes,
  • collaborate,
  • and maintain project history.

Features of Git

Git supports:

  • collaboration,
  • version tracking,
  • branching,
  • and source code management.

Importance of Git

Git improves:

  • software development workflows,
  • collaboration,
  • and project management.

KT0602 — Version Control

Version control is the process of tracking and managing changes made to source code over time.

Version control systems allow developers to:

  • restore previous versions,
  • track modifications,
  • and manage collaboration.

Benefits of Version Control

Benefit Purpose
History Tracking Records code changes
Collaboration Supports teamwork
Backup Protects source code
Recovery Restores previous versions

Importance of Version Control

Version control improves:

  • software reliability,
  • collaboration,
  • and project maintenance.

KT0603 — Collaboration

Git supports collaboration between multiple developers working on the same project.

Developers can:

  • share code,
  • review changes,
  • and merge updates.

Collaboration Activities

Activity Purpose
Sharing Code Team development
Reviewing Changes Quality control
Merging Code Combine updates

Importance of Collaboration

Collaboration supports:

  • teamwork,
  • efficient development,
  • and project coordination.

KT0604 — Repositories

A repository is a storage location used to manage source code and project files.

Repositories contain:

  • source code,
  • project history,
  • and version information.

Types of Repositories

Repository Type Description
Local Repository Stored on local computer
Remote Repository Stored online/server

Examples of Remote Repositories

  • GitHub
  • GitLab
  • Bitbucket

Importance of Repositories

Repositories help developers:

  • organize projects,
  • manage code,
  • and collaborate online.

KT0605 — Branch

A branch is a separate version of a project used for development or experimentation.

Branches allow developers to:

  • work independently,
  • test features,
  • and avoid affecting the main project.

Common Branch Types

Branch Purpose
main/master Main project branch
feature branch New feature development

Importance of Branches

Branches improve:

  • safe development,
  • testing,
  • and collaboration workflows.

KT0606 — Changes

Changes refer to modifications made to source code or project files.

Git tracks:

  • added files,
  • modified files,
  • and deleted files.

Types of Changes

Change Type Description
Added New file created
Modified Existing file updated
Deleted File removed

Importance of Tracking Changes

Tracking changes helps developers:

  • monitor progress,
  • review updates,
  • and manage project history.

KT0607 — Pull Requests

A pull request is a request to merge changes from one branch into another branch.

Pull requests allow team members to:

  • review code,
  • discuss changes,
  • and approve updates.

Pull Request Workflow

Step Process
Create Branch Develop feature
Commit Changes Save updates
Create Pull Request Request merge
Review Check code
Merge Combine changes

Importance of Pull Requests

Pull requests improve:

  • code quality,
  • collaboration,
  • and software reliability.

KT0608 — Source Code Control

Source code control refers to managing and tracking source code changes during software development.

Git provides source code control by:

  • storing versions,
  • tracking modifications,
  • and supporting collaboration.

Benefits of Source Code Control

Benefit Purpose
Tracking Records updates
Collaboration Supports teamwork
Recovery Restores previous versions
Security Protects source code

Importance of Source Code Control

Source code control improves:

  • software maintenance,
  • collaboration,
  • and project stability.

KT0609 — Git Commands: git clone, git fetch, git checkout, git init, git commit, git push, git diff, git pull, git add, git branch

Git commands are used to manage repositories and source code workflows.


Common Git Commands

Command Purpose
git init Creates a repository
git clone Copies repository
git add Adds changes
git commit Saves changes
git push Uploads changes
git pull Downloads updates
git fetch Retrieves updates
git checkout Switches branches
git branch Creates/views branches
git diff Displays differences

Example Commands

Initialize Repository

 
git init
 

Clone Repository

 
git clone repository-url
 

Add Files

 
git add .
 

Commit Changes

 
git commit -m "Initial commit"
 

Push Changes

 
git push
 

Importance of Git Commands

Git commands support:

  • source code management,
  • collaboration,
  • and version control workflows.

3.5 Key Notes / Summary

  • Git is a version control system.
  • Version control tracks source code changes.
  • Repositories store project files and history.
  • Branches support independent development.
  • Pull requests support code reviews and collaboration.
  • Source code control improves project management.
  • Git commands manage repositories and workflows.
Scroll to Top