I've been using microsoft dev stack for as long as i remember. Since I picked up C#/.NET in 2002 I haven't looked back. I got spoiled by things like type safety, generics, LINQ and its functional twist on C#, await/async, and Visual Studio, the best IDE one could ask for.

Over the past few years though, I've seen the rise of many competing open source stacks that get many things right, e.g. command line tooling, package management, CI, CD, containerization, and Linux friendliness. In general many of those frameworks are more Mac friendly than Windows. Microsoft started sobering up to this fact and started open sourcing its frameworks and tools, and generally being more Mac/Linux friendly, but I think that, first, it's a bit too late, and second, it's not mature yet; not even comparable to what you get on VS + Windows.

More recently I switched jobs and I'm mainly using Mac, Python, and some Java. I've also used node in a couple of small projects. My feeling: even though I may be resisting change, I genuinely feel that C# is a better designed language than Java, and I feel that static type languages are far superior to dynamic ones, especially on large projects with large number of developers. I get that dynamic languages gives you a productivity boost, and they make you feel liberated, but most of the time I feel that this productivity is lost when you have to compensate for type safety with more unit tests that would not be necessary in a static type language, also you tend to get subtle bugs that are only manifested at runtime.

So I'm really torn: enjoy world class development platform and language, but sacrifice large ecosystem of open source tools and practices that get the devops culture; or be content with less polished frameworks/languages but much larger community that gets how apps should be built, deployed, monitored, etc.

Damn you Microsoft for coming late to the open source party.

  • 5
    As a fellow c# .net dev I feel your pain.
  • 3
    I personally switched recently on C# .Net (about 10 months). I mainly learned Java, C, Python, JavaScript.. But I've no shame to say that I really like C# .Net since I first used it!

    I like the VS and all the features provided by C# and the .Net framework! You're right to say it's a bit late for Microsoft to think about open sourcing its ecosystem.. But better late than never ;)

    With time and releases, I'm sure it will be more and more affordable for their language and tools to be fully integrated in other systems (Linux, Mac..)
  • 0
    Great read!
  • 2
    Being a polyglot developer, I completely understand your perspective. These languages and frameworks grow out of different cultural and philosophical background.

    Nevertheless, all these different camps learn from each other continuously. Which is a really nice and healthy way for everyone to evolve. I don't think there will be a pleasant language such as C# if languages such as Java haven't shown us what works and what not. I definitely agree that a strong and static type language helps a lot in large projects. I also believe there are a lot of situations where dynamic languages is the right thing to use.

    I think there is a huge market for tooling in the dynamic language world. I would love to build debugging and other useful tools to replicate the the .Net and Java side in the dynamic world. Unfortunately I barely have time for anything. I envy people who seems to be able to make other stuff out of their professional time. I really want to know their secrets.
  • 1
    Totally agree that static types are superior to dynamic. This is one of the reasons i don't like the "new" languages (i started out in the 80's). It feels like hype rather than practical benefit. Over the years, i've never even once felt i need dynamic typing, or that it would fill any purpose. The only use i can think of is entry level programming classes, maybe.
  • 0
    @undefined I can understand why some people prefer dynamic typing. Static type systems can sometimes get in your way while developing, requiring you to fully specify interface contract types, which is not sometimes desirable, e.g. in situations where you are building a framework that has to infer types at runtime based on user-defined schemas. It's much easier to deal with this kind of problem in a dynamic language. Dynamic languages also lets you "monkey patch" base library classes, a useful feature that has to be dealt with extreme caution, and sometimes gets abused in a bad way.

    Overall, though, I still believe the benefits of type systems outweigh the cost you pay when trying to make the compiler happy. One particular language that I started enjoying recently is F#, which is statically typed, but require less type annotation than C#, making the code more readable and easier to write (not always), among many other benefits.
  • 1
    @khaledh Since you mentioned F#, I learned something very important from functional languages these past few years. In OO we are big on modeling the world. We have all these language artifacts that helps us with that. The logic of the business rules we are coding for is inherently second class.

    Our OO instinct is to first map all the business object and the graph traversal of relationships etc. When we start mapping the business rules the flow now interleaved with the code necessary to instantiate objects and making sure dependencies and states are setup properly. Look at majority of large OO projects out there. The business flow is not a first class citizen unless we use some third party orchestration platform like BizTalk, ESB etc.

    My recent venture into Haskell, Erlang Elm and Elixir taught me the superior way is to make the business flow front and center and model only when needed. Which is a real eye opener for me. I think it is high time for functional languages.
  • 1
    @azzuwan It's funny that I actually had a rant that talks about almost this exact topic (but coming from a CQRS/ES angle):


    I strongly believe that "rich" OO domain models are the wrong way to go about modeling the world. I prefer a more functional approach, where entities are "anemic" and get threaded through functional units that implement business logic use cases.
  • 1
    @khaledh Oh that's great! I keep finding more and more people who think just like us :D. I can smell the revolution coming!
  • 0
    @khaledh I can see that view as well, but the bottom line is that without full control over the data you handle, you end up with a non deterministic system. And as op said, debugging is difficult.
  • 0
    C# can also be dynamically typed... for when you just really want to fuck things up.
Add Comment