The Technically Universe

ChatGPT is a Machine Learning model, created and maintained by OpenAI, that generates paragraphs of text in response to prompts.

A context window is how much data an AI model can hold in memory at once

Training is the process of creating and teaching an ML model how to do something.

Inference is a fancy term that just means using an ML model that has already been trained.

A token is the basic unit of a Large Language Model's vocabulary.

Large Language Models take in a prompt and generate text.

Retrieval Augmented Generation (RAG) is a way to make LLMs like GPT-4 more accurate and personalized to your specific data

Machine Learning uses math to predict an output given an input

A benchmark is a standard way of measuring the performance of a piece of software. They’re common in infrastructure where many products compete for the same real estate, and a vendor might brag that they perform better than a competitor on a given benchmark. There are some standard ones, like TPC for servers, benchANT for databases, and tons of academic ones for ML models.

Experimentation is one of the ways that companies understand if their product efforts are working, and ipso facto, what they should be spending time on.

Analytics just means trying to use data to learn something. The most common context you’ll see it in is larger scale analysis of a company’s data: what are our users doing, how much money are we making (or losing), which parts of our website are most popular, things like that.

The Modern Data Stack™ (MDS) is a new-ish set of tools that data teams are using to collect, transform, explore, and make use of their company’s data.

Linear Regression is an old school statistical method for predicting outcomes from a series of numbers. It uses some intermediate math to automatically find patterns in data – like historical stock prices – and create a formula for what the expected output might be (stock price) given a new input (date and time). Though less in vogue these days, Linear Regression was highly popular and effective for traditional Machine Learning tasks before GenAI came around.

When developers monitor their applications and infrastructure to make sure things run smoothly, they set up metrics to track specific points of performance: how fast an API request gets fulfilled, the percentage of requests that fail, or even what % of total processing capacity is a server using up.

Product analytics is the process of companies figuring out what users are actually doing in their product, with the goal of improving it.

ETL stands for Extract - Transform - Load, and it’s the process of moving data around your internal systems to get it ready for analysis.

Reverse ETL is the process of syncing data from your data warehouse to your business tools like Salesforce and Hubspot.

A Data Lake is an unstructured place to put data. It’s usually meant for long term storage and infrequent querying.

A data warehouse is a special type of database designed for analytics instead of transactions.

Apache Kafka is a framework for streaming data between internal systems.

The frontend is the visual, interactive part of the application that your users actually use. If accessed through the browser, it's always written in HTML, CSS, and JavaScript.

The Linux operating system is a tiny fraction of the personal computer market: but it’s the default operating system for most servers in the cloud, and it’s getting more popular on personal computers too.

There are three dominant operating systems for non-mobile computers: Windows, MacOS, and Linux.

When you give an API a bunch of inputs to get the outputs you want, it’s called calling the API.

Cloud lets companies rent the servers (giant computers) they run their software on instead of buying them.

An application – like the one you’re reading this post on – is made up of just two parts: a frontend and a backend.

Computers break down all software instructions into a simple yes or no and use microscopic electrical signals and gates to process and store those instructions.

CPU stands for Central Processing Unit, and it’s what tries to understand and execute your software’s instructions.

Application Programming Interfaces (APIs) are like drive-thru windows, but in code: they take inputs and give you predictable outputs.

Every operating system is built off of a kernel, which is the core of the OS, doing most of the hardware management.

Open source technically means that an app’s code is publicly available, but more generally refers to the movement of communities of developers building transparent, open codebases free for everyone to use.

Disk is a physical part of your computer (or server) where you store data.

Every operating system is built off of a kernel, which is the core of the OS, doing most of the hardware management.

There are basically two big players for mobile: Android and iOS.

An operating system is a piece of software that sits between your applications and your hardware, and makes sure the two play well together.

Sometimes, companies will make a few of their APIs available, and give you instructions on how to use them.

RAM stands for Random Access Memory, and it’s the remedy to Disk being slow: it’s much faster “memory” that computers use for things like intermediate storage (storing the result of a calculation temporarily).

Merging means integrating your code changes into a branch. When a developer is satisfied with some code they've written, they'll merge it into whatever the current working branch is.

HTTP is the language that your computer speaks to web servers to let you browse the internet.

Houses have street addresses, and computers have IP addresses.

A Pull Request (PR for short) is a Github feature that you’d use when you want to merge your branch of code: it lets you tell other developers what you’re doing, request them to review it, and run tests and other automations.

A Virtual Private Network (VPN) lets you route your internet access through a specialized server that keeps your sensitive information private.

Tokenization is one of the ways that backends protect sensitive information, like credit cards or social security numbers.

A blockchain is just another way to store data, exactly like a database.

Metadata is data about data (🤯). It’s a term that developers use to describe higher level data about something, but not that thing itself. A picture, for example, is a bunch of data (pixels). But when and where that picture was taken is metadata. The same thing is true for an entire set of data: a table in a database with entries about your users is a bunch of data, but how large that table is, or what permissions different developers have for it, that’s metadata.

A relational database is sort of like Excel, but for developers: it’s how applications store and analyze data.

SQL, or structured query language, is a type of programming language for working with databases.

A vector database is a place where developers store specially formatted data to use for machine learning and AI.

Migrations mean a lot of things in software, but they usually entail some sort of important change.

GraphQL is a query language (and runtime) for building and using APIs: developers use it to simplify making API requests.

A database is just a place to store data; even Excel is technically a database.

An Object Relational Mapper is software that lets developers interact with their database in their programming language of choice – instead of SQL. ORMs translate SQL into languages developers are building their apps in, like JavaScript or Python.

Multi-tenant simply means shared with someone else, like having a roommate in an apartment. In the infrastructure context, it refers to one physical server that has software from multiple different people (or companies) running on it. Which could be hundreds of roommates depending on the size of the server.

NoSQL databases are databases with no rules: you just throw your data in there and worry about it later.

The largest category of databases – both in terms of number of available options and total market size – is production databases.

A query is how talk to your database.

A schema is like the blueprint for a relational database. It lays out which tables you have, which columns are in them, what data type those columns are, and which columns in one table map to columns in another table. Developers design schemas to enforce rigidity on their data: when you specify exactly what data needs to be where, you prevent errant (or missing) data from breaking your application.

CD is a philosophy around pushing your code to production: instead of giant, infrequent releases, it advocates many smaller changes, even multiple times per day.

Scaling means making something bigger: more users of your app, more API requests, more data in your database, a bigger server, more servers, etc. When your app gets an influx of users, the infrastructure you’re running on might not be big or powerful enough to support it. So you need to either scale up, by upgrading to a bigger more powerful server, or scale out, by distributing your software across multiple different servers, all working together.

A script is a term developers use to refer to a file of code that does something scoped and specific: to be distinguished from an app or a system, which is probably many files and does a lot more. A script might empty the trash on your computer, retrieve and format some weather data from an API, clean old records out of a database, or update the weekly metrics for the board deck.

Server is a catch all term for any sort of application backend

The Secure Shell Protocol is a (popular) way to securely connect to computers over the internet, usually in the context of powerful servers in the cloud. It uses cryptography to make sure that only specific, verifiable people and devices have access to the server in question. When you set up a machine in the cloud on something like AWS, the first thing you need to do is SSH into that server to run commands there and get things running.

Compiling just means translating one thing to another. In software, it’s usually about converting one programming language to another. Believe it or not, your operating system can’t really understand most of the programming languages that developers write code in. Compilers are software programs that convert high level, almost human readable languages like Python and JavaScript into lower level, faster, system-like languages like Assembly that a computer can actually understand.

Docker is an engine for running your code in containers, which are isolated little boxes.

A branch is a specific version of your code repository.

Microservices (all hype aside) are a way of building your application as a series of small, interacting services instead of one giant bundle of code.

Integrations are how two pieces of software talk to each other and share data

Some programming languages are object oriented, which means that they’re centered around the concept of an object. In code, an object is a “thing” that can hold data and do stuff, and you can create many of. There might be a “user” object in your app’s code, where users can do things like update their profiles, and also contain data like their preferences or the last time they logged in. Think about it more as a philosophy and style of programming more than anything else.

Platform as a Service is a category of infrastructure products that makes life easier for developers: instead of managing infrastructure on their own, the vendor takes care of things like installing the right software, managing upgrades, and connecting databases. For a fee, of course.

Production is the live, ready, tested, public facing version of your app. A new feature might start in a testing environment, then graduate to a staging environment, and then finally make it out to production when it’s ready and battle tested.

CI usually refers to a series of tests and automations that developers run on their code before they ship it to their users.

Debugging just means figuring out what’s wrong with your code or app. In the app context, it usually means running through the steps the user took before the error happened. When it’s something lower level – like some new code you’re writing isn’t working correctly – developers will step through each line of the code, sometimes with the aid of special software in their development environment.

Deploying means updating the running version of your app with new code

DevOps is a process (e.g. a bunch of key practices) that helps teams take software they’ve built and make sure it works well at scale.

Infrastructure is a loose term that developers use to refer to the lower level components that hold up an application. At the base level, physical hardware and the servers that things run on are definitely infrastructure. But networking is also infrastructure. As are databases and storage.

Serverless is a catch-all term for apps and products that don’t require you to manage your own servers.

IaaS stands for Infrastructure as a Service, and it’s the lowest level of service available in the modern cloud ecosystem. The provider, be it AWS or Google or Azure, rents out space on a server to you, and the rest is up to you to run and manage. Contrast this with Platform as a service, another level up, where they charge you extra to manage the infrastructure for you. These days, all of the major cloud providers offer products across the gamut: IaaS, PaaS, and even SaaS (fully managed).

The Terminal is the native way to talk to computers. You issue commands to it – like find me a file, create a new folder, run this set of code, or stop running this memory-hogging process, and the computer tries to do as you wish. The graphical user interface (GUI) that you’re used to, like Finder on Mac, is actually a fancy visual layer built on top of these very commands.

Computers have digital ports – literally, like for a boat – for other computers to connect to over a network. Ports map to specific things that an operating system might be doing, and there are some standard ones: port 22 is where you log into via SSH, port 80 is HTTP, port 443 is HTTPS (HTTP, but secure), port 53 is DNS, and so on and so forth.

Networking in software engineering refers to connecting two or more different things. Those things are usually computers or servers, but they could even be entire networks themselves. The internet is a very complicated place, with millions of networks, subnetworks, local networks, and otherwise obscure landmarks. Making sure only the right devices and people have access to your stuff, and that those rails work quickly and reliably, is a highly specialized (and increasingly rare) skill.

Remote usually means a computer or server that’s not physically located with you at the moment. It’s often used in the context of version control systems, where it refers to a branch of code that exists on a server. You work on your code changes locally (like on your laptop), and then push them over the web to the remote branch so other developers can see and use them, or so that you can deploy them into service.

Technical debt is a term developers use to refer to all of the annoying thorns they need to deal with because of past decisions someone made in their codebase and architecture. In software engineering, there are quick ways to do things and there are right ways to do things, and the two don’t always overlap. You also don’t always know which is which.

Version control lets you track and manage changes to your code in a more sophisticated way than you’re used to.

Developers use Kubernetes to turn their individual containers and virtual machines into full fledged, working applications.

A markup language, in software specifically used to distinguish something as not a programming language, is a system of tags that you can use to describe a structure. The classic Markup language is HTML, where tags like \<h1\> denote headers, \<p\> denote paragraphs, \<i\> means italics, stuff like that. But there are tons of other markup languages like XML and LaTeX.

Rendering means a lot of different things in software, but the theme is: something gets painted or drawn on a screen. In frontend development, you’ll hear rendering referring to when a UI element actually gets painted on the screen (“when you click this button, we want to render a dropdown”). In 3D graphics, rendering is the process of creating photorealistic images from a 3D model. And in video, you might hear someone use render to mean processing data from cameras into digital video.

Scraping means automating the process of pulling data off the internet. You might scrape sports scores off of ESPN to do a data analysis project, scrape profiles off of LinkedIn to do automated outreach, or scrape addresses from a list to spam them with direct mail. Scraping is usually done with a programming language like Python, a browser automation tool like Selenium, or even these days, some software products.

Authentication is how the apps you use know that you are who you say you are: through something as simple as a password, or as complex as biometrics.

In the context of software, client refers to the person or computer that's accessing an application.

An endpoint is a URL that lets you access REST APIs.

In software engineering, a framework usually means a foundation for building something in particular. You might use a web framework like NextJS or Django instead of writing a web server from scratch. You might use a frontend framework like React instead of writing tons of JavaScript from scratch. You might use an observability framework like Prometheus instead of emitting logs and metrics from scratch.

JavaScript is the most popular programming language in the world.

CSS stands for Cascading Style Sheets, and it's the primary way developers style their applications.

The Domain Name Service is like the address book of the internet. It maps IP Addresses – which are something unintelligible like 192.168.2.1 – to a URL, which for the most part humans can understand. When you type a URL into your browser and type enter, your request first goes to DNS, where it learns what the address of that URL’s destination is, and then follows that to the server where your desired webpage is sitting.

HTML is a programming language that developers use to build web pages. 

Caching is the process of storing things (webpages, images, etc.) closer to whoever is requesting them so that those things load faster. .

Headless e-commerce is like Shopify, but without most of the visuals you’re used to: it’s a pure backend and management portal for running and building shops on the web.

The JAMStack is an architectural pattern (sort of) for building apps that moves away from the traditional web server model and focuses on serving static files from “the edge” (data centers physically close to your computer).

UI stands for User Interface, and it's the part of the application that you actually interact with

A rate limit puts a cap on how much, and how fast, you can use a company’s API. They’re usually structured as a max number of requests per second.

React is a philosophy and framework for building interactive web (and native) applications that are built on reusable components.

A web app is an application that you access through your browser. Contrast it with an app on your iPhone (an iOS app), an Android app, a desktop app for your Mac, or an app running on a drone hundreds of feet in the air. Though these apps often have many of the same building blocks, they take different types of expertise and systems to build well.

Webhooks are APIs, but backwards - they’re ways for applications to send data to other applications, automatically.