undefined

Nothing more

[Elon Musk @elonmusk]

https://t.co/jn3ganMSpJ

[Muhammad Waseem @mwaseemzakir]

𝗬𝗼𝘂 𝗰𝗮𝗻 𝗿𝗲𝗰𝗶𝘁𝗲 𝗦𝗢𝗟𝗜𝗗. 𝗖𝗮𝗻 𝘆𝗼𝘂 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗮𝗽𝗽𝗹𝘆 𝗶𝘁?

I have reviewed hundreds of codebases. The pattern is always the same.

Developers know the definitions. They fail the moment a real design decision appears.
Here is what each principle actually means in production:

𝗦 — Single Responsibility
Not "one class, one job."
It means one reason to change. If your OrderService sends emails AND processes payments AND logs activity, you have three reasons to change one class. That is three bugs waiting to happen.

𝗢 — Open/Closed
Your code should be open for extension, closed for modification.
Stop adding if/else blocks every time a new requirement arrives. Use abstractions. A new payment method should not touch existing payment logic.

𝗟 — Liskov Substitution
If you replace a parent with a child, behavior should not break.
When your Square inherits Rectangle and overrides SetWidth, you have already violated this. Inheritance is not always the answer.

𝗜 — Interface Segregation
Do not force classes to implement methods they do not need.
A fat IUserRepository with 20 methods means every mock in your tests implements 19 methods it does not care about. Split them.

𝗗 — Dependency Inversion
Depend on abstractions, not concretions.
Your service should not new up a UserRepository. Inject IUserRepository. This is what makes your code testable, swappable, and production-ready.

The real lesson nobody talks about:
==> SOLID is not a checklist. It is a set of signals.
==> When your code becomes painful to change, SOLID tells you exactly which rule you broke.
==> The developers who apply it well are not the ones who memorized it.
==> They are the ones who felt the pain of violating it first.

Which principle did you violate before you truly understood it?

📌 If you found it helpful then you should join my weekly .NET newsletter with 10k+ engineers.

Subscribe here → https://t.co/xD0dyrLiSr

Repost ♻️ would be appreciated

[Anton Martyniuk @AntonMartyniuk]

𝗬𝗼𝘂 𝘀𝗵𝗼𝘂𝗹𝗱 𝘀𝘁𝗼𝗽 𝘂𝘀𝗶𝗻𝗴 𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿𝘀 𝗶𝗻 .𝗡𝗘𝗧 𝟭𝟬

While I was at Microsoft .NET Conf 2025

I saw this shocking benchmark 👇

In TechEmpower benchmarks for minimal APIs:
→ .NET 10 uses 93% less memory than .NET 8
→ While still being ~15% faster in throughput

.NET 10 also introduces significant garbage collection (GC) improvements, particularly through Dynamic Adaptation to Application Sizes (DATAS) and enhanced write barriers.

This automatically benefits both workstation and server GC modes (<ServerGarbageCollection> property in *csproj).

After migrating my projects to .NET 10 with Minimal APIs I have experienced:
→ Less RAM usage
→ Better throughput
→ Faster APIs

This is why I recommend everyone to use Minimal APIs instead of Controllers in every new .NET project.

Why is .NET so fast?

- 𝗔𝗱𝗮𝗽𝘁𝗶𝘃𝗲 𝗦𝗲𝗿𝘃𝗲𝗿 𝗚𝗖 adjusts in real time, reducing pause frequency and sustaining throughput during traffic spikes.

- 𝗦𝗺𝗮𝗿𝘁𝗲𝗿 𝗝𝗜𝗧 trims warm‑up time and accelerates hot methods, producing consistently shorter response cycles.

- 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝘃𝗲𝗰𝘁𝗼𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 leverages AVX10 and Arm SVE, letting loops process multiple data points per tick.

- 𝗡𝗮𝘁𝗶𝘃𝗲 𝗔𝗢𝗧 further cuts binaries and startup cost, ideal for containers, IoT, and edge workloads.

- 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗱 𝗻𝗲𝘁𝘄𝗼𝗿𝗸𝗶𝗻𝗴 improves socket handling and HTTP/3 support, delivering lower latency for high‑connection services.

- 𝗙𝗮𝘀𝘁𝗲𝗿 𝗝𝗦𝗢𝗡 processing in System.Text.Json reduces allocation, enabling leaner APIs and real‑time data streams.

- 𝗟𝗼𝘄𝗲𝗿 𝗮𝗹𝗹𝗼𝗰𝗮𝘁𝗶𝗼𝗻𝘀 via spans, inline arrays, and pooled buffers lighten GC pressure and memory footprint.

- 𝗧𝗵𝗿𝗲𝗮𝗱‑𝗽𝗼𝗼𝗹 logic minimizes contention, ensuring asynchronous operations remain smooth under mixed loads.

- 𝗘𝗻𝗵𝗮𝗻𝗰𝗲𝗱 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴 schedules tasks more evenly, unlocking full core capacity for parallel workloads.

- 𝗖𝗿𝘆𝗽𝘁𝗼𝗴𝗿𝗮𝗽𝗵𝘆 𝗿𝗼𝘂𝘁𝗶𝗻𝗲𝘀 are streamlined, providing robust security without incurring excessive computational overhead.

- 𝗖𝗹𝗼𝘂𝗱‑𝗻𝗮𝘁𝗶𝘃𝗲 tooling reduces cold starts and aligns neatly with Kubernetes, simplifying microservice deployment.

- 𝗙𝗶𝗹𝗲 𝗜/𝗢 now buffers intelligently, boosting throughput for applications that read or write extensive data.

- 𝗥𝗲𝗳𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 pathways are optimized, cutting overhead for dependency injection and dynamic object scenarios.

- 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 became 2-4 times faster in .NET 10, according to Microsoft Benchmarks

Here is what you need to know to migrate your projects to .NET 10:
↳ https://t.co/UIdUqy8NS6

——

♻️ Repost to help others migrate to .NET 10

➕ Follow me ( @AntonMartyniuk ) to improve your .NET and Architecture Skills

[Vishakha Singhal @vishisinghal_]

Most people think using Claude Code is about writing better prompts.

It’s not.

The real unlock is structuring your repository so Claude can think like an engineer.

If your repo is messy, Claude behaves like a chatbot.

If your repo is structured, Claude behaves like a developer living inside your codebase.

Your project only needs 4 things:

• the why → what the system does
• the map → where things live
• the rules → what’s allowed / forbidden
• the workflows → how work gets done

I call this:

The Anatomy of a Claude Code Project 👇

━━━━━━━━━━━━━━━

1️⃣ CLAUDE.md = Repo Memory (Keep it Short)

This file is the north star for Claude.

Not a massive document.

Just three things:

• Purpose → why the system exists
• Repo map → how the project is structured
• Rules + commands → how Claude should operate

If CLAUDE.md becomes too long, the model starts missing critical signals.

Clarity beats size.

━━━━━━━━━━━━━━━

2️⃣ .claude/skills/ = Reusable Expert Modes

Stop repeating instructions in prompts.

Turn common workflows into reusable skills.

Examples:

• code review checklist
• refactoring playbook
• debugging workflow
• release procedures

Now Claude can switch into specialized modes instantly.

Result:

More consistent outputs across sessions and teammates.

━━━━━━━━━━━━━━━

3️⃣ .claude/hooks/ = Guardrails

Models forget.

Hooks don’t.

Use hooks for things that must always happen automatically.

Examples:

• run formatters after edits
• trigger tests after core changes
• block sensitive directories (auth, billing, migrations)

Hooks turn AI workflows into reliable engineering systems.

━━━━━━━━━━━━━━━

4️⃣ docs/ = Progressive Context

Don’t overload prompts with information.

Instead, let Claude navigate your documentation.

Examples:

• architecture overview
• ADRs (engineering decisions)
• operational runbooks

Claude doesn’t need everything in memory.

It just needs to know where truth lives.

━━━━━━━━━━━━━━━

5️⃣ Local CLAUDE.md for Critical Modules

Some areas of your system have hidden complexity.

Add local context files there.

Example:

src/auth/CLAUDE.md
src/persistence/CLAUDE.md
infra/CLAUDE.md

Now Claude understands the danger zones exactly when it works in them.

This dramatically reduces mistakes.

━━━━━━━━━━━━━━━

Here’s the shift most people miss:

Prompting is temporary.

Structure is permanent.

Once your repository is designed for AI:

Claude stops acting like a chatbot...

…and starts behaving like a project-native engineer. 🚀

[Milan Jovanović @mjovanovictech]

800 Million Users. Millions of queries per second. 1 Primary Write Node.

OpenAI just revealed their database architecture.

The stack is simpler than you think:
- Single primary write DB
- 50 read replicas
- PgBouncer

I drew out the entire architecture: https://t.co/eRdEhC4U98

[Milan Jovanović @mjovanovictech]

How can you version Minimal APIs?

You need to define an ApiVersionSet and apply it to your endpoints.

A smarter approach is to create a route group and apply the API version. Then, you'll use the route group to map individual endpoints.

[Milan Jovanović @mjovanovictech]

Did you check out the resilience improvements in .NET 9?

We have two official NuGet packages:

- Microsoft.Extensions.Resilience
- Microsoft.Extensions.Http.Resilience

They're built on top of Polly, so the API should be familiar. You can use them to define resilience policies in C#.

They extend Polly with some useful features. For example, a standard pipeline you can add to HttpClients. There's also an OpenTelemetry integration.

A few strategies that are available out of the box:

- Retries
- Timeouts
- Fallbacks
- Circuit breakers

Want to learn more about resilience in .NET?

Start here: https://t.co/iVQQ2oWW2M

If this saves you from even one network failure, it'll be worth it.

---
Sign up for the .NET Weekly with 75K+ other engineers, and get a free Clean Architecture template: https://t.co/XPFjaPrtFG

[Unitree @UnitreeRobotics]

Unitree G1 has mastered more quirky skills 🤩
Unitree G1 has learned the "Anti-Gravity" mode: stability is greatly improved under any action sequence, and even if it falls, it can quickly get back up.

[Milan Jovanović @mjovanovictech]

How does vector search work?

[Anton Martyniuk @AntonMartyniuk]

𝗙𝗮𝘀𝘁𝗘𝗻𝗱𝗽𝗼𝗶𝗻𝘁𝘀 > 𝗠𝗶𝗻𝗶𝗺𝗮𝗹 𝗔𝗣𝗜𝘀 > 𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿𝘀

I used all 3 in production, here is the comparison

Most developers struggle to choose between these three.

I spent months comparing them in real large-scale projects, so you don't have to 👇

1. Controllers (⭐️ 3.5/5)

• Rich MVC ecosystem with built-in features
• Well-organized, familiar architecture
• Strong routing & filters
• Battle-tested in enterprise
• Full OpenAPI support

But... more ceremony, slower performance 🐌

2. Minimal APIs (⭐️ 4.5/5)

• Lightweight & blazing fast (10-15% boost)
• Less boilerplate code
• Simple endpoint mapping
• Authentication built-in
• Built-in parameter binding
• Perfect for Vertical Slices

But... requires manual setup in large apps 😕

3. FastEndpoints (⭐️ 5/5) 🏆

• Fastest development speed
• Ready endpoint structure
• Type-safe requests/responses
• FluentValidation built-in
• Authentication built-in
• Perfect for Vertical Slices
• Nearly Minimal APIs performance

The clear winner for me? FastEndpoints.

Why? It gives you:
✅ Minimal APIs speed
✅ Strongly-typed
✅ Best dev experience

Which approach do you prefer? Share below 👇

📌 Subscribe to my free .NET newsletter, improve how you write software (link in my profile)

—

♻️ Repost to help others compare ASP .NET Core options to build APIs

➕ Follow me ( @anton-martyniuk ) for more

[undefined @Lu69x]

@naiivememe bullshit, 2025 win

[Milan Jovanović @mjovanovictech]

Here are 9 excellent libraries I use in my projects:

1. YARP
2. Polly
3. EF Core
4. Refit
5. Testcontainers
6. OpenTelemetry
7. FluentValidation
8. SignalR
9. Dapper

Which library would you add to the list?

P.S. Here's a free Clean Architecture template showing you how to use these libraries: https://t.co/DEiKR3ed2K

[Milan Jovanović @mjovanovictech]

I struggled with Modular Monoliths until I learned these concepts:

1. What Is a Modular Monolith?
https://t.co/r63cHLNiGI

2. Monolith to Microservices: How a Modular Monolith Helps
https://t.co/1l5nEREWd8

3. Modular Monolith Data Isolation
https://t.co/LA8jWffHMW

4. Modular Monolith Communication Patterns
https://t.co/aW2Tjj2IgQ

5. Testing Modular Monoliths: System Integration Testing
https://t.co/IHyfwJ7wiC

6. How to Keep Your Data Boundaries Intact in a Modular Monolith
https://t.co/aMZOkyVuwu

7. How to Migrate Your Modular Monolith to Microservices
https://t.co/UaQwTGKpuf

8. Internal vs. Public APIs in Modular Monoliths
https://t.co/z0n4NmFOuS

9. Refactoring Overgrown Bounded Contexts in Modular Monoliths
https://t.co/EPJ6mSkQYU

10. Scaling Monoliths: A Practical Guide
https://t.co/u66dxu0xfS

The articles above will be a great foundation.

But if you truly want to master modular monoliths from scratch, I created the Modular Monolith Architecture course.

If you wanted to see a practical implementation of this architecture, this is it.

We're going to build a production-ready system from scratch. This includes dozens of API endpoints, 50+ use cases, and 6,000+ lines of code.

Get started today: https://t.co/0u3gr3RsjG

[Old Internet @OldInternetFeel]

most used web browser through time

[undefined @Lu69x]

@mjovanovictech well, you knew too ? :))

[undefined @Lu69x]

@CryptoHayes U mean 500$ and 30$ ?

[Milan Jovanović @mjovanovictech]

I run my integration tests inside the CI/CD pipeline.

This gives me maximum confidence in my code.

It's all thanks to Testcontainers and Docker.

You can run external services as containers and access them in the tests.

Here's how to spin up:

- PostgreSQL
- Keycloak
- Redis

And now you can connect to these services from your application code.

Ready to take your integration testing in .NET to the next level?

You will love this article: https://t.co/eYjqyvgKRv

[undefined @Lu69x]

@theo Bullshit, GO

[undefined @Lu69x]

@ThuanCapital Đã nhìn ra Trump lên và định hướng ra sao, đi trước chục bước, fuck