Chapter 1: Apply computer programming skills

Object Oriented Programming (OOP) forms a cornerstone of modern software development, enabling programmers to create modular, reusable, and maintainable code. In the Kenyan software industry, where diverse applications from banking systems to mobile platforms are rapidly evolving, mastering OOP principles is essential for delivering robust solutions. This chapter focuses on applying programming skills by exploring programming language types, criteria for language selection, and practical exercises involving class creation and collaborative development. These competencies prepare software developers to work effectively both individually and in teams, reflecting real-world software engineering practices.

1.1 Programming Language Types

Programming languages are the tools through which a developer turns human logic into instructions a computer can run. Languages differ in the way they ask the programmer to organise a program, in their syntax and in the environment where the finished program runs. A developer who understands these differences can choose a suitable language for work as varied as a stock-keeping app for a hardware shop, a booking system for a salon or firmware for a small device.

1.1.1 Overview of programming language categories

A programming language category groups languages by the main way they ask you to describe a computation. This unit covers three categories: procedural, object-oriented and functional. The same small job is solved in each of them below so that the differences can be seen in working code.

The job: a hardware shop order has three lines. Each line has a quantity and a unit price in Ksh: 4 items at 250, 10 items at 35 and 2 items at 1,200. The program must print the order total.

Line totals: 4 × 250 = 1,000; 10 × 35 = 350; 2 × 1,200 = 2,400.

Order total: 1,000 + 350 + 2,400 = 3,750.

Many languages belong to more than one category. Python, JavaScript and C++ let a programmer write in several styles, and Java now includes functional features. A language is placed in the category whose ideas shaped its design. The topic Programming Paradigms looks at the same styles as ways of thinking about a program.

1.1.1.1 Procedural

A procedural language organises a program as a sequence of instructions grouped into procedures, also called functions or subroutines. The programmer writes the steps in order, keeps data in variables and arrays, and calls procedures to carry out repeated work. The program state changes as variables are updated step by step.

Main features:

• Step-by-step flow: Instructions run from top to bottom, with loops and conditions deciding which steps repeat or are skipped.
• Procedures: A named block of code does one job, such as calculating a line total, and can be called from many places.
• Shared data: Variables and arrays are kept separately from the procedures that use them, so a procedure receives the data it needs as arguments.
• Close to the machine: Procedural languages give direct control over memory and hardware, which suits low-level work.
• Simple execution model: The order in which things happen is easy to follow, which helps when a beginner traces a program by hand.

Typical languages are C, Pascal, Fortran and COBOL. C is widely used for operating system components, device drivers and the firmware inside embedded devices.

The order total in C:

#include <stdio.h>

double line_total(int quantity, double unit_price) {
    return quantity * unit_price;
}

int main(void) {
    int quantities[] = {4, 10, 2};
    double prices[] = {250.0, 35.0, 1200.0};
    double total = 0.0;

    for (int i = 0; i < 3; i++) {
        total += line_total(quantities[i], prices[i]);
    }
    printf("Total: Ksh %.2f\n", total);
    return 0;
}

Output:

Total: Ksh 3750.00

The loop visits the three positions of the arrays. The procedure line_total returns 1000.0, then 350.0, then 2400.0, and total grows to 3750.0.

Strengths and limits:

• Speed and control: Compiled procedural code runs fast and uses little memory, which suits devices with limited resources.
• Easy to learn: The step-by-step model is a good first model of how a computer executes instructions.
• Data is exposed: Any procedure that can see an array can change it, so a mistake in one place can corrupt data used elsewhere.
• Growth is difficult: In a large program with hundreds of procedures it becomes hard to know which procedure may change which data.
• Reuse is limited: Related data and procedures are not bundled together, so copying a feature into another project means copying several separate pieces.

1.1.1.2 Object-oriented

An object-oriented language organises a program around objects. An object bundles data, called attributes or fields, with the procedures that work on that data, called methods. Objects are created from classes, and the program runs as objects send messages to each other by calling methods.

Main features:

• Classes and objects: A class is the blueprint and each object is one item built from it, such as one order line with its own quantity and price.
• Encapsulation: Data and methods sit together, and the class decides which parts other code may use.
• Inheritance: A new class can reuse and extend an existing class, for example a special order line that adds a discount.
• Polymorphism: Different classes can respond to the same method call in their own way.
• Abstraction: A class shows what an object can do and hides how it does it, so users of the class need not know the inner details.

Java, C# and Kotlin are designed around classes. C++ and Python support classes alongside other styles. The later topics Implementing Objects and Classes, Applying Object Encapsulation, Implementing Class Inheritance and Implementing Polymorphism teach these ideas in full.

The order total in Java:

public class Order {
    public static void main(String[] args) {
        OrderLine[] lines = {
            new OrderLine(4, 250.0),
            new OrderLine(10, 35.0),
            new OrderLine(2, 1200.0)
        };
        double total = 0.0;
        for (OrderLine line : lines) {
            total += line.total();
        }
        System.out.printf("Total: Ksh %.2f%n", total);
    }
}

class OrderLine {
    private final int quantity;
    private final double unitPrice;

    OrderLine(int quantity, double unitPrice) {
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }

    double total() {
        return quantity * unitPrice;
    }
}

Output:

Total: Ksh 3750.00

Each OrderLine object holds its own quantity and price and knows how to calculate its own total. The main method no longer handles two parallel arrays: it asks each object for its total and adds the results, 1000.0 + 350.0 + 2400.0 = 3750.0.

Strengths and limits:

• Models real things: Objects such as an order line, a customer or a booking match the things the user talks about, which makes requirements easier to translate into code.
• Protected data: A class can keep its data private and allow changes only through its methods.
• Reuse: Inheritance and well-built classes let a team reuse tested code in later projects.
• Teamwork: Different developers can build different classes against an agreed design.
• More planning: A small job needs more code than the procedural version, and a poor class design can be harder to repair than a poor procedure.

1.1.1.3 Functional

A functional language treats computation as the evaluation of functions. A function takes values in and gives a value out, and a pure function does nothing else: it does not change a variable outside itself and gives the same result every time for the same input. Functions are values too, so one function can be passed to another.

Main features:

• Pure functions: A function depends only on its arguments, so it can be tested alone and gives predictable results.
• Immutable data: Values are not changed after they are created. A new value is produced instead of updating an old one.
• Functions as values: A function can be stored, passed as an argument and returned from another function.
• Higher-order functions: Functions such as map, filter and fold apply another function to every item of a list, which replaces many loops.
• Recursion: Repeated work is written as a function that calls itself, instead of a loop with a counter.

Typical languages are Haskell, Erlang, Elixir, OCaml, F# and Clojure. Erlang was designed for telecommunication systems that keep very many separate activities running at once. JavaScript, Python and Java are not purely functional, but each lets a programmer use a functional style.

The order total in Haskell:

orderTotal :: [(Int, Double)] -> Double
orderTotal orderLines = sum (map lineTotal orderLines)
  where
    lineTotal (quantity, price) = fromIntegral quantity * price

main :: IO ()
main = putStrLn ("Total: Ksh " ++ show (orderTotal [(4, 250), (10, 35), (2, 1200)]))

Output:

Total: Ksh 3750.0

The program has no loop and no variable that changes. The function map applies lineTotal to each pair, giving the list [1000.0, 350.0, 2400.0], and sum adds the list to 3750.0. The function fromIntegral converts the whole-number quantity to a decimal number so it can be multiplied by the price.

Strengths and limits:

• Easier reasoning: With no hidden changes, a function can be understood from its own lines.
• Safe for concurrent work: Immutable data cannot be changed by two activities at the same time, which removes one source of faults.
• Short code for data transformations: Working through lists of records, such as order lines, takes only a few lines.
• A different way of thinking: Learners used to loops and changing variables need time to think in functions and recursion.
• Not every task fits: Programs that depend on a lot of changing state, such as an interactive screen, need extra techniques to be written in a purely functional style.

1.1.2 Criteria for selecting languages based on user requirements

Choosing a language starts with the user's requirements, then moves to the project's size, the speed needed, the team's skills, the target platform and the support available. A poor choice shows up later as slow programs, missed deadlines or code nobody can maintain, so a developer weighs these criteria before writing any code.

Project complexity and scope

A large system with many features and several developers benefits from a language with strong support for modular design, such as Java or C#. A small automation job, such as renaming files or producing a nightly stock report, is better served by Python or Bash because the code is short and quick to write.

Performance requirements

Programs that need high speed and low delay, such as firmware in a device or the engine of a game, are usually written in compiled languages such as C or C++. A website or a business app that must be built quickly can use a dynamic language such as JavaScript or Python, accepting slower execution in exchange for faster development.

Development team expertise

A team's familiarity with a language affects its productivity and the quality of its code. A software team that already works well in Python may choose it for a new project to use its existing skills and avoid the cost of training.

Platform compatibility

The target platform limits the choice. Android apps are written mainly in Kotlin or Java, and iPhone apps in Swift or Objective-C. Cross-platform frameworks use JavaScript or Dart. A developer finds out where the client's users will run the software before selecting a language.

Community support and ecosystem

A language with an active community offers many libraries, frameworks and tools, and answers to common problems are easy to find. Python's libraries for data analysis and machine learning are an example of an ecosystem that can shorten a project.

Applying the criteria

Example: the owner of a hardware shop asks for two things: a stock app that staff use on Android phones, and a nightly script that totals the day's sales into a report. For the app, platform compatibility points to Kotlin or Java. For the script, project size and speed of writing point to Python. The same client therefore receives two programs in two languages, each chosen for its own requirement.

Chapter Summary

This chapter explored various programming language types, highlighting procedural, object-oriented, and functional categories, and discussed how to select a language based on specific user requirements. It then examined common programming paradigms, including imperative and declarative approaches, emphasizing the importance of choosing the right paradigm to suit project needs. The program development life cycle was described with its key stages such as planning, design, and implementation, alongside best practices for adapting these stages to different work contexts. Design tools like algorithms, flowcharts, wireframes, pseudocode, and decision tables were introduced, with guidance on selecting appropriate tools depending on project complexity and user requirements. The chapter also covered program writing tools and integrated development environments, evaluating options like Visual Studio and Eclipse based on system needs and developer preferences. Practical skills were reinforced through activities involving creating simple classes, instantiating objects, and engaging in collaborative projects where team members implement different classes from a shared design. Together, these topics provide a comprehensive foundation for applying computer programming skills effectively.