Martin Fowler

How many years have you worked professionally? Do you have a team (or tech friends) to bounce things around with and learn from? What are you writing, websites or IoT or ??

Just some general comments not knowing those answers, this is usually what a mentor or team lead is there to help you with, they guide you and show you why one solution might be better than another etc. Read architecture blogs, read about failures as much as successes, read postmortems from startups they are great learning. Seriously study well design open source software that most people agree is done well, as well as bad. Studying both will show you patterns you are using and shouldn't be or ones you aren't using and should be etc. That is honestly the best way, open source software makes studying larger systems so much better today then when I was learning.

I do suggest you study some of Fowlers teachings/books https://martinfowler.com/ as he IMO is well balanced and sees value in many different architecture styles based on the problem you are solving. There are others of course, but he is the first that comes to mind for building larger or more complex systems.

The goal of software design/architecture is to use the least complex solution you can to solve the problem, that makes the software the easiest to maintain and usually makes it performant. There are exceptions of course, but that is the general rule I follow. Also, minimize unnecessary external dependencies which will also keep your…

Having your PR rejected in a healthy environment means that your PR is radically far from the reviewer's expectation.

Having your PR rejected in a toxic environment can mean a lot of things, and a company sought after doesn't mean that it MUST be not toxic.

First, you have to make sure if both of YOU and YOU ENVIRONMENT is healthy. If both are healthy, proceed reading.

> The challenge here is to deliver good quality code, while maintaining a decent speed of delivery.

You made it sound like producing good quality code = slowness. FALSE. Seeming slow, good quality code boosts your team's velocity. BUT keep in mind: "quality" is "the standard of something as measured against other things of a similar kind; the degree of excellence of something". Your team has its standards, either is a derivative of other globally acknowledged standards such as https://blog.golang.org/go-fmt-your-code, https://github.com/microsoft/TypeScript/wiki/Coding-guidelines, https://twitter.com/dan_abramov, etc, or self-made standards. You go follow them, make them happy!

Coding and design skill has a different definition than code quality. It is what punches up to the sky: the overall velocity, the success of the team, the balance of growth and culture retainment of the company, the development experience, the users' thumbs ups, amazements, and "this app is life changing" comments, the number of milestone celebration in All You Can Eat restaurants each years, the number of people rising up from…

Hi,

There's no single way. In fact, beeing a good software architect is all about having many ways in solving a problem, knowing wich solution is the most adapted depending on the context. All is about culture and cleverness
To improve, you can :

- Follow/read the well know architects. For example, I read this blog https://martinfowler.com/ and watch most of the conferencies he gives.

- Learn the design patterns and the architectural ones.

- Read a lot of code, like github repos. It does not care if you're reading repos on a subject close to the one you're interested to. You need to see a lot of architectures to see some clever solutions some peoples have used to solve some specific problems. I don't think there's any shortcut.

- get interested in meta development. Like "why does the languages work the way they work ?", read about how code is produced in real conditions (what are the processes involved), etc.

> there's no "decades-running trap of trying to solve this".

I’m not as certain. The fact that we’ve gone from ASN.1 to COBRA/SOAP to protobuf to Cap’n’web and all the million other items I didn’t list says something. The fact that, even given a very popular alternative in that list, or super tightly integrated RPC like sending terms between BEAMs, basic questions like “should optionality/absence be encoded differently than unset default values?” and “how should we encode forward compatibility?” have so may different and unsatisfactory answers says something.

Not as an appeal to authority or a blanket endorsement, but I think Fowler put it best: https://martinfowler.com/articles/distributed-objects-microservices.html

It absolutely is a decades old set of problems that have never been solved to the satisfaction of most users.

I have another book recommendation: Patterns of Enterprise Application Architecture, M. Fowler. If you don't want to purchase or just want a sampling read thru the catalog of patterns. https://martinfowler.com/eaaCatalog/

Another book recommendation is Head First Design Patterns - the one I read used Java in the examples but I learned better with the style of that book than a textbook style. There are probably a lot of design patterns books out there including the original by the "Gang of Four".

The most important thing after reading about these patterns is learning when to use one and to do that you just need to go use them. Some caution though, I found myself putting patterns into use more frequently than was probably necessary simply because it was a new thing.

I have been doing this kind of stuff both in ad tech and trust & safety industry, mainly to handle scalability. Something that looks like "Event-carried state transfer" here https://martinfowler.com/articles/201701-event-driven.html

These system are working fine, but maybe a common ground : * very few services * the main throughput is "fact" events (so something that did happen) * what you get as "Event carried state transfer" is basically the configuration. One service own it, with a classical DB and a UI, but then expose configuration to all the system with this kind of event (and all the consumers consume these read only) * usually you have to deal with eventual consistency a lot in this kind of setup (so it scales well, but there is a tradeoff)