3 ms·
> I think we should aim for kludgy but boring working solutions first Nice idea in theory. Can be awful in practice. For example in enterprises it's very comm
by threeseed 8y ago
> I think we should aim for kludgy but boring working solutions first
Nice idea in theory. Can be awful in practice.
For example in enterprises it's very common to see applications last years or even decades. And so that kludgy but boring solution would be the foundation on which you will have hundreds of engineers and years of work built on top of. And because your kludgy but boring solution worked in the beginning you rarely go back and redo it.
Hence why you see a lot of upfront developers built these over-architected monstrosities. It's because they are trying to cater for a decade of possible new features.
- Swizec 8y agoYou either die a startup or live long enough for everyone to hate the madman who picked the stack.
- WrtCdEvrydy 8y agoIn my case, you either die a startup or end up having to rewrite the whole thing in React... all 30 years of technical debt.
- fiddlerwoaroof 8y agoThis is always the best because you get to reimplement misfeatures in your shiny new codebase because “we don’t want to change how customers are used to working”
- Swizec 8y agoBug for bug rewrites are best because “You never know what system out there is relying on current behavior”
- jbigelow76 8y agoThis doesn't sound as bad a situation as you make it out to be... Dev Person: "Hey boss I finished that X, but I used a framework that hasn't been cool for at least 5 years but it will probably last a decade without a rewrite and everyone can build on top of it." CEO Person: "That sounds great, please keep doing more of that!" Admittedly, I like playing with the new shinies as much as the next dev, the above scenario sounds horrible to me to :)
- syastrov 8y agoI think boring could also be described as easily understandable. Kludgy could be interpreted to mean that all possible theoretical scenarios are not handled. Working could mean that the product works for the use cases it was intended for. In that case, I see this as a very positive pragmatic approach. You don’t waste time implementing features you “know” you will need in the future (you don’t know). You don’t waste time handling scenarios that make your feature theoretically complete and elegant but that have no significance to the users of the product. You go quicker to market and can more quickly iterate on your product. I think a much better approach is to implement these kludgy solutions that apply to the specific problem being solved. Then, you can revisit the code when it makes sense (e.g. the scope of the feature is being expanded, or just do it regularly to keep things healthy). Generally holding off on implementing things you don’t need will put you in a better position to implement the things you will need when you reach that point in the future.