Tags

Browse every topic on Trace in Time.

async-await 8design-principles 4dotnet 9observability 1Obsidian 2oop 4performance 2PKM 2series 12
Tag

All Topics

A collection of 16 Posts

PostHow to Get Roam-Style Bullet Navigation in ObsidianHow to replicate the click-to-zoom outliner interaction from Roam, RemNote, and Logseq in Obsidian, with two plugins and a CSS snippet for styled bullets.#Obsidian#PKM
Series PartInterface Segregation Principle (ISP): Narrow the ContractA shared contract that grows to serve everyone ends up serving no one well. Learn how ISP keeps each interface honest about what its client actually needs.#design-principles#oop#series
PostHow I Use Obsidian as a Thinking StudioHow I configured Obsidian as a developer's personal thinking studio — vault structure, web clipper, key plugins, and the PKM ideas behind each decision.#PKM#Obsidian
PostP50, P95, P99, and the Average: What Latency Numbers Actually Tell YouAverage response time hides the worst user experiences. P99 can run 100× slower than P50 on the same dataset. What P50, P95, and P99 mean, why they matter, and how to read them together.#performance#observability
PostHot Path: How to Identify and Optimize It in .NETA hot path is code that runs on every request — small inefficiencies there compound into P99 spikes users actually feel. How to find hot paths with profilers and fix them in .NET.#dotnet#performance
Series PartDependency Inversion Principle (DIP): Depend on AbstractionsWhen business logic knows which database it's talking to, the database owns the business logic. Learn how DIP breaks that grip by making policy depend on what it needs, not on how it's delivered.#design-principles#oop#series
Series PartLiskov Substitution Principle (LSP): Keep the PromiseA subtype that can't fully honor its parent's contract doesn't announce itself — it waits. Learn how LSP ensures the contract you depend on is the contract you actually get.#design-principles#oop#series
Series PartOpen Closed Principle (OCP): Extend Without BreakingCode that has to be opened every time requirements change is code you will eventually break. Learn how OCP lets new behavior arrive as new files, not as edits to existing ones.#design-principles#oop#series
Series PartAsync Best Practices in C#A checklist of async habits that prevent the most common bugs: keeping the async chain intact, avoiding .Result, using ConfigureAwait correctly, forwarding CancellationToken, and handling fire-and-forget exceptions.#dotnet#async-await#series
Series PartHow to Design Reliable Async Methods in C#Reliable async methods return Task, accept CancellationToken, and surface failures clearly. This part covers the structural decisions that make async methods composable and predictable for callers.#dotnet#async-await#series
Series PartException Handling in Async C# MethodsExceptions in async code are captured by the Task and re-thrown at the await point - not where they were thrown. This part covers where to catch them, why async void makes them disappear, and how to handle Task.WhenAll failures.#dotnet#async-await#series
Series PartContinuations and SynchronizationContext in C#After an await completes, the method resumes on a thread determined by the captured SynchronizationContext. In UI apps that means the UI thread; in ASP.NET Core it means a thread-pool thread. This is what ConfigureAwait(false) controls.#dotnet#async-await#series
Series PartAsync vs Parallel in C#: I/O-Bound vs CPU-Bound WorkAsync frees threads during I/O waits. Parallel divides CPU work across cores. They solve different problems and should not be swapped. This part explains when to use each and when to combine both.#dotnet#async-await#series
Series PartHow Async/Await Improves Throughput and Responsiveness in C#Blocking threads during I/O wastes capacity. Async handlers free threads while waiting, so a web API serves more concurrent requests and a desktop app stays responsive during data loads.#dotnet#async-await#series
Series PartHow async/await Works: The C# State Machine ExplainedThe compiler transforms every async method into a state machine that suspends at each await and resumes with local variables intact. This part shows what that transformation looks like and what it costs.#dotnet#async-await#series
Series PartWhat Is Async/Await in C# and Why Does It Exist?Async/await is not about making code faster. It is about not holding a thread hostage while it waits for I/O. This part explains the problem async solves and the mental model behind it.#dotnet#async-await#series
SEARCH