Michael Feathers

> You can already share and resuse components, modules, stores, functions? You're absolutely right that we can, but the issue is that most teams are too large or too disorganised to share complex codebases, so they choose to do a hard division: splitting the code itself. Here's an argument that I love: Microservices and microfrontends are (most of the time) a failure of encapsulation [1]. Of course there are other benefits, such as separate deployment processes and ability to use different frameworks. [1] https://michaelfeathers.silvrback.com/microservices-and-the-failure-of…

A few that I follow on a semi-regular basis: https://michaelfeathers.silvrback.com http://highscalability.com http://techblog.netflix.com http://www.natpryce.com https://8thlight.com/blog/ https://www.percona.com/blog/ https://www.smashingmagazine.com http://blog.crisp.se/author/henrikkniberg https://m.signalvnoise.com https://dannorth.net/blog/ https://codeascraft.com

I think people aren't getting yet is that this generalizable beyond software. We can do this with LLM and anything that can be designed. https://michaelfeathers.silvrback.com/prompt-hoisting-for-gpt-based-co…

There's this nice mix of technical and opinion papers: 10 Papers Every Developer Should Read https://michaelfeathers.silvrback.com/10-papers-every-developer-should…

This reminded me of a blog by Michael Feathers about a similar idea he calls Characterization Testing. There's also some code examples. The difference is instead of trying to find out where the gaps are in your scripted testing, it is about creating tests in order to understand something that isn't tested or has an unclear specification. The intentions are slightly different, but the I'd think the process is the same. https://michaelfeathers.silvrback.com/characterization-testing

As the example above (https://michaelfeathers.silvrback.com/microservices-and-the-failure-of… this doesn't change anything. I still can't comment.

Yeah. Michael Feathers' Working Effectively with Legacy Code book is good. Interestingly, Feathers defines Legacy Code as code without automated tests. the rough process goes like this: 0. you need to make a change to some code that you dont understand and that has no automated tests and no reliable documentation of what its behaviour is 1. you need to refactor the code or change some logic in order to fix the required bug / add the new feature, but you cannot do this safely without having a way to measure the impact upon the existing code's unknown behaviour. 2. a controlled way of making such changes is to first wrap the code in automated regression / characterisation tests. you need to get these automated tests in place without changing the behaviour of the code. this may be challenging. there may be a bit of a chicken and egg problem where you dont want to refactor without having regression tests, yet you need to refactor to wedge the tests in. 3. after you have some decent regression tests in place, you can try to focus in on isolating and understanding the region(s) that you need to modify to achieve your intended change. 4. it may be necessary to refactor the existing code to achieve this, or to add unit tests to key components. your safety net of regression tests gives you some confidence to do this, provided you are careful in how you refactor to get "seams" in place in the code structure to do fine-detail unit / characterisation tests. Most of the book is…

The dream of reuse has made a mess of many systems. The value of components (you can call them microservices if you like) lies in independent entities communicating over well defined interfaces. This means that you can split work up into manageable units (and distribute the work across teams if you want to). But if things are genuinely independent then we have to accept that there will be some redundancy. As long as you stick to communicating with another component through its top level protocol/interface then things are OK. The temptation is to notice that there is something else the other component does internally that you would like to re-use in your implementation. So you ask them to expose that. This is where it starts to go wrong. You have increased the complexity of interaction with the other component just to get some re-use. Do this a few more times and the system becomes unmanageably complex. Its like any organisation. If you want to succeed you need to be able to delegate fully and don't try to micromanage people for the sake of some minor optimisation. So the thing is to be disciplined. Only communicate over the formal interface and mind your own business/implementation. That means don't get involved in other peoples business and when other people try to get involved in yours tell them to $@&*!... please move along. Michael feathers has a good post [1] about how in COM it was hard to create components and so this enforced this kind of discipline. I think that…