The editorial team at Lycoris Technologies — covering tech news and writing hands-on tutorials.
The Lycoris Team · · 4 min read Git reflog records every place HEAD and branch tips have pointed, letting you recover commits that look lost after a reset, rebase, or deleted branch.
The Lycoris Team · · 4 min read A roaring bitmap is a compressed bitmap format that splits data into chunks and picks the best internal representation for each — fast and space-efficient.
The Lycoris Team · · 4 min read PgBouncer sits between clients and Postgres, reusing a small pool of real connections. Session, transaction, and statement modes trade features for scale.
The Lycoris Team · · 4 min read Memoization caches results top-down via recursion; tabulation builds a table bottom-up with loops. Same technique, opposite direction, different tradeoffs.
The Lycoris Team · · 4 min read Cardinality is how many distinct values a column has. Low-cardinality columns make poor index candidates because the database still scans most of the table.
The Lycoris Team · · 4 min read Ingress is traffic entering a network or system; egress is traffic leaving it. The distinction shapes firewall rules, cloud billing, and security posture.
The Lycoris Team · · 6 min read Apple's September 9 'Surprise and shine' event is set to unveil the iPhone 18 Pro and a first foldable iPhone — the first launch under new CEO John Ternus.
The Lycoris Team · · 5 min read Biometric authentication verifies identity using fingerprints, faces, or other traits — here's how enrollment, matching, and liveness checks work.
The Lycoris Team · · 4 min read Manacher's algorithm finds the longest palindromic substring in linear time by reusing symmetry from palindromes already found, avoiding redundant checks.
The Lycoris Team · · 5 min read The dining philosophers problem is a classic model of deadlock and starvation: five philosophers, five forks, and a resource-sharing rule that can lock up.
The Lycoris Team · · 4 min read Rolling back reverts to the last known-good deploy; rolling forward ships a fix on top of the bad one. How to choose, and why database changes complicate both.
The Lycoris Team · · 4 min read Quorum consensus lets distributed databases tune consistency and availability by requiring reads and writes to touch overlapping subsets of replicas.
The Lycoris Team · · 4 min read The Z-algorithm builds a Z-array in linear time to find every occurrence of a pattern in a text — a fast alternative to naive string search.
The Lycoris Team · · 5 min read Conventional Commits structures commit messages as type(scope): description so tools can auto-generate changelogs and version bumps from git history.
The Lycoris Team · · 5 min read PostgreSQL's built-in full-text search uses tsvector documents and tsquery queries matched with @@, indexed with GIN for speed at scale.
The Lycoris Team · · 5 min read ISR lets a static page be rebuilt in the background after deploy, on a timer or on demand, without a full site rebuild. How it works and its tradeoffs.
The Lycoris Team · · 4 min read Git hooks are scripts that run automatically at points in the Git workflow, like before a commit or push. How they work and when to use them.
The Lycoris Team · · 5 min read Terraform's state file maps your config to real infrastructure. How it works, why remote state and locking matter, and what causes state drift.
The Lycoris Team · · 4 min read An abstract syntax tree represents source code's grammatical structure as nodes a compiler, linter, or formatter can walk and transform programmatically.
The Lycoris Team · · 5 min read Floating-point numbers can't represent most decimals exactly in binary — that's why 0.1 + 0.2 gives 0.30000000000000004, and what IEEE 754 actually stores.
The Lycoris Team · · 4 min read Load testing measures how a system behaves under expected and peak traffic, revealing bottlenecks and capacity limits before real users do.
The Lycoris Team · · 5 min read CSRF forges a request using a victim's login session; XSS runs the attacker's own code inside the victim's browser. Different mechanisms, different fixes.
The Lycoris Team · · 4 min read A database view is a saved SQL query that behaves like a table — simplifying complex joins and restricting access, without storing the data twice.
The Lycoris Team · · 5 min read Binary search finds a value in a sorted array in O(log n) time by repeatedly halving the search space. How it works, why it needs sorted input, and common pitfalls.
The Lycoris Team · · 4 min read Vim and Emacs are the two long-lived terminal editors, built on opposite philosophies — modal editing vs an extensible Lisp environment. How they actually differ.
The Lycoris Team · · 4 min read Breadth-first search explores a graph level by level using a queue; depth-first search follows one path as far as it goes using a stack. When to use each.
The Lycoris Team · · 5 min read A clustered index determines the physical row order on disk; a non-clustered index is a separate lookup structure. How they differ and when to use each.
The Lycoris Team · · 4 min read Container image scanning checks a container's layers for known vulnerabilities and secrets before it ships. How it works and where to run it.
The Lycoris Team · · 4 min read A headless CMS stores and serves content through an API, with no built-in templating or frontend. Why teams split content management from presentation.
The Lycoris Team · · 4 min read Read-your-writes consistency guarantees a client sees its own writes immediately, even when other clients might not yet. How it's implemented.
The Lycoris Team · · 4 min read TypeScript's moduleResolution setting decides how import paths map to files. How node10, node16, and bundler resolution differ, and which to pick.
The Lycoris Team · · 4 min read A splay tree is a self-adjusting binary search tree that rotates recently accessed nodes to the root, giving fast amortized access to hot data.
The Lycoris Team · · 5 min read Two-phase commit locks resources until every node agrees to a transaction; the saga pattern trades that guarantee for availability using compensating steps.
The Lycoris Team · · 5 min read Functional programming builds programs from pure functions and immutable data; OOP bundles state and behavior into objects. Key differences explained.
The Lycoris Team · · 4 min read The halting problem proves no algorithm can determine, for every program and input, whether that program eventually stops. Why this limit is unavoidable.
The Lycoris Team · · 5 min read The traveling salesman problem asks for the shortest route visiting every city once — a classic NP-hard problem with major real-world stakes.
The Lycoris Team · · 4 min read HTTP methods signal intent — read, create, replace, update, or remove — and that intent determines caching, idempotency, and safety guarantees.
The Lycoris Team · · 4 min read Git stash saves uncommitted work to a hidden stack so you can switch branches cleanly. How stash, pop, apply, and stash branches actually work.
The Lycoris Team · · 4 min read Bloom filters and cuckoo filters both test set membership in constant space, but only one supports deletion. How they work and when to pick each.
The Lycoris Team · · 5 min read A Kubernetes CRD (CustomResourceDefinition) extends the API with new resource types, letting the cluster manage custom objects like native ones.
The Lycoris Team · · 4 min read An availability zone is an isolated data center (or cluster of them) within a cloud region, designed so one zone's failure doesn't take down another.
The Lycoris Team · · 4 min read Common table expressions and subqueries both let you build a query from smaller pieces, but they differ in readability, reuse, and optimizer behavior.
The Lycoris Team · · 4 min read B-trees update data in place for fast, predictable reads; LSM-trees batch writes sequentially for higher write throughput. How databases pick.
The Lycoris Team · · 5 min read A distributed lock coordinates exclusive access to a shared resource across multiple processes or machines, preventing race conditions in distributed systems.
The Lycoris Team · · 4 min read Natural keys use real-world data as a primary key; surrogate keys use a generated ID. Here's how to choose, with the trade-offs of each.
The Lycoris Team · · 5 min read Just-in-time (JIT) compilation translates code to native machine instructions while a program runs, trading startup time for peak execution speed.
The Lycoris Team · · 4 min read A Turing machine is a simple abstract model of computation — a tape, a head, and a set of rules — that defines what it means for something to be computable.
The Lycoris Team · · 4 min read Git cherry-pick applies one commit's changes onto a different branch without merging the whole branch. How it works, and when to use it instead of merging.
The Lycoris Team · · 4 min read Reservoir sampling picks a uniform random sample from a stream of unknown length using constant memory, without knowing the size in advance.
The Lycoris Team · · 4 min read Radix sort and counting sort can beat comparison sorts by never comparing elements at all — sorting integers in linear time under the right conditions.
The Lycoris Team · · 4 min read Multi-stage builds let a Dockerfile use one stage to compile code and a separate, minimal stage to ship it — cutting image size and attack surface.
The Lycoris Team · · 4 min read JSONB stores JSON in PostgreSQL as a parsed, indexable binary format instead of raw text. How it works, and when to reach for it.
The Lycoris Team · · 4 min read The N+1 query problem fires one query per row instead of one query total, quietly turning a fast page into hundreds of round trips. How to spot and fix it.
The Lycoris Team · · 4 min read Multi-tenancy lets one system serve many customers from shared infrastructure. The isolation models that keep tenants' data and performance separate.
The Lycoris Team · · 4 min read A suffix array sorts every suffix of a string into one compact index, enabling binary-search pattern matching without a full suffix tree.
The Lycoris Team · · 5 min read Hash joins, nested loop joins, and merge joins are the three ways a database executes a JOIN — here's when the query planner picks each one.
The Lycoris Team · · 5 min read Unit tests check one function in isolation, integration tests check pieces working together, and end-to-end tests check the whole system end to end.
The Lycoris Team · · 4 min read A hash index gives O(1) equality lookups but no range scans; a B-tree supports both. Here's how the two database index types actually differ.
The Lycoris Team · · 5 min read A monotonic stack keeps elements in strictly increasing or decreasing order, solving next-greater-element and range problems in linear time.
The Lycoris Team · · 4 min read Bellman-Ford handles negative edge weights and detects negative cycles; Dijkstra is faster but can't. When to use each shortest-path algorithm.
The Lycoris Team · · 4 min read A blameless postmortem examines an incident's causes without assigning fault, so teams surface real fixes instead of hiding mistakes.
The Lycoris Team · · 4 min read Floyd-Warshall finds shortest paths between every pair of nodes in a weighted graph using dynamic programming — how the recurrence works and when to use it.
The Lycoris Team · · 3 min read CI/CD automates building, testing, and shipping code on every change. How continuous integration and continuous delivery/deployment fit together.
The Lycoris Team · · 4 min read An internal developer platform packages infrastructure into self-service tools so developers ship without filing tickets or learning Kubernetes.
The Lycoris Team · · 4 min read The master theorem gives a direct formula for the time complexity of divide-and-conquer recurrences, skipping recursion-tree analysis by hand.
The Lycoris Team · · 4 min read The Rabin-Karp algorithm finds substrings by hashing, sliding a window in O(1) time per step instead of rehashing from scratch. Here's how it works.
The Lycoris Team · · 5 min read Prim's and Kruskal's both build a minimum spanning tree but grow it differently — one from a single node, the other by sorted edges. Here's how each works.
The Lycoris Team · · 5 min read Divide and conquer solves problems by splitting them into smaller subproblems, solving each recursively, and combining the results.
The Lycoris Team · · 4 min read A composite index spans multiple columns in a fixed order, speeding up queries that filter or sort on that combination. How column order changes everything.
The Lycoris Team · · 4 min read Vitest and Jest share a similar API, but Vitest's Vite-based architecture makes it faster with native ESM. How the two test runners compare.
The Lycoris Team · · 4 min read TCP guarantees ordered, reliable delivery via a handshake; UDP sends packets with no such guarantee but far less overhead. Where each one fits.
The Lycoris Team · · 5 min read Denormalization trades write-time consistency for read-time speed by duplicating data — the right call once joins become your bottleneck.
The Lycoris Team · · 4 min read git bisect finds the exact commit that introduced a bug by binary-searching your commit history, cutting the search space in half each step.
The Lycoris Team · · 4 min read Tail call optimization reuses a function's stack frame for its final call instead of pushing a new one, turning some recursion into constant stack space.
The Lycoris Team · · 4 min read Cache-aside puts the application in charge of loading cache misses; read-through delegates that job to the cache itself. How each pattern works.
The Lycoris Team · · 4 min read A database cursor is a pointer that lets you fetch a query's result set one row at a time instead of all at once. How cursors work and when to use them.
The Lycoris Team · · 4 min read Point-in-time recovery restores a database to any moment between backups by replaying transaction logs, undoing bad deploys and accidental deletes.
The Lycoris Team · · 3 min read Docker Compose defines multiple containers, networks, and volumes in one YAML file so you can start a whole application stack with a single command.
The Lycoris Team · · 4 min read Amdahl's Law says a program's speedup from parallelizing is capped by the fraction that must stay sequential — no matter how many cores you add.
The Lycoris Team · · 4 min read HyperLogLog is a probabilistic algorithm that estimates the number of distinct items in a huge dataset using only a few kilobytes of memory.
The Lycoris Team · · 4 min read GROUP BY collapses rows into groups for aggregation; HAVING filters those groups afterward. How the two clauses differ and where each runs in query order.
The Lycoris Team · · 4 min read A bitmap index uses a bit array per distinct value to speed up queries on low-cardinality columns, and combines multiple filters with fast bitwise AND/OR.
The Lycoris Team · · 4 min read A Count-Min Sketch is a probabilistic data structure that estimates item frequencies in a stream using fixed memory, trading exactness for space.
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.
