Welcome to Software

    Glossary

    Concise definitions of common terms

    Access Modifiers^

    Access modifiers are a feature of programming languages that help promote encapsulation of components in an application. Each language implements this feature in its own way, but there’s typically 3 approaches to access modifiers:

    1. Prefixing functions and classes with public and private (like Java or PHP).
    2. Exporting variables by either prefixing export before the variable (like JavaScript) name declaration or capitalizing it (like Golang).
    3. Don’t support them, like Python where any object’s fields are accessible from any part of the application (it’s the Wild West like that).

    API (Application Programming Interface)^

    An API is the collection of points of connection of a black box of software. Full post answering this is titled What is an API?

    Black Box of Software^

    A black box of software is any piece of software and its boundaries. Boundaries may be physical (like a computer case) or logical (like an access control software component). Black box, because an outside user (or software component) is not meant to know about another box’s internal details. An example in the physical world would be a lock — something you use every day. Yet, you probably don’t understand the internal details of any lock you use.

    Client-Server model^

    The client-server model is a very common design pattern over a network where one or more machines (clients) request services from a machine (server) which provide services. The server may or may not be a set of distributed machines.

    Coupling (Tight vs Loose, Coupled vs Decoupled)^

    Coupling describes how deeply intertwined software components are to each other. It applies to software components of any scale — from functions in an application to physically distinct machines that depend on each other. Decoupled (aka loosely coupled) software components are more modular and extendable.

    Dependency^

    Nothing in software is built 100% from scratch. Everything is built on top of something that came before it. Software component A is a dependency of software component B if software component A is required to be available and accessible for software component B to function.

    Design Pattern^

    A design pattern is a way of organizing software components together. Design patterns usually attempt to solve common problems by promoting modularity, reusability, and extendability.

    Encapsulation^

    Encapsulation is boxing up (code & data) using logical barriers. These logical barriers come in many forms, but they are feature that come from either:

    • the language of the application
    • a tool introduced into the application or the application’s environment
    • the operating system running the application
    • physical separation of machines and network cables

    Encapsulation makes code easy to read, modular, maintainable, testable, secure, etc… Here’s just a few examples of encapsulation:

    • Separating code into a function
    • Separating functions into a class
    • Separating classes into a library

    Endpoint^

    An endpoint is an application’s point of connection over a network. It often refers to a URL which maps to a function in the application, but not always (as with GraphQL or gRPC). An endpoint does always map to a function for handling the request.

    Kernel^

    Operating Systems are typically split into two parts:

    1. User Space: this is where all our apps run.
    2. Kernel: where essential system components live.

    Below is a simplified view of an Operating System showing its role between user applications and hardware:

    Simple Operating System Diagram with Kernel

    Levels of Scope^

    Level of Scope refers to the vertical position of a smaller concept within a bigger concept. It’s like zooming in and out of something. For example: International -> National -> Regional -> Municipal.

    Library^

    A library is a set of generic and related functionalities which are packaged together and intended to be used by many applications. Applications use the functionalities defined in libraries by importing references to the library’s public functions. When code executed by the application reaches a reference to the library, execution continues in the library. Execution exits the library once the library’s public function returns an output (if it returns an output). More on libraries in the post titled What is an API?.

    Loopback Connections^

    A loopback connection occurs when a machine’s network requests are made to itself. An operating system’s network stack handles network requests exactly the same whether a request is being sent to another machine over a network or to itself. Each packet is packaged with network headers (i.e. TCP headers) as needed, in preparation for a network request. However, once the address is revealed to be itself, the packet goes back through the network stack in the opposite direction as if it were coming from another machine.

    Map (as a verb)^

    Used to describe how a set of entities relates to another set of entities. Point to could be an appropriate synonym for map to. It can also be used to describe just one entity’s relation to another.

    Example: The shopping cart endpoints map to these functions in shopping_cart.py

    Markup^

    Markup is usually another word for HTML — the language that defines the structure of a web page on the internet. Dynamic content (such as a web page that welcomes you by your name) used to be exclusively stitched together on servers. However recently, with the increase in performance of mobile devices and push to save resources in the cloud, this stitching is being performed on client devices.

    Namespace (Namespacing)^

    Namespacing can mean something as simple as adding a prefix to several files to create groups of files distinguishable by their prefix:

    cat-max.jpg
    cat-ruby.jpg
    cat-charlie.jpg
    dog-navi.jpg
    dog-lester.jpg
    hamster-mary.jpg

    In software, namespacing is a form of encapsulation. It involves creating a logical barrier to prevent a problem where the same variable name in two different parts of an appication clash.

    If you wanted to invoke a function declared in a namespace from somewhere else in the application, you would have to import it (something that was mentioned in the post titled: What is an API?.

    Network Sockets^

    Network sockets are like a switchboard where applications can listen on a port. Listening just means asking (directly or indirectly — through intermediate applications) the Kernel if you can listen on a port. If no other application is listening on that port number (ranging from 0 to 65535), the Kernel will likely say yes. Other applications can then send data to this port number, and the listening application will receive it.

    Open-Source^

    Open-source software is any software whose source code is publicly accessible. Anyone can generally use the software for free. Anyone typically can also contribute to the project with updates. Different open-source projects have different requirements for accepting contributions. Different types of open-source licenses exist, which may for example, prevent the open-source software from being modified or used in commercial projects.

    Package Manager^

    Package managers are applications that manage third-party software. Most software languages have package managers to help developers manage an application’s third-party dependencies. Those dependencies may or may not be open-source libraries.

    Process^

    A process is an instance of a running application. Complex applications can have multiple processes. Web browsers like Google Chrome often start a new process for each tab.

    Public Function^

    A public function is a function where an access modifier has been applied to allow access to this function from ‘anywhere’. Different languages have different access modifiers. One exception is Python, which does not have any. In Python, everything can be imported and accessed from anywhere. Golang does not have the ‘public’ access modifier — Golang’s equivalent is ‘exported’.

    Static Resources^

    Static resources are data or code that is not processed before being served (sent) by a server. Examples are image, JavaScript, and CSS files. Static resources don’t change from request to request — regardless of who’s making the requests. The opposite would be a page or other piece of content that requires data to be stitched together within markup at the server before being sent to a client. If that stitching happens after the markup is sent to the client, then it’s happening in client-side JavaScript. It’s still dynamic information being stitched into code, but because it’s happening after the code was sent from the server, the JavaScript is considered a static resource. From the perspective of the server, the content does not change during its handling of that data.

    The Cloud^

    The cloud refers to either:

    1. the collection of all servers behind the internet
    2. the collection of data-centers powered by platforms such as Amazon Web Services, Google Cloud Platform, and Azure, which sell complex hosting services as units of resources. This new “cloud paradigm” allows multiple services and web products to safely and reliably share the same hardware.

    Transfer Protocol^

    Many layers of technologies (hardware and software) are involved in transferring data over the internet. Each layer has different responsibilities and uses many different protocols depending on logistical circumstances, type of data being transferred, and the use case for that data (example: streaming vs downloading).

    A protocol is an established convention for how to do something. A transfer protocol in the context of software is usually either or both of:

    • how data is packaged at a particular layer with metadata (data about the data).
    • a series of steps to ensure secure and reliable transfer of data between two points.

    Various models exist for defining the layers of technologies involved in transferring data over the internet. The most prominent is the OSI model. Wikipedia has a nice intro to this topic. A “full list” of transfer protocols doesn’t exist because of its broad definition.


    Authors

    Twitter

    Sam Malayek works in London for Thought Machine, and uses this space to fill in a few gaps.