5 ms·
One thing I like about this post is the story of how the feature came to be: Someone who understood redis very well, thinking about the problem over literally y
by jrochkind1 9y ago
One thing I like about this post is the story of how the feature came to be: Someone who understood redis very well, thinking about the problem over literally years, eventually resulting in a more targetted and goal-driven thinking, and even that "specification remained just a specification for months, at the point that after some time I rewrote it almost from scratch in order to upgrade it with many hints that I accumulated talking with people about this upcoming addition to Redis."
I've been thinking about this sort of thing for a while, wanting to maybe call it "slow code" (like "slow food"). This is how actual quality software that will stand the test of time gets designed and made, _slowly_, _carefully_, _intentionally_, with thought and discussion and feedback and reconsideration. And always based on understanding the domain and the existing software you are building upon. Not jumping from problem to a PR to a merge. (And _usually_ by one person, sometimes a couple/several working together, _rarely_ by committee).
- manigandham 9y agoThought/discussion usually leads to quality. Time has nothing to do with it.
- dvt 9y agoOf course it does: thought/discussion take time.
- manigandham 9y agoIt seems people are confused. Of course everything takes physical time, but slowly thinking about something isn't any objective sign of better outcomes.
- dvt 9y agoI think the salient point is that thinking takes more time than not thinking. At least in my experience, the policy is generally to push features, not to think (slowly or otherwise).
- jrochkind1 9y agoEveryone works differently, but for me thinking in a leisurely way does produce better outcomes. It's less that my actual thinking is somehow "slower", than that thinking about something and then letting it rest and come back to it, I have better conclusions than if I rushed to judgement. I guess the phrase 'rush to judgement' is instructive. We're not just thinking, we're deciding of course. If you can find out about a problem or issue or desire and very quickly come up with an architectural solution that will stand the test of time for years (at least without backwards-incompatibilities, which is what a redis requires), more power to you, but in my experience and observation most will not. But I get it, you just don't agree with my basic suggestion, from your experience. That's fine. It's not really an argument about the speed of one's thinking. Nobody is "confused".
- neduma 9y agoI heard that ruby was developed like that. It had lot of `freeze & thaw cycles` of good years before finally it got released.
- digaozao 9y agoI like this kind of development also. But I don't think it is for everyone (the person has to keep thinking on the problem for long time). A good talk about It, from the creator of clojure: https://youtu.be/f84n5oFoZBc https://youtu.be/f84n5oFoZBc
- threeseed 9y ago> This is how actual quality software that will stand the test of time gets designed and made .. No not really. It's called waterfall and we had it for decades. And it was largely abandoned in favour of agile development because despite architects spending months designing something there was always something that was left out. Or the scope changed during those months. Or millions of other things that change whilst your hidden away from your customers/end users instead of delivering them new value every week. For me personally the truth is somewhere between agile and waterfall. Some upfront design but not the slow code you refer to.
- tree_of_item 9y agoI think you're being downvoted because trying to slap a brand like "waterfall" on the very idea of slow, careful design is kind of ridiculous. Bonus points for throwing "agile" in to the mix as well.
- kochthesecond 9y agoThere is a difference between building products and tools for building products.
- jalfresi 9y agoYou missed the part where the definition of the problem was being percolated during this process. Agile won't save you from not understanding the problem you are trying to solve.
- jrochkind1 9y agoI disagree, I think "waterfall" (at least in stereotype) would be more like coming up with the specifications in advance and then _sticking to them_ regardless of new information from the world or from the experience of developing the software. That's not the story the OP told. I also agree with the person who responded that there is a difference between building products, and building tools for building products -- building shared libraries/code/tools may require different approaches. One of the things I've noticed about shared code, is it's _much harder_ to fix rethought decisions or change paths. "Backwards incompatibility" doesn't even exist as a thing in your local app really, at least you can always at least theoretically global search and replace when you change APIs. I don't think we've figured out any magic bullet process for developing software. It's definitely not the stereotype of "waterfall", but I don't think the stereotype of "agile" is it either -- at _least_ when it comes to shared library/tools. And I'm absolutely convinced that those shared tools which do well were almost always designed carefully and intentionally with understanding of the domain, not just slapped together with stimulus-response.
- antirez 9y agoThat's an excellent point. I try to do this always, I think that waiting time and thinking more about problems has huge benefits in the final solution. But... when there is a community waiting for new features sometimes this attitude is seen as losing time, and is very hard to explain, so it is important to keep people aware of the design process. Also because via communication it is possible to receive high quality feedbacks. Btw the "slow code" term is great :-)
- styfle 9y ago> And always based on understanding the domain and the existing software you are building upon This is good. My version of "slow code" is taking note of requests from users and storing in my long term memory to stew over. 1. User A says "It would be nice to have feature X" 2. I ask for more info, what problem are they trying to solve 3. Repeat steps 1 and 2 until user's stop saying "nice to have" and start saying "must have". The stew is now ready and development can begin now that I have thought about a solution that can address everyone's problems...just in time before users get angry :)
- d2clon 9y agoI feel very reflected in this "slow code" interpretation. Instinctively, I try to refrain my self to implement this new feature that looks important but not urgent. The positive outcome is not only that you have more time to think about the proper approach but also eventually, some times, the feature shows it self not needed any more.