Difficulty: Beginner | Prerequisites: None
This is your foundation. Before you write a single line of code, you need to understand what programming is, what a programming language does, and how languages are categorised. This material underpins everything else in the course, from structured programming through to data structures. If you are coming in cold, start here.
Computer programming is the process of writing instructions a computer can execute. Programming languages are the tools you use to write those instructions, and they fall into dozens of categories based on how they handle data, control flow, and abstraction. Choosing the right language depends on the task, portability, development speed, and ease of learning.
Computer programming
The art of developing a logical list of instructions to guide a computer in solving a problem. Also described as the process of designing and building source code that can be compiled or interpreted into usable object code. In simple terms, it is writing step-by-step directions a machine can follow.
Computer program
A list of instructions that tells a computer what to do when performing a given task. Think of it as a recipe: each step must be in order and unambiguous.
Programming language
A set of commands, instructions, and syntax used to create a software program. In simple terms, it is the vocabulary and grammar you use to talk to a computer.
Source code
The human-readable text a programmer writes in a programming language.
Object code
The machine-readable output produced after source code is compiled or interpreted.
Compiler
A program that translates an entire source-code file into object code before execution. Examples: GCC for C, javac for Java.
Interpreter
A program that translates and executes source code line by line at runtime. Examples: the Python interpreter, early BASIC interpreters.
Assembler
A translator that converts assembly language (mnemonics) into machine code.
Mnemonics
Short abbreviations used in assembly language to represent machine-level operations (e.g. MOV, ADD, ESC). Think of them as shorthand nicknames for binary instructions.
Portability
The ability of software to run on different machines or platforms without modification.
Purpose fitness – the language should suit the domain. COBOL and Java, for example, are common in business applications.
Speed of development – some languages let you build working software faster than others.
Portability – whether the language and its compiled output run across different machines and operating systems.
Ease of learning – a simpler syntax lowers the barrier for new programmers.
Languages are grouped by the features they emphasise or the way they handle computation. Below are the major categories covered in this course.
Array languages – operate on array (vector/multidimensional) data structures. Used in scientific and engineering work. Examples: Fortran 90, Analytica.
Assembly languages – sit very close to machine language, using mnemonics. Translated by an assembler. Machine-dependent and hard to read, which is their main disadvantage.
Authoring languages – designed for building tutorials and interactive programs. Examples: DITA, TUTOR.
Constraint programming languages – express relationships between variables as constraints; the runtime searches for values satisfying all constraints.
Command-line / batch / job-control languages – process commands typed at a command-line prompt. Example: DOS.
Compiled languages – translated entirely into machine code by a compiler before execution. Examples: Ada, BASIC, C, C++.
Concurrent / parallel / message-passing languages – provide built-in constructs for running tasks simultaneously. Example: Java.
Curly-bracket (brace) languages – use { } to group statements into blocks. Examples: C, C++.
Data-flow languages – specify programs through the representation of data flow. Example: Analytica.
Data-oriented languages – work with entity-relationship tables, mapping one set of things to another. Example: Clarion.
Data-structured languages – their logic mirrors their data types (array-based, list-based, stack-based).
Decision-table languages – help clarify logic before coding in any language.
Declarative languages – express the logic of a computation without spelling out control flow in detail.
Imperative languages – specify computation by giving serial orders that describe the control flow step by step.
Embeddable languages – embed small pieces of executable code inside free-form text such as a web page.
Educational languages – built specifically for teaching programming.
Esoteric languages – experimental languages that test the boundaries of language design.
Extension languages – attach to another program to add or extend features.
Fourth-generation languages (4GL) – high-level languages built around database systems.
Functional languages – define programs as mathematical functions. Examples: Haskell, Lisp.
Hardware description languages – describe the operation of electronic circuits. Examples: VHDL, Verilog.
Interactive-mode languages – let you enter expressions one at a time and see results immediately (a REPL).
Interpreted languages – executed line by line by an interpreter. Example: early BASIC.
Iterative languages – built around iteration (loops) as a core construct.
List-based languages (Lisps) – built on list data structures. Examples: Common Lisp, Scheme.
Little languages – small, specialised languages for narrow problem domains.
Macro languages – transform one piece of source code into another; a short macro expands into longer code.
Metaprogramming languages – write programs that manipulate other programs.
Multi-paradigm languages – support more than one programming style (e.g. both OOP and functional).
Object-oriented programming (OOP) languages – organise code around objects defined by classes, using message passing. Examples: Java, C++, Python.
Prototype-based languages – object-oriented, but classes are not distinct from instances. Example: JavaScript (prototype chain).
Off-side-rule languages – use indentation to define blocks. Example: Python.
Procedural languages – composed of one or more units or modules executed in sequence.
Reflective languages – allow programs to examine or modify their own structure at runtime or compile time.
Scripting languages – automate frequently used tasks. Examples: Bash, Python, Perl.
Stack-based languages – built around the stack concept. Example: Forth.
Synchronous languages – designed for systems that must respond promptly to interrupts.
Visual languages – use graphical layouts rather than text. Example: Scratch.
Wirth languages – designed by Niklaus Wirth. Examples: Pascal, Modula-2, Oberon.
Domain-specific languages – tailored for specialised applications. Example: SQL for databases.
System programming languages – deal with managing the computer system itself. Examples: C, Rust.
Application languages – aimed at performing user-facing tasks with the computer.
Choosing the right language category matters in practice. A systems programmer writing an operating-system kernel reaches for C or Rust (low-level, compiled). A data analyst automating a report picks Python (scripting, interpreted). An engineer modelling stress on a bridge might use Fortran 90 (array language, scientific computing). Knowing the categories helps you pick the right tool for the job.
Students often think "compiled" and "interpreted" are properties of the language itself. They are properties of the implementation. Python is usually interpreted, but compilers for Python exist.
Students sometimes confuse assembly language with machine language. Assembly uses human-readable mnemonics; machine language is raw binary. An assembler bridges the two.
"High-level" does not mean "better." It means further from hardware. Low-level languages give more control; high-level languages give more convenience. The right choice depends on the task.
⚠️ Know the difference between compiled and interpreted execution. This is a classic exam question.
⚠️ Be able to name at least three categories and give an example language for each.
⚠️ Understand the four factors for choosing a programming language (purpose, speed of development, portability, ease of learning).
⚠️ Assembly language disadvantages (machine-dependent, hard to read) come up frequently.
True or False: A compiler translates source code one line at a time during execution.
Fill in the blank: Assembly language uses short abbreviations called _______ to represent machine operations.
True or False: Portability means a program can run on different platforms without changes.
Fill in the blank: Languages that express computation logic without describing control flow are called _______ languages.
True or False: Fourth-generation languages are typically built around database systems.
Answers: 1. False (that describes an interpreter). 2. Mnemonics. 3. True. 4. Declarative. 5. True.
Q: Define computer programming.
A: Computer programming is the process of designing and building a logical list of instructions (source code) that can be compiled or interpreted into object code to guide a computer in solving a problem.
Q: List four factors to consider when choosing a programming language.
A: Purpose fitness, speed of development, portability across platforms, and ease of learning.
Q: What is the key disadvantage of assembly language?
A: Assembly language is machine-dependent and difficult for humans to read and write, making it less portable and harder to maintain than higher-level languages.
Q: Distinguish between a compiler and an interpreter.
A: A compiler translates the entire source code into object code before execution. An interpreter translates and executes the source code line by line at runtime.
Q: Give two examples of object-oriented programming languages.
A: Java and C++ (also acceptable: Python, C#, Smalltalk).
Q: What are declarative languages, and how do they differ from imperative languages?
A: Declarative languages express the logic of a computation without specifying control flow in detail. Imperative languages explicitly describe the control flow using serial instructions (commands).
This material connects directly to the next topic, structured programming, which is one specific paradigm within the broader landscape of language categories. Understanding the distinction between compiled and interpreted languages also matters when you study how programs are executed and debugged. The data structure categories (array-based, list-based, stack-based) reappear in detail in the data structures unit.
computer programming definition, programming language categories, compiled vs interpreted, assembly language mnemonics, imperative vs declarative, OOP, object-oriented programming, functional programming, scripting languages, 4GL, fourth-generation languages, portability, source code, object code, CSE 101, structured programming revision, Texas A&M CS