The Weeknd becomes the first artist in HISTORY to have 30 songs earn 1 BILLION+ streams on Spotify:
๐ Blinding Lights
๐ Starboy
๐ Die For You
๐ The Hills
๐ Save Your Tears
๐ One Of The Girls
๐ Call Out My Name
๐ I Feel It Coming
๐ Can't Feel My Face
๐ Save Your Tears Remix
๐ Earned It
๐ Creepin'
๐ Stargirl Interlude
๐ I Was Never There
๐ Reminder
๐ Moth To A Flame
๐ Timeless
๐ After Hours
๐ Popular
๐ Low Life
๐ Love Me Harder
๐ Die For You Remix
๐ Lost In The Fire
๐ Often
๐ Or Nah
๐ Heartless
๐ Pray For Me
๐ In Your Eyes
๐ You Right
๐ Is There Someone Else?
Polymorphism in Object Oriented Programming (OOP)
Polymorphism, in simple words, is like using a TV remote. You have different buttons on the remote, but they do different things based on the TV's brand or model. For example, the "power" button turns on different TVs, even though it's the same button on the remote. In the same way, in programming, polymorphism allows you to use the same name (like a button) for different functions (like turning on the TV) in different objects or classes. It lets you treat different things in a similar way, making your code more flexible and versatile.
Types of Polymorphism:
1. Compile time polymorphism
2. Runtime polymorphism
- Compile time polymorphism
Also known as static polymorphism, is a concept in programming where the determination of which method or function to call is made by the compiler at compile time, based on the method's name and the number and types of its parameters.
-> Function overloading:
Function overloading is a form of polymorphism where you define multiple functions with the same name in the same class, but each of them has a different set of parameters (number, type, or order of parameters). The compiler determines which version of the function to call based on the arguments provided at the call site. Function overloading is often used to provide multiple ways of performing a similar operation.
-> Operator overloading:
Allows you to redefine or extend the behavior of operators (like +, -, *, /, etc.) for user-defined classes. It enables you to define how these operators should work with your custom objects. For example, you can use operator overloading to add two instances of a custom class in a meaningful way.
- Runtime Polymorphism
Also known as dynamic polymorphism, is a fundamental concept in object-oriented programming where the determination of which method to execute is made at runtime, based on the actual type of the object. This is typically achieved through method overriding and inheritance.
-> Method Overriding:
In runtime polymorphism, a subclass(child class) provides a specific implementation for a method that is already defined in its superclass(parent class).
The method in the subclass has the same name, return type, and parameters as the method in the superclass. This is known as method overriding.
Youโre in a backend interview.
They ask:
โHow would you design a distributed job scheduling system like Cron but at scale?โ
Hereโs how to approach it:
How do you draw architectural diagrams?
One of the most popular approaches is using UML diagrams.
However, there's also the C4 model.
C4 stands for:
- (System) Context Diagram
- Container Diagram
- Component Diagram
- Code Diagram
It's a lightweight model to describe your architecture.
Want to learn more about the C4 model?
Check out this article: https://t.co/HdVIEl2lh9
What do you use for documenting software architecture?
---
Sign up for the .NET Weekly with 72K+ other engineers, and get a free Clean Architecture template: https://t.co/Sbt2ss8xuO
๐๐ผ๐ ๐๐ผ ๐น๐ฒ๐ฎ๐ฟ๐ป ๐๐น๐ฒ๐ฎ๐ป ๐๐ฟ๐ฐ๐ต๐ถ๐๐ฒ๐ฐ๐๐๐ฟ๐ฒ ๐ฎ๐ป๐ฑ ๐๐๐?
The Clean Architecture philosophy emphasizes the importance of separating concerns in software design and creating code that is ๐บ๐ผ๐ฑ๐๐น๐ฎ๐ฟ, ๐๐ฒ๐๐๐ฎ๐ฏ๐น๐ฒ, ๐ฎ๐ป๐ฑ ๐บ๐ฎ๐ถ๐ป๐๐ฎ๐ถ๐ป๐ฎ๐ฏ๐น๐ฒ.
It promotes the idea that software systems should be designed with the primary goal of ๐ฏ๐ฒ๐ถ๐ป๐ด ๐๐ป๐ฑ๐ฒ๐ฟ๐๐๐ผ๐ผ๐ฑ ๐ฎ๐ป๐ฑ ๐บ๐ฎ๐ถ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฑ ๐ฏ๐ ๐ฑ๐ฒ๐๐ฒ๐น๐ผ๐ฝ๐ฒ๐ฟ๐ over the long term.
To achieve this goal, Clean Architecture proposes a layered architecture with ๐ฐ๐น๐ฒ๐ฎ๐ฟ ๐ฏ๐ผ๐๐ป๐ฑ๐ฎ๐ฟ๐ถ๐ฒ๐ ๐ฏ๐ฒ๐๐๐ฒ๐ฒ๐ป ๐ฑ๐ถ๐ณ๐ณ๐ฒ๐ฟ๐ฒ๐ป๐ ๐ฐ๐ผ๐บ๐ฝ๐ผ๐ป๐ฒ๐ป๐๐ ๐ผ๐ณ ๐๐ต๐ฒ ๐๐๐๐๐ฒ๐บ, so we can achieve independence of frameworks, UI, databases, and delivery mechanisms, as well as the possibility to test in isolation.
If you want to learn more about it, here are some learning resources:
๐งต
Think your database is the source of truth?
Only if youโre capturing what changed, not just what is.
Thatโs where Change Data Capture (CDC) comes in.
It records every insert, update, and delete as it happens, by reading directly from the transaction log.
No polling. No missing changes. No extra database load.
You can stream those changes into Kafka, transform them, trigger workflows, or build real-time dashboards.
Itโs a game-changer for:
- Microservices that need to stay in sync
- Real-time data pipelines
- Database replication or migrations
But hereโs the real power: CDC is a great stepping stone to event sourcing. It turns passive data storage into a stream of domain events.
Curious how that works?
Start here: https://t.co/dw6gz1lsWp
Have you worked with CDC in your applications?
---
Sign up for the .NET Weekly with 72K+ other engineers, and get a free Clean Architecture template: https://t.co/Lu4aHmbyVn
5 books that made me a better software engineer:
1. Clean Architecture, Robert Martin
2. Domain-Driven Design, Eric Evans
3. Building Microservices, Sam Newman
4. Designing Data-Intensive Applications, Martin Kleppmann
5. Patterns of Enterprise Application Architecture, Martin Fowler
Which book made you a better software engineer?
---
Sign up for the .NET Weekly with 72K+ other engineers, and get a free Clean Architecture template: https://t.co/Lu4aHmbyVn
Writing code every day?
Here are 5 things I remind myself of often:
โข First, make it work
โข Then make it readable
โข Add safety with tests
โข Avoid over-engineering
โข Refactor when needed (tests will have your back)
Software engineering doesnโt have to feel overwhelming.
A clear, repeatable process goes a long way.
If you want to level up, focus on refactoring.
Itโs the skill that keeps your code healthy over time.
I put together a guide to help you sharpen that skill: https://t.co/NiACzoFyRk
Do you block time to refactor during feature work?
---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://t.co/pDIEdGkoIa
HttpClient is a powerful tool in .NET, but there's more to it than just making a request.
The real value comes from using it the right way.
Thatโs where IHttpClientFactory comes in.
It gives you a clean way to create and configure clients.
You can:
โข Register named clients with custom settings
โข Use typed clients that encapsulate logic and improve testability
โข Add resilience policies like retries and timeouts with ease
I usually go with typed clients.
They help keep things organized and are easy to test.
I put together a guide that explains when and how to use each option: https://t.co/H9Aapc1LGP
How are you using HttpClient in your projects?
I just got my third security audit back. All clear.
Most backend devs think HTTPS + JWT = secure. That's how you get owned.
Here are the security measures that actually work โ
Do you want fast EF Core queries?
I know, we all do...
Here's how eager loading can help.
Eager loading fetches related entities together with the main entity in a single query.
This can significantly improve performance by reducing the number of database roundtrips.
Here's how you can implement this (+4 awesome features): https://t.co/N4CdEqDCxq
The opposite of eager loading is lazy loading.
I don't use it, as it often introduces more problems than it solves.
๐ฆ๐ผ๐ณ๐๐๐ฎ๐ฟ๐ฒ ๐๐ป๐ด๐ถ๐ป๐ฒ๐ฒ๐ฟ != ๐๐ฒ๐๐ฒ๐น๐ผ๐ฝ๐ฒ๐ฟ
Software Engineer == Problem Solver
Don't attack problems with code. Try first to understand them from a business perspective and then a technical perspective. When you do this, make a plan for how to solve it.
Try to solve without coding.ย ๐ง๐ต๐ฒ ๐ฏ๐ฒ๐๐ ๐ฐ๐ผ๐ฑ๐ฒ ๐ถ๐ ๐ป๐ผ๐ ๐ฐ๐ผ๐ฑ๐ฒ.
If you must code, then do it.
Remember, ๐ฐ๐ผ๐ฑ๐ฒ ๐ถ๐ ๐ฎ ๐น๐ถ๐ฎ๐ฏ๐ถ๐น๐ถ๐๐, ๐ป๐ผ๐ ๐ฎ๐ป ๐ฎ๐๐๐ฒ๐.
#technology #softwareengineering #programming #developers #coding
If you need to register many services, don't do it manually.
You can use assembly scanning to solve this with a few lines of code.
You pay the price at app startup, but after that, there's no impact.
For an advanced solution, there's code generation.
Not everything should run inside your HTTP request.
Some tasks are better handled in the background.
Thatโs where background tasks come in.
They help you offload time-consuming or non-critical operations so your app stays fast and responsive.
Think:
- Sending email notifications
- Post-processing uploaded images
- Refreshing a cache
- Generating reports
- Scheduling recurring jobs
For recurring tasks, Quartz is one of the most powerful schedulers out there.
Hereโs what you need to know to use it effectively: https://t.co/X1yKOTvngW
Stop loading rows into memory just to delete them.
EF Core now supports bulk deletes with ExecuteDelete().
- Write a LINQ query to filter records
- Chain multiple Where clauses
- Call ExecuteDelete() to run a single SQL DELETE
No tracking, no materialization. Just SQL.
Learn how to use it (and a caveat) here: https://t.co/B9fUzc20DI
Are you using bulk deletes (or updates) in your projects yet?
Dapper is fast, but mapping one-to-many relationships can trip you up.
The problem?
A SQL join returns duplicated data on the โoneโ side, and Dapper gives you one row at a time.
The fix?
Use a Dictionary<TKey, TEntity> to track and reuse parent objects while adding child items.
Itโs simple once you know the pattern.
Hereโs a clean example: https://t.co/aJlSC9yreu
Have you hit this issue with Dapper before?
How to design a terrible API:
- Return 200 OK with "{ success: false }" in the response
A better solution?
Return Problem Details for API errors.
At the very least, agree on a standard error response as a team.
I've seen APIs returning 200 OK with an error in the envelope (sorry, GraphQL devs).
Problem Details is a standard for specifying errors in HTTP API responses.
HTTP status codes don't contain enough details about errors to be helpful.
Implementing Problem Details in .NET is actually straightforward.
Here's a simple guide: https://t.co/y9Ok2XwwDt
How do you return error responses in your APIs?
P.S. If you want to learn how to build production-ready REST APIs using the latest ASPNET Core features and best practices, this is for you: https://t.co/QfXnzq5A7j
The Domain layer should express business intent, not technical concerns.
A few years ago, I didnโt get this.
My old projects had Domain folders like:
- Entities
- Repositories
- ValueObjects
- Enumerations
- Exceptions
Looks clean, but it hides the Domain.
You lose cohesion. You jump across folders to understand a single use case.
Today, I group related concepts by feature, not by type.
The result?
- Higher cohesion
- Easier navigation
- Faster onboarding
- More maintainable code
Want to see how to apply this in practice?
I'll share all the secrets here: https://t.co/YcXMNstBHz