Blog

Recording technical learnings and daily insights.

2026-11-09System DesignDistributed SystemsDatabaseAlgorithmsAPI DesignInteractive

Designing Instagram's Grid Reordering: User-Defined Order in a System Built on Chronology

Instagram began rolling out grid reordering to everyone in June 2026. Using it as a case study, this article designs user-defined ordering for a large service that has always been chronological: the data model, sort-key algorithms, concurrent updates, pagination, caching, and backward compatibility, with code I ran to check the key numbers.

2026-11-02Agent Host ProtocolAI AgentProtocolVS CodeJSON-RPCDistributed SystemsArchitecture

Reading the Agent Host Protocol — A State-Synchronization Protocol for Sharing One Agent Session Across Many Screens

The Agent Host Protocol (AHP) v1.0.0 behind VS Code's Agent Host shares one agent session across many screens by treating it as replicated state that the host orders: clients apply their own operations immediately and treat the host's echo as confirmation. This article, written for client and host implementers, draws on the spec, the canonical reducers, the SDKs, and VS Code's implementation to cover channels and actions, reconnection via serverSeq, write-ahead optimistic updates, why reducers do not enforce invariants, which operations are safe to resend, client-provided tools, authentication and security, and how AHP differs from ACP, MCP, and AG-UI.

2026-11-02AILLMAI InfrastructureEconomicsSemiconductorsOpenAIAnthropicMicrosoft

Where Is the AI Industry Heading? — The Causal Chain from Capital to Free Cash Flow, 2023 vs 2026

Using Anthropic's S-1, the September-quarter 10-Qs of Microsoft, Amazon and Alphabet, and the WSJ report that OpenAI's latest round raised less than half its target, this article traces the causal chain from capital to free cash flow and compares 2023 with 2026. A frontier AI lab's next giant round now depends on proof of unit economics rather than on expectations about capability, and the most predictable axes to scale next are reinforcement learning and inference-time compute on verifiable tasks, together with effective compute per dollar and per watt. The binding constraints have moved from GPUs to power, data centres and memory; the article also covers low precision, process nodes, HBM, advanced packaging and model architecture with their next moves and limits through 2030, and how Microsoft's chain differs from OpenAI's.

2026-10-16LLMLLM-as-JudgeEvaluationMLOpsHuman-in-the-LoopRecommender SystemsEnterprise AIPaper Reading

Operating an LLM Judge Over Its Lifetime — Netflix's Lifecycle for Recommendation-Explanation Judges and an Enterprise Implementation Framework

A technical reading of Netflix's "The Lifecycle of LLM-as-a-Judge for Large-Scale Recommendation Explanations": the four phases of birth, training, deployment and monitoring, RART (rubric tuning that aligns the judge's reasons as well as its labels), one judge serving as both gate and critic, and drift detection measured against human disagreement. Our analysis shows that retries amplify the judge's misses when those misses are independent across attempts, and that the paper's drift rule, applied literally, is biased in the raters' favor; the article then turns the lifecycle into a framework for enterprises: charter, key decisions, maturity model, roadmap and checklists.

2026-10-09OntologyMicrosoft FabricFabric IQKnowledge GraphDDDData IntegrationSemantic Layer

What Is an Ontology, Really? — Testing the “View Where You Cannot Write the JOIN” Hypothesis, from Academic Definitions to Microsoft Fabric IQ

Is an ontology a set of business descriptions attached to table definitions, or a semantic mapping between different data sources? Drawing on definitions from philosophy and knowledge engineering, GAV/LAV and OBDA from data integration theory, and DDD’s bounded contexts and context maps, this essay finds that descriptions and mappings both hang off shared concepts, and that an ontology’s mapping half is a GAV-style view over the sources. The Microsoft Fabric IQ ontology works this way without holding data, and leaves record matching, normalisation, rule execution, agreement and formal reasoning to other tools and the organisation.

2026-10-01AlgorithmsStable MatchingMarket DesignGame TheoryInteractive

The Gale–Shapley Algorithm — Why Deferring Acceptance Produces Stable Matchings, Shown by Running It

Deferred acceptance, the Gale–Shapley algorithm behind residency matches and school choice, always stops at a stable matching, and the one it returns is the best stable matching for the proposing side. Proofs and interactive demos show why, and cover the lattice of stable matchings, strategic misreporting, random markets and the many-to-one extension.

2026-09-30BlazorAG-UI.NETMicrosoft.Extensions.AIAgentic UIArchitectureAPI Design

What Should an Agentic UI Runtime Abstract? — Reading the Boundaries Drawn by Blazor's AI Components and the AG-UI .NET SDK

When AI agents and humans operate on the same application state, what should a UI runtime abstract? Read as an answer to that question, Blazor's new AI components and the AG-UI .NET SDK give names and boundaries to who commits what, and when: UIAgent, ContentBlock, IInteractiveBlock, and AgentState introduce identity and lifecycle, suspension points, where side effects run, how state is committed, and an update log with replay, while rendering is left to the app. Merging concurrent edits and replaying human decisions are not abstracted yet, and the split between interfaces and classes can be explained by how each boundary is meant to grow.

2026-09-14TypeScriptType SystemSoftware DesignInteractive

Practical Algebraic Data Types — Modeling States and Errors, and Trade-offs with Inheritance

Replace confusing flags and nullable fields with explicit states so the compiler catches contradictory combinations and missing cases. Runtime checks remain for external input, authorization, and concurrency, and interfaces often suit interchangeable implementations better than unions. Includes four interactive experiments.

2026-09-11AlgorithmsDynamic ProgrammingCompetitive ProgrammingInteractive

How to Think in Dynamic Programming — Folding Brute Force into States

Dynamic programming as a design procedure: start from brute force and keep in the state only the information that affects future decisions. Running demos trace the path from brute force to a recurrence, followed by the standard patterns, faster transitions, and uses in production systems.

2026-09-10RPCRESTgRPCAPI DesignHTTPProtobufObservabilitySecurity

RPC vs REST — Rethinking the API Design Fork from the Wire Up

What actually separates RPC from REST: HTTP/2 frames and protobuf bytes, contracts and schema evolution, error design, caching, authn/authz, observability, and the operational traps.

2026-08-31GoConcurrencyBackpressureArchitecture

Where Go Concurrency Helps in Practice — When to Choose Channels, and Production Patterns

In production Go servers, concurrency is mainly about overlapping wait time and controlling lifecycle, and channels mainly carry timing and ownership. For developers who know goroutine and channel syntax but not when to use them at work: the four motivations for concurrency, channels versus mutexes, and production patterns — fan-out, bounded concurrency, backpressure, graceful shutdown, ownership serialization, batching, and pub/sub — with code verified on Go 1.27.

2026-08-25GitHub CopilotCopilot SDKArchitectureScalabilityAgentDistributed Systems

Running the GitHub Copilot SDK Server-Side — Can It Be Designed Stateless?

Can a backend built on the GitHub Copilot SDK be stateless enough to scale horizontally? The API tier can; the runtime cannot. This article covers where the runtime keeps state, session persistence, the single-writer constraint, resume cost, streaming, and capacity planning.

2026-08-25DuckDBDatabaseOLAPVectorized ExecutionStorage EngineC++

Inside DuckDB — Vectorized Execution, Morsel Parallelism and a Single-File Store, Read from the Code

How does DuckDB, often called 'the SQLite of OLAP', run fast analytics entirely inside your process? Through design decisions at every layer, from vectorized execution, push-based pipelines and morsel-driven parallelism to columnar storage, MVCC and the ART index, each traced to the source code that implements it.

2026-08-25LLMLoad BalancingDistributed SystemsAgentsSchedulingInteractive

Load Balancing LLM Calls — From Why Round Robin Fails to KV-Cache-Aware Routing

Round robin fails for LLM calls because per-request cost varies 100x and replicas hold prefix caches. From client retries to engine batching, every layer of an LLM or agent stack trades cache locality against load balance on stale signals before the first token ships — with a simulator you can run in the page.

2026-08-25DatabasePostgreSQLQuery OptimizationParserExecution EngineStorage

How SQL Reaches Bytes on Disk — Building a Query Engine From Scratch

Tracing a single SELECT statement all the way down — lexing, parsing, binding, logical planning, cardinality estimation, cost-based optimization, physical planning, Volcano execution, access methods, the buffer pool, slotted pages, and finally pread(2) — by writing the code that does it. Along the way: why sorting degrades gracefully past work_mem while hashing falls off a cliff, and why a parallel plan wants its Gather as high in the tree as possible.

2026-08-03AILLMAI AgentEvaluationAI InfrastructureEconomicsMicrosoft

The Frontier Moves from Models to Systems: The Cost-to-Outcome Curve and Microsoft's Vertical Integration

Read against Nadella's two essays, the FY26 results, and the restructured OpenAI agreement, Microsoft AI's 'Optimizing the frontier performance curve' makes the whole system, not a single model, the unit of the frontier; the system's advantage comes from varied task difficulty and cheap verification. The essay works through the economics of outcome per dollar (cascade break-even, model independence, owning the learning loop, A100s and depreciation) and what the argument does for Microsoft's vertical integration strategy.

2026-07-13NLPEvaluationBLEUROUGEMachine TranslationMetrics

Surface-Matching Metrics in NLP — Definitions, What They Measure, and How to Choose

Seven design families of surface-matching metrics—whole-sequence identity, bag/set overlap, edit distance, n-grams, subsequences, alignment, and corpus-weighted consensus—compared by definition, what each measures, aggregation, and limitations.

2026-07-13AlgorithmsSchedulingOperating SystemsLLMInteractive

A Genealogy of Task Scheduling — From FIFO to Fair Queueing and LLM Inference

The right answer to “what should run next?” depends on whether mean delay, responsiveness, deadlines, or fairness comes first. This guide traces FCFS, SJF, Round Robin, EDF, CFS, WFQ, SFQ, DRR, and LLM-oriented VTC by objective, mechanism, and assumptions, and shows with a simulator why SFQ suits LLM request admission when output length is unknown.

2026-07-10AIAgentAgent SkillsLLMOptimizationResearch

Automatic Optimization of Agent Skills — Applying Research on Generation, Distillation, Routing, and Compression in Practice

The strongest evidence in research on generating and improving Agent Skills from execution history comes from execution-verified candidate search. This review covers text-space optimization, trajectory distillation, reinforcement learning, routing, composition, compression, and safety, and turns the evidence into an evaluation design and operating principles for production use.

2026-07-01AIAgentAgent HarnessCodexClaude CodeGitHub CopilotOpen Source

Agent Harness Landscape 2026 — Comparing Copilot, Codex, Claude Code, Cursor, and OSS on 12 Axes

Which responsibilities GitHub Copilot, OpenAI Codex, Anthropic Claude Code, Cursor, Cline, Aider, OpenHands, and SWE-agent/mini-SWE-agent take on and which they leave to users, compared across execution locus, orchestration, extensibility, permissions, context strategy, long-running work, multi-agent design, Git/PR integration, observability, enterprise governance, OSS transparency, and evaluation readiness.

2026-07-01LLMChatbotEvaluationLLM-as-JudgeNLPQuality Assurance

How to Measure Output Variance in LLM Chatbots: A Seven-Layer Taxonomy and Evaluation Design

Output variance (differences that appear even when the model, parameters, prompts, and other generation conditions are fixed) can be classified into seven layers: contract, surface, lexical, structural, information-selection, semantic, and pragmatic. No single similarity score decides whether a response is acceptable; this article combines exact match, edit distance, ROUGE-L, embedding similarity, NLI, and LLM-as-judge into an evaluation design that judges responses against ground truth.

2026-06-11AIAgentMicrosoft Agent FrameworkAgent HarnessC#.NETTools

The Same Idea with Microsoft Agent Framework — Building a Document Review Agent by Just Adding Tools with the Agent Harness

The document review agent from the GitHub Copilot SDK article leaves orchestration to the runtime and just adds tools; we rebuild it in C# with Microsoft Agent Framework's Agent Harness (HarnessAgent). HarnessAgent sets up an autonomous agent with planning, todos, context compaction, and tool approval in one line. The design difference with the most effect is that capability is narrowed at configuration time rather than by approving operations at runtime.

2026-06-11AIAgentMemoryMicrosoft Agent FrameworkPythonC#LLM

Designing Agent Memory — A Practical Guide to Short-Term and Long-Term Memory with Microsoft Agent Framework

Agent memory is an architecture the application designs, not a capability of the model. This guide classifies it using cognitive science and two research surveys, then implements short-term and long-term memory in Python and C# with Microsoft Agent Framework's AgentSession, ContextProvider, and ChatHistoryProvider.

2026-06-11Conversation UXLLM AgentEvaluationVoice AIDialogue SystemsLLM-as-JudgeHCI

How to Evaluate Conversation UX: A MECE Framework for Agent–Human Dialogue Across Structure, Correctness, and Goodness

A systematic framework for evaluating the conversation UX of LLM-backed agents. We classify the evaluation rules MECE across three separable quality axes — structure, correctness, and goodness — plus a safety constraint axis, and separate what can be measured deterministically from what cannot. Drawing on research on human turn-taking, we show that in voice, unlike text, response timing dominates the experience.

2026-06-11AIAgentGitHub CopilotSDKTypeScriptTools

Letting Go of Orchestration — Building a Document Review Agent by Just Adding Tools with the GitHub Copilot SDK

Instead of writing the agent's planning and tool-calling loop (its orchestration) yourself, hand it to the GitHub Copilot SDK. We build a document review agent by passing in the operations a review needs as tools, and add permission control, an SSE server, and a UI. In exchange, the runtime decides the procedure: the steps aren't guaranteed, testing and cost prediction get harder, and you have to design the defenses against untrusted documents yourself.

2026-04-18AI AgentLLMClaude CodeArchitecturePaper ReadingMCPContext Engineering

The Design Space of a Production AI Agent — Harness-Centric Design in Claude Code's 512K Lines

A walkthrough of arXiv:2604.14228, 'Dive into Claude Code'. Claude Code wraps a simple while loop in a deterministic harness that makes up an estimated 98.4% of its code. The harness layers permission checks, compacts context in stages, tiers extensions by context cost, isolates subagents, and persists sessions append-only. For teams building AI agent products, the lesson is that most of the design space lies outside the model.

2026-04-17LinuxKernelio_uringepollAsync I/O

io_uring and epoll — How Linux Asynchronous I/O Evolved and How the Kernel Implements It

How Linux async I/O went from select and poll through epoll to io_uring, cutting syscalls and copies at each step, explained through the kernel's data structures and source code.

2026-04-17Vector DatabaseANNHNSWEmbeddingRAG

Vector Database Internals — Algorithms for Approximate Nearest Neighbor Search

How the approximate nearest neighbor (ANN) search at the core of vector databases works, from distance metrics through IVF, Product Quantization, HNSW, and DiskANN, following the papers and implementations such as FAISS.

2026-04-15AG-UIAIProtocolMicrosoft Agent FrameworkPython

AG-UI Protocol Explained — Implementing the Standard Protocol Between Agents and Users with Microsoft Agent Framework

AG-UI (Agent-User Interaction Protocol) standardizes communication between agents and user-facing apps as a stream of typed events, so a frontend that implements it can work with any AG-UI backend. This article covers its architecture, events, middleware, and state synchronization, with implementation examples in Microsoft Agent Framework.

2026-04-13Graph TheoryCommunity DetectionNetwork ScienceHigher-OrderDynamic Networks

Community Detection Part 2 — Higher-Order Structures, Dynamic Networks, and the Frontier

Community detection methods for structure that edge density misses: higher-order (motif-based) detection, tracking communities in dynamic networks, and multiplex network analysis, presented in the order the research developed, with interactive visualizations.

2026-04-13AIAgentWorkflowC#.NETMicrosoft Agent Framework

Agentic Workflow Deep Dive — From Concepts to C# Implementation with Microsoft Agent Framework

How Agentic Workflows differ from traditional automation and chatbots, how the Sequential, Concurrent, Handoff, Writer-Critic loop, and other patterns coordinate agents, and how to implement them in C# with Microsoft Agent Framework.

2026-04-13Graph TheoryCommunity DetectionAlgorithmsNetwork Science

Community Detection — The Science of Finding Hidden Groups in Graphs

The history and main algorithms of community detection in graphs, why the problem is ill-defined, where detection becomes impossible, and how to choose a method, with interactive visualizations.

2026-04-13GraphRAGRAGKnowledge GraphLLMC#Agent Framework

GraphRAG in Depth: Retrieval-Augmented Generation with Knowledge Graphs

How Microsoft Research's GraphRAG uses a knowledge graph and community reports to answer cross-document and dataset-wide questions that vector-search RAG handles poorly, how Leiden community detection and Global/Local/DRIFT Search work, and how to sketch the pipeline in C# with Microsoft Agent Framework.

2026-04-13MCPAIProtocolArchitecture

Model Context Protocol (MCP) Deep Dive — From Architecture to MCP Apps

How the Model Context Protocol (MCP) connects AI applications to external systems under the current 2026-07-28 specification: the Host/Client/Server architecture, the three server primitives (Tools, Resources, Prompts), the transport layer, client features (Sampling, Elicitation), and the MCP Apps extension, with implementation examples from microsoft/mcp-interactiveUI-samples.

2026-04-13Graph TheoryCommunity DetectionStreaming AlgorithmsNetwork ScienceDynamic Graphs

Streaming Community Detection — Updating Communities as Edges Arrive and Disappear

How community structure can be updated incrementally when edges arrive and are removed one at a time: the research history and recent work, centered on TILES, delta-screening Louvain, LabelRankT, and other representative algorithms.

2026-04-12VMPythonJavaJITRuntime

Inside Bytecode VMs — From Interpreters to JIT Compilers

How bytecode virtual machines such as CPython and the JVM work: compiling source code to bytecode, stack machines vs register machines, interpreter implementation patterns, and JIT compilers that optimize code at runtime.

2026-04-11Distributed SystemsMapReduceBig DataSystems Design

How MapReduce Works: Large-Scale Distributed Processing with Two Functions

Why Google built MapReduce in 2004, how its programming model and execution flow work, how it tolerates failures, how Hadoop implements it, and which systems came after it.

2026-04-09AlgorithmsProbabilityPageRankMarkov Chain

Random Walks — From a Drunkard's Stagger to PageRank

Whether a random walk returns to its start depends on the dimension. This article goes from 1D recurrence to Markov chains and stationary distributions on graphs, and to PageRank, which applies that stationary distribution to the web.

2026-04-08AlgorithmGraphBFSDFSDijkstra

Graph Traversal Algorithms — How to Invent BFS, DFS & Dijkstra from Scratch

BFS, DFS, and Dijkstra follow from a visited record and a choice of where to take the next vertex from: a queue, a stack, or a priority queue. Starting without knowing the algorithms, this article builds all three from the problem.

2026-04-06Workflow EngineEvent SourcingState MachinePythonArchitecture

Building an Event-Driven Workflow Engine from Scratch

How workflow engines carry processes through crashes, explained by implementing event sourcing, a state machine, task queues, and deterministic replay from scratch in Python.

2026-04-06MiddlewareDesign PatternsPythonWeb FrameworkArchitecture

Understanding the Middleware Chain by Building One in Python

Express.js's next(), Django's get_response, and ASP.NET Core's pipeline share one pattern: the middleware chain. Building one from scratch in Python shows that next is the rest of the chain composed into a single function, why registration order changes behavior, and how short-circuiting works.

2026-04-06ORMDesign PatternsPythonDatabaseArchitecture

ORM Internals — Building an Object-Relational Mapper from Scratch in Python

Build a small ORM in Python — metadata definitions, SQL expression trees, Identity Map, Unit of Work, and lazy loading — to see how SQLAlchemy, Django ORM, and EF Core generate SQL and where their performance pitfalls come from.

2026-04-05ASP.NET Core.NETArchitectureMiddlewareDependency Injection

Inside ASP.NET Core — From Request Arrival to Response

How ASP.NET Core handles a request from arrival to response: the hosting model, middleware pipeline, DI container, routing, filter pipeline, and other internals, explained with simplified code and diagrams.

2026-04-05.NET Aspire.NETCloud NativeDistributed SystemsObservability

.NET Aspire Deep Dive: From the App Model to Deployment Manifests

How .NET Aspire works internally: the App Model, local orchestration by DCP, service discovery, health checks, telemetry, custom resources, and deployment manifests.

2026-04-04Programming ParadigmsFunctionalOOPComputer ScienceInteractive

The Lineage of Programming Paradigms — From Imperative to Functional to Multi-Paradigm

The theoretical origins, ways of framing problems, and code examples of seven programming paradigms (imperative, declarative, functional, object-oriented, logic, reactive, and concurrency-oriented), with diagrams and interactive demos.

2026-04-04TestingPythonSoftware EngineeringArchitectureInteractive

Inside Test Frameworks — Designing and Building a Test Runner from Scratch

What do test frameworks like pytest and unittest do between finding your tests and reporting the results? A small test runner built in Python shows each step: discovery by filename patterns, collection by importing modules, setup and teardown hooks, assertions that raise exceptions, mocks that replace attributes, and swappable reporters.

2026-04-03AIAgentMicrosoftPython.NETLLM

Microsoft Agent Framework Internals — From the Agent Execution Model to the Workflow Engine

How Microsoft Agent Framework is put together: the overall structure, the run() execution flow, tools, middleware, sessions, and the workflow engine, walked through with the Python source code.

2026-04-03Design PatternsC#GoTypeScriptSoftware Architecture

The Options Pattern: Building Configuration with Anonymous Functions

How the Options Pattern used in ASP.NET Core and Go works: the problem it solves, ASP.NET Core internals, implementations in Go, C#, TypeScript, Rust, and Python, and when to choose it over Builder and similar patterns.

2026-04-02LLMTransformerNLPDeep LearningInteractive

The Architecture and Evolution of Large Language Models — From Transformer to ChatGPT, with Interactive Diagrams

LLMs generate text by repeatedly predicting the next token. This overview traces language models from Word2Vec to GPT-4 and uses interactive diagrams to show how tokenization, the Transformer, self-attention, text generation, and RLHF work.

2026-04-02Search EngineInverted IndexTF-IDFInformation RetrievalData Structures

How Search Engines Work — Understanding Inverted Indexes and TF-IDF with Interactive Diagrams

A search engine splits text into tokens, uses an inverted index to find candidate documents without scanning every document, and ranks them with TF-IDF or BM25. Interactive diagrams walk through each step.

2026-04-01Software EngineeringArchitectureDesign Patterns

Libraries vs Frameworks — Understanding Inversion of Control

Your code calls a library, while a framework calls your code. Code examples show how this Inversion of Control (IoC) separates the two.

2026-04-01Type SystemTypeScriptGoRustInteractive

A Deep Dive into Type Systems — What Static Typing Protects You From

Static vs dynamic typing, structural vs nominal typing, type inference, generics, and null safety, compared across TypeScript, Go, Rust, Java, and Python with interactive diagrams.

2026-03-31Asyncasync/awaitEvent LoopCoroutineJavaScriptPythonRust

Inside async/await — Event Loops, Coroutines, and Runtime Mechanics

Behind async/await, a runtime suspends a function at each await and resumes it when the awaited I/O completes, without blocking the thread. This article compares how JavaScript's event loop, Python's asyncio, and Rust's poll-based Futures do this.

2026-03-31DatabaseIndexB+ TreeLSM-TreeData Structures

How Database Indexes Work — Inside B+ Trees and LSM-Trees

How indexes speed up queries: search, insertion, and splits in B+ trees, how LSM-Trees make writes fast, and which structures real databases use.

2026-03-31GCRuntimeGoJavaPython

How Garbage Collection Works — A History of GC and Language Strategies

How reference counting, tracing GC, generational GC, and concurrent GC work and how they evolved, with a comparison of memory management in Go, Java, Python, JavaScript, .NET, Rust, and Swift. An interactive diagram walks through tri-color mark and sweep.

2026-03-31GoConcurrencyRuntimeInteractive

How Go's Scheduler Works — Understanding the G, M, P Model Visually

Go's runtime scheduler puts goroutines (G) in run queues owned by logical processors (P) and runs them on OS threads (M) that hold a P. The runtime source and an interactive animation show each step.

2026-03-28Next.jsBlog

Hello World — Blog Launch

I built a personal blog with Next.js + MDX + Tailwind CSS. I'll be writing about what I learn in tech and things I notice day to day.

2025-05-15Distributed SystemsConsensusPaxosRaftPBFT

The Lineage of Consensus Algorithms — From 2PC to Paxos, Raft, and PBFT

Unlike 2PC, Paxos has no single point of failure. Raft kept Paxos's safety while making understandability a design goal, and PBFT reaches agreement even when some nodes lie, at the cost of more nodes and messages. Simulators step through each protocol's messages.

2025-02-15TravelSeattleVancouverStorytelling Map

Across the Pacific — Seattle & Vancouver Travel Diary

A record of a February 2025 trip through Seattle and Vancouver, from a city full of tech company headquarters to the canyons and forests around Vancouver.