Illustrated guide to terms used daily in programming

Here is a glossary of many terms used every day by tech people and programmers; this is a light and general glossary of many terms. Definitions are kept as simple and short as possible.

This may be used as a first overview of the programming world. This glossary is also a good fit if you ever wanted to be able to understand and communicate with developers or any other people working on digital projects.

Back End

The back-end, or the “server-side”, is basically everything that is behind the scene. Systems have all kinds of logic that happen in the background that make them work: data needs to be stored and retrieved, business logic needs to be followed, results need to be calculated… For a website or web application, this refers to everything the user can’t see in the browser, like databases and servers.

Command Line Interface (CLI)

A Command Line Interface is used to process commands to a computer program in the form of lines of text. They are opposed to GUI (Graphic User Interface). We use it all the when using the Terminal (e.g. Unix console), for instance using Git:

$ git clone https://github.com/Hurna/Hurna-Core.git

Code Review

Code review is a phase in the software development process in which the authors of code and peers review the code to make sure that the overall code is healthy, does not contain bug, and is improving over time.

Code reviews are classless: being the most senior person on the team does not imply that our code does not need review.

Continuous Delivery — Continuous Integration(CI/CD)

For big apps, pushing to production requires a lot of steps. Continuous integration and continuous delivery (CI/CD) is the activity of automated build, integration, and testing processes. It allows to release continuously new updates. Managing this process is often the work of people called DevOps.

Front End

For an application, the Front End is the part that is exposed to the user. The front end of a website is the part that users interact with. Everything that you see when you’re navigating around the Internet, from fonts and colors to dropdown menus and sliders, is a combo of HTML, CSS, and JavaScript being controlled by your computer’s browser.

Middleware

A Middleware is a software that bridges gaps between other applications, tools, and databases in order to provide unified services to users. It is commonly characterized as the glue that connects different software platforms and devices together.

In web development, it often lies between the part of the code that receives the request and the other part of the code that do database updates, generates the response, etc.

Refactoring

Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior.

The basic purpose of code refactoring is to make the code more efficient and maintainable. This is key in reducing technical cost since it’s much better to clean up the code now than pay for costly errors later.

Unit Testing (UT)

Unit testing is an essential part of developing software applications. Also called component testing, it is all about isolating one unit of code to verify that it’s working as it should be.

Unlike many types of testing, UTs are usually done by the developer of the code itself. If you’re not doing unit testing now, I recommend you to get started on it.

Another way to look at unit testing is that we write the tests first. This is known as Test-Driven Development (TDD for short). TDD brings additional advantages:
- We don’t write speculative “I might need this in the future” code — just enough to make the tests pass to cover our API.
- By writing the test first, we are forced into thinking about how you want to call the code, which usually improves the design of the code in the long run.

Algorithm

Everything that we do with a computer relies in some way on an algorithm. Any software (even the most advanced Artificial Intelligence) are only algorithms put together with some structured data (cf. below).
That’s it: Algorithms + Data Structures = Software.

In other words, it is a list of instructions, procedures, or formula that solves a problem… It can be a code to sort search results efficiently, a code to find the shortest route between A and B on a map, a formulal to encrypt and decrypt sensitive information, etc.

Data Structure

Data structures are the way we can store and retrieve data, they represent the knowledge to be organized in memory. No matter what problem are we solving, in one way or another we have to deal with them !

Dead Code

Dead code is any section of the codebase that is never used by the application.

Infinite loop — Endless loop

An infinite loop is a sequence of instructions that will continue endlessly, unless an external intervention occurs. It may be intentional, but most of the time, our breaking condition doesn’t work. The result of such infinite loop often results in a application that freezes (and consume most of our CPU which may then lead to general lags) or even crash.

Functional Programming

Functional programming or FP is a programming paradigm. This is a style of building software applications. Some of its principles are the way of building a program by composing pure functions, avoiding shared state, mutable data, and side-effects.

Garbage collection

When a program is running, it uses the computer’s memory. Garbage collection does exactly what it says, it looks for memory that can’t be used by the program anymore and frees it, allowing this freed space to be used again.

Memoization

Memoization is a technique used to store, the result of a computationally expensive function by storing it in a cache. If the function is called later using the same arguments, the result is loaded from the cache rather than being recomputed, saving CPU resources.

In brief: Memoization is a way to remember what we already found.
It is used to lower a function’s time cost in exchange for space cost.

Where naive recursion falls short with Fibonacci: the tree above shows for each indice (root) the nodes to be computed (all of its children). The red nodes are showing useless computation which may instead use the results already computed by the blue ones.

As a reminder the Fibonacci numbers are defined as follow:
F(0) = 0
F(1) = 1
F(n) = F(n−1) + F(n−2)

Parse

The action of transforming data described textually into data stored within a data structure. When we fetch data from a web API, it is usually a JSON (just a string). We need to parse it, to transform it into an object, to manipulate data efficiently:

// JSON data (stored as a string)
  {
    "name": "Maze Solver - Pathfinding",
    "list": {
      "a_star": "A* (A-Star)",
      "bfs": "Breadth First Search",
      "dfs": "Depth First Search",
      "dijkstra": "Dijkstra"
    }
  }
// JS manipulate data through an Object built from the string parse.
  const parsedData = JSON.parse(data);
  // parsedData is now an object and can be accessed as follows:
  parsedData.name;              // "Maze Solver - Pathfinding"
  parseData.list.forEach(...);  // Iterate over the list

Spaghetti code

Spaghetti code is a slang used to describe a program’s source code that is difficult to read or follow by a human because of how the original programmer wrote the code. It can be caused by several factors, such as volatile project requirements, lack of programming style rules, and insufficient ability or experience of the programmer.

Class (Prototype) — Object (Instance)

A class (prototype) is a template that defines object properties and may also describe object behavior.
An object is an instance of a class.

We can think of class as a sketch (prototype) of a car. It contains all the details about the number of tires, the doors, the color… Based on these descriptions we build a car, let’s say the Green car: this Green car is the object. As many cars can be made from the same prototype, we can create as many objects as we want from a class.

Find more details in the ‘Function — Class’ glossary.

Constant

A constant is a value or a variable with a value that will never change during the running time of the program. The keyword ‘const’ is used to define such data in most programming language:

const auto lastName = "CantBeChanged";

Data Structure

Data structures are the way we can store and retrieve data, they represent the knowledge to be organized in memory. No matter what problem are we solving, in one way or another we have to deal with them !

A data structure instance is an Object.

Null — Nullptr

Null and NullPtr represent an intentional absence of a value.

let uninstantiated = null; // JS
Car* lostPtr = nullptr; // C++

Pointer

A pointer is a variable that holds a memory address where a value lives. As an analogy, a page number in a book’s index could be considered a pointer to the corresponding page.

Pointers are the foundation of how computers allocate and deal with memory in hardware. They allow us to read and write directly in memory space.

String

A string is a sequence of characters used to represent text.

const string = "hello world";

A string can be manipulated as an Array containing chars (cf. below).

Primitives

The primitive data type is the basic building block of data. They hold one single value. They represent a char, number, or boolean.

Note: the actual range of primitive data types that is available is dependent upon the specific programming language that is being used (those are the most basic ones).

Boolean — bool

A boolean has 2 possible values: true or false.

bool truth = true;

Character — Char

It stores a single character and requires a single byte of memory:

const char letter = 'H';

Number — Integer (Int), Float…

A numeric data type.

const pi = 3.14; // :p

Undefined

Undefined with JS is a primitive value automatically assigned to a variable that has just been declared or to the argument of a function that has not been provided.

Formats

JSON

JSON stands for JavaScript Object Notation. It is a way to format data so that it can be human readable, storable as a string and thus be transmitted from one place to another. It is most commonly used in web development.

{
  "id" : 8,
  "name" : "Globo",
  "functions" : ["solver", "player", "teacher"],
  "isAvailable" : true
}

XML

XML stands for eXtensible Markup Language and was designed to store and transport data in a readable way for both humans and machines. Both XML and JSON have the same purpose.

Argument — Parameter

A parameter (or formal argument) is a variable in a function or method definition. When the function is called, the argument is the data we pass in the function call.

int square(int number)  // number is the parameter
  { return number * number; }
  ---
  auto result = square(3); // 3 is the argument

Callback

A callback is a function that is passed as an argument to a function, which is expected to call back (execute) at a convenient time. This may for instance be to display information (as the number of lines) of a file once read.

// Callback definition
  function displayCount(count)
  { console.log("File contains " + count + " lines."); }
  readFile("text.txt", displayCount); // Callback passed as argument

Callbacks are used everywhere in association with events in web development. In the case of an asynchronous call, call back can be executed when a response has been received.

Constructor

The constructor is a method, inside a class, that is used to instantiate (create an instance) an object. It is automatically called when an object is built.

Function

A function is a named section of a program that performs a specific task.

multiply(3, 3); // multiply is the function called

Some programming languages make a distinction between a function, which returns a value, and a procedure, which performs some operation but does not return a value.

Method

A method is a function that belongs to a class or an object. It is bound to it, defined only within that scope of usage.

Nested Function

A nested function is a function contained inside of another function. It can be used to limit the scope of the inner function.

function getSurfBoard(weather, size, height) {
  const boardList = getBoardForWeather(weather);
  // Nested function
  function filterBoardByBody(size, height) {...}
}

Recursive Function

The term recursive describes a function or method that calls itself.

Understanding how recursion works is a fundamental programming skill.

function fibonacci(number) {
  if (number === 0) return 0;
  if (number === 1) return 1;
  return fibonacci(number - 1) + fibonacci(number - 2);
}

As a reminder the Fibonacci numbers are defined as follow:
F(0) = 0
F(1) = 1
F(n) = F(n−1) + F(n−2)

Git — Version Control

Git is an open-source distributed version control system designed to track changes and in computer files and coordinating work on those files among multiple people and locations. It is primarily used to allow programmers to work together in a codebase.

One might never know all the git commands because they are numerous but there are some that every developer is expected to know to be able to collaborate with other developers.

Branch

Branching allows each developer to branch out from the original code base and isolate their work from others. It also helps Git to easily merge versions later on.

Imagine that you are working with your colleagues on the same file. There is a solid chance that someone will, at least partially, overwrite one other’s work. We can avoid that by branching in order to isolates our work from that of other team members.

In short, a Git branch is an independent line of development.
Note: each node on the image above represents a commit.

$ git checkout -b [branch name] // Create a new branch and switch to it

Commit

To commit is the action of adding your changes to the local repository. It needs to be accompanied with a commit message that describes what this change is bringing to the code base:

$ git commit -m "This fix a bug in the code base" // Commit changes

We recommend to use a GUI to manage commits, it gives us a better control on what we want to commit.

$ git gui // (git-gui)

Conflicts

When working in Git, users can combine commits from two different branches through an action known as merging. Files are automatically merged unless the commits update the same line of code differently. In that case there is a conflict: which version of this line should be taken?

Merge conflicts can traditionally cause developers a lot of grief when working in the terminal. This is why we advise to use a GUI (such as meld) to resolve conflicts.

GitHub

GitHub, Inc. is a US-based global company that provides hosting for software development version control using Git. This is the world’s largest open source platform. It is now a subsidiary of Microsoft, which acquired the company in 2018 for US$7.5 billion.

Merge

To merge one branch into another is the action of fusing 2 different versions of the project together. If you are done working on a branch named “my-feature”, you can merge it to master in order for the master branch to be updated with your work.

$ git merge [source branch] [target branch] // Merge a branch into a target branch

Pull

This is the action of updating your local version of a repository to the newest commit. Do not forget to do it before starting to work on something!

$ git pull // Update local repository to the newest commit

Push

This is the action of sending your commits to the remote repository (on GitHub or GitLab, for example).

$ git push // Push changes to remote repository

Repository (repo)

Take it as a folder that contains all the source files and tracks all the changes made, building a history over time. On Github, each project is a repo.

Web — HTTP

CSS

CSS stands for Cascading Style Sheets, it describes how HTML elements are to be displayed. It allows you to create great-looking web pages and control their layout all at once form external stylesheets (stored in CSS files).

CSS saves a lot of work.

// All of the tag h1 are green and centered
  h1 {
    color: green;
    text-align: center;
  }

Document Object Model (DOM)

The HTML we write is parsed by the browser and turned into the DOM (Object), which is essentially an API to the page that allows to read and manipulate the page’s content, structure, and styles.

With the DOM, JavaScript gets all the power it needs to manipulate our pages dynamically.

Event, Event Listener

Clicking, scrolling, pressing a key on our keyboard are what is called: “event”. There are a lot of them. On a website, we might want to listen to them by creating an event listener in order to do form validation, react to a click on a button, etc.

HTML (Hypertext Markup Language)

HTML (Hypertext Markup Language) is the code that is used to structure a web page and its content. HTML is not a programming language; it is the standard markup language used to create web pages and web applications. This markup uses tags ‘<>’ to tell a web browser how to display text, images and other forms of multimedia on a webpage.

HTTP

HTTP is a protocol which allows the fetching of resources, such as HTML documents. It is the foundation of data exchange on the Web and it is a client-server protocol, which means requests are initiated by the recipient, usually throughout he Web browser. A complete document is constructed (or fetched) on the server side and then sent to the useer.

HTTPS

Hypertext transfer protocol secure (HTTPS) is the secure version of HTTP. HTTPS is encrypted in order to increase security of data transfer. This is particularly important when users transmit sensitive data, such as by logging into a bank account, email service, or health insurance provider.

Any website, especially those that require login credentials, should use HTTPS. In modern web browsers, websites that do not use HTTPS are marked differently than those that are. Look for a green padlock in the URL bar to signify the webpage is secure.

JWT

JWT or JSON Web Token is a standard used to create secure access tokens for an application.

In the case of a web application, the server will generate a token that certifies the user identity and send it to the Client. The Client will, for every subsequent request, attach the JWT to it so the server knows the request comes from a particular identity.

VOILA ! Don’t hesitate to visit H.urna Academy to get deeper knowledge for each of these concepts: https://hurna.io/academy/glossaries/index.html

H.urna - Opening sciences for all