Programming Languages and Paradigms

A line such as x = a + b names a calculation without mentioning a processor register. Abstraction makes this possible: a language hides lower-level details so that a programmer can focus on the work the program should do.

What the processor runs

Machine code consists of instructions encoded as binary numbers. A processor's instruction set architecture (ISA) defines its instructions and their encodings. x86-64 is common in PCs and servers; ARM is common in phones, tablets, and many laptops. Code built for one ISA needs translation or emulation to work on another.

Hexadecimal makes instruction bytes shorter to display. On x86-64, B8 01 00 00 00 puts 1 into the register EAX. The bytes 01 D8 add the value in EBX to EAX. Registers are small storage locations inside the processor. Each instruction performs a small action, such as moving data, adding, comparing, or jumping. The fetch-decode-execute cycle runs these instructions.

Names for the same small actions

Assembly language replaces instruction bytes with readable names called mnemonics. Those two x86-64 instructions can be written:

mov eax, 1
add eax, ebx

An assembler converts assembly into machine code. An ordinary instruction line normally produces one machine instruction. Register names and instructions still belong to a particular ISA, so using words instead of bytes does not make assembly portable.

Describe a problem in fewer lines

A high-level language provides variables, expressions, conditions, loops, and functions. Python, C, Java, and JavaScript let the programmer describe operations without selecting registers. One statement commonly requires several machine instructions. A simplified translation of x = a + b would:

1. Load the value of a into a register.
2. Load the value of b into another register.
3. Add the register values.
4. Store the result for x.

A real compiler may combine or rearrange those steps while keeping the required behavior.

High-level source is easier to read, change, and check. Portable C source can be compiled once for an x86-64 system and again for an ARM system. Each build still needs the right operating-system support and libraries. Portability of source does not make a native executable universal.

Why the lower levels still matter

Assembly remains useful in startup code, some operating-system and driver routines, small embedded systems, and security analysis of programs with no available source. For ordinary application code, modern compilers usually produce machine code with performance comparable to handwritten assembly.

The shift toward higher levels happened gradually. Assembly spread in the late 1940s and early 1950s. Grace Hopper's A-0 system in 1952 helped advance automatic translation. IBM released FORTRAN in 1957; COBOL followed in 1959, and Lisp emerged around 1958–1960. "High-level" names the distance from hardware details, not the difficulty of learning the language.

A compiler translates source code into target code. The target may be native machine code or an intermediate form such as bytecode. Ahead-of-time (AOT) compilation happens before the program runs; just-in-time compilation happens during execution.

From text to instructions

For an ahead-of-time build, several stages turn a source file into instructions:

1. Lexical analysis splits text into tokens: meaningful pieces such as names, operators, and numbers.
2. Parsing checks the grammar and builds a structure showing how the pieces fit together.
3. Semantic analysis checks rules about meaning, including declarations and allowed type combinations.
4. Optimization finds a more efficient way to perform the required work.
5. Code generation emits the target instructions.

Consider the C statement total = price * 3;. Its six tokens are total, =, price, *, 3, and ;. The names are identifiers, 3 is an integer literal, and the semicolon ends the statement. Parsing records that multiplication belongs inside the assignment: calculate price * 3, then store its value in total.

These stages have different jobs. A correctly spelled sequence of tokens can still violate the grammar. A grammatical statement can still misuse a type. Finding tokens is not enough to establish that a program is valid.

Make the same work cheaper

Suppose source code contains seconds_per_day = 60 * 60 * 24. The factors are constants, so the compiler can multiply 60 by 60 to get 3600, then multiply by 24 to get 86400 during the build. It can place the final value in the output instead of repeating the multiplication at run time. This is constant folding.

An optimization must preserve the behavior the language requires. It cannot replace a calculation with a faster one that gives different required results. The aim is to reduce work, time, or memory while keeping the program's meaning.

Join the pieces

Large programs are usually built from many files. A compiler can produce an object file for each source file. An object file contains translated code that may still need connections to other code. A linker joins the pieces and resolves calls to library routines, such as printing or math functions.

The resulting executable is built for a target platform, including an ISA and operating-system conventions. The user does not need the ahead-of-time compiler to run it. Shared libraries or runtime components can still be required.

Understand what a successful build proves

In Java, int count = "five"; fails a type check before execution. Text cannot initialize that integer variable. The program must pass the required compile-time checks before a runnable build is available.

Other faults survive compilation. Division by a user-entered zero depends on runtime data. A program intended to subtract that instead adds can run and return the wrong value. Compilation checks language rules; testing must also check that the result matches the intended task.

A program does not have to become a native executable before a user starts it. An interpreter carries out the program through another running program. Many implementations combine interpretation with compilation, so the useful question is how this particular system executes code.

Execute through an interpreter

An interpreter needs to be available whenever it runs the program. An interactive REPL repeats four actions: read an entry, evaluate it, print a result, and loop for the next entry. It gives quick feedback while trying small expressions.

Interpreting does not necessarily mean reading raw source one line at a time. CPython, the standard Python implementation, first compiles a file into bytecode. A software virtual machine then executes those internal instructions. Bytecode belongs to that runtime; it is not the processor's native instruction set.

Why some errors appear earlier

Compare two Python files. This one has valid syntax:

print("start")
x = 10
print(x + "5")

It prints "start", binds x to 10, and then raises TypeError. Adding that integer to a string fails only when the expression is executed. A similar operation in an unvisited branch can remain unnoticed until the branch runs.

Now remove the closing parenthesis from the last line. CPython cannot compile the file because its syntax is incomplete. It reports a syntax error before any statement in that file executes, so "start" is not printed. Syntax checking of the whole file and runtime checking of an executed operation happen at different times.

Share bytecode, specialize while running

Java shows a common hybrid route. javac Hello.java produces Hello.class, which contains bytecode. java Hello starts a compatible Java Virtual Machine (JVM). Different JVM implementations let that bytecode run on different processor families. The bytecode is portable across compatible runtimes; each runtime must itself work on its host platform. C# similarly targets an intermediate language used by .NET.

A just-in-time (JIT) compiler generates machine code while the program runs. Java's HotSpot runtime commonly starts with interpretation and compiles frequently used methods. Browser JavaScript engines also combine execution techniques, including JIT compilation. Compiling busy parts can improve sustained speed, but uses time and memory during execution.

A loop adding one billion values typically runs much faster in compiled C than in CPython: CPython performs interpreter work and type checks around many operations. For a script renaming 20 files, development effort may matter far more than that difference. Measure the workload before treating a language label as a speed prediction.

Compiled and interpreted describe implementation choices. CPython uses bytecode interpretation; PyPy uses JIT techniques. A language can have more than one implementation, and one implementation can use several execution methods.

Syntax sets the rules for valid program text. Semantics gives that text its meaning. A program can follow every grammar rule and still calculate the wrong result, so checking its appearance is only the first part of reading it.

Recognize the pieces and the grammar

Tokens include keywords such as if, identifiers such as total, literals such as 3 or "hello", operators such as + and ==, and punctuation. A grammar describes how these pieces can form expressions and statements.

Python requires a colon after if x > 3: and uses indentation to mark the statements controlled by that condition. C, Java, and JavaScript use curly braces for blocks; C and Java also require semicolons after many statements. In those languages, indentation helps a human reader but does not select the block.

Different syntax can express a similar action. These statements print a greeting:

print("hello")

printf("hello\n");

System.out.println("hello");

The C escape \n adds a newline. Knowing the idea of printing helps when learning each language's way of expressing it.

The same symbols can mean different things

A symbol's familiar appearance does not determine its meaning across languages.

Evaluation order matters too. Precedence makes multiplication and division happen before addition. With a = 4 and b = 6, average = a + b / 2 divides 6 by 2 first, then adds 4, producing 7.0. Parentheses in average = (a + b) / 2 make the sum happen first and give 5.0.

Tell errors apart

A syntax error breaks the grammar, such as a missing Python colon. A runtime error occurs during an executed operation, such as Python division by zero. A logic error allows execution but gives an unintended answer, as in the incorrect average.

Some valid expressions deliberately skip an operation. In Python, x != 0 and 10 / x > 2 uses short-circuit evaluation. When x is zero, the first condition is false, so the right side is not evaluated and no division occurs. Reversing these conditions would remove that protection. Python writes and, or, and not; C, Java, and JavaScript use &&, ||, and !.

Assignment and comparison are another important distinction. = stores a value; == tests equality. C permits if (x = 5): it assigns 5 and treats that nonzero value as true. Python rejects if x = 5: as invalid syntax. The same mistake can therefore be caught at a different stage in different languages.

A short program is easier to understand when you follow one executed statement at a time. Keep the current values visible instead of jumping from the first line to a guessed result.

Expressions and assignments

An expression produces a value: price * 3, x > 10, and len(name) are examples. A statement performs an action, such as assigning a value or controlling a block. In total = price * 3, the right-hand expression is evaluated before its result is assigned to total.

A variable is a name that refers to a value. Assignment gives the name its current value; it is not a mathematical claim that two sides have always been equal. If count holds 4, count = count + 1 first reads 4, adds 1, and binds count to 5.

Follow the next executed statement

Three structures organize control flow:

• Sequence runs statements in order.
• Selection uses a condition to choose a path, such as if and else.
• Iteration repeats a block with a for or while loop.

The structured program theorem, associated with Böhm and Jacopini in 1966, shows that these structures can express any algorithm. A for loop commonly visits the items of a collection. A while loop repeats while its condition remains true.

Consider this Python loop:

total = 0
for n in [3, 8, 5]:
    total = total + n

The indented assignment runs once for each item. A trace table records the state after each update:

Each new total uses the previous one. Resetting total inside the loop would produce a different calculation because earlier additions would be lost.

Enter and leave a function

A function groups a task under a name. A parameter is a name in the definition; an argument is a value supplied by a call:

def area(width, height):
    return width * height

result = area(3, 4)

The call binds width to 3 and height to 4. The multiplication produces 12, and return sends it to the caller. Execution continues at the assignment, so result receives 12. The names describe one task that can be reused with other arguments.

A name has a scope

Scope determines where a name can be used. Names created inside a function are ordinarily local to that call. A top-level name is global to its module. Separate calls have separate local bindings even when they use identical names.

count = 7

def reset():
    count = 0

reset()
print(count)

This prints 7. The assignment inside reset creates a local count; it does not replace the global binding. A function can instead return a result and let its caller assign that result.

Scope and lifetime answer different questions. A local name is not available to outside code just because the object it referred to still exists. Returned objects can remain alive, and a returned nested function can keep access to variables from its enclosing call; that retained environment is part of a closure.

A data type specifies possible values and the operations supported on them. An integer supports whole-number arithmetic; a Boolean represents true or false. Strings, lists, records, and objects combine or organize other values. Types also guide how values are represented in memory, although a value's size may depend on the value and implementation.

When are types checked?

In Python, count = 5 followed by count = "five" is valid. The name now refers to a string. Evaluating count + 1 then raises TypeError. Dynamic typing gives values definite types; it does not remove types.

Static typing does not require a visible type label on every variable. Type inference lets a compiler derive a type from surrounding code. Kotlin infers an integer for val n = 5, and Rust can infer an integer for let n = 5;. Python's optional type hints are different: separate tools such as mypy can check them, but ordinary Python execution does not enforce them.

When are values converted?

Checking time and conversion strictness are separate questions. Python rejects "3" + 4; explicit conversion in int("3") + 4 gives 7. JavaScript applies different automatic conversion rules for different operators:

• "3" + 4 gives the string "34".
• "3" * 4 gives the number 12.
• "3" - 4 gives the number -1.

Automatic conversion is called coercion. The labels "strong" and "weak" typing are informal ways to discuss conversion strictness, not a second name for static and dynamic typing. Python is dynamic and strict about the mixed addition above; C is static and still permits many implicit numeric conversions.

Python's input() returns a string. If a person types "30", the result still has type str. age + 1 fails, while int(age) + 1 gives 31 when age holds that text. What appears on screen is not enough to determine the type.

Numbers have representation limits

A signed 32-bit integer represents values from −2,147,483,648 through 2,147,483,647. Java's int wraps from the maximum to the minimum when 1 is added. C signed overflow is undefined behavior, so that same wraparound must not be assumed in C. Python integers grow as memory permits: 2 ** 100 is exactly 1,267,650,600,228,229,401,496,703,205,376.

Floating-point numbers represent most decimal fractions approximately in binary. In Python and JavaScript, 0.1 + 0.2 produces 0.30000000000000004. Comparing that result directly with 0.3 gives false.

When a calculation allows a small error, compare values using a tolerance chosen for the task, for example abs(a - b) < 1e-9. An absolute tolerance this small suits only some scales. For exact decimal accounting, use whole smallest units or a suitable decimal type. Changing the comparison cannot make an approximate representation exact.

Main memory stores a running program's data. Each byte has an address. Languages provide names so that programmers can work with values without writing raw addresses for every operation.

Calls use frames; objects have lifetimes

In C, an int commonly occupies 4 bytes, and &x obtains the address of x. Higher-level languages often hide addresses behind references. The important distinction is between a binding that names an object and the object itself.

The call stack tracks active function calls. Each call has a stack frame with information such as parameters, local bindings, and where execution should continue after return. If main calls area(3, 4), an area frame is added above the caller's frame. The function calculates 12, returns, and its frame is removed. For ordinary nested calls, the newest call returns first.

Recursion adds a call for each unfinished level. If calls keep accumulating, available stack space can run out. Python normally raises RecursionError after roughly 1,000 nested calls, with the limit depending on its settings. A stopping condition must be reached for a finite recursive calculation to finish.

The heap holds dynamically allocated objects, such as a list that grows or an object that outlives the function that created it. Allocation reserves storage. A returned list can remain on the heap after its creating call has ended.

Copying a reference shares an object

A reference identifies an object. A pointer in C or C++ explicitly represents an address used to access data. Copying a reference copies access to the object, not all the object's data.

a = [1, 2]
b = a
b.append(3)

After the first line there is one list. The second line binds another name to it. The last line mutates that list, so both a and b show [1, 2, 3]. This sharing is aliasing. Using b = a.copy() would create a separate outer list; for this list of integers, appending to the new list would leave a unchanged.

Contrast assignment with mutation:

x = 5
y = x
y = y + 1

The integer 5 is immutable. Addition produces 6, and only y is rebound. x still refers to 5. Python numbers, strings, and tuples are immutable; lists and dictionaries are mutable. A tuple's fixed contents can include a reference to a mutable list, so immutability of the outer container does not freeze every nested object.

Apply the same rules to arguments

When Python passes a list to a function, the parameter refers to the same object. Calling items.append(4) inside the function changes that list. Assigning items = [] binds only the local parameter name to a new list. The caller's name remains bound to the original object.

C passes argument values by value. To let a function update a caller's variable through its address, pass a pointer to it. In each language, ask two separate questions while tracing: "Which object does this name refer to?" and "Does this operation change that object or bind a name to something else?"

Allocated memory must eventually become reusable. The challenge is releasing data after its last use while keeping every object the program still needs. Languages assign this responsibility to the programmer, a runtime system, or compiler-checked ownership rules.

Manual management and its failures

In C, malloc(n) requests n bytes and returns a pointer to the block if successful. free(p) releases a block obtained by allocation. The programmer must use it at the right time and exactly once. C++ also supports manual management, although its standard tools can automate release through object lifetimes.

Several mistakes have different causes:

A pointer left referring to released storage is dangling. The storage might be reused for something else, so accessing it can corrupt data or crash the program.

For a C array int scores[10], valid positions are 0 through 9. Writing to scores[10] goes beyond the array, and C provides no automatic bounds check. Python raises IndexError when index 10 is used on a ten-item list, preventing that access from overwriting adjacent memory.

Trace reachability or count references

A tracing garbage collector starts from live roots, such as active references, follows links between objects, and can reclaim unreachable objects. Java, C#, Go, and JavaScript use tracing approaches. Collection requires runtime work and memory; depending on the collector, it can introduce pauses.

Reference counting tracks references to an object. For a fresh Python list, the simplified sequence is: a = [1, 2] supplies one reference; b = a supplies a second; del a removes one; b = None removes the other. CPython normally reclaims this ordinary list when its count reaches zero.

A group of objects can keep one another's counts above zero even when no live part of the program can reach the group. This is a reference cycle. CPython supplements reference counting with cycle collection. Reference counting and tracing are both automatic memory-management techniques.

Check ownership before execution

Rust gives each value an owner and checks rules for borrowing references. When ownership ends, generated cleanup code releases the value. Safe Rust rejects uses of references that could outlive their valid target, without requiring a tracing garbage collector. Swift uses automatic reference counting inserted by the compiler.

Memory safety matters beyond crashes. Microsoft reported in 2019 that roughly 70% of the vulnerabilities it assigned CVEs to each year involved memory safety; Chromium reported a similar share of serious bugs in 2020. In December 2023, CISA, NSA, FBI, and international partners urged software makers to plan transitions toward memory-safe languages.

Automatic reclamation still retains reachable objects. An ever-growing global list can keep every old record alive even after the application has finished using it. A collector cannot decide that these reachable records have become unnecessary to the task; the program must stop retaining them.

A programming paradigm is a way to organize code and think about computation. In imperative programming, a program gives commands that change its state: the values currently held by variables and objects.

Make the state changes visible

A running total is a simple imperative calculation:

total = 0
for n in [3, 8, 5]:
    total = total + n

The initial state is total = 0. Adding 3 changes it to 3. Adding 8 changes it to 11. Adding 5 changes it to 16. Each assignment uses the state left by the previous step, so order is part of the method.

This style matches the processor's step-by-step changes to registers and memory. It also fits algorithms that deliberately update a collection in place, such as a sorting routine that exchanges items.

Give tasks names

Procedural programming organizes imperative code into functions or procedures. A report program might call read_scores(), average(scores), and print_report(avg). The names let a reader see the overall task without following every internal line at once. Each procedure can be understood and tested separately.

C, Pascal, Fortran, and COBOL are classic procedural languages. Python also supports this style: a script can use named functions without defining any classes.

Structured programming organizes control flow with sequence, selection, loops, and procedure calls. It avoids arbitrary jumps that make the next executed statement hard to predict. Edsger Dijkstra's 1968 letter "Go To Statement Considered Harmful" helped popularize this approach. Controlled exits such as break, continue, and return remain useful: they leave a defined loop iteration, loop, or function.

Effects can extend beyond a return value

A side effect changes something outside a function's returned result. Printing, saving a file, sending a network message, and changing shared data are side effects. Programs need such actions to interact with the world.

Problems arise when unrelated code silently changes the same state. Suppose apply_discount() reduces a global price by 10%, and add_shipping() adds 5. Starting from 100, discounting first gives 90, then shipping gives 95. Shipping first gives 105, then discounting gives 94.5. Both procedures perform their own steps correctly, but the combined result depends on their order.

Passing values and returning new results can make that order visible:

price = add_shipping(apply_discount(100))

The inner call runs first: discount, then shipping. A different nesting expresses a different rule. Clear data flow helps reveal whether shipping should itself receive the discount.

Imperative code is still common inside modern object methods and event handlers. Choosing a broader object-oriented or functional design does not prevent a small part from using direct commands where those steps make the algorithm clear.

Object-oriented programming (OOP) models a program as cooperating objects. Each object combines data with operations on that data. An account can hold its owner and balance while offering deposit and withdrawal operations.

Separate the blueprint from its instances

A class defines the attributes and methods its objects provide. An object, or instance, is one particular member of that class. BankAccount is the blueprint; Ana's account with 150 and Ben's account with 40 are distinct instances. Their balances can change independently.

An attribute stores data associated with an object. A method is an operation called through an object, such as acct.deposit(50). self in a Python instance method refers to the object receiving the call.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

Calling BankAccount("Ana", 100) constructs a new instance. Its __init__ method initializes the instance's data. A constructor is the setup process for a new object; Python separates creation from this initialization step. Calling acct.deposit(50) on that account changes its balance from 100 to 150.

Put the rule at the update point

Encapsulation brings data and the operations that maintain its rules together. Suppose an account must never have a negative balance. The withdrawal method checks the proposed change before making it:

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

This method belongs inside BankAccount. From a balance of 150, withdraw(200) raises an error and leaves 150. withdraw(30) succeeds and leaves 120. The failed call does not first subtract and then discover the problem; checking happens before the update.

Other code should use those methods instead of assigning an unchecked balance. Java and C# can restrict direct access with private. Python's leading underscore in _balance signals an internal detail by convention; it does not enforce privacy.

Information hiding goes further: callers depend on the operations a class offers without needing to know its internal representation. The balance could later be stored differently while the public deposit and withdrawal operations retain their meaning.

Let the problem suggest responsibilities

A library system has books, members, and loans. Those nouns suggest possible classes or attributes; actions such as borrowing and renewing suggest methods. Choose one clear responsibility for each class. An account class that also sends every email and formats every report becomes harder to change because unrelated work is mixed together.

Classes and objects appeared in Simula 67 in 1967; Smalltalk helped spread the approach in the 1970s. Java, C#, C++, and Python support OOP, but using one of those languages does not force every program into classes. The useful design question is which data and rules belong together.

Objects often need to share operations while differing in details. Inheritance, polymorphism, and composition solve different parts of that design problem.

Specialize an existing kind of object

Inheritance defines a subclass from a superclass. In Python, class SavingsAccount(BankAccount): gives the specialized class access to inherited account behavior. It can add add_interest(rate): a balance of 1000 with a 2% interest addition becomes 1020.

The intended relationship is is-a. A savings account is still a bank account and must honor the rules expected of bank accounts. Reusing a few lines is not enough reason to claim that one kind of object is another.

A subclass can override a method with its own implementation. Suppose a checking account charges a fee of 1 for each successful withdrawal. With a balance of 100, withdrawing 30 costs 31 and leaves 69. To preserve the account rule, the method must check the withdrawal plus the fee before changing the balance. If that combined cost exceeds the balance, it refuses the whole operation.

Make one call work with different objects

Polymorphism lets the same operation work across different object types. A circle and rectangle can both provide area():

for shape in shapes:
    print(shape.area())

The loop does not need an if for every shape class. Each object supplies its own implementation. Selecting that implementation during execution is dynamic dispatch.

For Circle(2), the area is about 12.57 square units. For Rectangle(3, 4), it is 12 square units. Their combined area is about 24.57 square units. A later Triangle can join the collection by providing a compatible area() operation; the loop itself does not need another branch.

An interface states the operations a type must offer. Java's interface Shape { double area(); } requires implementing classes to supply the area method. An abstract class can provide some shared implementation while leaving other methods for subclasses. Python often uses duck typing: an object can work in the loop if it provides the required operation, even without a shared superclass.

Hold a part instead of becoming it

Composition stores other objects as parts. A car has an engine and wheels. It can call its engine's start() method without inheriting from Engine.

Deep inheritance chains can spread the effects of a superclass change through many classes. A subclass that must disable inherited behavior can signal a poor is-a relationship. Composition often keeps such dependencies smaller and clearer.

The four commonly named OOP pillars fit together here: encapsulation protects data through operations, abstraction hides implementation details, inheritance specializes a type, and polymorphism lets a caller use a shared operation across implementations.

Functional programming builds results by combining functions. Its central habit is to produce new values from inputs while limiting shared mutation. Lisp introduced widely used functional ideas around 1958; Haskell, Erlang, Clojure, F#, and OCaml develop those ideas in different ways.

Know what makes a function pure

A pure function gives the same result for the same arguments and has no side effects. def with_tax(price): return price * 1.2 illustrates the idea: with_tax(50) gives 60.0. A function that also appends to a global list or prints a message has an effect beyond its returned value. A result that depends on the current time also depends on more than the arguments.

A pure call can be replaced by its returned value without changing program behavior. This property is referential transparency. It makes isolated tests straightforward and permits independent calls to run in parallel without competing to update shared state.

Immutability keeps an existing value unchanged. [n + 1 for n in nums] creates a new list, leaving nums intact. A program can still represent changing information by producing new versions; it does not have to overwrite the old version.

Pass behavior as data

Functions are first-class when they can be assigned to names, passed as arguments, and returned as values. A higher-order function takes a function or returns one. A lambda is an unnamed function expression, such as lambda n: n * n.

Three common higher-order operations form a pipeline:

• filter keeps items that satisfy a test.
• map transforms each remaining item.
• reduce combines items into one result using an accumulator.

To total the squares of even numbers from 1 through 6, filtering leaves 2, 4, and 6; squaring gives 4, 16, and 36; summing gives 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Here % 2 == 0 tests evenness, and range(1, 7) supplies 1 through 6. Haskell expresses the same calculation as sum (map (^2) (filter even [1..6])).

With reduce imported from Python's functools, reduce(lambda acc, n: acc + n, [3, 8, 5], 0) combines 0 with 3 to get 3, then with 8 to get 11, then with 5 to get 16. The pipeline describes transformations without a surrounding loop updating a shared total.

Preserve an environment or call a smaller problem

def multiplier(k): return lambda x: k * x returns a function that retains access to k. Thus multiplier(3)(10) returns 30 even after the outer call has finished. The returned function and retained environment form a closure.

Recursion has a function call itself on a smaller problem. Factorial returns 1 at n == 0; otherwise it returns n * factorial(n - 1). For 5, the products give 120. A finite calculation needs a reachable base case. Python's unresolved nested calls eventually raise RecursionError; languages with proper tail calls can reuse stack space for calls in final position.

Using functions alone does not make code functional: procedural functions can mutate state. Real functional programs still read input and write output, commonly keeping effects near the program's edges and the central calculations pure.

Declarative programming describes the result wanted while leaving execution steps to a language engine. Functional code is commonly grouped under this broad idea, alongside query languages and logic programming.

Read a query as a request

A relational database stores data in tables. Suppose students has the name and grade rows Ana 92, Ben 75, Chen 80, and Dara 64:

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM names the table, WHERE gives the condition, SELECT chooses the returned field, and ORDER BY requests alphabetical order. Ana and Chen satisfy the condition, including Chen's grade of exactly 80. The result is their names in that order.

An imperative program would create a result list, visit rows, test each grade, append qualifying names, and sort the list. SQL gives the database the required outcome without writing that loop.

A query optimizer chooses an execution plan. It might scan the table or use an available index, a lookup structure that can speed suitable searches. Many indexes use sorted structures; others use different arrangements. Adding an index can change the plan without changing the query. More data still means work: declaring the result does not guarantee that every query is cheap.

Ask what follows from facts and rules

Logic programming describes facts and relationships, then searches for values satisfying a question. In Prolog:

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

The rule means X is a grandparent of Z when there is a Y for which both parent relationships hold. The query ?- grandparent(tom, Who). finds Who = ann: Tom is Bob's parent and Bob is Ann's parent. Capitalized names stand for variables; the lowercase names identify particular people.

Recognize declarative tools around you

A spreadsheet formula =SUM(B2:B5) states a dependency. The spreadsheet recalculates it when relevant cells change. The regular expression [0-9]{3}-[0-9]{4} describes three digits, a hyphen, and four digits, as in "555-0199". A text-matching engine performs the search.

CSS states appearance with a rule such as h1 { color: navy; }; HTML marks page structure. They are declarative notations, commonly classified as styling and markup languages. Their role differs from a general-purpose language that can express a wide range of computations.

Declarative code can stay close to a problem statement and let an engine improve its method. It also gives the programmer less direct control over individual steps, which can make a slow plan harder to diagnose. Concrete instructions still run underneath: declarative describes the programmer's expression of the task, not a processor that works without steps.

A paradigm changes how a solution is expressed, not which numerical answer a correct solution should produce. Consider orders with amounts [120, 45, 300, 80]: find the total of amounts strictly greater than 100.

Follow state changes

The imperative version exposes the loop and accumulator:

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

The first amount changes total to 120. The second leaves it unchanged. The third changes it to 420, and the fourth leaves it there. The program makes the test and update order visible.

Transform a collection

A compact functional-style Python expression is sum(a for a in amounts if a > 100). It selects 120 and 300 and combines them into 420. Another version is sum(filter(lambda a: a > 100, amounts)). Here the predicate describes membership and sum combines the selected values.

A generator expression or filter call uses Python's multi-paradigm features; its presence does not make every surrounding part of the application pure.

Put rules with objects

In an object-oriented design, an Order stores an amount and offers is_large(), which returns self.amount > 100. An OrderBook holds order objects and offers large_total(). That method can loop through orders, ask each whether it qualifies, and add qualifying amounts.

The total remains 420. The difference is where responsibilities live: the rule for a large order belongs to Order, and collection-level work belongs to OrderBook. Other features can reuse the rule without copying its threshold test.

Ask the database

If the data is already in a relational database, SQL can request the total:

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

The database chooses the retrieval and aggregation plan. The query does not instruct a caller to visit every row or keep a local accumulator.

Combine styles where they help

Python supports procedural, object-oriented, and functional techniques. JavaScript provides objects, first-class functions, and closures. C++, C#, Kotlin, Scala, Swift, and Rust also mix styles. Java is strongly associated with OOP but has supported lambdas since Java 8 in 2014; Haskell is purely functional.

A web application can use classes for users and orders, functional transformations for report data, imperative updates inside methods, and SQL for database queries. These choices work at different layers.

Event-driven programming adds another organizing idea: register a handler that runs when an event arrives. In JavaScript, button.addEventListener("click", showMenu) passes showMenu as a function value. A later click invokes it. The handler can itself use objects, pure transformations, or imperative steps. Its event-driven role says when it runs, not the only style its body may use.

No programming language is the best fit for every project. General-purpose languages are commonly Turing complete: with unbounded time and memory, they can express the same class of computations. Real choices depend on whether a solution fits the actual platform, resources, tools, and people.

Start with what must work

The platform is often a hard constraint. Browsers run JavaScript and can run compiled modules through WebAssembly. TypeScript adds static checking and compiles to JavaScript. Swift is a standard choice for Apple-platform apps; Kotlin is recommended for Android. SQL is the usual language for relational queries.

Next consider the domain and ecosystem. Python has widely used data and machine-learning libraries such as NumPy and pandas. R focuses on statistics. C and C++ are common in operating systems, game engines, and embedded code. Java and C# are common in large business systems; Bash is useful for automating operating-system tasks.

These are practical associations, not exclusive territories. A suitable library can save far more development work than a small difference in language syntax.

Examine resource and safety needs

A microcontroller with only a few kilobytes of RAM may need fine control over memory and runtime overhead. C, C++, or Rust can be suitable where the target supports them. Demanding game or database components often favor those languages too, but engines and resource budgets differ: Unity uses C#, and some databases use Java or Go.

Before choosing for speed, find the bottleneck: the part limiting performance. A program waiting mainly for a network response will not become dramatically faster just because a small local loop is compiled more efficiently. Measure representative work on the target platform.

Memory safety reduces errors such as invalid memory access. Safe Rust checks ownership rules at compile time; managed languages such as Java, C#, Go, and Python provide runtime memory management. Static typing catches many incompatible operations before execution, which can help in a large codebase. Neither memory safety nor static typing proves that the program's logic is correct.

Include the cost of maintaining the result

Team knowledge, available developers, debuggers, test tools, libraries, licenses, and existing code all affect a decision. A familiar, supported language can reduce delivery and maintenance costs. Rewriting a working system creates migration work and risks even if the new language has attractive features.

For a city weather network, different components have different needs:

A useful justification links each choice to a requirement: "The team already maintains the Java service and its libraries support the new feature." A popularity rank alone cannot supply that reasoning. Surveys can indicate a large community or hiring pool; they do not establish the best language for a particular workload.