Nostr notes by codementor

Learn: IDisposable and using Some objects hold things the garbage ...

2026-10-18T12:08:01Z

Learn: IDisposable and using

Some objects hold things the garbage collector doesn't manage well: files, network connections, database connections. They implement IDisposable, and you must call Dispose when done.
using does it for you, even if an exception is thrown:

```csharp
using (var r = new Resource()) Console.WriteLine("working");
Console.WriteLine("after");

class Resource : IDisposable { public void Dispose() => Console.WriteLine("cleaned up"); }
```

It prints working, cleaned up, after.
Shorter form: using var file = File.OpenRead(path); disposes at the end of the method or block.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/using

#tip · TIP-101

Learn: Decorator Wrap an object in another object of the same ...

2026-10-16T18:37:58Z

Learn: Decorator

Wrap an object in another object of the same type that adds behavior before or after it.

```csharp
INotifier n = new Loud(new Plain());
Console.WriteLine(n.Send("hi"));

interface INotifier { string Send(string m); }
class Plain : INotifier { public string Send(string m) => m; }
class Loud(INotifier inner) : INotifier { public string Send(string m) => inner.Send(m).ToUpper() + "!"; }
```

It prints HI!.
You already use it: GZipStream wraps another Stream and adds compression. (ASP.NET Core middleware is a similar wrapping idea, usually called a pipeline.) Use it to add logging, caching or retries without changing the original class.

Read more: https://www.geeksforgeeks.org/system-design/decorator-pattern/

#tip · TIP-055

Learn: IDisposable and using Some objects hold things the garbage ...

2026-10-16T18:08:03Z

Learn: Repository and Unit of Work Repository: hides data access ...

2026-10-16T17:38:02Z

Learn: Repository and Unit of Work

Repository: hides data access behind an interface like IOrderRepository with GetById and Add, so the rest of the code doesn't know about SQL.
Unit of Work: collects changes and saves them together in one transaction.

Interview point: in EF Core, a DbSet already acts like a repository and the DbContext like a unit of work (SaveChanges). Add your own repository when you want to hide EF Core or make testing easier, not by habit.

Read more: https://www.geeksforgeeks.org/system-design/software-design-patterns/

#tip · TIP-070

Learn: JWT in one post A normal JSON Web Token (JWS) has three ...

2026-10-16T17:07:58Z

Learn: JWT in one post

A normal JSON Web Token (JWS) has three parts: header.payload.signature, each base64url-encoded. The payload holds claims (user id, roles, expiry).
It is signed, not encrypted: anyone can read it.

```csharp
string part = Base64Url.EncodeToString(Encoding.UTF8.GetBytes("{\"sub\":\"ann\",\"role\":\"admin\"}"));
Console.WriteLine(part);
Console.WriteLine(Encoding.UTF8.GetString(Base64Url.DecodeFromChars(part)));
```

It prints the encoded part, then the plain JSON. Never put secrets in a token. The signature proves who issued it and that nobody changed it. Keep access tokens short-lived (for example 1 hour) and use refresh tokens for longer sessions.

Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/

#tip · TIP-085

Learn: Producer-consumer with Channel<T> One part of the ...

2026-10-16T16:38:07Z

Learn: Producer-consumer with Channel<T>

One part of the code produces work, another consumes it, and a queue sits between them. In .NET, Channel<T> is that queue, made for async code.

```csharp
var channel = Channel.CreateBounded<int>(2);
var producer = Task.Run(async () =>
{
for (int i = 1; i <= 3; i++) await channel.Writer.WriteAsync(i);
channel.Writer.Complete();
});
await foreach (int item in channel.Reader.ReadAllAsync()) Console.WriteLine(item);
await producer;
```

It prints 1, 2, 3. A bounded channel holds at most N items:

```csharp
var small = Channel.CreateBounded<int>(2);
Console.WriteLine($"{small.Writer.TryWrite(1)} {small.Writer.TryWrite(2)} {small.Writer.TryWrite(3)}");
```

It prints True True False: full. By default WriteAsync then waits; other modes drop items instead.

Read more: https://learn.microsoft.com/en-us/dotnet/core/extensions/channels

#tip · TIP-078

Learn: Strings What: a sequence of characters. In C# a string ...

2026-10-16T16:08:01Z

Learn: Strings

What: a sequence of characters. In C# a string can't change: every "change" makes a new string.
Interview favorites: reverse, palindrome, anagram, count characters, longest substring.
Tip: turn it into a char[] to change it in place, or use StringBuilder to build it.

```csharp
string s = "hello";
char[] a = s.ToCharArray();
Array.Reverse(a);
Console.WriteLine(new string(a));
```

It prints olleh.

Read more: https://www.geeksforgeeks.org/dsa/string-data-structure/

#tip · TIP-029

Learn: The Lock type (.NET 9+) .NET 9 added ...

2026-10-16T15:38:00Z

Learn: The Lock type (.NET 9+)

.NET 9 added System.Threading.Lock, a type made only for locking, and lighter than locking on a plain object.
With the .NET 10 SDK it works in async methods too (older compilers may reject this), as long as there is no await inside the lock block:

```csharp
var gate = new Lock();
await Task.Yield();
lock (gate) { Console.WriteLine("inside"); }
```

It prints inside. An await inside the block is error CS1996, just like with any lock:

```csharp
var gate = new Lock();
lock (gate) { await Task.Delay(1); }
```

Need to await while holding a lock? Use SemaphoreSlim.

Read more: https://learn.microsoft.com/en-us/dotnet/api/system.threading.lock

#tip · TIP-075

Learn: Prefix sums, where to use them What: prefix[i] = the sum ...

2026-10-16T15:08:07Z

Learn: Prefix sums, where to use them

What: prefix[i] = the sum of the first i items. Build it once in O(n); then any range sum is one subtraction.
Use it when: you answer many "sum from i to j" questions, or look for subarrays with a given sum (together with a Dictionary). It also works in 2D for grids.

```csharp
int[] a = { 3, 1, 4, 1, 5 };
var prefix = new int[a.Length + 1];
for (int i = 0; i < a.Length; i++) prefix[i + 1] = prefix[i] + a[i];
Console.WriteLine(prefix[4] - prefix[1]); // a[1] + a[2] + a[3]
```

It prints 6: 1 + 4 + 1.

Read more: https://www.geeksforgeeks.org/dsa/prefix-sum-array-implementation-applications-competitive-programming/

#tip · TIP-040

Learn: Binary search in one post On a sorted array, look at the ...

2026-10-16T14:37:59Z

Learn: Binary search in one post

On a sorted array, look at the middle. If the target is bigger, keep the right half; if smaller, the left half. Each step halves the range: O(log n).

```csharp
int[] a = { 1, 3, 5, 7, 9, 11 };
int target = 7, lo = 0, hi = a.Length - 1;
while (lo <= hi)
{
int mid = lo + (hi - lo) / 2;
if (a[mid] == target) { Console.WriteLine(mid); break; }
if (a[mid] < target) lo = mid + 1; else hi = mid - 1;
}
```

It prints 3. Write mid as lo + (hi - lo) / 2: plain (lo + hi) / 2 can overflow an int on huge arrays.

#tip · TIP-006

Learn: Scale up or scale out Scale up (vertical): a bigger ...

2026-10-16T14:08:00Z

Learn: Scale up or scale out

Scale up (vertical): a bigger machine. Simple, but there is a limit, and it is still one machine that can fail.

Scale out (horizontal): more machines behind a load balancer. No hard limit, but the app must not keep user state on one server.

#tip · TIP-014

Learn: Divide and conquer The pattern: split the problem into ...

2026-10-16T13:38:05Z

Learn: Divide and conquer

The pattern: split the problem into smaller parts of the same kind, solve each part (usually with recursion), then combine the answers.

Examples: merge sort (split, sort halves, merge), quick sort, binary search (keep only one half).

Why it helps: splitting in half again and again gives about log n levels, which is where the "log n" in O(n log n) comes from.

Read more: https://www.geeksforgeeks.org/dsa/divide-and-conquer/

#tip · TIP-036

Learn: Data structures: which one when? A one-page cheat sheet: ...

2026-10-16T13:08:12Z

In reply to naddr1qq…xnaa
_________________________

Learn: Data structures: which one when?

A one-page cheat sheet: what each basic data structure is good at, what it costs, and the C# type to use.

Read the full article:

quoting naddr1qq…3ppj

Data structures: which one when?

Pick a data structure by asking: what will I do most often? Read by position? Look up by key? Add and remove at the ends? Keep things sorted?

Need Use C# type Main cost

Read by position, loop over all Array / list int[], List<T> index O(1), middle insert O(n)

Look up by key, count, remove duplicates Hash table Dictionary<K,V>, HashSet<T> O(1) on average

Last in, first out (undo, brackets, DFS) Stack Stack<T> push amortized O(1), pop O(1)

First in, first out (BFS, jobs) Queue Queue<T> enqueue amortized O(1), dequeue O(1)

Always take the smallest (top k, Dijkstra) Heap PriorityQueue<T,P> O(log n)

Keep sorted while changing, ranges Balanced tree SortedSet<T>, SortedDictionary<K,V> O(log n)

Many inserts/removes at known nodes Linked list LinkedList<T> O(1) at a node, O(n) to find it

Grid data Matrix int[,] O(rows × cols) to visit all

Nested data Tree your own node class depends on shape

How to answer in an interview

Say what operation the problem needs most.

Pick the structure that makes that operation cheap.

Say the cost out loud, and the trade-off: a hash table is fast but unordered; a sorted set is ordered but O(log n).

A quick example

"Find if any two numbers sum to 10" needs fast "have I seen x?" checks, so a HashSet<int> turns it into one pass:
int[] nums = { 3, 9, 7, 1 };
var seen = new HashSet<int>();
bool found = false;
foreach (int x in nums)
{
    found |= seen.Contains(10 - x);
    seen.Add(x);
}
Console.WriteLine(found);
It prints True (3 + 7 = 10).

Read more: https://roadmap.sh/datastructures-and-algorithms

#tip · TIP-032

Need	Use	C# type	Main cost
Read by position, loop over all	Array / list	`int[]`, `List<T>`	index O(1), middle insert O(n)
Look up by key, count, remove duplicates	Hash table	`Dictionary<K,V>`, `HashSet<T>`	O(1) on average
Last in, first out (undo, brackets, DFS)	Stack	`Stack<T>`	push amortized O(1), pop O(1)
First in, first out (BFS, jobs)	Queue	`Queue<T>`	enqueue amortized O(1), dequeue O(1)
Always take the smallest (top k, Dijkstra)	Heap	`PriorityQueue<T,P>`	O(log n)
Keep sorted while changing, ranges	Balanced tree	`SortedSet<T>`, `SortedDictionary<K,V>`	O(log n)
Many inserts/removes at known nodes	Linked list	`LinkedList<T>`	O(1) at a node, O(n) to find it
Grid data	Matrix	`int[,]`	O(rows × cols) to visit all
Nested data	Tree	your own node class	depends on shape

#tip · TIP-032

Learn: Sharding splits data by a key When one database is too big ...

2026-10-16T12:38:07Z

Learn: Sharding splits data by a key

When one database is too big or too busy, split the data across several databases (shards), for example by user ID.

The risk is a hot shard: if one key gets most of the traffic, one shard does most of the work. Choose a key that spreads load evenly.

#tip · TIP-016

Learn: The lock statement lock lets only one thread at a time run ...

2026-10-16T12:08:05Z

Learn: The lock statement

lock lets only one thread at a time run a block of code; the others wait.

```csharp
var sync = new object();
int total = 0;
Parallel.For(0, 1000, i => { lock (sync) total += i; });
Console.WriteLine(total);
```

It prints 499500 (0 + 1 + ... + 999) every time. On a plain object, lock is Monitor.Enter/Exit in a try/finally, so it is released even when an exception is thrown, and the same thread may enter it again (it is reentrant).
Rules: lock on a private object, never on this, a string or a type. Keep the block short. You can't await inside a lock.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/lock

#tip · TIP-074

Learn: Hashing What: a hash function turns a key into a number ...

2026-10-16T11:37:56Z

Learn: Hashing

What: a hash function turns a key into a number that picks a bucket, so a lookup jumps straight to the right place.
Cost: insert, find and delete are O(1) on average; many collisions can slow them down.
Use it when: you look things up by key, count things, remove duplicates, or cache results.

```csharp
var counts = new Dictionary<string, int>();
foreach (var w in "to be or not to be".Split(' '))
counts[w] = counts.GetValueOrDefault(w) + 1;
Console.WriteLine(counts["be"]);
```

It prints 2. In C#: Dictionary<K, V> and HashSet<T>.

Read more: https://www.geeksforgeeks.org/dsa/hashing-data-structure/

#tip · TIP-024

Learn: Bitwise tricks Operators: & (and), | (or), ^ (xor), ~ ...

2026-10-16T11:08:01Z

Learn: Bitwise tricks

Operators: & (and), | (or), ^ (xor), ~ (not), << and >> (shift).

```csharp
int n = 12; // 1100 in binary
Console.WriteLine(n & 1);
Console.WriteLine((n & (n - 1)) == 0);
Console.WriteLine(5 ^ 3 ^ 5);
Console.WriteLine(1 << 4);
```

n & 1 is 0 for even numbers. n > 0 && (n & (n - 1)) == 0 is true only for powers of two (.NET also has int.IsPow2). x ^ x is 0, so xor finds the one number without a pair. 1 << 4 is 16.
Use them for flags, compact sets of booleans, and these classic interview tricks.

Read more: https://www.geeksforgeeks.org/dsa/bitwise-algorithms/

#tip · TIP-042

Learn: What a load balancer does It spreads incoming requests ...

2026-10-16T10:38:00Z

Learn: What a load balancer does

It spreads incoming requests over several servers, and stops sending traffic to a server that fails its health check.

Simple strategies: round robin (take turns) or least connections (send to the least busy server). In an interview, mention health checks and what happens when a server dies.

#tip · TIP-015

Learn: Decorator Wrap an object in another object of the same ...

2026-10-16T10:07:57Z

Learn: Mutex A Mutex is a lock that can also work across ...

2026-10-16T09:38:04Z

Learn: Mutex

A Mutex is a lock that can also work across processes when you give it a name. Example: allow only one copy of your app to run.
It has thread affinity (it belongs to one thread): only the thread that took it can release it.

```csharp
var m = new Mutex();
m.WaitOne();
var t = new Thread(() =>
{
try { m.ReleaseMutex(); } catch (ApplicationException) { Console.WriteLine("only the owner can release"); }
});
t.Start(); t.Join();
m.ReleaseMutex();
```

It prints only the owner can release. Don't hold a Mutex across await: the code after it may run on another thread, which can't release it. Without a name, use lock instead: it is much faster.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/overview-of-synchronization-primitives

#tip · TIP-076

Learn: volatile Without it, the compiler or CPU may keep reusing ...

2026-10-16T09:08:02Z

Learn: volatile

Without it, the compiler or CPU may keep reusing an old read of a field, so a loop can miss a "stop" flag that another thread set. volatile makes every read and write go to the field itself (the compiler can't keep an old copy), and limits how those reads and writes are reordered.
What it doesn't do: make count++ safe (use Interlocked or lock), or guarantee the very latest value on every processor.
For stopping work, prefer a CancellationToken.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/volatile

#tip · TIP-090

Learn: Sliding window that grows and shrinks Most interview ...

2026-10-16T08:37:56Z

Learn: Sliding window that grows and shrinks

Most interview windows have no fixed size. Grow the window with right. For the longest window, shrink from left while it breaks the rule. For the shortest, shrink while it still meets the goal.
Example: the shortest run of numbers with a sum of at least 8.

```csharp
int[] a = { 1, 4, 2, 2, 5, 1 };
int target = 8, left = 0, sum = 0, best = int.MaxValue;
for (int right = 0; right < a.Length; right++)
{
sum += a[right];
while (sum >= target) { best = Math.Min(best, right - left + 1); sum -= a[left++]; }
}
Console.WriteLine(best);
```

It prints 3 (2 + 2 + 5, or 4 + 2 + 2). O(n): each index moves forward only.
This sum trick needs non-negative numbers. If no window reaches the target, best stays int.MaxValue: report "none".

Read more: https://www.geeksforgeeks.org/dsa/window-sliding-technique/

#tip · TIP-066

Learn: Deadlock Thread 1 holds lock A and waits for B. Thread 2 ...

2026-10-16T08:08:05Z

Learn: Deadlock

Thread 1 holds lock A and waits for B. Thread 2 holds B and waits for A. Both wait forever.
It needs four things at once:
1. Only one thread can hold a lock.
2. A thread holds one lock while it waits for another.
3. Nobody can take a lock away.
4. The waiting forms a circle.
Prevent it: take locks in the same order, hold them briefly, use timeouts (Monitor.TryEnter).

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices

#tip · TIP-079

Learn: Factory A factory creates objects for you, so the caller ...

2026-10-16T07:38:04Z

Learn: Factory

A factory creates objects for you, so the caller asks for "a pdf exporter" without naming the class.

```csharp
Console.WriteLine(Create("pdf").Export());
static IExporter Create(string kind) => kind switch
{
"pdf" => new PdfExporter(),
"csv" => new CsvExporter(),
_ => throw new ArgumentException(kind),
};
interface IExporter { string Export(); }
class PdfExporter : IExporter { public string Export() => "PDF file"; }
class CsvExporter : IExporter { public string Export() => "CSV file"; }
```

It prints PDF file.
Use it when: which class to create depends on input or configuration, or creating it is complicated.

Read more: https://www.geeksforgeeks.org/system-design/factory-method-for-designing-pattern/

#tip · TIP-052

Learn: The middleware pipeline Every request passes through a ...

2026-10-16T07:08:05Z

Learn: The middleware pipeline

Every request passes through a chain of middleware, in the order you add them in Program.cs, and the response comes back through them in reverse.
Each one can do work, then call the next, or stop the chain (short-circuit), like the static files middleware returning a file.
app.Use(...) adds a step that can call next; app.Run(context => ...) adds a final step (not the app.Run() that starts the server).
Order matters: exception handling first, then HTTPS, static files, routing, authentication, authorization, endpoints.

Read more: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/

#tip · TIP-095

Learn: Task vs Thread A Thread is an operating system thread: ...

2026-10-16T06:38:04Z

Learn: Task vs Thread

A Thread is an operating system thread: expensive to create, and it holds memory the whole time.
A Task is a promise of a result. CPU work started with Task.Run runs on a shared pool of threads. A task waiting for I/O (a web call, a database) holds no thread at all while it waits.

In modern C#, use Task and async/await; create a Thread yourself only for rare long-running, dedicated work.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming

#tip · TIP-045

Learn: Linked list classic: reverse it Interviewers want your own ...

2026-10-16T06:08:04Z

Learn: Linked list classic: reverse it

Interviewers want your own Node class, not LinkedList<T>. Walk the list and point each node back to the one before it. Save the next node first, or you lose the rest of the list.

```csharp
Node? cur = new Node(1, new Node(2, new Node(3, null))), prev = null;
while (cur != null)
{
Node? next = cur.Next; // save it before relinking
cur.Next = prev;
prev = cur;
cur = next;
}
Console.WriteLine($"{prev!.Value} {prev.Next!.Value} {prev.Next.Next!.Value}");
```

It prints 3 2 1. O(n) time, O(1) memory.
The other classic: fast and slow pointers (fast moves 2, slow moves 1) find the middle, or detect a cycle when they meet.

Read more: https://www.geeksforgeeks.org/dsa/linked-list-data-structure/

#tip · TIP-063

Learn: Making microservices resilient Timeouts, retries with ...

2026-10-16T05:38:07Z

In reply to naddr1qq…qdak
_________________________

Learn: Making microservices resilient

Timeouts, retries with backoff, circuit breakers, idempotency and the outbox: how services survive each other's failures.

Read the full article:

quoting naddr1qq…cqcr

Making microservices resilient

In a microservice system, some call always fails somewhere: a service restarts, the network hiccups, a database is slow. Design for these partial failures instead of hoping they don't happen.

The toolbox

Timeout: never wait forever for another service. A slow dependency must not hold your threads and requests.

Retry with backoff: retry short, temporary failures, waiting longer each time (for example 200 ms, 400 ms, 800 ms) and adding a little randomness (jitter), so many clients don't retry at the same moment.

Circuit breaker: after many failures, stop calling the broken service for a while and fail fast. Then try again carefully.

Bulkhead: limit how many calls can go to one dependency, so one slow service can't use up everything.

Fallback: return a cached or default answer when a call fails.

In .NET, Microsoft.Extensions.Http.Resilience (built on Polly) adds these to HttpClient in a few lines.

A retry, by hand
int calls = 0;
Console.WriteLine(await RetryAsync(() => ++calls < 3 ? throw new HttpRequestException("busy") : Task.FromResult("ok")));
async Task<string> RetryAsync(Func<Task<string>> action)
{
    for (int attempt = 1; ; attempt++)
    {
        try { return await action(); }
        catch (HttpRequestException) when (attempt < 5) { await Task.Delay(10 * (1 << attempt)); } // wait longer each time
    }
}
It prints ok: the first two calls fail, the third succeeds, with a growing wait between tries.

Data across services

Idempotency: retries mean the same request can arrive twice. Make handlers safe to repeat, for example with a request ID.

Outbox: save the business change and the message to send in the same database transaction; a background job publishes the messages. No lost events, but a message may be published twice, so consumers must be idempotent.

Saga: a business process across services is a series of local steps, each with a compensating step to undo it if a later step fails.

At the edge

An API gateway gives clients one entry point and handles routing, authentication and rate limiting for the services behind it.

Read more: https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/

#tip · TIP-099

#tip · TIP-099

Learn: The three pattern families Creational: how objects get ...

2026-10-16T05:08:04Z

Learn: The three pattern families

Creational: how objects get created. Singleton, Factory, Builder.
Structural: how objects are put together. Decorator, Adapter, Facade.
Behavioral: how objects talk and share work. Strategy, Observer, Command.

In an interview, don't just name a pattern: say the problem it solves and where you used it.

Read more: https://www.geeksforgeeks.org/system-design/software-design-patterns/

#tip · TIP-056

Learn: Strategy Put each version of an algorithm behind the same ...

2026-10-15T18:38:05Z

Learn: Strategy

Put each version of an algorithm behind the same shape, and choose one at run time. No growing if/else chain.

```csharp
Func<decimal, decimal> blackFriday = p => p * 0.7m;
Console.WriteLine(Checkout(100m, blackFriday));

static decimal Checkout(decimal price, Func<decimal, decimal> discount) => discount(price);
```

It prints 70.0 (decimal keeps one decimal place from 0.7).
In C#, a strategy can be an interface or just a Func. Use it for pricing rules, sorting orders, payment methods.

Read more: https://www.geeksforgeeks.org/system-design/strategy-pattern-set-1/

#tip · TIP-053

Learn: What log n means log₂ n answers one question: how many ...

2026-10-15T18:08:04Z

Learn: What log n means

log₂ n answers one question: how many times can you halve n before you reach 1? 8, 4, 2, 1 is 3 halvings, so log₂ 8 = 3.

```csharp
int n = 1_000_000, steps = 0;
while (n > 1) { n /= 2; steps++; }
Console.WriteLine(steps);
```

It prints 19: integer division rounds down, so it counts only full halvings. The exact log₂ of 1,000,000 is about 19.9.

So O(log n) grows very slowly. Doubling n adds just one step. O(n log n) is often log n rounds of O(n) work each.

#big006 · BIG-006-N

Learn: Array What: items stored side by side in memory, each at ...

2026-10-15T17:38:07Z

Learn: Array

What: items stored side by side in memory, each at an index.
Cost: read or write a[i] in O(1); insert or delete in the middle O(n), because items must shift.
Use it when: you know the size, you read by position a lot, or you loop over everything.

```csharp
int[] a = { 10, 20, 30 };
Console.WriteLine(a[1]);
var list = new List<int>(a) { 40 };
Console.WriteLine(list.Count);
```

It prints 20, then 4. In C#, int[] has a fixed size; List<T> is an array that grows.

Read more: https://www.geeksforgeeks.org/dsa/array-data-structure-guide/

#tip · TIP-023

Learn: Value types vs reference types A value type (struct, int, ...

2026-10-15T17:07:57Z

Learn: Value types vs reference types

A value type (struct, int, bool, DateTime) holds its data directly; assigning it makes a copy.
A reference type (class, string, arrays) holds a reference; two variables can point to the same object.

```csharp
var p1 = new PointStruct { X = 1 }; var p2 = p1; p2.X = 9;
var c1 = new PointClass { X = 1 }; var c2 = c1; c2.X = 9;
Console.WriteLine($"{p1.X} {c1.X}");

struct PointStruct { public int X; }
class PointClass { public int X; }
```

It prints 1 9: changing the copied struct didn't touch the original, but both class variables see the change.
Boxing: putting a value type into an object (object o = 5) copies it to the heap. It is slower, so avoid it in hot loops.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types

#tip · TIP-100

Learn: Linked list What: nodes, each holding a value and a link ...

2026-10-15T16:38:10Z

Learn: Linked list

What: nodes, each holding a value and a link to the next node.
Cost: insert or remove at a node you already hold is O(1); reaching item k is O(k), because you must walk.
Use it when: you add and remove at the ends or in the middle a lot, and rarely jump to a position. Example: an LRU cache, which pairs a Dictionary (find a node fast) with a linked list (move it to the front).

```csharp
var list = new LinkedList<int>();
list.AddLast(2); list.AddLast(3); list.AddFirst(1);
Console.WriteLine(string.Join(" ", list));
```

It prints 1 2 3. .NET's LinkedList<T> is doubly linked. In practice List<T> is often faster, because its items sit next to each other in memory.

Read more: https://www.geeksforgeeks.org/dsa/linked-list-data-structure/

#tip · TIP-026

Learn: What a load balancer does It spreads incoming requests ...

2026-10-15T16:08:02Z

Learn: Sharding splits data by a key When one database is too big ...

2026-10-15T15:38:17Z

Learn: Mutex A Mutex is a lock that can also work across ...

2026-10-15T15:08:02Z

Learn: Concurrency in .NET: which tool when A one-page map of ...

2026-10-15T14:38:03Z

In reply to naddr1qq…78r8
_________________________

Learn: Concurrency in .NET: which tool when

A one-page map of .NET's concurrency tools, with the bugs each one prevents.

Read the full article:

quoting naddr1qq…f8q8

Concurrency in .NET: which tool when

When several threads touch the same data, three bugs appear: race conditions (lost updates), deadlocks (threads waiting on each other forever) and starvation (some work never gets a turn). Pick the tool that fits the situation.

Situation Tool Why

Add to a shared counter Interlocked atomic, no lock needed

Protect a few lines of sync code lock (on a private object, or Lock in .NET 9+) simple, fast; no await inside

Protect code that uses await SemaphoreSlim(1, 1) works with WaitAsync

Limit how many run at once SemaphoreSlim(n, n) lets n callers in

One lock across processes named Mutex visible to other processes

Many readers, few writers ReaderWriterLockSlim readers don't block each other; not for async code

Shared dictionary or queue ConcurrentDictionary, ConcurrentQueue thread-safe operations

Hand work from producers to consumers Channel<T> async queue; a bounded one makes fast producers wait

Wait for I/O async/await no thread held while waiting

Rules that prevent most bugs

Share as little as possible. Immutable data needs no lock.

Keep locked blocks short, and never call unknown code (events, callbacks) while holding a lock.

Take locks in one fixed order to avoid deadlocks.

Don't block on async code (.Result, .Wait()); in ASP.NET Core it starves the thread pool.

You can't await inside a lock; use SemaphoreSlim.

Readers and writers
var rw = new ReaderWriterLockSlim();
var prices = new Dictionary<string, int> { ["tea"] = 3 };
rw.EnterReadLock(); try { Console.WriteLine(prices["tea"]); } finally { rw.ExitReadLock(); }
rw.EnterWriteLock(); try { prices["tea"] = 4; } finally { rw.ExitWriteLock(); }
Console.WriteLine(prices["tea"]);
It prints 3, then 4. Many threads can hold the read lock together; the write lock is exclusive. For short sections a plain lock is often just as fast.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices

#tip · TIP-082

Situation	Tool	Why
Add to a shared counter	`Interlocked`	atomic, no lock needed
Protect a few lines of sync code	`lock` (on a private object, or `Lock` in .NET 9+)	simple, fast; no `await` inside
Protect code that uses `await`	`SemaphoreSlim(1, 1)`	works with `WaitAsync`
Limit how many run at once	`SemaphoreSlim(n, n)`	lets n callers in
One lock across processes	named `Mutex`	visible to other processes
Many readers, few writers	`ReaderWriterLockSlim`	readers don't block each other; not for async code
Shared dictionary or queue	`ConcurrentDictionary`, `ConcurrentQueue`	thread-safe operations
Hand work from producers to consumers	`Channel<T>`	async queue; a bounded one makes fast producers wait
Wait for I/O	`async`/`await`	no thread held while waiting

#tip · TIP-082

Question: An algorithm does O(log n) steps. n grows from 1,000 to ...

2026-10-15T14:08:05Z

Question: An algorithm does O(log n) steps. n grows from 1,000 to 1,000,000, a thousand times bigger.

About how many more steps does it need?

Try to answer before you open the reply.

#big006 · BIG-006-Q1

Only about 10 more. log₂ of 1,000 is about 10, and log₂ of ...

2026-10-15T14:08:05Z

In reply to nevent1q…ru55
_________________________

Only about 10 more.

log₂ of 1,000 is about 10, and log₂ of 1,000,000 is about 20. The input grew 1,000 times, but the steps only doubled. That is why O(log n) algorithms are so fast on big inputs.

#big006 · BIG-006-A1

Learn: Grid problems: flood fill How to walk a grid in four ...

2026-10-15T13:38:03Z

In reply to naddr1qq…2gep
_________________________

Learn: Grid problems: flood fill

How to walk a grid in four directions, stay inside the bounds, and count connected areas.

Read the full article:

quoting naddr1qq…a7s9

Grid problems: flood fill

Many interview questions give you a grid of cells: a map, an image, a maze. The key move is flood fill: from one cell, visit every connected cell of the same kind.

Counting areas

Count the separate areas of 1s (cells connected up, down, left or right):
string[] map = { "11000", "11001", "00001" };
int rows = map.Length, cols = map[0].Length, areas = 0; var seen = new bool[rows, cols];
for (int r = 0; r < rows; r++) for (int c = 0; c < cols; c++)
    if (map[r][c] == '1' && !seen[r, c]) { areas++; Fill(r, c); }
Console.WriteLine(areas);
void Fill(int r, int c)
{
    if (r < 0 || c < 0 || r >= rows || c >= cols || seen[r, c] || map[r][c] == '0') return;
    seen[r, c] = true; Fill(r + 1, c); Fill(r - 1, c); Fill(r, c + 1); Fill(r, c - 1);
}
It prints 2: one area of four cells top-left, and one of two cells on the right.

The pattern

Loop over every cell.

When you find an unvisited 1, count a new area and flood-fill it.

The fill marks cells as seen and spreads in four directions.

Check the bounds first (row and column inside the grid) before reading a cell; this is where most bugs are.

Cost

Each cell is visited a constant number of times: O(rows × cols) time. The seen grid is O(rows × cols) memory. The recursion can go as deep as the area is big; for very large grids, use a queue (breadth-first) instead of recursion.

C# note

int[,] is one rectangular block; int[][] (jagged) is an array of arrays, where rows can differ in length. Many online judges give you jagged arrays.

Read more: https://www.geeksforgeeks.org/dsa/matrix/

#tip · TIP-069

#tip · TIP-069

Learn: Interface An interface is a contract: members a class must ...

2026-10-15T13:08:01Z

Learn: Interface

An interface is a contract: members a class must provide. It can't hold instance data (no fields); since C# 8 it may give a method a default body.
A class can implement many interfaces.
Use it when: different classes should be usable the same way, for DI and testing with fakes, or plug-ins.

```csharp
IShape[] shapes = { new Square(2), new Circle(1) };
foreach (var s in shapes) Console.WriteLine(s.Area().ToString("0.00"));

interface IShape { double Area(); }
record Square(double Side) : IShape { public double Area() => Side * Side; }
record Circle(double R) : IShape { public double Area() => Math.PI * R * R; }
```

It prints 4.00, then 3.14.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interface

#tip · TIP-048

Learn: Data structures: which one when? A one-page cheat sheet: ...

2026-10-15T12:38:05Z

In reply to naddr1qq…6x7r
_________________________

Learn: Data structures: which one when?

A one-page cheat sheet: what each basic data structure is good at, what it costs, and the C# type to use.

Read the full article:

quoting naddr1qq…hk6c

Data structures: which one when?

Pick a data structure by asking: what will I do most often? Read by position? Look up by key? Add and remove at the ends? Keep things sorted?

Need Use C# type Main cost

Read by position, loop over all Array / list int[], List<T> index O(1), middle insert O(n)

Look up by key, count, remove duplicates Hash table Dictionary<K,V>, HashSet<T> O(1) on average

Last in, first out (undo, brackets, DFS) Stack Stack<T> push amortized O(1), pop O(1)

First in, first out (BFS, jobs) Queue Queue<T> enqueue amortized O(1), dequeue O(1)

Always take the smallest (top k, Dijkstra) Heap PriorityQueue<T,P> O(log n)

Keep sorted while changing, ranges Balanced tree SortedSet<T>, SortedDictionary<K,V> O(log n)

Many inserts/removes at known nodes Linked list LinkedList<T> O(1) at a node, O(n) to find it

Grid data Matrix int[,] O(rows × cols) to visit all

Nested data Tree your own node class depends on shape

How to answer in an interview

Say what operation the problem needs most.

Pick the structure that makes that operation cheap.

Say the cost out loud, and the trade-off: a hash table is fast but unordered; a sorted set is ordered but O(log n).

A quick example

"Find if any two numbers sum to 10" needs fast "have I seen x?" checks, so a HashSet<int> turns it into one pass:
int[] nums = { 3, 9, 7, 1 };
var seen = new HashSet<int>();
bool found = false;
foreach (int x in nums)
{
    found |= seen.Contains(10 - x);
    seen.Add(x);
}
Console.WriteLine(found);
It prints True (3 + 7 = 10).

Read more: https://roadmap.sh/datastructures-and-algorithms

#tip · TIP-032

Need	Use	C# type	Main cost
Read by position, loop over all	Array / list	`int[]`, `List<T>`	index O(1), middle insert O(n)
Look up by key, count, remove duplicates	Hash table	`Dictionary<K,V>`, `HashSet<T>`	O(1) on average
Last in, first out (undo, brackets, DFS)	Stack	`Stack<T>`	push amortized O(1), pop O(1)
First in, first out (BFS, jobs)	Queue	`Queue<T>`	enqueue amortized O(1), dequeue O(1)
Always take the smallest (top k, Dijkstra)	Heap	`PriorityQueue<T,P>`	O(log n)
Keep sorted while changing, ranges	Balanced tree	`SortedSet<T>`, `SortedDictionary<K,V>`	O(log n)
Many inserts/removes at known nodes	Linked list	`LinkedList<T>`	O(1) at a node, O(n) to find it
Grid data	Matrix	`int[,]`	O(rows × cols) to visit all
Nested data	Tree	your own node class	depends on shape

#tip · TIP-032

Learn: Queue What: first in, first out, like a line at a shop. ...

2026-10-15T12:02:07Z

Learn: Queue

What: first in, first out, like a line at a shop. Enqueue at the back (amortized O(1)), Dequeue from the front in O(1).
Use it when: work must be handled in arrival order: breadth-first search, task and print queues, messages between services.

```csharp
var line = new Queue<string>(new[] { "Ann", "Ben", "Cho" });
line.Enqueue("Dan");
Console.WriteLine($"{line.Dequeue()} is served, {line.Count} waiting");
```

It prints Ann is served, 3 waiting.

Read more: https://www.geeksforgeeks.org/dsa/queue-data-structure/

#tip · TIP-028

Learn: Bitwise tricks Operators: & (and), | (or), ^ (xor), ~ ...

2026-10-15T11:37:58Z

Learn: Authentication vs authorization Authentication: who are ...

2026-10-15T11:08:03Z

Learn: Authentication vs authorization

Authentication: who are you? (login, a cookie, a token)
Authorization: what may you do? (roles, policies)
On a protected endpoint: no valid login → 401; logged in but not allowed → 403. (Cookie login redirects web pages to a login page; since .NET 10, API endpoints get 401/403.)

```csharp
var identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, "ann"), new Claim(ClaimTypes.Role, "Admin") }, "demo");
var user = new ClaimsPrincipal(identity);
Console.WriteLine($"{user.Identity!.IsAuthenticated} {user.IsInRole("Admin")} {user.IsInRole("Billing")}");
```

It prints True True False. IsAuthenticated is true only because an authentication type ("demo") was given. ASP.NET Core builds this ClaimsPrincipal for every request (HttpContext.User).

Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/

#tip · TIP-083

Learn: Merge sort, step by step How merge sort splits, sorts and ...

2026-10-15T10:38:03Z

In reply to naddr1qq…m8g2
_________________________

Learn: Merge sort, step by step

How merge sort splits, sorts and merges; why it is O(n log n); and when to choose it.

Read the full article:

quoting naddr1qq…c9t3

Merge sort, step by step

Merge sort is the classic divide and conquer sort.

Divide: split the array into two halves.

Conquer: sort each half, with merge sort again (recursion).

Combine: merge the two sorted halves into one sorted array.

An array of one item is already sorted, so the recursion stops there.

The code
Console.WriteLine(string.Join(" ", Sort(new[] { 5, 2, 9, 1, 6 })));
static int[] Sort(int[] a)
{
    if (a.Length <= 1) return a;
    int[] left = Sort(a[..(a.Length / 2)]), right = Sort(a[(a.Length / 2)..]); // split in half
    var result = new List<int>(); int i = 0, j = 0;
    while (i < left.Length && j < right.Length) result.Add(left[i] <= right[j] ? left[i++] : right[j++]);
    result.AddRange(left[i..]); result.AddRange(right[j..]); // copy what is left
    return result.ToArray();
}
It prints 1 2 5 6 9.

Merging

Look only at the front of each half and take the smaller item. Repeat until one half is empty, then copy what is left of the other. Using <= keeps equal items in their original order, so merge sort is stable.

Cost

Time: O(n log n) in every case. There are about log n levels of splitting, and each level merges n items in total.

Memory: O(n) extra for the merged arrays.

When to choose it

You need a stable sort.

You sort a linked list (merging needs no random access).

The data is too big for memory and is sorted in chunks on disk (external sorting).

In everyday C#, Array.Sort is O(n log n) and the right default, but it is not stable; OrderBy in LINQ is stable. Know merge sort for interviews and for the cases above.

Read more: https://www.geeksforgeeks.org/dsa/merge-sort/

#tip · TIP-037

#tip · TIP-037

Go forward with a loop and keep only the last two values: ...

2026-10-15T10:08:02Z

In reply to nevent1q…9dyt
_________________________

Go forward with a loop and keep only the last two values:

```csharp
long a = 0, b = 1;
for (int i = 0; i < 50; i++) (a, b) = (b, a + b);
Console.WriteLine(a);
```

It prints 12586269025. O(n) time, O(1) memory, and no recursion, so no risk of a stack overflow.

#big011 · BIG-011-A3

Interviewer's follow-up: "Now compute Fib(n) with O(1) ...

2026-10-15T10:08:02Z

Interviewer's follow-up: "Now compute Fib(n) with O(1) memory."

Try to answer before you open the reply.

#big011 · BIG-011-Q3

Learn: Value types vs reference types A value type (struct, int, ...

2026-10-15T09:38:03Z

Learn: Decorator Wrap an object in another object of the same ...

2026-10-15T09:08:04Z

Learn: Scoped services in a singleton or BackgroundService A ...

2026-10-15T08:38:01Z

Learn: Scoped services in a singleton or BackgroundService

A BackgroundService is a singleton, but a DbContext is scoped. Injecting the DbContext directly would keep one DbContext forever.
Fix: inject IServiceScopeFactory. For each piece of work: create a scope, get the DbContext from it, and dispose the scope when done.
In Development, ASP.NET Core checks this for you (scope validation) and throws at startup if a singleton depends on a scoped service.

Read more: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection

#tip · TIP-096

Question: The fast/slow cycle loop runs while (fast?.Next != ...

2026-10-15T08:08:06Z

Question: The fast/slow cycle loop runs while (fast?.Next != null). These two lists have no cycle:

1 → 2 → 3
1 → 2 → 3 → 4

For each one, where is fast when the loop stops? And why must the condition check both fast and fast.Next?

Try to answer before you open the reply.

#ll014 · LL-014-Q2

1 → 2 → 3: fast jumps from 1 to 3. Node 3 is the last node, ...

2026-10-15T08:08:06Z

In reply to nevent1q…k0we
_________________________

1 → 2 → 3: fast jumps from 1 to 3. Node 3 is the last node, so fast.Next is null and the loop stops with fast on node 3.
1 → 2 → 3 → 4: fast jumps from 1 to 3, then to 3.Next.Next, which is null. The loop stops with fast null.

```csharp
foreach (Node head in new[] { Build(1, 2, 3), Build(1, 2, 3, 4) })
{
Node? slow = head, fast = head;
while (fast?.Next != null) { slow = slow!.Next; fast = fast.Next.Next; if (slow == fast) break; }
Console.WriteLine(fast == null ? "fast is null" : $"fast is on node {fast.Value}");
}
```

So the end of the list shows up in two ways. Check only fast != null, and an odd-length list reads fast.Next.Next on the last node, where fast.Next is null: a NullReferenceException. Check only fast.Next, and an even-length list throws on the null fast. fast?.Next != null covers both.

#ll014 · LL-014-A2

Learn: Monolith vs microservices What each architecture is, the ...

2026-10-15T07:37:58Z

In reply to naddr1qq…tgs9
_________________________

Learn: Monolith vs microservices

What each architecture is, the real trade-offs, and how to answer the classic interview question.

Read the full article:

quoting naddr1qq…tmlm

Monolith vs microservices

Monolith

One codebase, one deployable. All features run in the same process.

Pros: simple to develop, test, debug and deploy. Calls between parts are fast in-process calls. One database keeps data consistent.

Cons: you scale everything together. A large codebase gets slow to change and to build. One bad deploy or crash affects every feature.

Microservices

Many small services, each with one job, its own data, and its own deployment. They talk over HTTP or messages.

Pros: teams deploy independently. You scale only the busy service. A failure can stay inside one service.

Cons: network calls are slower and can fail, so you need timeouts and retries. Data is spread out, so there is no simple transaction across services. You need logging, tracing, monitoring and automated deployment from day one.

How to choose

Situation Better fit

New product, small team, changing requirements Monolith

Several teams stepping on each other in one codebase Microservices

One part needs much more scale than the rest Split out that part

A popular middle way is the modular monolith: one deployable, but clear internal modules with their own boundaries. Modules can later become services when there is a real reason.

The interview answer

Don't say one is always better. Say: start with a monolith with clear modules; move a module to its own service when a team or scaling need justifies the extra complexity. Then mention what microservices require: independent data, network resilience, and observability.

Read more: https://roadmap.sh/software-design-architecture

#tip · TIP-061

Situation	Better fit
New product, small team, changing requirements	Monolith
Several teams stepping on each other in one codebase	Microservices
One part needs much more scale than the rest	Split out that part

#tip · TIP-061

Learn: Deadlock Thread 1 holds lock A and waits for B. Thread 2 ...

2026-10-15T07:08:03Z

Learn: IDisposable and using Some objects hold things the garbage ...

2026-10-15T06:37:59Z

Merge them one by one: simple, but the result list is walked ...

2026-10-15T06:08:04Z

In reply to nevent1q…4r6w
_________________________

Merge them one by one: simple, but the result list is walked again and again, O(N · k) for N nodes in total.

Better: put the k front nodes in a min-heap (in .NET, PriorityQueue). Take the smallest, then add that list's next node. Each node costs one heap step, O(log k), so O(N log k) in total.

#ll013 · LL-013-A3

Interviewer's follow-up: "Now merge k sorted lists." ...

2026-10-15T06:08:04Z

Interviewer's follow-up: "Now merge k sorted lists." What are your options?

Try to answer before you open the reply.

#ll013 · LL-013-Q3

Learn: Tree traversals The four ways to visit a tree, when each ...

2026-10-15T05:38:00Z

In reply to naddr1qq…5drh
_________________________

Learn: Tree traversals

The four ways to visit a tree, when each one is useful, and how much memory they need.

Read the full article:

quoting naddr1qq…z89k

Tree traversals

Most tree questions start with visiting every node in some order.

Depth-first (recursion)

Pre-order: node, then left, then right. Use it to copy a tree or print it top-down.

In-order: left, then node, then right. On a binary search tree this gives the values in sorted order, a favorite interview fact.

Post-order: left, then right, then node. Use it to delete a tree or compute sizes (children first).
var root = new Tree(2, new Tree(1, null, null), new Tree(3, null, null));
var order = new List<int>();
InOrder(root, order);
Console.WriteLine(string.Join(" ", order));

static void InOrder(Tree? t, List<int> order)
{
    if (t == null) return;
    InOrder(t.Left, order); order.Add(t.Value); InOrder(t.Right, order);
}
It prints 1 2 3: in-order on a BST is sorted.

Breadth-first (level by level)

Use a queue: take a node out, add its children at the back. Use it for "shortest path in steps", "print level by level", or "nodes closest to the root".
var root = new Tree(1, new Tree(2, new Tree(4, null, null), null), new Tree(3, null, null));
var queue = new Queue<Tree>(new[] { root });
var visited = new List<int>();
while (queue.Count > 0)
{
    var t = queue.Dequeue(); visited.Add(t.Value);
    if (t.Left != null) queue.Enqueue(t.Left);
    if (t.Right != null) queue.Enqueue(t.Right);
}
Console.WriteLine(string.Join(" ", visited));
It prints 1 2 3 4: the root, then its children, then the next level.

Cost

Every traversal visits each node once: O(n) time. Memory: recursion uses O(h), where h is the tree's height (O(log n) if balanced, O(n) if it is a chain); breadth-first keeps up to one full level in the queue.

Read more: https://www.geeksforgeeks.org/dsa/tree-data-structure/

#tip · TIP-064

#tip · TIP-064

Learn: Linked list classic: reverse it Interviewers want your own ...

2026-10-15T05:08:04Z

Learn: Two pointers Two indexes walk the data instead of nested ...

2026-10-14T18:38:04Z

Learn: Two pointers

Two indexes walk the data instead of nested loops. Two common shapes:
From both ends of a sorted array, to find a pair with a given sum (here 11):

```csharp
int[] a = { 1, 3, 4, 7, 9 };
int left = 0, right = a.Length - 1, target = 11;
while (left < right && a[left] + a[right] != target)
if (a[left] + a[right] < target) left++; else right--;
Console.WriteLine(left < right ? $"{a[left]} + {a[right]}" : "no pair");
```

It prints 4 + 7 (or "no pair"). Too small: move left; too big: move right.
Same direction, to remove duplicates from a sorted array in place:

```csharp
int[] a = { 1, 1, 2, 3, 3 };
int w = Math.Min(1, a.Length); // 0 for an empty array
for (int r = 1; r < a.Length; r++)
if (a[r] != a[w - 1]) a[w++] = a[r];
Console.WriteLine(string.Join(" ", a[..w]));
```

It prints 1 2 3. Both are O(n) time, O(1) memory.

Read more: https://www.geeksforgeeks.org/dsa/two-pointers-technique/

#tip · TIP-038

Learn: Big-O rules in one post 1. Drop constants: O(2n) is O(n). ...

2026-10-14T18:08:07Z

Learn: Big-O rules in one post

1. Drop constants: O(2n) is O(n).
2. Keep only the biggest term: O(n² + n) is O(n²).
3. Loops one after another add: O(n) then O(n) is still O(n).
4. Nested loops multiply: a loop over n inside a loop over n is O(n²).
5. Different inputs get different letters: n for one, m for the other.

```csharp
int n = 3, m = 4, steps = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) steps++;
Console.WriteLine(steps);
```

It prints 12: n · m steps.

#big005 · BIG-005-N

Learn: Sharding splits data by a key When one database is too big ...

2026-10-14T17:38:36Z

Learn: PriorityQueue for "smallest first" .NET has ...

2026-10-14T17:08:01Z

Learn: PriorityQueue for "smallest first"

.NET has PriorityQueue<TElement, TPriority>. Dequeue always returns the item with the lowest priority value.

```csharp
var pq = new PriorityQueue<string, int>();
pq.Enqueue("low", 5); pq.Enqueue("urgent", 1); pq.Enqueue("mid", 3);
Console.WriteLine(pq.Dequeue());
```

It prints urgent. Use it for "top k" problems, merging k sorted lists, and Dijkstra's shortest path.

#tip · TIP-011

Learn: Queues decouple services Put a message queue between a ...

2026-10-14T16:08:03Z

Learn: Queues decouple services

Put a message queue between a service that produces work and one that does it. The producer doesn't wait, and a slow consumer just builds a backlog instead of failing.

Most queues deliver "at least once", so a message can arrive twice. Make consumers idempotent (same result when repeated): processing the same message twice must be safe.

#tip · TIP-018

Learn: Observer When something happens, notify everyone who ...

2026-10-14T15:38:15Z

Learn: Observer

When something happens, notify everyone who subscribed. The sender doesn't know who listens.
C# has it built in: events.

```csharp
var button = new Button();
button.Clicked += () => Console.WriteLine("saved");
button.Clicked += () => Console.WriteLine("logged");
button.Click();

class Button
{
public event Action? Clicked;
public void Click() => Clicked?.Invoke();
}
```

It prints saved, then logged.
Use it for UI events, domain events ("order placed"), and notifications.

Read more: https://www.geeksforgeeks.org/system-design/observer-pattern-set-1-introduction/

#tip · TIP-054

Learn: Grid problems: flood fill How to walk a grid in four ...

2026-10-14T15:08:04Z

In reply to naddr1qq…de4k
_________________________

Learn: Grid problems: flood fill

How to walk a grid in four directions, stay inside the bounds, and count connected areas.

Read the full article:

quoting naddr1qq…xlcm

Grid problems: flood fill

Many interview questions give you a grid of cells: a map, an image, a maze. The key move is flood fill: from one cell, visit every connected cell of the same kind.

Counting areas

Count the separate areas of 1s (cells connected up, down, left or right):
string[] map = { "11000", "11001", "00001" };
int rows = map.Length, cols = map[0].Length, areas = 0; var seen = new bool[rows, cols];
for (int r = 0; r < rows; r++) for (int c = 0; c < cols; c++)
    if (map[r][c] == '1' && !seen[r, c]) { areas++; Fill(r, c); }
Console.WriteLine(areas);
void Fill(int r, int c)
{
    if (r < 0 || c < 0 || r >= rows || c >= cols || seen[r, c] || map[r][c] == '0') return;
    seen[r, c] = true; Fill(r + 1, c); Fill(r - 1, c); Fill(r, c + 1); Fill(r, c - 1);
}
It prints 2: one area of four cells top-left, and one of two cells on the right.

The pattern

Loop over every cell.

When you find an unvisited 1, count a new area and flood-fill it.

The fill marks cells as seen and spreads in four directions.

Check the bounds first (row and column inside the grid) before reading a cell; this is where most bugs are.

Cost

Each cell is visited a constant number of times: O(rows × cols) time. The seen grid is O(rows × cols) memory. The recursion can go as deep as the area is big; for very large grids, use a queue (breadth-first) instead of recursion.

C# note

int[,] is one rectangular block; int[][] (jagged) is an array of arrays, where rows can differ in length. Many online judges give you jagged arrays.

Read more: https://www.geeksforgeeks.org/dsa/matrix/

#tip · TIP-069

#tip · TIP-069

Learn: Abstract class An abstract class is a base class you ...

2026-10-14T14:38:21Z

Learn: Abstract class

An abstract class is a base class you can't create directly. It can hold shared code and fields, plus abstract members each subclass must fill in.
A class can inherit from only one class.
Use it when: related classes share real code, not just a contract.

```csharp
Animal[] animals = { new Dog(), new Cat() };
foreach (var a in animals) Console.WriteLine(a.Describe());

abstract class Animal
{
public string Describe() => $"{GetType().Name} says {Sound()}"; // shared code
protected abstract string Sound(); // each subclass fills in
}
class Dog : Animal { protected override string Sound() => "woof"; }
class Cat : Animal { protected override string Sound() => "meow"; }
```

It prints Dog says woof, then Cat says meow.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract

#tip · TIP-049

Question: One loop prints every item of array a (length n). After ...

2026-10-14T14:08:23Z

Question: One loop prints every item of array a (length n). After it, a second loop prints every item of array b (length m).

What is the Big-O? And what if the second loop is inside the first?

Try to answer before you open the reply.

#big005 · BIG-005-Q1

One after the other: O(n + m). The loops add. Nested: O(n · m). ...

2026-10-14T14:08:23Z

In reply to nevent1q…hjvr
_________________________

One after the other: O(n + m). The loops add.

Nested: O(n · m). For every item of a, the inner loop walks all of b.

Don't write O(n) or O(n²) here: a and b have different sizes, so each gets its own letter.

#big005 · BIG-005-A1

Learn: Service lifetimes Transient: a new object every time the ...

2026-10-14T13:38:03Z

Learn: Service lifetimes

Transient: a new object every time the service is asked for (resolved). For light, stateless helpers.
Scoped: one object per web request. For things like a database context.
Singleton: one object for the whole app, until it shuts down. For caches and configuration.

Classic bug: a singleton (or a BackgroundService) that keeps a scoped service, which then lives forever. Fix: create a scope with IServiceScopeFactory for each piece of work.

Read more: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/service-lifetimes

#tip · TIP-044

Learn: Linear search What: check the items one by one until you ...

2026-10-14T13:08:04Z

Learn: Linear search

What: check the items one by one until you find the target.
Cost: O(n) in the worst case, O(1) extra memory.
Use it when: the data is not sorted, is small, or you search only once. Sorting first costs O(n log n), more than one linear search.

```csharp
int[] a = { 7, 3, 9, 1 };
Console.WriteLine(Array.IndexOf(a, 9));
Console.WriteLine(Array.IndexOf(a, 5));
```

It prints 2, then -1 (not found). Array.IndexOf and List<T>.Contains are linear searches.

Read more: https://www.geeksforgeeks.org/dsa/linear-search/

#tip · TIP-033

Learn: Merge sort, step by step How merge sort splits, sorts and ...

2026-10-14T12:38:04Z

In reply to naddr1qq…ed8x
_________________________

Learn: Merge sort, step by step

How merge sort splits, sorts and merges; why it is O(n log n); and when to choose it.

Read the full article:

quoting naddr1qq…ctjv

Merge sort, step by step

Merge sort is the classic divide and conquer sort.

Divide: split the array into two halves.

Conquer: sort each half, with merge sort again (recursion).

Combine: merge the two sorted halves into one sorted array.

An array of one item is already sorted, so the recursion stops there.

The code
Console.WriteLine(string.Join(" ", Sort(new[] { 5, 2, 9, 1, 6 })));
static int[] Sort(int[] a)
{
    if (a.Length <= 1) return a;
    int[] left = Sort(a[..(a.Length / 2)]), right = Sort(a[(a.Length / 2)..]); // split in half
    var result = new List<int>(); int i = 0, j = 0;
    while (i < left.Length && j < right.Length) result.Add(left[i] <= right[j] ? left[i++] : right[j++]);
    result.AddRange(left[i..]); result.AddRange(right[j..]); // copy what is left
    return result.ToArray();
}
It prints 1 2 5 6 9.

Merging

Look only at the front of each half and take the smaller item. Repeat until one half is empty, then copy what is left of the other. Using <= keeps equal items in their original order, so merge sort is stable.

Cost

Time: O(n log n) in every case. There are about log n levels of splitting, and each level merges n items in total.

Memory: O(n) extra for the merged arrays.

When to choose it

You need a stable sort.

You sort a linked list (merging needs no random access).

The data is too big for memory and is sorted in chunks on disk (external sorting).

In everyday C#, Array.Sort is O(n log n) and the right default, but it is not stable; OrderBy in LINQ is stable. Know merge sort for interviews and for the cases above.

Read more: https://www.geeksforgeeks.org/dsa/merge-sort/

#tip · TIP-037

#tip · TIP-037

Learn: Matrix What: a grid of rows and columns; m[row, col] reads ...

2026-10-14T12:08:14Z

Learn: Matrix

What: a grid of rows and columns; m[row, col] reads one cell.
Cost: visiting every cell is O(rows × cols).
Use it when: data is naturally a grid: images, game boards, maps, seating plans, or a table of results in dynamic programming.

```csharp
int[,] grid = { { 1, 2 }, { 3, 4 } };
int sum = 0;
foreach (int x in grid) sum += x;
Console.WriteLine($"{grid.GetLength(0)}x{grid.GetLength(1)}, sum {sum}");
```

It prints 2x2, sum 10. Common interview moves: walk row by row, walk the diagonal, rotate, or spiral.

Read more: https://www.geeksforgeeks.org/dsa/matrix/

#tip · TIP-025

Learn: Think out loud In a coding interview, the interviewer ...

2026-10-14T11:38:03Z

Learn: Think out loud

In a coding interview, the interviewer grades how you think, not only the final code. Say what you are trying, why, and what you would check next.

Silence for five minutes looks the same as being stuck, even when you are close.

#tip · TIP-001

Learn: Dependency injection in ASP.NET Core Why DI exists, how to ...

2026-10-14T11:08:03Z

In reply to naddr1qq…ll7y
_________________________

Learn: Dependency injection in ASP.NET Core

Why DI exists, how to register services, the three lifetimes, and the mistakes interviewers ask about.

Read the full article:

quoting naddr1qq…gsgw

Dependency injection in ASP.NET Core

The idea

A class shouldn't create the things it depends on. It asks for them in its constructor, and something outside provides them. That something is the DI container.
IEmailSender sender = new ConsoleEmailSender();
var orders = new OrderService(sender);
orders.PlaceOrder("book");

interface IEmailSender { void Send(string text); }
class ConsoleEmailSender : IEmailSender { public void Send(string text) => Console.WriteLine(text); }
class OrderService(IEmailSender sender)
{
    public void PlaceOrder(string item) => sender.Send($"Ordered: {item}");
}
It prints Ordered: book. The demo wires the objects by hand; in ASP.NET Core the container does it. Swap ConsoleEmailSender for a fake in a unit test, and OrderService doesn't change.

Registering services

In Program.cs, tell the container which class to use for each interface:

builder.Services.AddTransient<IClock, SystemClock>();

builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();

builder.Services.AddSingleton<ICache, MemoryCache>();

Controllers, minimal API handlers and other services then just list what they need in their constructors or parameters.

The three lifetimes

Lifetime One object per… Typical use

Transient every time it is asked for (resolved) small stateless helpers

Scoped HTTP request DbContext, unit of work

Singleton whole app caches, configuration, clients meant to be shared

Mistakes interviewers ask about

Captive dependency (a longer-lived service holding a shorter-lived one): a singleton that takes a scoped service in its constructor keeps it for the whole app. A DbContext shared by all requests is not thread-safe and breaks.

new inside the class: creating dependencies with new hides them and makes testing hard.

Too many constructor parameters: a sign the class does too much.

Read more: https://roadmap.sh/aspnet-core

#tip · TIP-047

Lifetime	One object per…	Typical use
Transient	every time it is asked for (resolved)	small stateless helpers
Scoped	HTTP request	`DbContext`, unit of work
Singleton	whole app	caches, configuration, clients meant to be shared

#tip · TIP-047

Learn: Ask before you code Before writing anything, ask about the ...

2026-10-14T10:38:01Z

Learn: Ask before you code

Before writing anything, ask about the input:

Can it be empty or null?
Are there duplicates or negative numbers?
Is it sorted?
How big can it get?

The answers often change the best solution, and asking shows the interviewer you think about edge cases.

#tip · TIP-002

Both are O(n) time. The HashSet is simpler: the first node you ...

2026-10-14T10:08:00Z

In reply to nevent1q…4fzg
_________________________

Both are O(n) time.

The HashSet is simpler: the first node you see twice is the loop start. But it stores nodes, so it needs O(n) memory.

Fast and slow pointers need only O(1) memory. In an interview, give the HashSet idea first, then improve it.

#ll012 · LL-012-A3

Which is better for finding where a loop starts: a HashSet of ...

2026-10-14T10:08:00Z

Which is better for finding where a loop starts: a HashSet of visited nodes, or fast and slow pointers?

Try to answer before you open the reply.

#ll012 · LL-012-Q3

Learn: Concurrency vs parallelism Concurrency: several tasks are ...

2026-10-14T09:37:56Z

Learn: Concurrency vs parallelism

Concurrency: several tasks are in progress at the same time, maybe taking turns on one core. Example: a server waiting on many database calls.
Parallelism: work really runs at the same moment on several cores. Example: resizing 1,000 images.

In .NET: waiting on I/O → async/await. CPU-heavy work → Parallel.For, or Task.Run in UI apps (on a server, Task.Run only moves work between pool threads). Both bring the same risk: shared data touched by two threads at once.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming

#tip · TIP-072

Learn: Tree What: nodes in a hierarchy. One root at the top, each ...

2026-10-14T09:08:00Z

Learn: Tree

What: nodes in a hierarchy. One root at the top, each node has children, nodes with no children are leaves.
Use it when: data is nested: folders, HTML, company org charts, menus, and database indexes.
Most tree problems are recursion: solve for the children, then combine.

```csharp
var root = new Tree(1, new Tree(2, null, null), new Tree(3, new Tree(4, null, null), null));
Console.WriteLine(Count(root));

static int Count(Tree? t) => t == null ? 0 : 1 + Count(t.Left) + Count(t.Right);
```

It prints 4: the number of nodes.

Read more: https://www.geeksforgeeks.org/dsa/tree-data-structure/

#tip · TIP-030

Learn: Array What: items stored side by side in memory, each at ...

2026-10-14T08:38:05Z

Interviewer's follow-up: "For the sum from index i to j, ...

2026-10-14T08:08:03Z

Interviewer's follow-up: "For the sum from index i to j, you wrote prefix[j + 1] - prefix[i]. Why j + 1? Why not prefix[j] - prefix[i]?"

Use prefix = { 0, 6, 8, 15, 16, 20 } and the range index 1 to 3.

Try to answer before you open the reply.

#arr016 · ARR-016-Q2

prefix[k] is the sum of the first k items: index 0 to k - 1. So ...

2026-10-14T08:08:03Z

In reply to nevent1q…kn8h
_________________________

prefix[k] is the sum of the first k items: index 0 to k - 1. So prefix[j] stops just before index j.

To include index j you need the first j + 1 items. Then subtract the first i items.

```csharp
Console.WriteLine(prefix[4] - prefix[1]); // index 1 to 3
Console.WriteLine(prefix[3] - prefix[1]); // misses index 3
```

prefix[4] - prefix[1] = 10 = 2 + 7 + 1. prefix[3] - prefix[1] = 9 misses the item at index 3.

#arr016 · ARR-016-A2

Learn: Stack What: last in, first out. Push adds on top ...

2026-10-14T07:37:57Z

Learn: Stack

What: last in, first out. Push adds on top (amortized O(1): usually instant, sometimes the stack has to grow), Pop takes from the top in O(1).
Use it when: you must undo or go back: undo in an editor, the browser back button, matching brackets, depth-first search.

```csharp
var pairs = new Dictionary<char, char> { [')'] = '(', [']'] = '[' };
var stack = new Stack<char>();
bool ok = true;
foreach (char c in "([])")
if (!pairs.ContainsKey(c)) stack.Push(c);
else ok &= stack.Count > 0 && stack.Pop() == pairs[c];
Console.WriteLine(ok && stack.Count == 0);
```

It prints True: every closing bracket matched the last open one.

Read more: https://www.geeksforgeeks.org/dsa/stack-data-structure/

#tip · TIP-027

Learn: Sharding splits data by a key When one database is too big ...

2026-10-14T07:08:02Z

Learn: Brute force first, then improve If you don't see the ...

2026-10-14T06:38:00Z

Learn: Brute force first, then improve

If you don't see the best solution right away, say the simple one first, with its Big-O. For example: "Check every pair: O(n²)."

Then ask yourself what work is repeated. A HashSet, sorting, or two pointers often removes it. A working slow answer beats an unfinished fast one.

#tip · TIP-003

Interviewer's follow-up: "Find the shared node without ...

2026-10-14T06:08:01Z

Interviewer's follow-up: "Find the shared node without computing the lengths."

Try to answer before you open the reply.

#ll011 · LL-011-Q3

Walk both lists, and when a pointer reaches the end, restart it ...

2026-10-14T06:08:01Z

In reply to nevent1q…awuq
_________________________

Walk both lists, and when a pointer reaches the end, restart it at the head of the other list.

```csharp
Node shared = Build(8, 9);
Node a = new(1, new(2, new(3, shared))), b = new(5, shared);
Node? p = a, q = b;
while (p != q)
{
p = p == null ? b : p.Next;
q = q == null ? a : q.Next;
}
Console.WriteLine(p?.Value);
```

It prints 8. Each pointer walks lenA + lenB steps in total, so they arrive at the shared part at the same moment.

No shared node? Then both reach null after lenA + lenB steps, together. p == q (both null), and the loop ends.

#ll011 · LL-011-A3

Learn: Costs worth knowing by heart Read array[i]: O(1) Search an ...

2026-10-14T05:38:00Z

Learn: Costs worth knowing by heart

Read array[i]: O(1)
Search an unsorted array: O(n)
Sort: O(n log n)
HashSet or Dictionary lookup: O(1) on average
Search a sorted array with binary search: O(log n)

When you state a solution in an interview, say its Big-O with it.

#tip · TIP-005

Learn: OAuth 2.0 vs OpenID Connect OAuth 2.0 is about access: it ...

2026-10-14T05:07:58Z

Learn: OAuth 2.0 vs OpenID Connect

OAuth 2.0 is about access: it lets an app call an API for the user, with an access token.
OpenID Connect (OIDC) adds login on top: an ID token that says who the user is.
The usual flow for web and mobile apps is the authorization code flow with PKCE: the user logs in at the identity provider, the app gets a code, and swaps it for tokens.
Short version: access token → for the API; ID token → for the app, to know who logged in.

Read more: https://learn.microsoft.com/en-us/entra/identity-platform/v2-protocols-oidc

#tip · TIP-093

Learn: Linear search What: check the items one by one until you ...

2026-10-13T18:37:58Z

Store each result the first time you compute it, and return the ...

2026-10-13T18:08:04Z

In reply to nevent1q…h6m5
_________________________

Store each result the first time you compute it, and return the stored value next time. This is called memoization.

```csharp
var memo = new long[51];
Console.WriteLine(Fib(50));

long Fib(int n)
{
if (n < 2) return n;
if (memo[n] != 0) return memo[n];
return memo[n] = Fib(n - 1) + Fib(n - 2);
}
```

It prints 12586269025 at once. Each value is computed once: O(n) time. Memory: O(n) for the array, plus O(n) for the recursion depth.

#big011 · BIG-011-A2

Question: Make Fib fast by remembering results you already ...

2026-10-13T18:08:04Z

Question: Make Fib fast by remembering results you already computed. What are the new time and memory?

Try to answer before you open the reply.

#big011 · BIG-011-Q2

Learn: Bitwise tricks Operators: & (and), | (or), ^ (xor), ~ ...

2026-10-13T17:38:03Z

Learn: Starvation Starvation: a thread is ready to work but never ...

2026-10-13T17:08:04Z

Learn: Starvation

Starvation: a thread is ready to work but never gets the resource or CPU time, because others keep taking it. Unlike a deadlock, the program still moves; one part just never does.
Classic example: a lock that is not fair. Monitor (lock) doesn't promise first come, first served, so under heavy use one thread can keep losing.
In .NET servers, a related problem is thread-pool starvation: blocking calls (.Result, .Wait()) hold pool threads, so new requests wait.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices

#tip · TIP-080

Learn: Merge sort, step by step How merge sort splits, sorts and ...

2026-10-13T16:37:57Z

In reply to naddr1qq…473e
_________________________

Learn: Merge sort, step by step

How merge sort splits, sorts and merges; why it is O(n log n); and when to choose it.

Read the full article:

quoting naddr1qq…0mf9

Merge sort, step by step

Merge sort is the classic divide and conquer sort.

Divide: split the array into two halves.

Conquer: sort each half, with merge sort again (recursion).

Combine: merge the two sorted halves into one sorted array.

An array of one item is already sorted, so the recursion stops there.

The code
Console.WriteLine(string.Join(" ", Sort(new[] { 5, 2, 9, 1, 6 })));
static int[] Sort(int[] a)
{
    if (a.Length <= 1) return a;
    int[] left = Sort(a[..(a.Length / 2)]), right = Sort(a[(a.Length / 2)..]); // split in half
    var result = new List<int>(); int i = 0, j = 0;
    while (i < left.Length && j < right.Length) result.Add(left[i] <= right[j] ? left[i++] : right[j++]);
    result.AddRange(left[i..]); result.AddRange(right[j..]); // copy what is left
    return result.ToArray();
}
It prints 1 2 5 6 9.

Merging

Look only at the front of each half and take the smaller item. Repeat until one half is empty, then copy what is left of the other. Using <= keeps equal items in their original order, so merge sort is stable.

Cost

Time: O(n log n) in every case. There are about log n levels of splitting, and each level merges n items in total.

Memory: O(n) extra for the merged arrays.

When to choose it

You need a stable sort.

You sort a linked list (merging needs no random access).

The data is too big for memory and is sorted in chunks on disk (external sorting).

In everyday C#, Array.Sort is O(n log n) and the right default, but it is not stable; OrderBy in LINQ is stable. Know merge sort for interviews and for the cases above.

Read more: https://www.geeksforgeeks.org/dsa/merge-sort/

#tip · TIP-037

#tip · TIP-037

Learn: Ask before you code Before writing anything, ask about the ...

2026-10-13T16:08:00Z

Learn: The lock statement lock lets only one thread at a time run ...

2026-10-13T15:38:03Z