Moody developer with a penchant for making cutting remarks. Interested in the marvels of the universe #Ravenclaw #Tech #SJSU
Joined June 2014
- Tweets5.9K
- Following705
- Followers108
- Likes6.1K
Ashutosh retweeted
Iโve Read 20+ Books on Agentic AI - Here Are My Top 5 Recommendations for 2026 buff.ly/OcUxP6v
Ashutosh retweeted
๐# ๐ญ๐ฐ ๐๐ต๐ถ๐ฝ๐ฝ๐ฒ๐ฑ ๐๐ถ๐๐ต ๐ฒ๐ถ๐ด๐ต๐ ๐ฟ๐ฒ๐ฎ๐น ๐น๐ฎ๐ป๐ด๐๐ฎ๐ด๐ฒ ๐ฐ๐ต๐ฎ๐ป๐ด๐ฒ๐.
Runs on .NET 10, available now in Visual Studio 2026 or the .NET 10 SDK. Here's the full list:
๐๐
๐๐ฒ๐ป๐๐ถ๐ผ๐ป ๐บ๐ฒ๐บ๐ฏ๐ฒ๐ฟ๐
โ Declare extension properties, static extension members, and operators, not just methods
๐ง๐ต๐ฒ ๐ณ๐ถ๐ฒ๐น๐ฑ ๐ธ๐ฒ๐๐๐ผ๐ฟ๐ฑ
โ Reference a compiler-synthesized backing field right inside a property accessor; no manual field needed
๐ก๐๐น๐น-๐ฐ๐ผ๐ป๐ฑ๐ถ๐๐ถ๐ผ๐ป๐ฎ๐น ๐ฎ๐๐๐ถ๐ด๐ป๐บ๐ฒ๐ป๐
โ ?. and ?[] now work on the left side of an assignment; the right side never evaluates when the target is null
๐ป๐ฎ๐บ๐ฒ๐ผ๐ณ ๐๐ถ๐๐ต ๐๐ป๐ฏ๐ผ๐๐ป๐ฑ ๐ด๐ฒ๐ป๐ฒ๐ฟ๐ถ๐ฐ๐
โ nameof(List<>) works directly, no more picking a throwaway type argument just to get the name
๐๐บ๐ฝ๐น๐ถ๐ฐ๐ถ๐ ๐๐ฝ๐ฎ๐ป ๐ฐ๐ผ๐ป๐๐ฒ๐ฟ๐๐ถ๐ผ๐ป๐
โ T[], Span, and ReadOnlySpan convert into each other automatically, including through extension method receivers
๐๐ฎ๐บ๐ฏ๐ฑ๐ฎ ๐ฝ๐ฎ๐ฟ๐ฎ๐บ๐ฒ๐๐ฒ๐ฟ ๐บ๐ผ๐ฑ๐ถ๐ณ๐ถ๐ฒ๐ฟ๐
โ Add ref, out, in, or scoped to a lambda parameter without typing the whole parameter list
๐ ๐ผ๐ฟ๐ฒ ๐ฝ๐ฎ๐ฟ๐๐ถ๐ฎ๐น ๐บ๐ฒ๐บ๐ฏ๐ฒ๐ฟ๐
โ Constructors and events can now split into a defining declaration and an implementing declaration, same as partial methods
๐จ๐๐ฒ๐ฟ-๐ฑ๐ฒ๐ณ๐ถ๐ป๐ฒ๐ฑ ๐ฐ๐ผ๐บ๐ฝ๐ผ๐๐ป๐ฑ ๐ฎ๐๐๐ถ๐ด๐ป๐บ๐ฒ๐ป๐
โ Override += and friends to mutate a value in place, instead of always going through operator+ and allocating a new instance
๐ If you found it helpful, then you should join my weekly .NET newsletter with 10k+ engineers. Subscribe here โ mwaseemzakir.com
Repost โป๏ธ would be appreciated
#csharp
#dotnet
#dotnetcore
#csharp14
#programming
Ashutosh retweeted
๐ช๐ต๐ฎ๐ ๐๐ฟ๐ฒ ๐๐ถ๐๐๐ฟ๐ถ๐ฏ๐๐๐ฒ๐ฑ ๐ ๐ผ๐ป๐ผ๐น๐ถ๐๐ต๐?
When we talk about monoliths over the past few years, we hear they are bad and have a negative connotation. One of the main reasons for this is that those monoliths are connected with legacy systems.
The phrase "๐บ๐ผ๐ป๐ผ๐น๐ถ๐๐ต" can suggest that the software for a whole system or application is contained in a container made to house several subsystems. Most or all the subsystems of an entire application or system are stored in the monolith container. It is referred to as ๐๐ฒ๐น๐ณ-๐ฐ๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฑ ๐๐ถ๐ป๐ฐ๐ฒ ๐ฒ๐๐ฒ๐ฟ๐ ๐ฐ๐ผ๐บ๐ฝ๐ผ๐ป๐ฒ๐ป๐ ๐ผ๐ณ ๐๐ต๐ฒ ๐๐๐๐๐ฒ๐บ ๐ถ๐ ๐ต๐ผ๐๐๐ฒ๐ฑ ๐ถ๐ป ๐ฎ ๐๐ถ๐ป๐ด๐น๐ฒ ๐ฐ๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฟ.
๐๐ฟ๐ฒ ๐บ๐ผ๐ป๐ผ๐น๐ถ๐๐ต๐ ๐ฏ๐ฎ๐ฑ? They are not. What is bad is their internal state during development over a long time usually. We can have architected monoliths that will fulfill all our use cases and request architecture attributes in the system without dealing with the complexity of microservice architecture.
๐ง๐ต๐ฒ ๐ฏ๐ฒ๐๐ ๐ฒ๐
๐ฎ๐บ๐ฝ๐น๐ฒ ๐ผ๐ณ ๐๐ต๐ถ๐ ๐ถ๐ ๐ฆ๐ต๐ผ๐ฝ๐ถ๐ณ๐, with over 3 million lines of code one of the largest monoliths in the world. Instead of rewriting its entire monolith as microservices, Shopify chose modularization as the solution. Also, monoliths can scale, they served 117 million requests per minute on app servers during Black Friday in 2025.
There are three types of monoliths:
๐ญ. ๐ง๐ฟ๐ฎ๐ฑ๐ถ๐๐ถ๐ผ๐ป๐ฎ๐น ๐บ๐ผ๐ป๐ผ๐น๐ถ๐๐ต๐
These are the most common monolith types, where everything is bundled together. Usually, we have some user interface, business logic, and data access layers in a single tier and deployment.
There are no clear boundaries between domains, and the code will have shared libraries.
๐ฎ. ๐ ๐ผ๐ฑ๐๐น๐ฎ๐ฟ ๐บ๐ผ๐ป๐ผ๐น๐ถ๐๐ต๐
With modular monoliths, we have defined clear functional slices and dependencies, meaning each module can be independent of the others. Yet, there will still be a single deployment unit and a single database.
๐ฏ. ๐๐ถ๐๐๐ฟ๐ถ๐ฏ๐๐๐ฒ๐ฑ ๐บ๐ผ๐ป๐ผ๐น๐ถ๐๐ต๐
Here, we have one modern monolith variant (antipattern), where our system is deployed like a microservice architecture but built with monolith principles in mind. We usually get to this point while attempting to build a microservice architecture without considering some architectural and process changes needed.
We know we have a distributed monolith when some services cannot be deployed separately, are chatty, cannot scale, and share the same data source.
Ashutosh retweeted
System design is how large-scale applications get planned before theyโre built.
And in this course, youโll learn how to design scalable, reliable systems step by step.
It covers APIs, databases, caching, and real-world architecture patterns.
freecodecamp.org/news/learn-โฆ
Ashutosh retweeted
Different companies test different patterns. ๐
Use this company-wise DSA cheat sheet to focus on what actually matters for your target company.
Need help mastering those topics?
Here are the best free resources:
Learn DSA
โข Striver A2Z
takeuforward.org/strivers-a2โฆ
โข NeetCode Roadmap
neetcode.io/roadmap
โข CP-Algorithms
cp-algorithms.com/
Visualize Algorithms
โข VisuAlgo
visualgo.net/
โข USFCA Algorithm Visualizer
cs.usfca.edu/~galles/visualiโฆ
Practice
โข LeetCode
leetcode.com/
โข Codeforces
codeforces.com/
โข AtCoder
atcoder.jp/
โข CodeChef
codechef.com/
Mock Interviews
โข Pramp
pramp.com/
โข Interviewing.io
interviewing.io/
Patterns & Complexity
โข Big-O Cheat Sheet
bigocheatsheet.com/
โข AlgoMonster Flowchart
algo.monster/flowchart
Revision
โข Tech Interview Handbook
techinterviewhandbook.org/
Study company-wise.
Practice pattern-wise.
Interview with confidence.
Bookmark this.
Ashutosh retweeted
this is f*cking gold
a guy spent 6 weeks with no sleep building a personal AI agent from scratch, then wrote down all 100 things he learned
not a chatbot wrapper. an assistant that manages tasks, tracks deals, reads emails, and flags things before you even ask.
if I had this before I built my first agent, I would've skipped a month of trial and error
in the right hands, this changes everything:
โ separate hard rules from guidelines
โ give your agent a name, a voice, a role
โ build a Capability and a Component Map
โ write a Constitution, not a system prompt
And that's tip 5 out of 100.
(All tips are dropped in the comments below)
then read the full article below: โ
Ashutosh retweeted
RIP toy projects.
If your portfolio doesnโt touch real business problems, youโll get filtered out.
Here are 300+ real ML system case studies from top companies (free).
Ashutosh retweeted
Many engineers miss critical real-world system design concepts, most notably idempotency, cache stampedes, and failure domains. Focusing only on high-level architecture means forgetting the messy operational edges where systems actually break down.
Idempotency : Repeating a network request (like a payment click) should not repeat the side effect, but many APIs fail to use unique request tokens or tracking IDs.
blog.bytebytego.com/p/masterโฆ
oneuptime.com/blog/post/2026โฆ
Stampede: When a popular cache key expires, a thousand concurrent requests miss the memory layer and slam the primary database all at once.
medium.com/@rachoork/criticaโฆ
vergecloud.com/blog/what-is-โฆ
Failure Domains: People group servers or databases into separate logical units while keeping them in the exact same physical rack or availability zone power supply.
github.com/keyvanakbary/learโฆ
Graceful Degradation: Designing what happens when a third-party microservice completely dies instead of letting the main application thread hang indefinitely.
sreschool.com/blog/comprehenโฆ
Ashutosh retweeted
System Desing- Event Driven Architecture & Messaging โ Day 41
Why Message Queues?
The Problem with Synchronous Communication
Your application has grown into multiple microservices.
A customer places an order.
Your Order Service immediately calls:
- Payment Service
- Inventory Service
- Email Service
- Notification Service
- Analytics Service
Everything happens synchronously.
Client
โ
Order Service
โโโโบ Payment
โโโโบ Inventory
โโโโบ Email
โโโโบ Notification
โโโโบ Analytics
Looks fine...
Until one service becomes slow.
Suppose the Email Service takes 5 seconds to respond.
Now this happens:
Order Service
โ
Waiting...
โ
Email Service
The customer keeps waiting.
Even though the payment was successful.
One slow service delays the entire request.
Now imagine the Email Service goes down.
Order Service
โ
Email Service
โ
Should the customer be unable to place an order just because an email couldn't be sent?
Of course not.
This is where Message Queues come in.
Instead of calling every service directly...
The Order Service publishes a message.
Order Created
โ
โผ
Message Queue
Other services consume it independently.
Message Queue
/ | \
โผ โผ โผ
Email Inventory Analytics
Now:
โ Customer receives a response immediately.
โ Email can be sent later.
โ Analytics can process independently.
โ Inventory updates asynchronously.
Why Message Queues?
1. Decoupling
Services no longer depend on each other's response time.
2. Better Performance
The client doesn't wait for every downstream operation.
3. Better Reliability
If Email is temporarily unavailable:
The message stays in the queue.
It can be processed later.
4. Better Scalability
Need more throughput?
Add more consumers.
Queue
โ
โโโโบ Worker 1
โโโโบ Worker 2
โโโโบ Worker 3
Real Example
When you order on Amazon:
You immediately receive:
"Order Placed Successfully"
But behind the scenes...
- Payment processing
- Inventory updates
- Shipping
- Invoice generation
- Recommendation updates
- Email notifications
don't all happen in a single synchronous request.
Many of these tasks are handled asynchronously.
Synchronous vs Queue-Based
Synchronous
Order
โ
Payment
โ
Inventory
โ
Email
โ
Notification
One slow service affects the entire chain.
Queue-Based
Order
โ
Queue
โโโโบ Payment
โโโโบ Inventory
โโโโบ Email
โโโโบ Analytics
Each consumer works independently.
Key Takeaway
Message queues don't make systems faster by themselves.
They make systems more resilient, scalable, and loosely coupled.
Instead of waiting for every task to finish...
Applications can acknowledge the request quickly and process non-critical work asynchronously.
That's why almost every large-scale distributed system relies on messaging.
Tomorrow we will compare the three most popular messaging systems:
Kafka vs RabbitMQ vs ActiveMQ
Ashutosh retweeted
The AI protocol stack in one list
โช๏ธ MCP
โช๏ธ A2A
โช๏ธ ACP
โช๏ธ AG-UI
โช๏ธ ANP
โช๏ธ LSP
โช๏ธ OpenAPI
โช๏ธ OAuth 2.0
โช๏ธ OpenTelemetry AI
โช๏ธ JSON Schema
โช๏ธ JSON-RPC 2.0
Bookmark the list to keep it handy!
Here is also a practical guide explaining all these protocols - what each one does, where it fits, and when to use it.
Check it out โ turingpost.com/p/ai-protocolโฆ
Ashutosh retweeted
Kubernetes Components explanation:
๐ฆ Pods โ Where your application runs
๐ฅ๏ธ Nodes โ Machines that host Pods
๐ Cluster โ Collection of Nodes managed together
๐ Deployment โ Ensures your application stays updated and available
๐ฅ ReplicaSet โ Maintains the desired number of Pods
๐พ StatefulSet โ Designed for databases and stateful applications
โ๏ธ DaemonSet โ Runs one Pod on every Node (great for monitoring/logging agents)
โ
Job & CronJob โ One-time and scheduled tasks
๐ Service โ Gives Pods a stable network identity
๐ช Ingress โ Routes external traffic to your applications
๐ ConfigMap & Secret โ Manage configuration and sensitive data securely
๐ฝ PV & PVC โ Persistent storage for applications
๐ท๏ธ Namespace โ Organize workloads across teams or environments
๐ค Kubelet โ Agent running on every Node
๐ Kube-Proxy โ Handles networking between services and Pods
๐ฏ Scheduler โ Decides where Pods should run
๐ง API Server โ The heart of Kubernetes communication
โก Controller Manager โ Continuously keeps the cluster in its desired state
๐ก Think of Kubernetes like a city:
๐๏ธ Cluster = City
๐ข Nodes = Buildings
๐ Pods = Apartments
๐จโ๐ผ Deployment = Property Manager
๐ฆ Service = Reception Desk
๐ฃ๏ธ Ingress = Main Entrance Gate
๐ฆ PV/PVC = Storage Room
Ashutosh retweeted
Backend Roadmap (Part 1/11): API Design ๐
APIs are the backbone of every modern application.
Wrong API choice -> performance bottlenecks, scaling nightmares, unhappy developers.
In this post, I covered:
โข REST - Simple, stateless, uses HTTP methods. The industry standard for public APIs.
โข GraphQL - Client asks exactly what it needs. No more over-fetching or under-fetching.
โขgRPC - Binary + HTTP/2 = blazing fast. Built for high-performance microservices.
The real skill isn't knowing all three - it's knowing when to use which:
- REST -> Public APIs, simple CRUD, easy caching
- GraphQL -> Complex queries, multiple clients (mobile + web)
- gRPC -> Internal services, real-time streaming, low latency
Don't just memorize definitions. Understand the trade-offs.
As a backend developer in 2026, these are the 11 skills that will keep you relevant in today's job market:
1) API Design -> REST, GraphQL, gRPC
2) Authentication & Authorization -> OAuth 2.0, JWT, OpenID Connect, Passkeys
3) Databases -> SQL, NoSQL, indexing, query optimization, sharding
4) Caching -> Redis, CDNs, edge caching strategies
5) Event-Driven Systems -> Kafka, Pulsar, streaming pipelines
6) Concurrency & Async Programming -> Async I/O, reactive programming, structured concurrency
7) Distributed Systems -> Microservices, service mesh, eventual consistency
8) Security -> HTTPS, encryption, Zero Trust, OWASP Top 10
9) Observability -> Logging, metrics, tracing, OpenTelemetry
10) Cloud & Deployment -> Docker, Kubernetes, serverless, GitOps
11) AI Engineering -> LLM APIs, MCP, AI agents, vector databases, RAG
Stop jumping from one programming language to another.
Master the fundamentals that actually make you a better backend engineer.
Ashutosh retweeted
Anthropic engineer:
"You're not supposed to prompt Claude. You're supposed to build a system that prompts itself."
In 45 minutes, she breaks down how Anthropic builds agents that remember, learn from their mistakes, and get smarter with every run.
Worth more than any paid course you'll find on building agents.
Watch this and bookmark
Ashutosh retweeted
๐จ Harvard just made its AI course free.
No tuition.
No application.
Just world-class AI education.
Harvard University just released 6 high-quality lectures on AI + Prompt Engineeringโ and anyone can access them.
If you're serious about AI in 2026, start here:
๐ Harvard University LECTURES
1. Introduction to Generative AI
A step-by-step guide to how GenAI actually works.
Link: lnkd.in/e9rWNjBE
2. Prompt Engineering
Real tips for improving output quality from any LLM.
Link: lnkd.in/e5nekvS2
3. Beyond Chatbots: System Prompts, RAG
Move past surface use cases into scalable applications.
Link: lnkd.in/exsX5tP7
4. Generative AI in Teaching & Learning
How educators can adapt and lead with AI.
Playlist: lnkd.in/erdwPRvu
5. Teaching with AI in the Classroom
Frameworks for trainers and educators.
Link: lnkd.in/eWXskwWG
6. The Basics of Generative AI
No jargon. Just clarity.
Link: lnkd.in/eSCJ62Bi
BONUS
๐ฉ CS50x 2025 โ Artificial Intelligence Lecture
LLMs, neural nets, and real-world use cases
Link: lnkd.in/eYg6vdCr
๐ฉ CS50 Extension โ AI / Prompt Engineering
Design prompts that think with you
Link: lnkd.in/eJH4DWQR
๐ฉ GPT-4: How it works + how to build with it
Behind the curtain on GPT-4
Video: lnkd.in/eeh7QXUM
๐ฉ LLMs and the End of Programming
Why prompting is the new coding
Video: lnkd.in/e3JbSFi7
---
๐ก REALITY CHECK
โ
Harvard-level AI knowledge is now free
โ
Prompting = career acceleration
โ
2 lectures can put you ahead of 90% of professionals
โ
The future belongs to people who can โtalk to machinesโ strategically
Donโt just consume AI. Learn how to control it.
๐ Which lecture are you starting with?
โป๏ธ Repost to help others learn AI
๐ Save this (youโll need it later)
๐ Follow @JayBisen473370 for more AI insights
Ashutosh retweeted
This paper is f*cking brilliant
A computer science paper proves that graph engineering is the missing layer for production AI systems
The result: developers build stateful workflows using typed state, explicit nodes, conditional routing edges, and durable checkpointers
The crazy part is how graph engineering strips control flow completely away from prompt text
Graph nodes execute deterministic tools, edge functions evaluate execution state, and checkpointers preserve workflow memory across server restarts
Most teams try to enforce agent behavior inside long prompts
This framework constructs an inspectable control graph in pure python
Read the complete paper + article below
Bookmark it for future reference
Ashutosh retweeted
What is the Dependency Rule in Clean Architecture?
This rule states that source code dependencies can only point inwards.
By following this rule, you create a system in which your application's core business logic is independent of external dependencies.
The main idea behind the Dependency Rule is controlling coupling.
Our domain entities and business rules are at the center of the system. They don't depend on anything, which is valuable because it makes them stable.
Things around the Domain can change, but that shouldn't affect the domain entities or business rules.
Let's illustrate this with a use case for registering a user:
โข The Domain layer contains the entity and doesn't have any other references
โข The Application layer contains the use case and defines an interface for data access. It references the Domain layer so it can access the domain entity.
โข The Infrastructure layer implements the repository interface. So, it has to reference the Application layer.
โข The Presentation layer exposes the API endpoint. It references the Application layer to access the use case. But it also references the Infrastructure layer to wire up DI.
If you want to see a practical example of implementing Clean Architecture, check out this: milanjovanovic.tech/pragmatiโฆ
Ashutosh retweeted
System design has no right answers, only trade-offs.
Here are 15 of the most common ones every engineer should know:
1. Scalability vs performance (handle more work vs do each task faster)
2. Vertical vs horizontal scaling (more powerful hardware vs more servers)
3. Latency vs throughput (fast individual responses vs more tasks over time)
4. Monolith vs microservices (a single unified application vs many small independent services)
5. Stateful vs stateless architecture (remember user sessions vs treat each request as independent)
6. Synchronous vs asynchronous processing (wait for each task to finish vs move on and handle results later)
7. Batch vs stream processing (process data in chunks vs handle it as it arrives)
8. SQL vs NoSQL (structured data and strict schemas vs flexibility for varied data)
9. Normalization vs denormalization (no duplicated data vs faster reads with some redundancy)
10. Consistency vs availability (up-to-date data everywhere vs a system that's always up)
11. Strong vs eventual consistency (immediate accuracy on all nodes vs a short delay in exchange for availability)
12. Read-through vs write-through cache (cache data when it's requested vs write to cache and database together)
13. TCP vs UDP (reliable and ordered delivery vs faster but possibly unordered)
14. Long polling vs WebSockets (a request that waits for data vs a continuous two-way connection)
15. REST vs GraphQL (standard HTTP methods vs querying exactly what you need)
The real skill isn't picking a side.
It's knowing exactly what you're giving up with every choice.
Which trade-off are you struggling with the most right now?
Ashutosh retweeted
The problem with distributed Sagas is that they at least double your work.
I loved service decomposition from day one; it was so close to divide-and-conquer that it felt like the logical next step.
Then I started learning the hidden complexities; that beautiful atomic DB transaction won't save me anymore.
Now, for each write operation, you also need compensation, so you can revert if anything goes wrong at any step.
Let's take a look at the standard e-commerce flow:
Create order -> Charge payment -> Initiate shipping
How about if any of these steps fail?
What if the shipping service is down after payment succeeds?
Now you need to reverse every step that happens before.
Refund the payment <- Cancel the order <- Log failure and notify support
And just like that, you have 6 operations; half for success, half for recovery.
Mathematically speaking, if your system has n distributed actions, you have to design for 2n:
Total operations = n forward + n compensating
Success is only half the equation.
Thoughts?
