Martin Fowler

Many folks in this thread are recommending which specific subreddits and blogs they like, but I thought I'd comment on the "how" of my web routine that I found useful. I use feedly.com to follow HN, blogs, subreddits, and news outlets. I split up "Backlogging" and "Reading" as separate activities, which I think promotes focus when reading. To "backlog", I browse through my feedly feed of HN/Reddit/blogpost titles, marking the ones that sound interesting to "Read Later". Then later I read through those "read later' posts, saving the best ones in lists and highlights/notes for the future. As for specifics, 1. https://www.reddit.com/r/ExperiencedDevs/ 2. https://www.joelonsoftware.com/ 3. https://martinfowler.com/ 4. https://refactoring.fm/

I guess searching YouTube is best for these things. https://martinfowler.com/ but I'm not sure if he touches the real world sometimes, it all feels very academic rather than pragmatic. I wonder if you'll find "good" outcomes though, it seems to most startups or companies bumble their way to an architecture that works for them. It might not be correct but it might be best way to build a company without architecting everything too much up front.

I would recommend Martin Fowler articles https://martinfowler.com/

If you like Julia Evans style you may also like Charity Majors aka @mipsytipsy on twitter https://charity.wtf/ Also I use the open source Django project Newsblur as my RSS reader, and follow Samuel's blog: http://blog.newsblur.com/ A couple others I like: https://watirmelon.blog https://martinfowler.com

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…

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.

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…

Martin Fowler's overview of LMAX Disruptor is one of the best reads on this subject re high-load system design https://martinfowler.com/articles/lmax.html

This remains one of the best articles I have read on LLMs (by the same author) https://martinfowler.com/articles/llm-learning-loop.html Also this article is a good pre-cursor to the DSL article: https://martinfowler.com/articles/what-is-code.html

This is classically called "Inversion of Control"[0] or the "Hollywood Principle"[1] as in "Don't call us-- we'll call you". [0] - https://martinfowler.com/bliki/InversionOfControl.html [1] - https://wiki.c2.com/?HollywoodPrinciple

Have a read of this: https://martinfowler.com/articles/is-quality-worth-cost.html

> 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.ht… It absolutely is a decades old set of problems that have never been solved to the satisfaction of most users.

Excellent article on the internals of coding CLIs. I learned a similarly powerful way to build DIY coding CLIs from this Martin Fowler post, which uses PydanticAI and MCP-based tools: https://martinfowler.com/articles/build-own-coding-agent.html Once you understand the underlying LLM tool-calling protocols described here—and how MCP tool calls work (they’re conceptually very similar)—most coding CLIs stop feeling like magic. Anthropic’s own deep dive on MCP was especially useful for me in seeing how to integrate this into a DIY “Claude Code”-style CLI, and even adapt the same approach for non-coding agents as well: https://www.deeplearning.ai/short-courses/mcp-build-rich-context-ai-ap…

Think you need a healthy mix? eg: if you want distributed systems, esp Java-style, https://www.martinfowler.com is a pretty handy reference. (similar for other areas of SWE). It’s nice to have a single resource that documents a bunch of non-obvious but still-generally-accepted engineering practices relevant to a domain. It’s of course an opinion, but is reasonably uncontroversial. Or at least, you won’t go too wrong while you develop your own taste in said domain.

I've seen this referred to as Chain of Thought. I've used it with great success a few times. https://martinfowler.com/articles/2023-chatgpt-xu-hao.html

https://martinfowler.com/aboutMe.html > [...] I work for Thoughtworks [...] > [...] I don't come up with original ideas, but do a pretty good job of recognizing and packaging the ideas of others [...] > [...] I see my main role as helping my colleagues to capture and promulgate what we've learned about software development to help our profession improve. We've always believed that this openness helps us find clients, recruit the best people, and help our clients succeed. [...] So, we should read him as such. It's a consultant, trying to capture what successful teams do. Sometimes succeeding, sometimes failing.

The article doesn’t provide any alternatives? I think there are indeed many challenges when evaluating Compound AI Systems (http://bair.berkeley.edu/blog/2024/02/18/compound-ai-systems/) But evals in complex systems are the best we have at the moment. It’s a “best-practice” just like all the forms of testing in the “test pyramid” (https://martinfowler.com/articles/practical-test-pyramid.html) Nothing is a silver bullet. Just hard won, ideally automated, integrated quality and verification checks, built deep into the system and SDLC.

This is also known as event sourcing [0] and is a common pattern used inside of databases, in git, in lots of popular software. I don't generally recommend it for every application as the tooling is not as well integrated as it is in an RDBMS and the data model doesn't fit every use-case. However, if you have a system that needs to know "when" something happened in an on-going process, it can be a very handy architecture... although with data-retention laws it can get tricky quickly (among other reasons). [0] https://martinfowler.com/eaaDev/EventSourcing.html

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.

This is the opposite of today's "You aren't going to need it" (YAGNI). I think the best approach might be somewhere in between. https://martinfowler.com/bliki/Yagni.html

A great companion read is Martin Fowler’s “Accounting Patterns”[1]. Having built and maintained systems that manage financial events for over a decade, I wish I had read these patterns earlier. [1] https://martinfowler.com/apsupp/accounting.pdf

People are smart - how about listen to their concerns? Do that before hitting them over the head with a list of 'best practices' and 'desired outcomes'. I'm starting to come to the opinion that nits are entirely and outright counterproductive in code reviews. Since I learned about "Ship/Show/Ask" - it's drastically changed my view of code reviews: https://martinfowler.com/articles/ship-show-ask.html; I no longer believe reviewing every change is healthy, seeing the difference of other models I can tell it's actively harmful now. Another good approach IMO is allowing for post-merge reviews, 'ship/show/ask' is better, but why is it written in stone that a code review MUST happen before merge?

If words don't mean anything then of cause there is no difference. You might as well program in brainf*ck -- hey, it is turing complete, so same diff. Personally, I like seeing "dummy" name passed into a function and understanding just from the name that no methods are expected to called on it during the test. Or seeing "fake_something " and understanding that a manual (perhaps test-specific) implementation is used. It is a minor point but such chunking is universally useful (there is enough stuff to keep track of). My original point was that the architecture can facilitate so called classical unit tests over mocks (make the latter less necessary) https://martinfowler.com/articles/mocksArentStubs.html#ClassicalAndMoc…

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)

I would vote this down if I could for the following reasons: - I prefer state-based TDD as opposed to interaction-based (see https://martinfowler.com/articles/mocksArentStubs.html). - I've used both testcontainers and dockertest, and from my experience dockertest is more robust. - The capital T for the outer argument comes across as being hypercorrect. Why would one consider the shadowing of this argument bad?

That is a common misconception about TDD. TDD is _about_ writing tests that matter, but most people think it is about writing all unit tests first. If you are following TDD anywhere close to the way it is described, you will only be writing tests that relate to domain functionality first. Note how it is described here, although it is turse. https://martinfowler.com/bliki/TestDrivenDevelopment.html The coverage metric as a goal writing style doesn't work for TDD, sorry you were exposed to that. You are correct that model doesn't work.

Fowler has a longer article on the topic of modernizing legacy systems that discussed this. I found it worth a read, even though it appears to be in flux: https://martinfowler.com/articles/patterns-legacy-displacement/

Due to (async) code reviews slowing down the development, we've adopted some workflows described at https://martinfowler.com/articles/ship-show-ask.html and it's working out pretty great. The committer decides how many approvals they need to merge a pull request, based on how confident they are about the code they wrote. This allows us to quickly merge small incremental improvements that would otherwise be bundled in a crowded feature pull request.

Martin Fowler has a lovely deep-dive blog post on this architecture: https://martinfowler.com/articles/lmax.html It includes lots of diagrams and citations. One term I always loved re: LMAX is “mechanical sympathy.” Covered in this section: https://martinfowler.com/articles/lmax.html#QueuesAndTheirLackOfMechan…

Though not a course Would highly recommend unmesh Joshi's https://martinfowler.com/articles/patterns-of-distributed-systems/ To learn i tried adapting them in video lectures.https://youtube.com/playlist?list=PLNFJm7gz3hcPjqOK2PUkcJnGIhhUxJaLa&a…