Daily micro-tips for C#, SQL, performance, and scalable backend engineering.
Exceptions are control-flow bombs. Cost Stack trace capture Heap allocations Cache pollution Rule Exceptions = exceptional cases. Alternative if (!TryParse(value, out result)) { // handle } Cause → Effect Using exceptions as logic → invisible performance debt.
Records are great.Until you overuse them. Why Value-based equality Copy semantics More allocations in loops Rule Use records for: DTOs Messages Boundaries Avoid in: Hot loops Performance-critical paths
Async ≠ non-blocking by default. The trap await Task.Run(() => LongCpuWork()); You just moved blocking to the thread pool. Rule Async is for I/O, not CPU. Correct Use async APIs for I/OUse background workers for CPU
It’s not the count.It’s locking + metadata access. Reality COUNT must respect: Isolation level Pending writes Allocation metadata Production alternative Use approximate counts for dashboards. Why Accuracy isn’t always worth blocking.
The index is fine.The predicate is not. Example WHERE YEAR(OrderDate) = 2024 Why it fails Functions on columns prevent index seeks. Rewrite WHERE OrderDate >= ‘2024-01-01’ AND OrderDate < ‘2025-01-01’ Cause → Effect Function → scan → CPU spike → slow queries.
Most people think it magically fixes everything. Reality Misusing named clients causes: DNS caching issues Handler lifetime misuse Hidden fix Use typed clients for long-lived services. Why Typed clients scope handlers correctly to the service lifetime.
Looks fine locally.Stops running in prod. Root cause Unhandled exceptions inside ExecuteAsync. What actually happens The host kills the service quietly. Correct pattern protected override async Task ExecuteAsync(CancellationToken ct) { while (!ct.IsCancellationRequested) { try { await DoWork(ct); } catch (Exception ex) { logger.LogError(ex, “Background task failed”); await Task.Delay(5000, ct); } } } Cause → Effect […]
Big commits don’t just slow reviews. Real damage Breaks git bisect Makes rollback risky Hides causal relationships Rule One commit = one reason. Mental model If you can’t describe the commit in one sentence, it’s too big.
The issue is not conflicts.It’s implicit merge commits. What happens git pull = fetch + merge That merge commit: Breaks linear history Hides real change intent Makes bisect harder Safer default git config –global pull.rebase true Why this matters Rebase preserves intent, merge preserves state.Teams need intent.
Locally works.Production fails. Cause Preflight CORS requests. What happens Browser sends: OPTIONS /api/data Before: POST /api/data If server doesn’t handle OPTIONS → fail. Minimal fix (ASP.NET example) app.UseCors(builder => builder.AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader()); Why this matters Ajax failures are often network policy, not JS bugs.
This is NOT about micro-optimizations.It’s about callback overhead. Example items.forEach(item => process(item)); vs for (let i = 0; i < items.length; i++) { process(items[i]); } Why forEach creates a function call per iteration Harder for JS engines to optimize No early break support When it matters Large arrays Hot paths Real-time processing Rule Readability first.But […]
Everyone uses it for images.Almost nobody uses it for iframes. Example <iframe src=”https://www.youtube.com/embed/VIDEO_ID” loading=”lazy”> </iframe> Why this matters Prevents layout blocking Improves First Contentful Paint (FCP) Massive win for content-heavy blogs Cause → Effect Less initial network pressure → faster perceived load.
Most people blame the browser.The real reason is parent overflow context. Problem .sidebar { position: sticky; top: 0; } Works… until it doesn’t. Hidden cause If ANY parent has: overflow: hidden; overflow: auto; overflow: scroll; Sticky breaks. Why position: sticky is calculated relative to the nearest scroll container, not the viewport. Fix .parent { overflow: […]
Press: Win + V You get: Clipboard history Pinned snippets Cross-app reuse Use case Store: SQL snippets Git commands Email templates This alone can save hours per week.
Cause Background apps + power profile mismatch. Fix Settings → Power → Power Mode → Best performance Disable “Startup apps” you don’t need Turn off transparency effects Why this works Windows dynamically downclocks UI threads on balanced mode.
Not productivity porn. Real execution. Prompt Create a 30-day plan to learn [SKILL].Constraints: max 45 minutes per day no paid resources weekly measurable outcome final real-world deliverableAvoid motivational language. Be practical. Why it works AI shines at structured planning, not motivation.
Humans profile what they expect to be slow.AI finds what’s actually slow. Prompt Review this code for performance risks.Focus on: hidden allocations unnecessary async boundaries repeated I/O GC pressureExplain WHY each issue matters and when it becomes visible in production.Code: [PASTE HERE] Why this matters These issues don’t appear in small test data. They explode […]
Use this when You inherit ugly but working code. Prompt Analyze the following code. Identify hidden coupling and responsibility leaks Propose a Clean Architecture refactor without changing behavior Suggest incremental steps, not a full rewrite Show before/after structure diagramsCode: [PASTE HERE] Why it works AI is excellent at structural reasoning, not just code generation.
Image size ≠ image performance. Hidden cause Layer invalidation. Most Dockerfiles are written like this: COPY . . RUN npm install Every small file change invalidates the cache. Correct approach COPY package.json package-lock.json ./ RUN npm install COPY . . Cause → Effect Stable dependency layers Faster rebuilds Lower CI/CD costs This is why two […]
This is a classic production trap. Root cause readinessProbe ≠ livenessProbe Most people use only one. Correct pattern livenessProbe: httpGet: path: /health/live port: 80 readinessProbe: httpGet: path: /health/ready port: 80 Why this matters Liveness = should I restart? Readiness = should I receive traffic? If your app is warming caches or reconnecting DBs, traffic arrives […]
WordPress creates pages for every uploaded image. What happens Thin content pages Duplicate titles Crawled but useless URLs Fix (no plugin) Redirect attachment pages: add_action(‘template_redirect’, function () { if (is_attachment()) { wp_redirect(home_url(), 301); exit; } }); Why this works You’re reclaiming crawl budget and removing SEO noise. Most blogs never fix this. That’s why it […]
Most WordPress sites are plugin-heavy for no reason. Hidden power WordPress Block Editor already supports conditional rendering via PHP + block patterns. Example Show a CTA only for logged-out users: if (!is_user_logged_in()) { echo do_blocks(‘<!– wp:buttons –>…<!– /wp:buttons –>’); } Why this matters Fewer plugins → fewer update risks Faster TTFB Full control over UX […]
Great for e-commerce & ads. Steps Convert to Smart Object Apply Gradient Map (dark gray → silver) Overlay Directional Motion Blur mask Why it works Metal reflects directionally; plastic diffuses light.You’re faking physics, not color.
Most people retouch. Professionals reconstruct. Technique Duplicate layer Use Content-Aware Fill only for structure Switch to Clone Stamp (Lighten mode) Why Lighten? It preserves shadows while rebuilding highlights — ideal for cracks. Pro tip Finish with a 5–8% noise layer to unify texture.
Ever noticed code behaving differently in Debug vs Release? Root cause Visual Studio injects: Different JIT optimizations Conditional compilation (#if DEBUG) Altered timing (especially async code) Hidden fix Force Release-mode debugging: <PropertyGroup Condition=”‘$(Configuration)’==’Release'”> <DebugType>portable</DebugType> </PropertyGroup> Why this matters Many race conditions only exist in optimized builds.Debug mode can mask real production bugs.
LINQ is elegant… and allocates. Problem Deferred execution Hidden enumerators Fix Use LINQ at boundaries, not inside loops. for (int i = 0; i < list.Count; i++) { Process(list[i]); } Why Predictable execution beats elegance under load.
You don’t control who else locks this. Fix private readonly object _sync = new(); lock (_sync) { } Why Encapsulation matters in threading.
async void hides exceptions. Only valid Event handlers Wrong async void Process() { throw new Exception(); } Correct async Task Process()
Indexes are not magic. Bad case Low-selectivity columns Over-indexing Diagnosis SET STATISTICS IO ON; Why Wrong index = more lookups than scans.
Today it’s fine. Tomorrow it’s slow. Why Schema changes Wider rows More IO Fix Select only what you need. SELECT Id, Name FROM Users;