Kicking off this little series, we enter into the first language/platform I used professionally which is .NET - I don't tend to make a secret of this history although I don't usually admit that I also spent a year writing VB.NET before switching to C# for most things. (This is true, and in some ways VB was actually better at the time)
There is very little I can say negatively about C# and .NET that hasn't been said before but as I built a lot of software in it I'd be remiss to ignore it in a series like this. The industry built up around it is probably my biggest beef when it comes to being irritated rather than the language and platform itself. The managers who are persuaded by salespeople that what they need is TFS and WCF and other TLAs and then development will be easy. The hordes of developers who blindly just use whatever Microsoft has provided because thinking for yourself is too hard. The tooling and environments that pretty much destroyed my wrists from the crappy mouse-driven UIs (Visual Studio and Windows) and the developers who tried to persuade me every year that "things were changing or different now and it wasn't like that any more".
Trying to step away from that environment and carry on using C# in a way that wasn't inside the tooling jail that Microsoft had built for us with esoteric combinations of OmniSharp and ctags and other such things always ended up as a war of attrition and the language itself seemed to be the personal playground for the designers to just stick anything in that people thought was cool two years beforehand. (The inevitable point where Scala and C# are almost the same language draws near...).
Then let's talk about that; the language started off as a simple Java clone (not starting out brilliantly when you consider the mess of factories and abstract bean providers in that world) and then tacked on layers of complexity solving problems that any real language simply doesn't have. One thing that moving onto pastures anew has taught me is that the solution to most things is rarely to add more features (and XML rarely solves anything other than data-interchange).
Yet in small projects once you had indeed fought the system and got your mono based development environment up and running C# wasn't too bad providing you stayed away from the dynamic keyword and frameworks and libraries with their layers of indirection and either over-design based on IOC container magic or lack of it entirely. Compared to other technologies that by default would just work in your choice of environments there just didn't seem to be enough benefit to justify the effort of getting to this point.
Yes - F# did and does still exist and it is a shining beacon in that world; it is going against the grain much like trying to use alternative environments is and finding a .NET job that actually does F# is like looking for a needle in a haystack. The fervour shown by its many adherents is admirable and I suspect were I forced to do .NET for a project (perhaps integration) this is what I would choose to use and even enjoy but I can't imagine this happening in the future given the direction my career/life ended up taking.
The community and friends that I built up from my time in this pit has stayed with me ever since the beginning; in the same way that being trapped in a broken elevator can bring people together or being held hostage forces people to make connections with those around them - working in the .NET environment forced us to find nearby developers with similar experiences so we could have a few beers at the end of the working day and talk about our shared pains.
The constant aches pains and frustration also led to a lot of conversations about the basic acts of software development (most of it bike-shedding of course) but the constant arguments about tests, SOLID, interface-use and framework adoption and the push to constantly be improving is what pushed me off into different pastures in the first place. This kind of activity going on at community events everywhere even now and these entry level discussions have their use in helping developers to learn to move beyond the status quo and go further than "just enough to make some cash".
Perhaps this kindergarten has its use, but we all have to grow up and it would be nice if that pain wasn't even needed.
Current position of .NET on the disinterest curve: Bitter, bitter memories.
Next up is JS/Node, I have nicer things to say about this - promise.
2015 © Rob Ashton. ALL Rights Reserved.