Reactive programming was my object lesson here. Years ago I had a very brief love affair with .NET's Reactive Extensions Framework for a streaming data intake pipeline for a BI system. It made writing the data transformation code so quick and easy!
That all evaporated within a month of initial release, when I had to diagnose my first production defect. It turns out that usable call stacks are a very nice thing to have in your exception reports! I could already see that, in the long run, this design was going to cost us more to maintain than it saved us in initial development costs. Soon after, the team and I agreed to revert to doing it the crufty old boring way, and we were ultimately glad we did.
I've subsequently had similar experiences with other "easy button" compute frameworks, IoC containers, etc. They were all high quality pieces of software that did a good job of doing what they do, and possibly did save on initial development costs. But when the beeper wakes you up at 3AM, nothing beats a readable call stack that corresponds very closely to the lexical structure of the code.
The moral of the story for me has been that it's always good to experiment with clever tools techniques. But you should also remember that you have the option to thank them for the learning experience they provided while choosing to put something unsexy into production.
The C# community has a problem with haphazard implementations of complex ideas. Nothing there is complete enough to add value, and yet everybody wants the shiniest and most convoluted tools.
Just because your event-based framework didn't give you debugging information, it doesn't mean that FRP sucks, and just because your IoC containers depend on undiscoverable undocumented voodoo setup procedures, it doesn't mean IoC containers suck.
And ok, now I'll do the meme... both of those things do suck (for almost every use case people put them through), but it's not because of the perfectly solvable issues you see on their C# implementations.
FWIW I'm not exclusively a .NET programmer and I've had similar experiences on Java and Python. (Sometimes more painful, sometimes less. I think .NET's usually pretty middle-of-the-road on this sort of thing.) My wake-up moment just happens to have happened while I was working on a .NET project.
That all evaporated within a month of initial release, when I had to diagnose my first production defect. It turns out that usable call stacks are a very nice thing to have in your exception reports! I could already see that, in the long run, this design was going to cost us more to maintain than it saved us in initial development costs. Soon after, the team and I agreed to revert to doing it the crufty old boring way, and we were ultimately glad we did.
I've subsequently had similar experiences with other "easy button" compute frameworks, IoC containers, etc. They were all high quality pieces of software that did a good job of doing what they do, and possibly did save on initial development costs. But when the beeper wakes you up at 3AM, nothing beats a readable call stack that corresponds very closely to the lexical structure of the code.
The moral of the story for me has been that it's always good to experiment with clever tools techniques. But you should also remember that you have the option to thank them for the learning experience they provided while choosing to put something unsexy into production.