Technology Dictionary 18 terms

An Application Programming Interface (API) is a set of defined rules and protocols that allows different software applications to communicate with each other. APIs specify the methods and data formats that programs can use to request and exchange information. They serve as an abstraction layer, enabling developers to use complex functionality without needing to understand the underlying implementation details.

A Software Development Kit (SDK) is a collection of software tools, libraries, documentation, code samples, and APIs bundled together to help developers build applications for a specific platform or service. SDKs typically include a compiler, debugger, and framework, reducing the effort required to integrate with the target platform. Popular examples include the Android SDK, iOS SDK, and AWS SDK.

A runtime (or runtime environment) is the software infrastructure that supports the execution of programs written in a particular language. It provides essential services such as memory management, type checking, garbage collection, and access to system resources while a program is running. The Java Runtime Environment (JRE) and the Node.js runtime are widely used examples that abstract away operating system differences.

A Dynamic Link Library (DLL) is a file format used in Windows operating systems that contains code and data which can be shared by multiple programs simultaneously. Unlike static libraries, DLLs are loaded into memory at runtime rather than being compiled directly into the executable, which reduces memory usage and disk space. DLL files use the .dll extension and are conceptually similar to shared objects (.so) on Unix-based systems.

A framework is a pre-built, reusable software structure that provides a foundation and set of conventions for developing applications. Unlike a library, which the developer calls on demand, a framework enforces an architectural pattern through inversion of control, calling the developer's code at specific points. Common examples include React and Angular for front-end development, Django and Spring for back-end web applications.

A compiler is a program that translates source code written in a high-level programming language into lower-level code, typically machine code or bytecode, that a computer's processor can execute. The compilation process involves multiple stages including lexical analysis, parsing, semantic analysis, optimization, and code generation. GCC, Clang, and the Rust compiler (rustc) are prominent examples of modern compilers.

A debugger is a software tool used to test and find errors (bugs) in other programs by allowing a developer to execute code step by step, inspect variable values, and set breakpoints. Debuggers operate by either interpreting the code directly or by attaching to a running process to monitor its execution state. GDB, LLDB, and the Chrome DevTools debugger are widely used across different development environments.

An Integrated Development Environment (IDE) is a software application that consolidates the core tools a developer needs into a single interface: a source code editor, build automation tools, and a debugger. Many IDEs also include features such as intelligent code completion, syntax highlighting, version control integration, and refactoring support. Visual Studio Code, IntelliJ IDEA, and Xcode are among the most popular IDEs in use today.

A Command Line Interface (CLI) is a text-based interface through which users interact with software or an operating system by typing commands as text input. CLIs provide direct, scriptable control over system operations and are favored by developers and system administrators for their speed, precision, and ability to be automated through shell scripting. Bash, PowerShell, and Zsh are common shells that provide CLI environments.

A Graphical User Interface (GUI) is a visual interface that allows users to interact with a computer through graphical elements such as windows, icons, buttons, and menus rather than text commands. GUIs rely on a pointing device (mouse, trackpad, or touchscreen) to manipulate on-screen elements and were popularized by the Apple Macintosh and later by Microsoft Windows. Modern GUIs are built using frameworks like Qt, GTK, WinUI, and SwiftUI.

The Domain Name System (DNS) is a hierarchical, decentralized naming system that translates human-readable domain names (such as example.com) into numerical IP addresses that computers use to locate each other on a network. DNS operates through a chain of authoritative nameservers and recursive resolvers, caching results at multiple levels to improve speed. It is often called the "phonebook of the internet" and is essential to virtually all internet communication.

Hypertext Transfer Protocol (HTTP) is an application-layer protocol that serves as the foundation of data communication on the World Wide Web. It follows a request-response model in which a client (typically a web browser) sends a request to a server, which then returns a response containing the requested resource. HTTP/2 introduced multiplexing and header compression, while HTTP/3 moves to the QUIC transport protocol for reduced latency.

Secure Sockets Layer (SSL) and its successor Transport Layer Security (TLS) are cryptographic protocols designed to provide secure communication over a computer network. They establish an encrypted link between a server and a client by using asymmetric cryptography for key exchange and symmetric encryption for data transfer. Although SSL is technically deprecated, the term is still commonly used to refer to TLS-secured connections, indicated by the padlock icon and HTTPS in a browser's address bar.

JavaScript Object Notation (JSON) is a lightweight, text-based data interchange format that is easy for humans to read and write, and easy for machines to parse and generate. Despite its name, JSON is language-independent and is supported by virtually every modern programming language through built-in or standard library parsers. Its structure is based on two universal data types: key-value pairs (objects) and ordered lists (arrays), making it the dominant format for web API responses and configuration files.

Representational State Transfer (REST) is an architectural style for designing networked applications, defined by a set of constraints including stateless communication, uniform interfaces, and the use of standard HTTP methods (GET, POST, PUT, DELETE). RESTful APIs expose resources as URLs and use HTTP status codes to indicate the outcome of operations. Its simplicity and compatibility with HTTP have made REST the most widely adopted approach for building web services and public APIs.

Docker is an open-source platform that automates the deployment, scaling, and management of applications inside lightweight, portable containers. Containers package an application together with all its dependencies, libraries, and configuration files, ensuring it runs identically across any environment. Docker uses OS-level virtualization through Linux namespaces and cgroups, which makes containers far more efficient than traditional virtual machines in terms of resource overhead and startup time.

Git is a distributed version control system designed to track changes in source code during software development, allowing multiple developers to collaborate on the same codebase. Created by Linus Torvalds in 2005 for Linux kernel development, Git stores the full history of a project as a directed acyclic graph of snapshots rather than file diffs. Its branching and merging model is exceptionally lightweight, making feature branches, pull requests, and code reviews a standard part of modern development workflows.

Kubernetes (often abbreviated as K8s) is an open-source container orchestration platform originally developed by Google and now maintained by the Cloud Native Computing Foundation. It automates the deployment, scaling, load balancing, and management of containerized applications across clusters of machines. Kubernetes organizes containers into logical units called pods and uses declarative configuration to maintain desired state, self-healing failed containers and distributing workloads to maximize resource utilization.