The editorial team at Lycoris Technologies — covering tech news and writing hands-on tutorials.
The Lycoris Team · · 4 min read The producer-consumer problem is a classic concurrency pattern: coordinating producers and consumers around a shared, bounded buffer safely.
The Lycoris Team · · 4 min read Write amplification is when a system writes more data physically than the logical write requested, wearing out storage faster and hurting throughput.
The Lycoris Team · · 4 min read Redis is in-memory, so RDB snapshots and the AOF log are how it survives a restart — each trades durability against performance differently.
The Lycoris Team · · 4 min read Regular expressions are matched by finite automata or backtracking engines. How regex engines parse patterns, and why some patterns run slowly.
The Lycoris Team · · 5 min read A stored procedure is precompiled SQL saved inside the database and invoked by name, cutting network round trips and centralizing business logic.
The Lycoris Team · · 6 min read A step-by-step guide to running EXPLAIN ANALYZE in PostgreSQL and reading the query plan it returns — node types, costs, and where the real time went.
The Lycoris Team · · 5 min read Backpressure is how a slow consumer signals a fast producer to hold off, preventing memory exhaustion in streams, queues, and network protocols.
The Lycoris Team · · 4 min read P is problems solvable quickly; NP is problems whose solutions are quickly checkable. Whether P equals NP is one of computing's open questions.
The Lycoris Team · · 5 min read A database trigger is a procedure that runs automatically on an insert, update, or delete — enforcing rules the application layer can't guarantee.
The Lycoris Team · · 5 min read A SQL view is a saved query re-run on every read; a materialized view stores the result physically and needs refreshing. Here's when to use each.
The Lycoris Team · · 5 min read Little's Law relates the number of requests in a system, their arrival rate, and how long each one takes — a simple formula for sizing capacity.
The Lycoris Team · · 5 min read LRU evicts whatever hasn't been used in the longest time; LFU evicts whatever has been used the fewest times. How each policy behaves and when to pick it.
The Lycoris Team · · 5 min read Postgres offers several index types beyond the default B-tree. When GIN and GiST outperform it for arrays, JSONB, full-text search, and ranges.
The Lycoris Team · · 4 min read The Knuth-Morris-Pratt algorithm finds a pattern inside a text in linear time by never re-examining characters it has already matched.
The Lycoris Team · · 5 min read A ring buffer is a fixed-size array that wraps its read and write pointers around, giving O(1) enqueue and dequeue without ever resizing.
The Lycoris Team · · 5 min read A Fenwick tree, or binary indexed tree, answers prefix-sum queries and point updates in O(log n) with far less memory than a segment tree.
The Lycoris Team · · 5 min read A covering index holds every column a query needs, letting the database answer from the index alone without a lookup back to the table.
The Lycoris Team · · 4 min read URI paths, custom headers, and content negotiation are the three common ways to version an API. Tradeoffs of each, and how to avoid breaking clients.
The Lycoris Team · · 4 min read Dependency injection passes an object's dependencies in from outside rather than letting it construct them, making code easier to test and swap.
The Lycoris Team · · 4 min read Distributed tracing follows a single request as it crosses service boundaries, using spans and trace IDs to reconstruct the full call path and find where time goes.
The Lycoris Team · · 4 min read A data warehouse stores structured, pre-modeled data optimized for queries; a data lake stores raw data of any shape. When each one fits.
The Lycoris Team · · 4 min read Primary keys identify a row, foreign keys link one table to another, and unique constraints just prevent duplicates. How the three differ in SQL.
The Lycoris Team · · 4 min read A monad is a wrapper type with rules for chaining operations that might fail, be async, or carry extra context — like Promise or Optional, generalized.
The Lycoris Team · · 4 min read A database deadlock happens when two transactions each wait on a lock the other holds. Why deadlocks occur, how databases detect them, and how to avoid them.
The Lycoris Team · · 5 min read Raft is a consensus algorithm that lets a cluster of servers agree on a shared state even when some nodes fail. How leader election and log replication work.
The Lycoris Team · · 4 min read Bit manipulation uses operators like AND, OR, XOR, and shifts to work directly on binary representations — the basics behind flags, masks, and fast math.
The Lycoris Team · · 5 min read Write-through writes to cache and store together, write-back delays the store write, write-around skips the cache on writes entirely. When to use each.
The Lycoris Team · · 4 min read A dead letter queue holds messages a system couldn't process after repeated retries, isolating failures so they don't block or silently vanish. How it works.
The Lycoris Team · · 4 min read An SBOM is a complete inventory of every component in a piece of software, including its dependencies. Why it matters for tracking vulnerabilities at scale.
The Lycoris Team · · 4 min read Star schema denormalizes dimensions into flat tables for fast queries; snowflake schema normalizes them to save space. How to choose for your warehouse.
The Lycoris Team · · 4 min read Amortized analysis measures the average cost of an operation over a sequence of calls, not its worst case. How dynamic array resizing gets O(1) amortized inserts.
The Lycoris Team · · 3 min read A container registry stores and distributes container images by content-addressed layers, letting Docker and Kubernetes pull only what's changed.
The Lycoris Team · · 3 min read Kafka is a durable, replayable log built for high-throughput streams; RabbitMQ is a traditional broker built for flexible routing and task queues.
The Lycoris Team · · 4 min read When two keys hash to the same slot, a hash table needs a collision strategy. Chaining and open addressing solve it differently — here's the tradeoff.
The Lycoris Team · · 4 min read Vacuuming reclaims space left by deleted and updated rows in databases like PostgreSQL, preventing bloat and transaction ID wraparound.
The Lycoris Team · · 4 min read API keys are static secrets tied to an app; OAuth tokens are short-lived, scoped, and tied to a specific user's consent. Here's when to use each.
The Lycoris Team · · 5 min read A segment tree answers range queries — sum, min, max — over an array in logarithmic time, and supports updates without rebuilding the whole structure.
The Lycoris Team · · 4 min read MVCC lets readers and writers work on a database concurrently without blocking each other, by keeping multiple versions of each row instead of locking it.
The Lycoris Team · · 4 min read Backtracking solves problems by building candidate solutions incrementally and abandoning any path that can't lead to a valid answer. How it works, with examples.
The Lycoris Team · · 4 min read The saga pattern coordinates a multi-step transaction across services using local commits and compensating actions instead of a distributed lock.
The Lycoris Team · · 4 min read A query optimizer turns declarative SQL into an execution plan by estimating the cost of alternative strategies. How that estimation works and how to read a plan.
The Lycoris Team · · 5 min read Union-find tracks a collection of disjoint sets and answers 'are these two items connected?' in near-constant time. How it works and where it's used.
The Lycoris Team · · 5 min read A foreign key constraint ties a column to a row in another table and blocks changes that would break that link. How referential integrity works in SQL.
The Lycoris Team · · 5 min read SQLite is a serverless, file-based SQL database compiled directly into an application. How it works, why it's everywhere, and when to reach for it.
The Lycoris Team · · 4 min read Topological sort orders the nodes of a directed acyclic graph so every dependency comes before what depends on it. How it works and where it's used.
The Lycoris Team · · 5 min read Two pointers walk a sorted array or string from both ends (or in tandem) to solve problems in one linear pass instead of nested loops.
The Lycoris Team · · 4 min read An LSM tree batches writes in memory and flushes them as sorted files on disk, trading read complexity for the fast, sequential writes many databases rely on.
The Lycoris Team · · 5 min read Two-phase commit coordinates a transaction across multiple databases with a prepare phase and a commit phase, trading availability for strong consistency.
The Lycoris Team · · 4 min read The sliding window technique tracks a moving subrange of an array or string, turning many O(n²) brute-force problems into a single O(n) linear pass.
The Lycoris Team · · 5 min read A read replica is a synced copy of a database that serves read queries, taking load off the primary. How replication lag and failover actually work.
The Lycoris Team · · 4 min read Partitioning splits a table within one database; sharding splits data across separate database instances entirely. Here's how each works and when to use them.
The Lycoris Team · · 5 min read A graph database stores data as nodes and relationships instead of tables, making deeply connected queries fast instead of a chain of costly joins.
The Lycoris Team · · 6 min read Dijkstra's algorithm finds shortest paths by exploring uniformly outward; A* reaches the same answer faster by using a heuristic to aim at the goal.
The Lycoris Team · · 4 min read A Merkle tree hashes data in pairs up to a single root hash, letting huge datasets be verified for integrity without downloading all of them.
The Lycoris Team · · 5 min read A digital signature uses a private key to prove a message's origin and integrity, and a public key lets anyone verify it — no shared secret required.
The Lycoris Team · · 4 min read A skip list is a layered linked list with shortcut pointers giving O(log n) search, insert, and delete — a simpler alternative to balanced trees.
The Lycoris Team · · 5 min read Greedy algorithms commit to the locally best choice at each step; dynamic programming weighs every subproblem. When each one actually works.
The Lycoris Team · · 4 min read A CTE is a named, temporary result set defined with WITH that you can reference elsewhere in a SQL query. How they work and when to use one.
The Lycoris Team · · 4 min read Red-black and AVL trees both keep binary search trees balanced, but trade off rebalancing cost against lookup speed differently. How each works.
The Lycoris Team · · 4 min read Optimistic locking checks for conflicts at write time; pessimistic locking blocks other writers up front. How each works and when to pick one.
The Lycoris Team · · 5 min read A SQL join combines rows from two tables based on a related column. How inner, left, right, and full outer joins differ, with examples.
The Lycoris Team · · 4 min read A quantum computer uses qubits in superposition and entanglement to explore many possible states at once, rather than one bit value at a time.
The Lycoris Team · · 4 min read A finite state machine models a system as a fixed set of states and the transitions between them. How FSMs work and where they show up in real software.
The Lycoris Team · · 4 min read A data lakehouse combines a data lake's cheap object storage with a data warehouse's transactional guarantees and schema. How the architecture works.
The Lycoris Team · · 4 min read Object, block, and file storage organize data differently and suit different workloads. How each one works and how cloud providers implement them.
The Lycoris Team · · 4 min read An LRU cache evicts the least recently used item first when it runs out of room, keeping the most useful data in memory. Here's how it's built.
The Lycoris Team · · 4 min read Write-ahead logging records changes to a log before applying them to a database, making crash recovery and replication possible. Here's how it works.
The Lycoris Team · · 4 min read Row-oriented databases store each record together on disk; columnar databases store each column together. The layout decides which workloads are fast.
The Lycoris Team · · 4 min read Recursion solves a problem by calling itself on smaller inputs; iteration solves it with a loop. Same results, different trade-offs in memory and clarity.
The Lycoris Team · · 4 min read A git worktree lets you check out several branches at once in separate folders, sharing one .git history without cloning the repo again.
The Lycoris Team · · 4 min read Isolation levels control how much of a concurrent transaction's uncommitted work another transaction can see, trading consistency for concurrency.
The Lycoris Team · · 4 min read Change data capture streams row-level inserts, updates, and deletes out of a database in real time, powering sync pipelines, caches, and event-driven systems.
The Lycoris Team · · 4 min read A B-tree is a self-balancing tree that keeps data sorted with logarithmic search, insert, and delete time — the structure behind most database indexes.
The Lycoris Team · · 5 min read Quicksort and mergesort are the two classic O(n log n) sorting algorithms — how they differ in memory use, stability, and worst-case behavior.
The Lycoris Team · · 4 min read Consistent hashing maps keys and nodes onto the same ring so adding or removing a server only reshuffles a small fraction of keys, not all of them.
The Lycoris Team · · 5 min read Graphs model networks of connected nodes; BFS and DFS are the two core ways to traverse them. How each works, and which to reach for.
The Lycoris Team · · 4 min read Stacks remove the most recent item first (LIFO); queues remove the oldest first (FIFO). How each works, their operations, and where they show up.
The Lycoris Team · · 5 min read The N+1 query problem turns one database request into hundreds by issuing a separate query per row. Here's how to spot it and fix it.
The Lycoris Team · · 5 min read Connection pooling reuses a fixed set of open database connections instead of opening a new one per request. How pools work and why they prevent overload.
The Lycoris Team · · 4 min read A trie stores strings by sharing common prefixes across tree branches, making prefix lookups and autocomplete fast. How it compares to hash tables and BSTs.
The Lycoris Team · · 4 min read OLTP systems handle many small, fast transactions like orders and logins; OLAP systems run large analytical queries across historical data for reporting.
The Lycoris Team · · 4 min read A heap is a tree-based structure that keeps the smallest or largest element at the root, enabling priority queues and heap sort in logarithmic time.
The Lycoris Team · · 4 min read A materialized view stores a query's result as physical data instead of recomputing it on every read. How it differs from a view, and when to use one.
The Lycoris Team · · 5 min read A Bloom filter is a compact data structure that tests whether an item might be in a set, using far less memory than storing the set itself.
The Lycoris Team · · 4 min read Memoization caches a function's return value by its input, skipping recomputation on repeat calls. How it works and when it actually helps.
The Lycoris Team · · 4 min read An idempotent operation produces the same result no matter how many times it runs. Why that matters for retries, payments, and reliable APIs.
The Lycoris Team · · 4 min read ACID — atomicity, consistency, isolation, durability — defines the guarantees a database transaction makes so concurrent, failure-prone operations stay correct.
The Lycoris Team · · 4 min read A linked list stores elements as nodes linked by pointers rather than contiguous memory, trading fast random access for cheap insertion and removal.
The Lycoris Team · · 4 min read Dynamic programming solves complex problems by breaking them into overlapping subproblems and caching results, avoiding redundant recomputation.
The Lycoris Team · · 4 min read An ORM lets you query a database using your programming language's objects instead of raw SQL. How they work, what they trade off, and when to skip one.
The Lycoris Team · · 4 min read Database normalization organizes tables to eliminate redundant data and update anomalies. The normal forms explained with a worked example.
The Lycoris Team · · 4 min read A binary search tree keeps every left descendant smaller and every right descendant larger than its parent. How lookups, inserts, and balance work.
The Lycoris Team · · 4 min read Database replication keeps copies of data on multiple servers for redundancy and read scaling, at the cost of consistency and lag tradeoffs.
The Lycoris Team · · 4 min read A hash table maps keys to array slots with a hash function for near O(1) lookups. How hashing, collisions, and resizing actually work under the hood.
The Lycoris Team · · 5 min read Database sharding splits one dataset across many servers so no single machine holds it all. How sharding works, how to pick a shard key, and the trade-offs.
The Lycoris Team · · 5 min read Big O notation describes how an algorithm's time or memory grows as input grows. The common classes, what they mean, and how to reason about them.
The Lycoris Team · · 4 min read A database index is a sorted data structure that lets the engine find rows without scanning the whole table. How indexes work, and when they help or hurt.
The Lycoris Team · · 4 min read Landed a summer tech internship in a new city? How to find short-term housing fast — and why SubLeaps, a verified .edu sublease marketplace, stands out.
The Lycoris Team · · 5 min read JSON Schema is a vocabulary for describing and validating the shape of JSON data. How schemas work, where they show up, and the keywords that matter.
The Lycoris Team · · 2 min read Getty Images will surface its licensed library inside ChatGPT's search experience under a multi-year deal with OpenAI — another step from lawsuits to licensing.
The Lycoris Team · · 4 min read Monoliths ship faster early; microservices buy independent scaling and team autonomy at the cost of distributed complexity. How to choose.
The Lycoris Team · · 3 min read Git is a distributed version control system that tracks changes to code and enables collaboration. Learn the core concepts and everyday workflow.
The Lycoris Team · · 3 min read China unveiled a $295 billion, five-year national AI infrastructure plan — one of the largest state AI commitments ever. Here's the scale and the strategic stakes.
The Lycoris Team · · 5 min read When should you rebase and when should you merge? A clear, example-driven breakdown of the trade-offs, plus a simple workflow you can adopt today.
The Lycoris Team · · 5 min read Platform engineering transforms DevOps into a product mindset, giving developers self-service golden paths so they can ship without becoming Kubernetes experts.
The Lycoris Team · · 7 min read A load balancer distributes traffic across servers to prevent overload and downtime. Layer 4 vs Layer 7, routing algorithms, health checks, and TLS.
The Lycoris Team · · 5 min read JSON and YAML represent the same data — the difference is syntax, strictness, and footguns. Where each format wins, and which to pick for configs and APIs.
The Lycoris Team · · 5 min read Noam Shazeer, a co-author of the Transformer paper that underpins modern AI, is leaving Google DeepMind for OpenAI — the AI talent war's latest marquee move.
The Lycoris Team · · 4 min read Apache Kafka is a distributed event-streaming platform built on a durable, append-only log. How topics, partitions, and consumers power real-time pipelines.
The Lycoris Team · · 2 min read On August 2, 2026, the EU gains real enforcement power over general-purpose AI models — fines, mandated mitigations, even recalls. What providers need to know.
The Lycoris Team · · 5 min read A growing movement wants apps that work offline, sync seamlessly, and keep your data yours. Here's what 'local-first' means and why developers are excited.
The Lycoris Team · · 3 min read Go is a compiled language from Google built for simplicity, fast builds, and easy concurrency — the language behind Docker and Kubernetes.
The Lycoris Team · · 3 min read An API is a defined contract that lets one piece of software talk to another. Learn what APIs are, how they work, and why modern software runs on them.
The Lycoris Team · · 4 min read Terraform lets you declare cloud infrastructure as code and provision it reproducibly across AWS, GCP, and Azure. How plan/apply, state, and modules work.
The Lycoris Team · · 2 min read At WWDC 2026, Apple unveiled 'Siri AI' — a ground-up redesign powered by Google's Gemini through a multi-billion-dollar partnership. Here's what changed and why.
The Lycoris Team · · 6 min read JSON is a lightweight text format for structured data — the default for APIs and config files. Syntax, examples, common mistakes, and why it beat XML.
The Lycoris Team · · 5 min read Supply chain attacks exploit your dependencies, not your code. Learn SBOMs, SLSA, and Sigstore to defend against them before a CVE drops.
The Lycoris Team · · 4 min read Serverless means deploying code without managing servers — the platform scales it and you pay per use. How it works and where it fits.
The Lycoris Team · · 4 min read SQL and NoSQL aren't rivals — they suit different shapes of data. How relational and non-relational databases compare, and how to pick.
The Lycoris Team · · 3 min read A REST API is a web API that follows a set of conventions built on HTTP. Learn how URLs, HTTP methods, status codes, and JSON fit together.
The Lycoris Team · · 5 min read Zig is a systems language built on radical explicitness — no hidden allocations, no macros, no preprocessor. Why developers are paying attention.
The Lycoris Team · · 6 min read RISC-V is a free, open instruction set architecture anyone can implement without royalties. How it works, why it matters, and where it's already winning.
The Lycoris Team · · 3 min read Python is a high-level, readable general-purpose programming language that dominates data science, AI, and web backends. Here's why it became so popular.
The Lycoris Team · · 5 min read Putting compute at the edge is old news — now the data is moving there too. Edge databases promise low latency everywhere, with some real trade-offs.
