Easy everything in Backend Dev, page 13
Rust HashMap: Fast, Secure Key-Value Storage
A Rust HashMap is like a dictionary, mapping unique keys to values for fast lookups. Use it for caching or frequency counting. The footgun: never modify a key after insertion, as changing its hash will break the map's internal logic.
Rust Vectors: Your Go-To Growable List
A Vec<T> is Rust's smart, growable array. It automatically gets more memory when full, keeping items together for fast access. Use it for lists of unknown size. The footgun: frequent reallocations can be slow if you don't pre-allocate capacity.
Go Maps: Your Built-in Hash Table
Go maps are the language's built-in hash tables for fast key-value lookups. Use make(map[K]V) to initialize one before writing. The biggest footgun is writing to a nil map, which causes a runtime panic. Always initialize your maps first.
Go Slices: A Window into an Array
Think of a Go slice not as a list, but as a lightweight window into an underlying array. It's used everywhere for managing sequences of data. The footgun: since slices can share memory, modifying one can unexpectedly alter another.
Go vs. Rust: Variable Mutability by Default
Rust variables are immutable by default; Go's are mutable. Rust forces you to opt-in to changeability with mut for compile-time safety. Go prioritizes convenience, trusting the developer.
Go Interfaces: Describe Behavior, Not Data
Go interfaces define behavior, not data. A type satisfies an interface implicitly by implementing its methods, without an implements keyword. This enables writing flexible functions, like io.Writer handling files or HTTP responses.
Goroutines
A goroutine is a lightweight function managed by Go's own runtime scheduler rather than the operating system, letting a single program run hundreds of thousands of concurrent tasks cheaply instead of the handful an OS thread model allows.
Rust's Philosophy: Documentation and Community First
Rust's philosophy is deeply tied to its learning resources and community, ensuring developers are well-supported. This is evident in its official book, which is bundled with the language installation itself.
Go's Design Philosophy: Engineering Over Novelty
Go's design philosophy is engineering over novelty, built to solve Google's problems with slow builds and complexity in massive codebases. It excels at large, networked systems where maintainability and fast compilation are critical.
Data Retention Policy: Your Schedule for Deleting Data
A data retention policy is your company's official schedule for deleting data, not a plan to keep it forever. It's essential for legal compliance (like GDPR) and managing storage costs.
Vector Embeddings: Turning Meaning into Math
Vector embeddings turn complex data like words or images into lists of numbers (vectors). This lets computers measure "similarity" by calculating the distance between these vectors, powering search and recommendations.
Cache-Aside Pattern: Your App Owns the Cache
The Cache-Aside pattern makes your application the gatekeeper for the cache. On a read, your code checks the cache first; on a miss, it fetches from the database and writes to the cache. This speeds up read-heavy apps. The key footgun is stale data.
Inverted Index: How Search Engines Find Your Keywords
An inverted index is like a book's index: it maps keywords to the documents containing them. This is the core of full-text search in search engines and databases, allowing instant lookups.
Message Queues: Decoupling Your Services
Think of a message queue as a digital post office for your services. It lets one part of your system drop off a task for another to handle later, decoupling them so they don't have to run in lock-step.
Data Pipelines: From Raw Data to Actionable Insights
A data pipeline is the plumbing for your data, moving it from raw sources to a refined state for analysis. It feeds dashboards and ML models by cleaning data from APIs and databases. The key footgun is choosing batch processing for real-time needs.
Amazon RDS: Managed Relational Databases in the Cloud
Amazon RDS is like hiring a DBA to manage your database's plumbing. It's for when you need a SQL database like PostgreSQL or MySQL without the hassle of patching and backups. The footgun is assuming it's 'serverless'—you still manage cost and performance.
Database as a Service (DBaaS): Rent, Don't Build
DBaaS is like leasing a database instead of owning it. A cloud provider handles the backups, patching, and scaling, so you can focus on your app. The main footgun is assuming "managed" means you can ignore configuration, query performance, and costs.
Connection String: Your App's Key and Address to Data
A connection string is your app's address and key to a data source. It bundles the host, port, database name, and credentials into a single string for a driver to use. The main footgun is committing credentials to version control by hardcoding the string in.
ODBC: The Universal Translator for Databases
ODBC acts as a universal translator, letting one application speak to many different relational databases. Your app uses the standard ODBC interface, and a specific "driver" handles the unique protocol for each database. The footgun is performance overhead.
JDBC: Java's Universal Translator for Databases
JDBC is Java's universal adapter for databases, letting your app speak SQL to any database via a standard API. It's used for connecting, querying, and managing transactions. The biggest footgun is building SQL strings directly; always use PreparedStatements.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles