Colin Pear

@dkruglyak @fbinegotiator I think thats the same thing. First you say you are respecting the person, then follow up with something disrespectful.

@fbinegotiator How about “with all due respect”? ✊

Saying “I do not want to sound disrespectful” usually backfires. It signals exactly what comes next. Labeling the negative instead makes the message land better and builds credibility.

@adamwathan @tailwindcss I think this ad was made with everything except tail wind. :-/

The web's most beautiful websites are built with @tailwindcss 🥰 (so are all the others ones, too.)

@EricLDaugh @grok how long will it take to make this happen?

🚨 JUST IN: Democrats are now TERRIFIED that the Trump affordability agenda is surging ahead of the midterms - 1 year 10% cap on credit card rates - BLOCK big investors from buying up homes - Force Big Tech to pay their own electricity at data centers - $200B mortgage bond purchase to slash rates - Suspend tariffs on lumber, furnishings and other critical housing imports It's coming in at FULL-FORCE, just as promised, for 2026! 🇺🇸🇺🇸

@unclebobmartin No you didnt. You chose it cause youre a geek like the rest of us and wanted to use some cool tech.

The app I’m building is not a traditional web app. It is a desktop Clojure app using an event driven GUI. (Quil). I chose this platform because I want to push the limits of the AI.

Microservices is the software industry’s most successful confidence scam. It convinces small teams that they are “thinking big” while systematically destroying their ability to move at all. It flatters ambition by weaponizing insecurity: if you’re not running a constellation of services, are you even a real company? Never mind that this architecture was invented to cope with organizational dysfunction at planetary scale. Now it’s being prescribed to teams that still share a Slack channel and a lunch table. Small teams run on shared context. That is their superpower. Everyone can reason end-to-end. Everyone can change anything. Microservices vaporize that advantage on contact. They replace shared understanding with distributed ignorance. No one owns the whole anymore. Everyone owns a shard. The system becomes something that merely happens to the team, rather than something the team actively understands. This isn’t sophistication. It’s abdication. Then comes the operational farce. Each service demands its own pipeline, secrets, alerts, metrics, dashboards, permissions, backups, and rituals of appeasement. You don’t “deploy” anymore—you synchronize a fleet. One bug now requires a multi-service autopsy. A feature release becomes a coordination exercise across artificial borders you invented for no reason. You didn’t simplify your system. You shattered it and called the debris “architecture.” Microservices also lock incompetence in amber. You are forced to define APIs before you understand your own business. Guesses become contracts. Bad ideas become permanent dependencies. Every early mistake metastasizes through the network. In a monolith, wrong thinking is corrected with a refactor. In microservices, wrong thinking becomes infrastructure. You don’t just regret it—you host it, version it, and monitor it. The claim that monoliths don’t scale is one of the dumbest lies in modern engineering folklore. What doesn’t scale is chaos. What doesn’t scale is process cosplay. What doesn’t scale is pretending you’re Netflix while shipping a glorified CRUD app. Monoliths scale just fine when teams have discipline, tests, and restraint. But restraint isn’t fashionable, and boring doesn’t make conference talks. Microservices for small teams is not a technical mistake—it is a philosophical failure. It announces, loudly, that the team does not trust itself to understand its own system. It replaces accountability with protocol and momentum with middleware. You don’t get “future proofing.” You get permanent drag. And by the time you finally earn the scale that might justify this circus, your speed, your clarity, and your product instincts will already be gone.

This is such a great talk.

@SumitM_X If you are trying to solve this problem in your app then you dont understand distrubuted systems, service boundaries, and data ownership.

Your microservice needs to transfer large amounts of data (e.g., files, images) between services. How do you design the communication to avoid performance bottlenecks and manage large payloads efficiently?

@solarise_webdev @voidcompiler @DevLeaderCa Just curious as to where your dev time goes. Are you building business applications or something else?

@voidcompiler @DevLeaderCa Yeah algorithms and data structures was an important part of my comp sci stuff years ago and remains just as relevant today.

People seem hesitant to learn programming because of math. How much math do YOU do regularly in your coding?

@dougrday @voidcompiler @DevLeaderCa And spending time optimizing an algorithm is probably more expensive than just throwing more compute at it with your cloud service.

@voidcompiler @DevLeaderCa It's true, but generally only for your high traffic code. Everything else that's hit less frequently - algorithm optimization is often a waste of time.

@GenuineRex @DevLeaderCa Dont forget that your performance results are through the roof!

@DevLeaderCa I put all my microservices in the same process and they can call each other with regular function calls.

Are you building microservices in DotNet? How do you ensure communication and integration between services?

@jerrynixon The context is the ability to create a config, give it a DB connection string, and add all of your tables as entities. This feels like your opening the door to anyone with access to sift through you data however they like.

@ColinPear What DBA says that? I must be missing context because DAB echos basically most every solution in existence. That's why I think I misunderstood something.

If you're doing microservices or building distributed systems, then you need this more than you could possibly know.

@techNmak Unpopular opinion: API endpoints on your "microservices" are an anti-pattern. Json is not your bottle kneck its your request/respone pattern and downstream database updates. Save a bandwidth fairy, clap 3 times and use a queue.

Why JSON is burning your CPU Your API is slow. You blame the database. You blame the network. But the real bottleneck might be the language you are speaking. JSON is not a data format. It is a text string. Every time you send {"id": 12345}, your server pays a hidden 'Parse Tax.' Even with modern SIMD-optimized parsers, text processing faces architectural limits that binary formats do not. Here is the rigorous engineering breakdown: 1./ The CPU Cost (state machine vs. arithmetic) JSON (Text): To read the number 12345, the CPU receives raw bytes. Even the fastest parsers (like simdjson) must implement a State Machine: Scan for structural delimiters (: and ,). Check for escape sequences (\). the conversion: Loop through ASCII characters, subtracting '0', multiplying by powers of 10, and summing. This involves branch mispredictions and memory lookups. Protobuf (Binary): It sends a Varint (for small numbers) or Fixed-Width (for large ones). Fixed-Width (e.g., fixed32) => It is a raw memory copy (memcpy). Zero parsing. Varint => It reads 1 byte at a time, checking the "Most Significant Bit" (MSB) to see if the number continues. The Result => Decoding is effectively a few bitwise shifts and masks. For numeric-heavy workloads, this is mathematically guaranteed to be significantly faster than text parsing. 2./ The Bandwidth Cost (entropy vs. redundancy) JSON: [{"status": "active"}, {"status": "active"}] You are sending the key "status" repeatedly. Counter-argument => "But GZIP compression fixes this!" The Rebuttal => GZIP reduces the Network bytes, but it increases the CPU cost. Your server now has to Serialize JSON -> Compress -> Send. The receiver has to Decompress -> Parse JSON. You are burning CPU to compress redundant text that shouldn't have been there in the first place. Protobuf: It separates the Schema from the Data. The wire message replaces "status" with a Field ID (e.g., 1). [Tag: 1][Value: "active"]. This reduces the payload size before compression is even applied, saving CPU cycles on both ends. 3./ The Robustness Cost (schema-on-read) JSON is "Schema-on-Read." The receiver gets a blob. It hopes the ID is a number. Your code is full of runtime checks (if typeof(id) !== 'number'...) or you use a validation library (like Zod/Pydantic), which adds another layer of CPU overhead at runtime. Protobuf is "Schema-on-Write." It enforces a contract. While it doesn't catch logic errors, it guarantees Type Fidelity at the serialization boundary. You generally don't need expensive runtime validation libraries to check if an Integer is an Integer. In a nutshell - JSON is excellent for Public APIs (debuggable, easy). But for high-throughput Microservices, JSON is a tax. Switching to gRPC/Protobuf isn't magic. It is simply moving the complexity from Runtime (parsing text) to Compile Time (code generation). Happy Learning! Follow @techNmak for more insights.

@jerrynixon Let me say it differently. "One big piece of conventional wisdom for software operation is 'never expose internal-facing services to the public', and databases (especially SQL databases) fall into that category." GraphQL allows you to do that yes? Or am I missing something?

@jerrynixon Can you tell us more about DAB and security. Connecting to the DB seems so easy, but any DB engineer will tell you not to expose your database in such a way. How do you really add security? What are the best practices?

Literally good over everything.

@SamNewby_ I don't know, but I will stick with visually scannable JSON.

just saw this on LinkedIn wtf is toon?

Not sure if anyone needs to hear this, but: .NET is better than Java

Im out here in Florence Italy trying to represent for Texas, but man it sure is hard when they bring out the 1.34 kg T-Bone they are about to grill up for you. This is what the wife and I split fot dinner. Gave away a bunch of it to the people sitting next to us.

.NET 10 and C# 14 will be released tomorrow It's one of the best releases in recent years 👇 .NET 10 is a Long-Term Support (LTS) release. It will receive three years of support until November 14, 2028 This makes it a solid choice for production applications that need long-term stability. The biggest addition in .NET 10 is support for file-based apps. This feature changes how you can write C# code for scripts and small utilities. Traditionally, even the simplest C# application required three things: a solution file (sln), a project file (csproj), and your source code file (*.cs). You would then use your IDE or the dotnet run command to build and run the app. Starting with .NET 10, you can create a single *.cs file and run it directly: 𝚍𝚘𝚝𝚗𝚎𝚝 𝚛𝚞𝚗 𝚖𝚊𝚒𝚗.𝚌𝚜 This puts C# on equal with Python, JavaScript, TypeScript and other scripting languages. Tomorrow, I'll share with 16,350+ people in details: ➡️ What's New in .NET 10 ➡️ What's New in C# 14 ➡️ What's New in ASP .NET Core in .NET 10 ➡️ What's New in EF Core 10 ➡️ Other Changes in .NET 10 📌 If you want to join us, subscribe to my weekly newsletter: ↳ antondevtips.com/?utm_source=tw… —— ♻️ Repost to help others learn about .NET 10 features tomorrow ➕ Follow me ( @AntonMartyniuk ) to improve your .NET Skills