Cover photo by AltumCode on Unsplash
I recently discovered a few interesting Latin based words used as programming terms. Here they are,
Idempotent
Having the same result for a given input every time. This means a function that returns the same result every time with the same input. Here is an example,
// Multiply argument "a" by 2
const fun = a => a * 2;
fun(2) // 4
fun(2) // 4
The above is Itempotent because it returns the same value when it is given the same input. This function would not be Idempotent,
let counter = 0;
// Add counter to argument "a" and increment counter
const fun = a => a + counter++;
fun(2) // 2
fun(2) // 3
Predicate
This one is simple. It just means that the output of a function will be true of false. Example,
const userLoggedIn = user => user.status === 1;
Abstraction
Abstraction is the process of simplifying the code so that you hide major functionality. Basically, it is where you make your code organized and separate from the functionality of code. It is practically the DRY (dont repeat yourself) technique.
// Less abstraction
users.push({id: result.id});
// More Abscraction
addUser(result.id);
Serialization
Simply, Serialization is where you convert data from one application so it can be read by another application. Let's say you have a Javascript application that needs to communicate to a Python application. In the Javascript application, you would Serialize the output to a JSON file, and then the Python script would read the file and parse the text.
Immutable
Immutable simply means that the state of a variable does not change. It is like a const
variable or an object with properties that do not change.
Operand
An operand is basically a function with a set of math operators like a => a+b*c
Ephemeral
Used to describe things that when changed, cannot go back to the original state. Let's say you have a simple object that you modify, you can not go back to the original state of the object so it is Ephemeral. Computer RAM is also considered Ephemeral because it is temporary.
Hard Code
This is one that most people might know. It means code that when done is hard to change. They are things that require manual coding changes to modify. Generally, Hard Coding things could a bad thing because you may not be abstracting the entire application.
Now go make an application that abstracts serialization of the output from an Idempotent operation using Ephemeral states to manage results from Immutable operations and set them by Abstracting them Predicatively.
Top comments (1)
Algorithm