Do all the things like ++ or -- rants, post your own rants, comment on others' rants and build your customized dev avatarSign Up
From the creators of devRant, Pipeless lets you power real-time personalized recommendations and activity feeds using a simple APILearn More
As a fellow c# .net dev I feel your pain.
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..)
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.
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.
khaledh7134y@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.
@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.
khaledh7134y@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.
C# can also be dynamically typed... for when you just really want to fuck things up.