Introduction to Programming

Introduction

Programming is the process of designing and writing instructions that a computer can execute to perform a task. In a vocational setting, programming may help you process measurements, automate repetitive office work, control equipment through approved systems, analyze production data, build web tools, test devices, or support maintenance and quality processes. The specific programming language may change from workplace to workplace, but the core ideas in this course transfer across many languages and technical fields.

This aiMOOC is designed for apprentices, trainees, and vocational students who are new to programming. You will learn to break a practical problem into steps, represent those steps as an algorithm, express them in code, test the result, and improve it. Python is used for several examples because its syntax is readable, but the course also shows how the same thinking appears in command-line work, web development, industrial automation, and PLC environments.

By the end of the course, you should be able to explain how programs work, use variables and data types, make decisions with conditions, repeat actions with loops, organize code with functions, work with collections, identify common errors, test and debug small programs, use basic development tools, and describe responsible programming practices in a workplace.

Learning Goals for Vocational Practice

After completing the course, you should be able to:

Problem solving: Translate a workplace problem into clear inputs, processing steps, decisions, and outputs.
Algorithm: Design a step-by-step solution before writing code.
Programming language: Read and write small programs using common language features.
Debugging: Find, explain, and correct syntax, runtime, and logic errors.
Software testing: Check normal cases, boundary cases, and invalid inputs.
Version control: Explain why teams record and review changes to code.
Occupational safety and health: Recognize that software connected to machines or infrastructure requires controlled testing, authorization, and safety procedures.
Communication: Document code and explain your solution to a supervisor, colleague, or customer.

What a Program Does

A program takes input, performs processing, and produces output. It may also store data, communicate with other systems, or react to events. For example, a maintenance program might read machine running hours, compare the value with a service limit, and display a maintenance message. A warehouse program might read stock quantities, identify products below a reorder point, and prepare a report.

The computer follows instructions exactly as they are expressed. It does not automatically understand the intention behind your code. This is why precise requirements, clear algorithms, testing, and review are essential professional skills.

Computers ultimately execute low-level machine instructions represented in binary form. Programmers usually work in higher-level languages such as Python, JavaScript, Java, C, or C++. Tools such as compilers, interpreters, runtimes, and virtual machines help translate or execute higher-level code. The exact process depends on the language and implementation, so it is better to think of “compiled” and “interpreted” as implementation approaches rather than a perfect division between all languages.

From Requirement to Result

A useful programming workflow is:

Requirements analysis: Define what the user or workplace process actually needs.
Algorithm: Describe the solution as logical steps.
Pseudocode or Flowchart: Represent the logic before committing to a programming language.
Source code: Implement the solution.
Software testing: Check that the program behaves as required.
Debugging: Locate and correct faults.
Documentation: Explain use, assumptions, and important decisions.
Version control: Record changes so that work can be reviewed and recovered.

In professional work, these steps are often repeated rather than completed only once. Requirements change, tests reveal problems, and users provide feedback.

Algorithms, Pseudocode, and Flowcharts

An algorithm is a finite sequence of clear steps for solving a problem or completing a computation. A good beginner algorithm identifies the required input, the decisions that must be made, the actions to repeat, and the expected output.

Consider a workshop task: decide whether a machine is due for routine service based on its recorded running hours. Before coding, you could describe the logic in plain English:

Read the current running hours.
Read the service interval.
Compare the current hours with the interval.
If the running hours are at or above the interval, show a maintenance message.
Otherwise, show a continue-monitoring message.

A flowchart uses symbols and arrows to show the path through a process. Rectangles commonly represent actions, diamonds represent decisions, and arrows show the direction of control. Flowcharts are useful when you need to explain logic to people who may not use the same programming language.

Pseudocode is an informal, language-independent way to describe an algorithm. For example:

READ running_hours
READ service_limit
IF running_hours is at least service_limit
    DISPLAY "Schedule maintenance"
ELSE
    DISPLAY "Continue monitoring"
END IF

Pseudocode is valuable because you can review the logic before worrying about exact syntax. In a workplace, this can help a technician, operator, programmer, and supervisor discuss the same process.

Your First Program

A small Python program can display text with the print function:

print("Hello, workshop!")

The text inside quotation marks is a string. The function call tells Python to send that text to the output. A first program is simple, but it introduces a professional habit: make one small change, run the program, observe the result, and keep working in controlled steps.

The full Python video above is longer than this course requires. You can use its chapters selectively when you want extra practice with setup, variables, input, conditions, loops, functions, files, and other beginner topics.

Variables, Values, and Data Types

A variable is a name associated with a value. Clear names make code easier to understand and maintain.

machine_id = "A17"
running_hours = 510
service_limit = 500
temperature_c = 21.5
inspection_passed = True

These values use several common data types:

Data type	Example	Typical use
Integer	`510`	Counts, whole quantities, indexes
Floating-point number	`21.5`	Measurements and calculated values where decimal representation is appropriate
String	`"A17"`	Text, names, identifiers
Boolean	`True`	Conditions with true or false states

Choose types carefully. A product code such as "00127" may look numeric, but it is often better stored as text because leading zeroes are part of the identifier. A measured value may need a decimal type, while money in real business systems may require a decimal representation designed to avoid binary floating-point rounding effects.

Assignment and Naming

An assignment stores or updates a value:

units_completed = 12
units_completed = units_completed + 1

The second line reads the old value, adds one, and stores the new value. The name should describe the meaning of the value. Names such as temperature_c or failed_checks communicate more than x or n.

Use your workplace or project naming conventions. Consistency matters when several people maintain the same code.

Operators and Expressions

An expression combines values, variables, and operators to produce a result. Common categories include arithmetic, comparison, and logical operators.

Purpose	Python examples	Meaning
Arithmetic	`+ - * /`	Calculate values
Remainder	`%`	Find the remainder after division
Comparison	`== != < <= > >=`	Compare two values
Logical	`and or not`	Combine or reverse Boolean conditions

Do not confuse assignment = with equality comparison == in Python. This difference is a common beginner source of errors.

Decisions with Conditions

A conditional executes different code depending on whether a Boolean expression is true or false.

running_hours = 510
service_limit = 500

if running_hours >= service_limit:
    print("Schedule maintenance")
else:
    print("Continue monitoring")

Python uses indentation to mark blocks of code. In many other languages, braces or keywords mark blocks instead. The concept is the same: a decision controls which path the program follows.

Conditions can be combined:

guard_closed = True
emergency_stop_clear = True

if guard_closed and emergency_stop_clear:
    print("Training condition is satisfied")
else:
    print("Training condition is not satisfied")

This is only a programming example. Real machinery must not rely on a classroom script for safety. Safety functions require appropriate hardware, standards, risk assessment, authorization, and validated procedures.

Repetition with Loops

A loop repeats instructions. A for loop is useful when you want to process each item in a collection:

inspection_steps = ["check label", "check housing", "record result"]

for step in inspection_steps:
    print(step)

A while loop repeats while a condition remains true:

attempts = 0

while attempts < 3:
    print("Run test")
    attempts = attempts + 1

Every loop needs a clear stopping rule. An accidental infinite loop can make a program unresponsive or consume resources. In automation and device control, uncontrolled repetition can have more serious consequences, so changes must be tested in safe, authorized environments.

Choosing Between for and while

Use a for loop when you are working through a known collection or a defined range. Use a while loop when repetition depends on a condition whose duration is not known in advance. This is a guideline rather than a strict rule; many tasks can be expressed in more than one way.

Functions and Reuse

A function groups instructions under a name. Functions help you divide a large problem into smaller parts, avoid repeated code, and test behavior independently.

def needs_service(hours_run, limit):
    return hours_run >= limit

hours_run = 510
service_limit = 500

if needs_service(hours_run, service_limit):
    print("Schedule maintenance")
else:
    print("Continue monitoring")

The names hours_run and limit are parameters. The return statement sends a result back to the caller. A good function normally has one clear responsibility.

Functions also support collaboration. One team member can work on input validation while another works on reporting, as long as the interfaces are agreed and tested.

Collections: Lists and Dictionaries

Programs often work with groups of values. A Python list stores an ordered sequence:

temperatures = [20.8, 21.1, 21.4]

A dictionary stores key-value pairs:

machine = {
    "id": "A17",
    "hours": 510,
    "status": "service due"
}

Collections let you model practical information such as inspection results, work orders, stock items, sensor samples, or customer records. Choose a structure that matches how the data will be used.

When working with real personal, customer, or business data, follow your organization's privacy, security, retention, and access rules. Training exercises should use fictional or approved test data.

Input, Validation, and Output

Many programs receive data from users, files, sensors, networks, or other applications. Input should be treated as potentially incorrect until it has been checked.

text = input("Enter units completed: ")

try:
    units = int(text)
    if units < 0:
        print("Units cannot be negative")
    else:
        print("Recorded:", units)
except ValueError:
    print("Please enter a whole number")

This example checks whether the input can be converted to an integer and rejects a negative quantity. Real workplace validation may also need range checks, format checks, permissions, audit logs, and rules for missing data.

Good output is understandable to the intended user. Prefer messages such as “Enter a whole number from 0 to 500” over vague messages such as “Error”.

Errors, Testing, and Debugging

Errors are a normal part of programming. Professional programmers expect to test, diagnose, and correct them.

Error type	What it means	Example approach
Syntax error	The code does not follow the language grammar	Read the error message and inspect the indicated line
Runtime error	The program starts but fails during execution	Reproduce the failure with the same input and inspect the state
Logic error	The program runs but produces the wrong result	Compare expected and actual results with focused test cases

Debugging is the process of locating and understanding the cause of a defect. Useful techniques include reading error messages, reproducing the problem, simplifying the test case, printing or inspecting variable values, using a debugger, checking assumptions, and changing one thing at a time.

Testing should include more than the normal case. For a service-limit function, test values below the limit, exactly at the limit, and above the limit. Also consider invalid values if the function can receive them.

def needs_service(hours_run, limit):
    return hours_run >= limit

assert needs_service(499, 500) is False
assert needs_service(500, 500) is True
assert needs_service(501, 500) is True

An assertion is useful for simple training examples, but larger projects normally use a testing framework and documented test cases.

Development Tools

Programming rarely means typing code into a single plain text box. You may use several tools:

Text editor: Edits source files.
Integrated development environment: Combines editing with features such as running, debugging, project navigation, and code assistance.
Command-line interface: Runs programs and development tools using typed commands.
Debugger: Lets you pause execution and inspect program state.
Version control: Records changes and supports collaboration.
Issue tracking system: Records defects, tasks, and improvement requests.

The command line is common in software development, system administration, networking, and technical support. Learn commands in a safe environment and understand their effect before running them, especially commands that modify or delete files.

IDEs and Hardware Projects

An IDE can support many kinds of work, from general software development to microcontrollers.

The image shows an early Arduino IDE with a simple program. Modern tools look different, but the development cycle is familiar: edit code, build or interpret it, transfer or run it, observe the result, and debug.

When software controls physical hardware, use training equipment, approved procedures, and appropriate supervision. A programming mistake in a simulation may only produce the wrong number; a mistake connected to real machinery can cause motion, heat, pressure, or other physical effects.

Vocational Applications of Programming

Programming appears across many occupations. You do not need the job title “software developer” to benefit from programming skills.

Vocational area	Example programming use	Relevant concepts
Industrial maintenance	Analyze service logs or device data	Variables, conditions, files, testing
Mechatronics and automation	Configure or program approved controllers	Logic, state, timing, safety-aware testing
Logistics	Check stock levels and generate reports	Collections, conditions, data validation
Office administration	Automate repetitive data transformations	Files, functions, error handling
Electronics	Program a microcontroller on a training board	Input, output, loops, device libraries
IT support	Write small diagnostic or setup scripts	Command line, strings, files, permissions
Web development	Create interactive pages or services	Functions, data, events, testing

The same core ideas appear in different forms. A PLC ladder diagram may look very different from Python source code, but both represent logic that reads conditions and determines outputs.

The PLC video introduces the role of programmable logic controllers in industrial automation. In real vocational practice, programming a PLC is only one part of a larger safety and engineering process that may include electrical design, risk assessment, interlocks, commissioning, documentation, and authorized change control.

Code Quality and Professional Habits

Code is read many more times than it is written. Professional habits make maintenance safer and faster.

Useful habits include choosing descriptive names, keeping functions focused, avoiding unnecessary duplication, formatting code consistently, documenting assumptions, checking input, writing tests, reviewing changes, and removing secrets from source code.

Comments should explain why a decision was made when the reason is not obvious. Avoid comments that merely repeat the code.

# Service is due at or above the contractual hour limit.
if running_hours >= service_limit:
    print("Schedule maintenance")

Documentation should describe how to run the program, required inputs, expected outputs, limitations, dependencies, and any operational precautions.

Version Control and Teamwork

Version control systems record changes to files over time. They help teams review work, compare versions, restore earlier states, and coordinate changes. Git is a widely used distributed version control system.

A beginner workflow might include checking the current status, creating a focused change, testing it, recording the change with a meaningful message, and sharing it through an approved repository. Team workflows vary, so follow local conventions.

Never commit passwords, private keys, access tokens, confidential customer data, or other secrets to a repository. If a secret is exposed, deleting one line from the latest file may not remove it from repository history; follow your organization's incident and credential-rotation procedures.

Pair programming and code review can improve communication and catch mistakes earlier. One person may write while another reviews the logic, and the roles can switch. The goal is shared understanding rather than simply producing code faster.

A Practical Mini-Project: Maintenance Reminder

This mini-project combines several ideas from the course. The goal is to read a fictional machine identifier and running hours, compare the hours with a service limit, and print a clear status. It is a training example and must not be used as a safety or maintenance control system.

def service_status(hours_run, limit):
    if hours_run >= limit:
        return "Service due"
    return "Continue monitoring"

machine_id = "A17"
hours_run = 510
service_limit = 500

status = service_status(hours_run, service_limit)
print(machine_id, "-", status)

You can improve the project by validating values, reading several machines from a list, writing tests, or producing a summary report. Every improvement should start with a clear requirement and include a test that demonstrates the expected behavior.

Review the Mini-Project Like a Technician

Ask yourself:

What input does the program require?
What output does it produce?
Where is the decision made?
What boundary case should be tested?
Which values should be configurable rather than fixed?
What would need to change before a real organization could rely on the program?

The last question is important. Workplace software may need authentication, logging, data protection, integration testing, change approval, backups, fail-safe behavior, user training, and formal validation depending on the risk and industry.

Interactive Tasks

Quiz: Test Your Knowledge

What is an algorithm? (A clear sequence of steps for solving a problem) (!A physical computer component) (!A type of password) (!A screen resolution)

Which Python value is a Boolean? (True) (!Twenty) (!Machine A) (!Three point five)

Which structure is used to choose between different paths? (Conditional) (!Comment) (!String) (!Editor)

Which structure is designed to repeat instructions? (Loop) (!Variable) (!Debugger) (!Repository)

What is a main purpose of a function? (To group reusable instructions) (!To increase monitor brightness) (!To replace all testing) (!To store electrical power)

Which error means a program runs but gives the wrong result? (Logic error) (!Syntax color) (!Keyboard error) (!Display mode)

Why should input be validated? (To detect unacceptable or malformed data) (!To make every value a string) (!To remove all functions) (!To avoid writing tests)

What does version control help a team record? (Changes to project files) (!Room temperature only) (!Printer paper levels) (!Monitor size)

Which test is especially useful for a service limit of five hundred hours? (A value exactly at the limit) (!Only a random color) (!Only the program title) (!Only the file extension)

What is the safest approach when code can control real machinery? (Use approved procedures and controlled testing) (!Test every change directly on live equipment) (!Ignore interlocks during debugging) (!Assume a short program cannot cause harm)

Memory Game

Algorithm	Step-by-step solution to a problem
Variable	Named place for a value
Conditional	Decision that selects a path
Loop	Structure that repeats instructions
Function	Named reusable block of behavior
Debugger	Tool for inspecting program execution
Repository	Storage location for version-controlled project history
Boolean	Data value that is true or false

Drag and Drop

Match the correct terms.	Topic
Stores a named value	Variable
Repeats a block of instructions	Loop
Chooses a path from a condition	Conditional
Groups reusable behavior	Function
Records project changes over time	Version control

Match every description with the programming concept that best fits it.

Crossword Puzzle

Algorithm	What is a step-by-step method for solving a problem called?
Variable	What stores a named value in a program?
Debugger	What tool helps inspect program execution while finding faults?
Function	What named block groups reusable instructions?
Boolean	What data type represents true or false?
Compiler	What kind of tool can translate source code into another executable form?

LearningApps

Cloze Text

A program follows a set of written

to perform a task. Before coding, you can describe a solution as an

. A named value in a program is commonly stored in a

. A decision based on a true-or-false expression is a

. Repeating a block of code can be done with a

. Reusable behavior can be organized in a

. Finding the cause of a defect is called

. Checking expected behavior with planned cases is called

. A system that records changes to project files provides

. Code connected to physical equipment should be tested using approved

.

Open-Ended Tasks

Easy

Hello world: Write a short program that displays your name, vocational field, and one task you would like to automate; run it and explain each line.
Flowchart: Draw a flowchart for deciding whether a fictional tool is due for inspection based on a date or usage limit.
Variable: Create a table of eight meaningful variable names for a workshop, office, logistics, IT, or service scenario and state the data type you would use for each.
Debugging: Take a small program with three intentional beginner errors, correct it, and write one sentence explaining each correction.

Standard

Input validation: Build a program that asks for a fictional quantity, checks that it is a valid non-negative whole number, and gives a clear message for invalid input.
Loop: Create a program that processes a list of at least five fictional inspection items and produces a simple checklist report.
Function: Refactor a repeated calculation or decision into a function, then test it with normal, boundary, and invalid cases.
Interview: Interview a technician, administrator, developer, or supervisor about where software is used in their work; summarize the tasks, benefits, risks, and skills they describe without including confidential information.

Advanced

Mini project: Design and implement a small vocational tool such as a stock checker, maintenance reminder, unit converter, or training log using fictional data; include requirements, code, tests, and user instructions.
Version control: Create a small repository for a training project, make several focused commits with meaningful messages, and produce a short reflection on how history and review improve teamwork.
Software testing: Design a test plan for a program that accepts user input and makes a decision; include equivalence classes, boundary cases, invalid data, expected results, and a record of actual results.
Workplace automation: Produce a short video or illustrated presentation that explains how a programming concept such as conditions, loops, or functions appears in a real vocational system, and clearly distinguish a classroom model from safety-critical production use.

Learning Assessment

Algorithm design: Given a new workplace scenario, identify inputs, outputs, decisions, repeated actions, and failure cases, then represent the solution in pseudocode or a flowchart and justify the structure.
Code review: Analyze a short program for naming, duplication, validation, boundary errors, and readability, then propose improvements and explain which improvement has the greatest effect on reliability.
Testing strategy: Create a set of test cases for a maintenance-threshold function and explain why each case is necessary, including at least one boundary and one invalid-input case.
Debugging process: Diagnose a program that produces an incorrect result, document the evidence you collect, isolate the cause, correct the defect, and verify that the correction did not break another case.
Transfer between languages: Rewrite the logic of a Python conditional and loop as language-neutral pseudocode, then explain how the same logic could appear in another programming language or an automation environment.
Professional responsibility: Evaluate a proposed plan to test new control software directly on production machinery and identify safer development, simulation, authorization, review, and validation steps.

Evidence of Learning

Evidence of learning should show not only that you remember vocabulary, but that you can use programming ideas responsibly in realistic tasks.

Evidence area	What successful work can show
Knowledge	You can explain algorithms, variables, data types, operators, conditions, loops, functions, collections, errors, tests, and version control.
Skills	You can decompose a problem, write and run a small program, validate input, debug faults, design boundary tests, and explain your code.
Products	You can produce flowcharts, pseudocode, source code, test records, documentation, and a version-controlled mini-project.
Communication	You can describe requirements, assumptions, results, defects, and risks clearly to a learner, colleague, supervisor, or customer.
Transfer	You can recognize the same programming logic in software, scripts, device projects, web tools, or industrial automation contexts.
Professional practice	You can distinguish a classroom prototype from production software and identify when authorization, security, privacy, safety, review, and formal validation are required.

OERs on the Topic

The English Wikipedia article on Computer programming provides a broad overview of programming concepts, languages, practices, and history.

Linked Learning Areas

The essential learning path moves from understanding a problem to designing an algorithm, writing code, testing behavior, and collaborating responsibly. These areas connect programming with mathematics, electronics, automation, data work, IT support, software development, and workplace communication.

Introduction to Programming