A
Abstract Class
Abstract Syntax Tree (AST)
Abstraction
Access Control
Access Token
Activation Function
Actor Model
AI Ethics
Algorithm
Algorithm Design
Algorithm Efficiency
Algorithmic Bias
Annotations
API
API Authentication
API Design
API Gateway
Approximation Algorithms
Arithmetic Optimization
Array
Artifact Repository
Artificial Intelligence (AI)
Artificial Neural Network (ANN)
ASCII
Assembler
Assembly Language
Asymptotic Analysis
Async/Await
Asynchronous Programming
Attribute
Attribute-Based Access Control (ABAC)
Authentication
Authorization
Authorization Header
Automatic Speech Recognition (ASR)
Automation
Auto-Scaling
AVL Tree
Await
B
Backpressure
Backpropagation
Batch Gradient Descent
Bearer Token
Benchmark Suite
Benchmarking
Big Data
Big O Notation
Binary
Binary Search
Binary Search Tree
Binary Tree
Bisect Left
Bisect Module
Bisect Right
Bit
Bit Rot
Bitwise Operation
Bit Depth
Bit Mask
Blockchain
Blocking
Boolean Data Type
Boolean Expression
Boolean Logic
Branch Coverage
Branch Prediction
Browser
Buffer
Bug
Build Automation
Build System
Byte
Bytecode
Bytecode Compilation
C
Cache
Callback Hell
CDN (Content Delivery Network)
Channel Communication
Chatbot Development
Checksum
CI Server
Class
Cloud Computing
Cluster
Code Pipeline
Code Smells
Codebase
Cognitive Architecture
Cognitive Computing
Compilation
Compiler
Computational Complexity
Computational Limits
Concurrency
Conditionals
Conditional Statement
Configuration File
Conjugate Gradient
Const Correctness
Constant
Constant Folding
Constant Propagation
Constructor
Constructor Chaining
Context Aware AI
Continuation
Continuous Delivery
Continuous Integration (CI)
Continuous Integration / Continuous Delivery or Deployment (CI/CD)
Continuous Deployment (CD)
Control Flow
Convergence Rate
Convergence Speed
Conversational AI
Cooperative Scheduling
Copy Constructor
Coroutine
Coroutine Scope
Cost Function
CPU
CPU Affinity (Processor Affinity)
CPU Cache
Crash Report
CRC (Cyclic Redundancy Check)
Cross Compilation
Cybersecurity
D
Data Integrity
Data Lake
Data Mining
Data Science
Data Structure
Data Throttling
Data Type
Data Warehouse
Database
Dead Code Elimination
Deadlock
Debugging
Decision Support
Decision Tree
Decorators
Deep Learning
Default Constructor
Dependency
Deployment Pipeline
Design Patterns
DevOps
DevTools
Dialogue Management
Digital Circuit
Digital Signal
Digital Signature
Disassembler
Disk I/O
Divide and Conquer
DNS
Docker
DOM (Document Object Model)
Dynamic List
Dynamic Typing
E
ECC Memory
Edge Computing
Elastic Computing
Else If Clause
Emotion AI
Encapsulation
Encoding
Encryption
Endianness
Endpoint
Entropy Encoding
Enum
Epoch
Error Bound
Error Detection and Correction (EDAC)
Error Propagation
ETL (Extract, Transform, Load)
Event Loop
Event-Driven Programming
Exception Handling
Executable
Execution Time
Expert Systems
Explicit Type Casting
Exponential Time
Expression
Expression Evaluation
Extension
External Library
F
Factory Pattern
Fault Injection
Feedforward Network
Fetch API
File Descriptors
File I/O
File System
Firewall
Float
Floating Point
Flowchart
Flow Control
For Loop
Fork
Framework
Frontend
Full Stack
Function
Future
G
Garbage Collection
Generative AI
Generator
Git
GitHub
GitHub Actions
Global Interpreter Lock (GIL)
Global Variable
Goroutine
GPU
Gradient Descent
Graph
GraphQL
Greedy Optimization
Green Threads
GUI
Gzip
H
Hackathon
Hash Function
Hash Table
Heap
Hexadecimal
Heuristic Algorithms
High-Level Language
High Water Mark
Hotfix
HTML
HTTP
HTTP Headers
HTTPS
Human-Computer Interaction (HCI)
Hybrid App
Hypervisor
I
I/O Multiplexing
IaaS (Infrastructure as a Service)
IDE
Identity and Access Management (IAM)
Identity Provider (IdP)
If Statement
Immutable
Immutable Data Structures
Index
Indexing
Infrastructure as Code (IaC)
Inheritance
Initialization Method
Inline Assembly
Input/Output
Insertion Operation
Insertion Point
Insort
Instance
Instance Variables
Instantiation
Intent Recognition
Intermediate Language
Intermediate Representation (IR)
Interrupts
Intractability
Introspection
Instruction Set Architecture (ISA)
Integer
Interface
Interpreter
In Order Traversal
Iteration
J
Jar File
Java
JavaBeans
JavaScript
JavaScript Engine
Jenkins
JIT
Job Scheduling
JOIN
JSON
JSON Web Token (JWT)
Jupyter Notebook
JVM
K
K-Nearest Neighbors
Karnaugh Map
Keras
Kernel
Key Exchange Protocol
Key-Value Store
Keylogger
Keystroke
Keyword
Knowledge Graph
Kotlin
Kubernetes
Kubernetes Deployment
L
Lambda Function
Latency
Lazy Loading
Learning Rate
Least Privilege
Least Significant Bit
Library
Linked List
Linker
Linux
Lipschitz Continuity
List
Literal
Livelock
Load Balancer
Load Shedding
Loader
Localhost
Locks and Semaphores
Logarithmic Time
Logic Gate
Logic Gates
Logic Operator
Logical Operators
Loop
Loss Function
Lower Bound
Low-Level Language
M
Machine Code
Machine Learning
Machine Learning Pipelines
Macro
Map Function
MASM (Microsoft Macro Assembler)
Master Theorem
Matrix
MD5
Memory
Memory Addressing
Memory Allocation
Memory Hierarchy
Memory Segmentation
Merkle Tree
Message Queue
Metadata
Method
Microbenchmarking
Microservices
Microservices Automation
Microtask Queue
Middleware
Mini Batch Descent
Mnemonics
Model
Modularity
Module
Momentum Optimization
MongoDB
Most Significant Bit
Multi-Tenant Architecture
Multilayer Perceptron
Multimodal Interface
Multimodal Systems
Multithreading
Multi-Factor Authentication (MFA)
N
Namespace
NaN
NASM (Netwide Assembler)
Natural Language Generation (NLG)
Natural Language Processing (NLP)
Natural Language Understanding (NLU)
Nested Condition
Nested Statements
Nesting
Network Layer
Network Packet
Network Protocol
Newton Method
Neural Network
Neural Network Training
Neuro-Symbolic AI
No-Code/Low-Code Platforms
Node.js
NoSQL
Non-blocking I/O
Normalization
NP-Completeness
Null
Nullish Coalescing
NumPy
O
OAuth
OAuth2
Object
Object Lifecycle
Object Store
Object-Oriented Programming
Adaptive Optimizer
Opcode
Open Domain Conversation
OpenID
OpenID Connect
Open Source
Operating System
Operator
Optimization
Optimization Algorithm
ORM
Output
Output Layer
Overflow
Overloading
P
PaaS
Package Manager
Parameter
Parameter Update
Parameterized Constructor
Parallelism
Parser
Parsing
Password Hashing
Pattern Matching
Pattern Recognition
Payload
Peephole Optimization
Permission Matrix
Pipeline Script
Pointer
Policy Enforcement Point (PEP)
Polymorphism
Polynomial Time
Port
Preconditioning
Predicate Logic
Predictive Analytics
Prefetching
Probabilistic Reasoning
Problem Reduction
Process
Program
Programming Language
Promise
Prototype
Pseudocode
PyTorch
Python
Python Asyncio
Python Standard Library
P vs NP
Q
QoS
Quadratic Convergence
Qualitative Data
Quantum Computing
Quarantine
Query
Query String
Queue
Quicksave
QuickSort
Quota
Qubit
R
Race Conditions
RAM
Range Query
Randomized Algorithms
Rasa Framework
Raspberry Pi
Reactive Programming
Reactive Stream
Recursion
Recursion Tree
Red-Black Tree
Redis
Refactoring
Reflection
Refresh Token
Regex (Regular Expression)
Register
Regression Testing
Regularization Technique
Reinforcement Learning
Release Automation
ReLU Function
Repository
Response Time
REST API
Return Statement
Robotic Process Automation (RPA)
Role-Based Access Control (RBAC)
Rollback Strategy
Rolling Hash
Router
Runtime
S
SaaS (Software as a Service)
Sandbox
Scheduler
Scopes and Claims
Scripting
Scripting Language
SDK
Search Algorithms
Search Operation
Secure Token Storage
Self Balancing Tree
Semantic Analysis
Semantic Web
Sentiment Detection
Separation of Concerns
Server
Serverless Architecture
Service Level Agreement (SLA)
Session
Session Management
SGD (Stochastic Gradient Descent)
SHA-256
Shared Memory
Shell
Short Circuit Evaluation
Sigmoid Function
Software
Software Architecture
Sorted Array
Sorted Collection
Sorted Data
Sorted Insert
Source Code
Space Complexity
Speech Recognition
Speedup
SQL
Staging Environment
Stack
Stackless Function
Static Analysis
Static Constructor
Static Method
Static Values
Stochastic Gradient Descent
Strength Reduction
Structured Concurrency
Subscriber Backpressure
Superclass Initialization
Supervised Learning
Suspend Function
Swap
Switch Case
Syntax Tree
T
Task
Task Scheduling
TCP/IP
TCP Congestion Control
Technical Debt
TensorFlow
Terminal
Ternary Operator
Test Automation
Test Case
Testing
Text to Speech (TTS)
Theta Notation
Thread
Thread Pool
Thread Safety
Thread Starvation
Throttle Mechanism
Time Complexity
Timeout Handling
TLS Handshake
Token
Token Authentication
Token Expiration
Token Revocation
Token Validation
Token-Based Security
Tokenization
Training Dataset
Transaction
Treap
Tree
TreeNode
Tree Traversal
Truth Table
Truthy/Falsy
Try-Catch
Tuple
Turing Completeness
Turing Test
Two’s Complement
Type Annotations
Type Casting
Type Coercion
Type Hints
Type Inference
U
UI
UML
Unbalanced Tree
Undecidability
Unicode
Unit Test
Unstructured Data
Unsupervised Learning
Upper Bound
Uptime
URL
Usability
USB
User Experience
UTF-8
V
Value Comparison
Variable
Vector
Version Control
Viewport
Vim
Virtual Assistant (VA)
Virtual Machine
Virtualization
Visualization
Voice Interface
Voice Recognition
Volatile Memory
Vulnerability
W
Walrus Operator
Watson
Watson Assistant
Web API Security
Web Browser
Web Development
Web Server
Web Standards
WebAssembly
Webhook
Weight Adjustment
Weight Initialization
Weight Update
While Loop
Wi-Fi
Widget
Windows
Word
Word Size
Workflow YAML
Wrapper Function
X
X11
Xamarin
Xcode
XHTML
Xlib
XML
XNOR (Exclusive NOR)
XOR (Exclusive OR)
XOR Encryption
XOR Gate
XPath
XSS
Y
Y-axis
Y-coordinate
Y2K Bug
YAML
YAML Schema
Yarn
Yes/No Logic
Yield Statement
Yottabyte
YouTube API
Z
Z-buffering
Z-index
Zero Trust Architecture (ZTA)
Zero-Based Indexing
Zero-Day Exploit
Zettabyte
Zip File
Zlib
Zombie Process
Zone File
Zsh