yared Almaw retweeted
⛔️Ethiopia faces multiple active conflicts under Abiy Ahmed, including renewed fighting in Tigray since late September and ongoing violence in Amhara and Oromia. Recent reports confirm over 60 Orthodox Christians killed in Oromia attacks on Oct 20-24, with mass funerals in the video. ‼️
⛔️Accusations of genocide come from some activist groups citing patterns of civilian targeting, though no international court has ruled on it. Multiple sides report atrocities amid the instability.‼️
yared Almaw retweeted
A few years ago, building and hosting a full application meant paying for licenses, servers, and courses.
Today, almost the entire stack is free, and this image shows what I mean.
The .NET SDK is free, and so is PostgreSQL for your database.
You can build the frontend with Blazor or React and style it with Tailwind.
You can write all of it in VS Code, keep it on GitHub, and run your builds and tests with GitHub Actions.
Docker and Terraform are free too, and the AWS free tier is enough to try hosting a small project.
That is a complete setup with a frontend, backend, database, CI/CD, containers, and cloud hosting. All you really need is a laptop and an internet connection.
The learning material is free as well. The official .NET docs are very good, and there are plenty of videos, blogs, and sample projects on GitHub.
My .NET Web API Zero to Hero course is also completely free, with 150+ written lessons on .NET 10 and the full source code. The link is in the first comment.
So the only thing left is to pick one small project and start building it. In my experience, finishing one small project teaches you more than watching many tutorials.
What is one project you have been planning to build?
I post about .NET and developer growth every day.
Follow me if you want to keep learning along.
yared Almaw retweeted
When people look at .NET development from the outside, they usually see the easy part. You write some C#, open Visual Studio, scaffold EF Core, build a few CRUD endpoints with Minimal APIs, and deploy with one click.
That part is real, and it's a great way to start. But once you work on a production project, you realize that most of the work sits below the surface.
You need a structure that other developers can follow, so Clean Architecture, SOLID and sometimes Domain Driven Design come in. You need proper security and authorization, so users only see the data they are allowed to see. You need EF Core queries that stay fast as the tables grow, and transactions so a failure doesn't leave half-written data behind.
Then there is caching and memory management, system design that scales, testing and code coverage, code reviews and clean pull requests, and keeping your cloud bill under control.
None of this shows up in a demo, but this is what makes an app hold up in production. It takes years to get good at all of it, so don't worry if the list feels long right now.
My free .NET Web API Zero to Hero course covers most of these topics step by step on .NET 10, from your first endpoint to production. I'll drop the link in the comments.
Which of these topics are you learning right now?
Save this post for later, and follow me so you don't miss the next one.
yared Almaw retweeted
If your API is public, sooner or later one client will send far more requests than it should. Rate limiting makes sure that one client can't slow down the API for everyone else.
Think of a club with a bouncer at the door. The room only holds so many people, so the bouncer lets people in at a steady pace and the rest wait in line.
Rate limiting is that bouncer for your API. You set a limit, for example 100 requests per minute per client. Requests under the limit go through as usual. Once a client crosses it, the extra requests either wait in a short queue or get rejected.
.NET has a built-in rate limiting middleware with four algorithms: fixed window, sliding window, token bucket and concurrency. You can apply a policy to the whole app or to specific endpoints. One small thing to know: rejected requests return 503 by default, so set the RejectionStatusCode to 429 Too Many Requests.
The tricky part is choosing the number. Too low and you block real users on a busy day. Too high and it doesn't protect anything. Start from your real traffic, watch how many requests you reject, and adjust from there.
I have a complete lesson on rate limiting in .NET 10 in my free .NET Web API Zero to Hero course. Link is in the first comment.
Happy Coding :)
For more simple explanations like this, follow me. I post every day.
yared Almaw retweeted
2,001 database queries to build one list of customer totals, and every test passed.
One for the customers, then one per customer, because Sum() executes immediately. With 15 customers in dev it's 16 fast queries, and nobody notices.
The fix: describe the whole result as one query and let the database do the math.
yared Almaw retweeted
All applications become Event-Driven at some point.
So you absolutely must understand these patterns and trade-offs.
Event notification is one of the simplest patterns you'll run into first.
For example, the Domain Events you see in Domain-Driven Design are an example of this.
Your domain aggregate acts as a consistency boundary. If you need to change something outside the aggregate, you publish a domain event. Other aggregates subscribe to this event.
A loosely coupled communication approach between two aggregates.
Here's how you can implement this: milanjovanovic.tech/blog/how…
What's the difference between domain and integration events?
Both can help you make your system loosely coupled. You separate the core domain logic from the side effects. The side effects are handled asynchronously.
I think of it as internal vs. external events. Domain events belong within the same bounded context. Integration events cross bounded contexts.
Another example is a microservices system. You publish and handle domain events in one service. You publish integration events from one service and handle them in another.
yared Almaw retweeted
I stopped using controllers for my new APIs, and I now use Minimal API endpoints instead.
The main reason is something that is easy to miss.
Let's say you have a ProductsController.
It starts with two or three actions, and over time you add pricing, stock and invoices to it.
Every new action needs its own services, so the constructor keeps growing, and soon it injects seven of them.
Now a simple request comes in to get a product by its id.
That action only needs the DbContext.
But the controller has to be created first, so all seven services are built for a request that uses just one of them.
I checked this on .NET 10 with a small test project that counts every service as it gets created.
The controller action built seven scoped services, and the same read written as an endpoint built one.
With Minimal APIs, I keep each endpoint in its own file.
The response, the route and the handler sit together in one small class, and the handler asks only for the services it needs.
A single MapEndpoints call registers every endpoint in the project, so the startup code stays small as well.
Controllers are still fine in some cases.
If you have a large API that already works well with controllers, or if you depend on OData or custom model binders, I would keep them.
You can also use both in the same project.
The video shows all of this inside the editor in under 90 seconds.
Are you still using controllers for new projects, or have you moved to endpoints?
Follow me if you want more .NET concepts explained this way.
yared Almaw retweeted
8 habits in Claude Code burning your tokens and your code quality right now
And how to fix them
1. One big task, one session.
Claude re-reads the entire context on every single message.
↳ The session you kept alive for 3 days is slower, pricier, and worse at following your own conventions.
2. Claude doesn't read your whole repo.
At session start it knows two things: your CLAUDE[.]md and the file tree. Nothing else.
↳ Type @ and pin the exact file you mean. Every wrong guess costs you tokens and quality. As Claude will search more files to find what it needs.
3. Match the model to the job.
Haiku for a rename. Sonnet for one small feature. Opus for a list of features, complex feature, or fixing a complex problem. Fable for creating a plan, making code review, and for the hardest problems.
↳ Max effort on a simple task doesn't buy quality. Claude can write overcomplicated code instead.
4. Write down the patterns you don't use.
Claude has seen a million repos with AutoMapper, MediatR and the Repository pattern.
↳ If "Patterns We Do NOT Use" is missing from your CLAUDE[.]md, they land in your code immediately.
5. Keep CLAUDE[.]md under 100 lines.
Every line is loaded into every message of every session, relevant or not.
↳ A bloated rulebook doesn't make Claude smarter. It buries the rules that matter. Move other details on implementing features to Claude skills.
6. The plan should live in the file
A markdown file in a plans/ folder survives the session, the laptop reboot, and can be reused by your team. A plan saved in the session's memory can be lost.
↳ Copy it into the frontend repo, and a fresh session continues like it was there all along.
7. Pre-approve the boring commands.
dotnet build, dotnet test and git diff belong in the allow list. git push and appsettings.Production.json belong in deny.
↳ If you need to approve 20 prompts in each session - you train yourself to click yes without reading.
8. Delegate the research.
"How does authorization flow through this API" can mean reading 30 files.
↳ Send a subagent to read them in its own window and hand back the answer. Your context stays clean.
The gap between fighting Claude Code and shipping with it is one weekend of setup.
👉 P.S. I packaged the full system into a free 10-lesson email course: Claude Code for .NET Developers.
Plan files, CLAUDE[.]md templates, skills, hooks, subagents, and PR reviews running in CI.
Grab it here: antondevtips.com/claude-code…
Which one are you fixing first: the session that never ends, or big CLAUDE[.]md?
yared Almaw retweeted
Most .NET developers try to learn everything at once. A skills tree works better, because it tells you what to unlock next instead of handing you a list to drown in.
It all sits on one root: C# fundamentals. Types, LINQ, async and await, collections. Everything above depends on this, so if it feels shaky, this is where your time goes first.
Level 1, Junior. The four nodes that make you employable: web API basics, EF Core CRUD, Git and pull requests, and unit testing with xUnit. Get comfortable shipping a small feature end to end.
Level 2, Mid. Now you go wider: clean or vertical slice architecture, auth with JWT and OAuth, Docker and CI/CD, caching with Redis, and background jobs. Each node unlocks a whole class of problems you can now solve on your own.
Level 3, Architect. Distributed systems, observability, multi-tenancy, system design and trade-offs, AI integration. Less about new syntax, more about knowing what breaks at scale and why.
Three things this tree taught me:
A solid line means "unlock the next thing." Don't jump to distributed systems before you can ship a plain CRUD API.
You don't need every node. Depth in one branch beats a shallow touch of all of them.
And the real jump: juniors collect nodes, seniors collect trade-offs, architects know which nodes NOT to use.
Do this today: find the highest node you can honestly say you've shipped in production. The one sitting right above it is your next focus. Pick that single node and go deep on it this month.
Drop a comment with the node you're on right now. I'm curious where most of you sit, and it might help someone else see they're not as far behind as they think.
yared Almaw retweeted
የብልጽግና የዲጂታል ሰራዊት የደብረዘይት አየር ሃይል በድሮን መመታቱን ካድ ተብሏል። የደረደሰኝ መረጃ ግን ይህን ይመስላል
ቀን 18/01/2019 ዓ/ም
ጉዳዩ፦አየር ኋይልን በተመለከተ የተረጋገጠ መረጃን አስመልክቶ የተዘጋጀ ሪፖርት
ትላንት ለሊት ማለትም 17/01/2019 ዓ/ም አጥቢያ ለሊት ላይ በተፈፀመው የአጥፍቶ ጠፊ ድሮን ጥቃት በደብረዘይት የአየር ኋይል ጠቅላይ መምሪያ ሱሳይድ ቦንብ የወደቀው ደብረዘይት አየር ኋይል በሚገኘው አዲስ በተገነባው ስታድዬም ሲሆን በሰው ኋይል ሁለት ሰው የሞተ 1ኛ ፍላይት ኢንጅነር ካሳሁን ሲኒየር ቴክንሻን
2ኛ ፊላትይት ኢንጅነር ገብሬ ጁኔር ቴክንሻን ሲሆኑ ሁለት ሰው የቆሰለ አአ ለህክምና ሪፈር የተላከ በንብረት ላይ የደረሰ ጉዳት የለም በዚህ የተበሳጨው አገዛዙ ደብረዘይት አየር ምድብ ያሉትን አውሮፕላኖች እንዲሁም ፖይሌቶች ወደ አአ ቦሌ ኤርፖርት አዘዋውሯል በአሁን ሰዓት በቀጠናው ትልቅ መረበሽና ድንጋጤ ተፈጥሯል።
አጋሩ
@NeaminZeleke @Tseday @HOAAffairs
@EmishawEskedar @GTWTW_Now @AltayeEthiopia
@yeabatulij @Wazemaradio
yared Almaw retweeted
The AU has kept silent for 3 years while genocide, crimes against humanity ( recorded and submitted to ICC) take place on its doorstep, choosing comfort of Addis over the plight of the people. This press release affirms that the AU has become an accomplice and not a peacemaker.
yared Almaw retweeted
አብይ አህመድ ጅቡቲ ሄዷል። ያው ወጀቡ አያስደነግጠኝም፥ ማዕበሉ አያስፈራኝም፥ እሳት እንደዶፍ ከሰማይ ቢዘንብ ምንም አይመስለኝም - አብይ አህመድ ነፍሱን የምታስፈነጥዝ ስነልቦና ናት። ሀገር በጦርነት ሲጥ ተደርጋ፥ ሚሊዮኖች ተፈናቅለው፥ ዓለም ስለእኛ ሰላምና እርቅ ምልጃ ሲገባ አብይ አህመድ ጉርድ ሸሚዝ አድርጎ፥ ሎጅ ለሎጅ፥ መናፈሻ ለመናፈሻ ይሽከረከራል። ዓላማው ይህቺው እንጭጭ ስነልቦናው ናት - ወጀቡ አያስደነግጠኝም። ይሄን እንደ ትልቅ የመሪነት ብቃት የሚመለከቱ ጀሌዎች አሉት። እነፕ/ር ብርሃኑ ነጋ ''እሱ ቆዳው ወፍራም ነው፥ ሌላው ሲርበተበት እሱ ቆፍጠን ብሎ ይቆማል'' ይሉታል። የአብይ ሚጢጢዬ ልብና አንጎል በኢጎ ይወጠራል።
በሁለተኛው ዙር ጦርነት ህወሀት ደሴን ለመቆጣጠር ከፍተኛ ትንቅንቅ በነበረ ጊዜ፥ ሀገር ምድሩ ዓይንና ጆሮውን ወደ ደሴ ተክሎ፥ ህዝብ ጭንቅ ጥብብ ብሎት አብይ አህመድ ምንም እንዳልተፈጠረ በጉርድ ሸሚዝ የበሰቃ ሎጅን ግንባታ ይጎበኝ ነበር። እኔም ከአጠገቡ ነበርኩና ህዝብን ያስጨነቀውን፥ ሀገርን በስጋት የናጠውን የህወሀቶችን ግስጋሴ ጠየኩት '' ለህወሀት ሰራዊት የአማራ ሚሊሺያ ይበቃዋል'' የምትል የንቀት መልስ ሰጥቶኝ ሌላ ጨዋታ ጀመረ። ምንም አይመስለኝም - በምንም አልደነግጥም - ዓይነት የጢቦ ስነልቦና ደም መቅኔውን ወርሶታል። አሁንም የጅቡቲ ጉዞው ሌላ ምክንያት የለውም። በትብብሩ ግስጋሴ አልደነገጥኩም፥ አልፈራሁም ለማለት ነው። የዚህኛው ግን ይለያል። ግስጋሴው ከደብረሲና የሚመለስ አይደለም። ከአራት ኪሎ የሚያፈናቅል እንደሆነ ምንም ጥርጥር የለኝም።
yared Almaw retweeted
Pick microservices too early and you'll spend a year fighting your own setup instead of shipping.
Architecture is a tradeoff, not a trophy. Here is how I decide for a new .NET project.
Monolith. One deployable app, all the code in one place. This is where you start. CRUD apps, internal tools, anything small or early. You get one codebase to build, one thing to deploy, and you ship fast. The "downside" people warn about only shows up at real scale, and most apps never get there.
Modular Monolith. Still one deployable app, but the code is split into clear modules behind an API or facade. Each module owns its own logic and its own slice of the database, and they talk through a shared kernel and common libraries. You get clean boundaries without the pain of running ten services. This is my default for almost everything serious. It keeps the team organized and leaves the door open if you ever need to split a module out later.
Microservices. Separate services, each with its own database, talking over a gateway and a message broker, with their own monitoring and tracing. This solves one real problem: parts of your system need to scale and deploy independently. That is it. If you don't have that problem yet, you are buying network calls, distributed bugs, and a heavy ops bill for nothing.
The honest rule: start with a modular monolith, draw your module boundaries well, and only split into services when one module truly needs to scale on its own.
If your last project went to microservices, what was the actual problem that pushed you there?
yared Almaw retweeted
በላፕ ቶብ መንጋህን ምራ:የታጠቀ አማራን በህይወትህ አላየኽም::መስቀሉ አስደነገጠህ? ቀሽም ድራማ ! We know how OPDO - Koree Negeyaa operates. ምስክርህ @addisstandard ኖ! ጭንቀታችሁ ብዙ ያስቀባጥርሀል:: ትብብሩ እየመጣ ነው:
አ.አ ከተማቸው ነው::
yared Almaw retweeted
Which type of test should you write?
My rule is:
- Unit testing for the domain entities and services
- Integration testing for the application use cases
yared Almaw retweeted
📌 Learning how to use Claude Code is hard.
I explain it simply in my free Claude Code for Developers course.
Join 3,000+ developers here: antondevtips.com/claude-code…