Jotting one man's journey through software development, programming, and technology
◀️ Home
Generative artificial intelligence, which is commonly referred to as gen AI, is a subset of artificial intelligence that is capable of creating text, images, or other data using generative models, often in response to prompts.
Generative AI encompasses a broader range of models capable of generating various types of content beyond just text, while LLM specifically refers to a subset of generative AI models focusing on language tasks.
While both terms describe AI models capable of generating human-like responses based on input prompts in many references, it’s important to note they’re not identical.
Large language models are highly sophisticated computer programs trained on gigantic amounts of data that can be text or images. LLMs refer to large, general-purpose language models that can be pre-trained and then fine-tuned for specific purposes.
In this context, large refers to: The size of the training dataset, which can sometimes be at the petabyte scale. And the number of parameters. Parameters are the memories and knowledge that the machine has learned during model training.
When you submit a prompt to an LLM, it calculates the probability of the correct answer from its pre-trained model. The probability is determined through a task called pre-training. In this way, the LLM works like a fancy autocomplete, suggesting the most common correct response to the prompt.
Hallucinations are words or phrases that are generated by the model that are often nonsensical or grammatically incorrect. This happens because LLMs can only understand the information they were trained on.
Piece of code that does an interesting thing.
Refers to the initial process of setting up an application or system when it starts. Specifically, it refers to the time and resources required for the application to load and become fully operational after it is triggered or launched. This process can include tasks like loading dependencies, initializing configurations, connecting to databases, and preparing the application to handle requests.
To mitigate the impact of long startup times (especially in serverless or cloud environments), you can pre-warm instances, meaning that the application is kept alive and ready to handle traffic without having to go through the bootstrap process every time a new request is made. This helps reduce the delay that could occur when an instance is started from scratch (often referred to as cold start).
Continuous Integration and Continuous Deployment (or Delivery) is a set of practices and tools in software development aimed at automating and improving the process of delivering software.
Automates and streamlines the development, testing, and deployment process, enabling faster and more reliable software delivery.
CI is the practice of frequently integrating code changes into a shared repository, followed by automated builds and tests to detect errors early.
Key Features:
Developers push code changes frequently (e.g., daily).
Automated systems build and test the code after each change.
Ensures new code integrates well with the existing codebase.
Catches bugs early, improving overall software quality.
Tools: Jenkins, GitHub Actions, GitLab CI, Travis CI.
CD extends CI by automating the process of deploying code to production or other environments after it passes all tests.
Deployment happens automatically (or semi-automatically) after successful tests.
Ensures faster delivery of new features and bug fixes to users.
Reduces human intervention, minimizing errors in the deployment process.
Continuous Delivery: Code is always ready for deployment, but deployment may require manual approval.
Continuous Deployment: Code is automatically deployed to production after passing all checks.
Tools: AWS CodePipeline, Azure DevOps, GitHub Actions, CircleCI.
Faster Development Cycles: Code changes are quickly tested and deployed.
Higher Code Quality: Automated tests ensure fewer bugs reach production.
Reduced Risks: Small, incremental updates are easier to test and rollback if needed.
Increased Collaboration: Teams integrate and share changes more frequently.
Fast storage used to hold data that programs are currently using. Measured in: GB (gigabytes) or GiB (gibibytes, a binary version).
More memory = more or bigger apps can run at once without slowing down.
The part that actually executes instructions.
Measured in cores: More cores = more things it can do at the same time. Clock speed (GHz) tells you how fast each core is, but core count is often the first concern.
| Use Case | Memory | CPU Cores |
|---|---|---|
| Light web browsing | 4–8 GiB | 2 |
| Coding + light tools | 8–16 GiB | 2–4 |
| Video editing / VMs | 16–32 GiB | 4–8 |
| Medium web server (API) | 8–32 GiB | 2–8 |
| Big data / ML workloads | 64+ GiB | 16+ |
The difference between GB (gigabytes) and GiB (gibibytes) is in how the size is calculated—decimal vs binary.
| Unit | Value (in bytes) | Based on |
|---|---|---|
| 1 GB | 1,000,000,000 bytes | Decimal (base 10) |
| 1 GiB | 1,073,741,824 bytes | Binary (base 2) |
Easy rule of thumb: GiB is slightly bigger than GB when referring to the same number.
The TCP protocol (Transmission Control Protocol) is a core internet protocol that ensures reliable, ordered, and error-checked data delivery between devices.
HTTP/2 is an improved version of the HTTP protocol that makes web communication faster and more efficient by:
It speeds up loading websites and reduces latency.
A TLS certificate is a digital file that enables secure, encrypted communication over HTTPS. It proves a website’s identity and ensures data is private and trusted between the user and the server. Without it, browsers show “Not Secure” warnings.
HTTP requests are messages sent by a client (like a browser) to a server to ask for data or perform an action.
WebSockets are a communication protocol that allows a persistent, two-way connection between a client and server. Unlike regular HTTP (which is one request, one response), WebSockets let both sides send and receive data in real time — great for chats, games, or live updates.
gRPC is a fast, open-source framework for remote procedure calls that lets different systems communicate efficiently using:
It’s great for connecting microservices with low latency and strong typing.
A reliable HTTPS endpoint is a secure web address (URL) that:
A TCP port is a numbered endpoint used by a computer to identify specific services or applications when communicating over the internet using the TCP protocol.
A VPC (Virtual Private Cloud) network is a private, isolated virtual network within a cloud provider where you can securely run your resources (like virtual machines or containers). It lets you control IP addresses, subnets, routing, and firewall rules—just like a traditional private network but in the cloud.
A prompt is a specific instruction, question, or cue given to a computer. In other words, it is the text that you feed to the model. Prompt engineering is a way of articulating your prompts to get the best response from the model. The better structured a prompt is, the better the output from the model will be.
Prompts can be in the form of a question, and are categorized into four categories:
Zero-shot prompts do not contain any context or examples to assist the model.
One-shot prompts, however, provide one example to the model for context.
Few-shot prompts provide at least two examples to the model for context.
Role prompts require a frame of reference for the model to work from as it answers the questions.
The two elements of a prompt: the preamble and the input.
A proxy is an intermediary that acts on behalf of something else. The meaning varies slightly by context:
A proxy server sits between a user and the internet. It forwards requests and responses between them.
Uses:
A proxy is someone or something authorized to act for another.
A proxy object is a placeholder or interface that controls access to another object.
Use cases:
A proxy variable is an indirect measure used when the actual variable isn’t available or measurable.
A unit test is a type of software testing that focuses on verifying the correctness of individual units or components of a program. A “unit” typically refers to the smallest piece of code that can be tested in isolation, such as a function, method, or class.
Ensure that individual components work as intended.
Catch bugs early in the development process.
Provide documentation of how a unit is expected to behave.
Facilitate refactoring by ensuring the code’s correctness before and after changes.
def add(a, b):
return a + b
A unit test for the function above might look like this:
import unittest
class TestMathFunctions(unittest.TestCase):
def test_add(self):
self.assertEqual(add(2, 3), 5)
self.assertEqual(add(-1, 1), 0)
self.assertEqual(add(0, 0), 0)
if __name__ == "__main__":
unittest.main()
A webhook is a way for one system to automatically send real-time data to another system when a specific event happens. It’s like a reverse API call: instead of your app asking for data, the webhook pushes the data to your app.
Real-World Analogy: Imagine you place an order at a coffee shop and give them your phone number. Instead of waiting around, they text you when your drink is ready. That text is the webhook: it’s sent when the “drink is ready” event happens.