Libraries, Linkers & Loaders (OCR A-Level Computer Science): Revision Notes

Libraries, Linkers & Loaders

Overview

In software development, code libraries, linkers, and loaders are essential tools that help manage, integrate, and execute code efficiently. Libraries are pre-written collections of code that developers can reuse, saving time and effort. Linkers and loaders are tools involved in preparing programmes for execution by connecting library code with the main programme. Understanding these tools and their roles during compilation helps developers produce robust and efficient software applications.

Libraries

• Definition: A library is a collection of precompiled code that can be used to perform common tasks without the need to write code from scratch. Libraries contain useful functions, classes, and procedures for various tasks, like mathematical operations, file handling, and graphics.
• Types of Libraries:
  • Static Libraries: These are directly included in the executable file during compilation, resulting in a larger executable file. Common in languages like C/C++.
  • Dynamic Libraries (or Shared Libraries): These are separate files linked to the programme at runtime, allowing multiple programmes to share the same library file, reducing memory usage.
• Benefits of Using Libraries:
  • Efficiency: Allows reuse of pre-written code, speeding up development.
  • Reliability: Library code is often tested and optimised, reducing bugs.
  • Modularity: Separates common functions from the main code, making it easier to manage and update.
• Drawbacks of Using Libraries:
  • Dependency Management: Programmes relying on dynamic libraries may fail if the required library is missing or incompatible.
  • Size and Complexity: Including too many libraries can increase programme size and complexity, especially if not all library functions are used.

Linkers

• Definition: A linker is a tool that combines different pieces of code and data from various files, including libraries, into a single executable programme.
• Types of Linking:
  • Static Linking: The linker includes all the library functions required by the programme directly in the executable file at compile time.
  • Dynamic Linking: The linker includes only references to the required libraries in the executable file, with the actual linking happening when the programme is run.
• Linking Process:
  • During compilation, the linker looks for all symbols (e.g., functions or variables) referenced in the code and ensures they are defined somewhere, either in the main programme or in an imported library.
  • If a required symbol isn't found, the linker generates an error, preventing the programme from compiling successfully.
• Output: After linking, the programme is either fully compiled into a standalone executable (for static linking) or references external libraries needed at runtime (for dynamic linking).

Loaders

• Definition: A loader is a part of the operating system responsible for loading an executable programme into memory and starting its execution.
• Loading Process:
  • The loader copies the executable programme into memory.
  • For programmes with dynamically linked libraries, the loader finds the necessary libraries and links them to the programme at this stage.
  • Once the code and libraries are loaded, the loader transfers control to the programme's starting point, initiating execution.
• Dynamic Loading: Some programmes load libraries only when specific functions are needed, which can save memory. This is common in larger applications or those with many optional features.

Libraries, Linkers, and Loaders in Compilation

• Using Libraries in Programmes:
  • Libraries can be included in code by importing them (e.g., #include <math.h> in C or import math in Python). These declarations signal to the compiler which libraries the programme will use.
• Role of Linkers: During the final steps of compilation, the linker resolves all the library functions and variables used in the code, either embedding them directly in the executable (static linking) or ensuring they're available through external files (dynamic linking).
• Role of Loaders: When the programme is executed, the loader ensures all required libraries are in memory and accessible. For dynamically linked programmes, this is where the final linking happens to create a seamless executable environment.

Example

#include <math.h>
int main() {
    double result = sqrt(25.0);
    return 0;
}

Note Summary