architecture

(Quite) A Few Words About Async

I’ve had a few conversations about async code recently (and not so recently) and seen some code that seems to make wrong assumptions about async, so I figured out it was time to have a serious chat about async, what it’s for, what it guarantees and what it doesn’t.

Rethinking async loops in JavaScript - Matt Smith

Struggling with 'await' in loops? Explore common mistakes and modern solutions to optimize async code for performance.

Code like a surgeon

A lot of people say AI will make us all “managers” or “editors”…but I think this is a dangerously incomplete view!

Do the simplest thing that could possibly work

When designing software systems, do the simplest thing that could possibly work. It’s surprising how far you can take this piece of advice. I genuinely think…

What is "good taste" in software engineering?

--

As a self professed minimalist, I’ve long been a fan of the axiom “Perfection is attained not when there is nothing more to add, but when there is nothing left to take away”, penned by Antoine de Saint Exupéry.

zakirullin/cognitive-load: 🧠 Cognitive Load is what matters

🧠 Cognitive load is what matters. Contribute to zakirullin/cognitive-load development by creating an account on GitHub.

zakirullin

Serverless Is a Scam. Just Use a Container.

Learn how serverless is a scam and why you should just use a container.

Startup Exercise: What can’t be solved with money?

What can't be solved with money, are the most valuable things.

Jason Cohen

Why I'm No Longer Talking to Architects About Microservices

I'm done talking about microservices: the term is confusing, discussions are abstract, and without organisational change, microservices are pointless

Ian Miell

Why I don't do Domain Driven Design

Tony Marston

The fallacies of distributed systems - by Franco Fernando

Eight distributed systems fallacies that are underrated during system design.

Franco Fernando

Note: This got and got some attention. This post is not advice, it's what's working for me. It's easy to pick up bad habits and hard to create good o...

microservices.md

GitHub Gist: instantly share code, notes, and snippets.

philippta

Why software only moves forward | Swizec Teller

At scale there are no rollbacks and no cut-overs. Your software only moves forward.

Stop Pretending To Do Domain-Driven Design

It doesn't matter how many entities, aggregates, factories, services, and repositories you have. That's not domain-driven design.

jamesmh

A Brief Intro to Clean Architecture, Clean DDD, and CQRS - Software Alchemy

We couldn’t find that page, please check the URL and try again.

At some point, I realized I would've argued the exact opposite position on a lot of topics just a few years ago.

htmx: Simplicity in an Age of Complicated Solutions

In an age of complicated front-end solutions, is there a simpler way of doing things? Spoiler alert: there is.

Erik Heemskerk

Commentaren | LinkedIn

Login to LinkedIn to keep in touch with people you know, share ideas, and build your career.

Skip SDKs in Simple Integrations | Epic Web Dev

When dealing with APIs, SDKs can lead to cognitive overhead and complexity. Make sure the SDK is worth the trade-offs.

Kent C. Dodds

The Notifier Pattern for Applications That Use Postgres

Maximizing Postgres connection economy by using a single connection per program to receive and distribute all listen/notify notifications.

4 Software Design Principles I Learned the Hard Way

If there’s two sources of truth, one is probably wrong. And yes, please repeat yourself.

Engineer’s Codex

How To Not Die By A Thousand Cuts. Or, How To Think About Software Quality.

Not a weighty meandering 300 page Zen dialogue on Motorcycle Maintenance. Merely a meandering blog post in which one contemplates /Quality/ of software products.

Aditya Athalye

Simplifying Complex Systems with Backend for Frontends (BFF)

Discover how the Backend for Frontends (BFF) pattern can revolutionize the way you structure your applications, ensuring a smoother and more efficient interaction between your frontend and backend systems.

Aien

It's not microservice or monolith; it's cognitive load you need to understand first

How understanding cognitive load and team capacity can help you decide on an architectural style

Fernando Villalba

In the world of programming, there are many concepts that every developer should understand in order to build efficient and reliable systems. One such vital concept is idempotency, which refers to the property of an operation or function that produces the same result when applied multiple times as it does when applied only once. This may seem like a simple concept, but it has significant implications for building distributed systems. In this article, we will explore what idempotency is, why it i

Berkan Sasmaz

A catalog of patterns to better understand, communicate, and teach the design of distributed systems

Unmesh Joshi 23 November 2023

How to be old, for young people.

What Kind of Asynchronous is Right For You?

There are a few ways for services to communicate that can be rightfully classified as asynchronous. But they have very different characteristics. Let's have a look at them and their impact on the overall system structure.

IKEA-Oriented Development

To frugally furnish a codebase, imitate Ikea.

Taylor Troesh

How To Design Software Architecture For Startups

There is a lot of information out there on how to build software for enterprise systems. If you are designing a system for a startup, a lot of these patterns and techniques simply don't work well. High levels of uncertainty, the need for maximum flex...

Christoph Burnicki

The importance of a name.

In 1936(!), Dale Carnegie wrote in his book, How to Win Friends and Influence People about how important names are to most people. I personally learned this in another great book from Steve McConnell. He wrote Code Complete in 1993. I must have been ...

Joe Bordes

12 Ways to Prepare your Monolith Before Transitioning to Microservices

Like tidying up a house before a total renovation, preparing your monolith is the first step towards transitioning to microservices.

Tomas Fernandez, Dan Ackerson

Events: Fat or Thin – code simple { }

When it comes to the events, the big debate is about the contents of its body. Martin Fowler has written a great post on this topic. Some devs argue that events should carry the complete load with …

Posted by:satjinder bath

Programming, Coffee and Indie Hacking

Dustin Moris Gorski