3 ms·

It's not specific to C#. Every language seems to start out as a crisp new tool for solving a well chosen specific set of problems. Then over the years with eac

It's not specific to C#. Every language seems to start out as a crisp new tool for solving a well chosen specific set of problems. Then over the years with each release a new set of use/edge cases get covered by introducing new concepts and syntax. And while each of these has its own merits, in aggregate they turn the system gradually into an unapproachable behemoth of opaque incantations. And so the wheel turns and we all start over the process with a crisp new language that targets a well chosen smaller set of use cases ....

pjmlp 7y ago
Which is why after some industry experience, one learns to be cynic with the next cycle of "simple" languages. Programming languages are software products as well, and to stay relevant they need to cover use cases that make developers "buy" them.
- UK-Al05 7y ago
  I'm the opposite I'm cynic over languages simply adding more and more stuff. The new languages are simple like original languages started out but with a different set of simple principles that have learned about from the previous generation. Languages are just as much about they exclude, as well as what they include.
  - pjmlp 7y ago
    Go is the latest example that starting simple and not adding features just doesn't work, if one wants to stay relevant on the market of programming languages.
    - arethuza 7y ago
      I used Common Lisp for a number of years, which probably is the most sublime example of a "behemoth of opaque incantations" - I never really saw that as a problem though.
      - pjmlp 7y ago
        Me neither. Those features are there for a reason, everyone's 10% aren't the same, yet the language (product) needs to provide a solution for 100% of the user base.
      - PeterStuer 7y ago
        While CL as described in Guy Steele's green book might have been expansive for it's time, It was utterly dwarfed by most of the "comprehensive" horizontal programming systems that came later. I'm specifically using 'system' as opposed to 'language' as reference to not just the core language syntax but including the canon APIs knowledge needed to claim a proficiency in developing in the language's ecosystem.
        arethuza 7y ago
        But that's just because they come with a pile of libraries - the core of C# and .Net aren't that complex, there's just a lot of it. e.g. Compare how classes and objects work in .Net with CLOS and its MOP.
        PeterStuer 7y ago
        But quantity brings its own complexity. When you are writing the code this is usually not a problem as you are selective in your patterns and features you employ. However, when you have to read other's code, you need to be aware of details and intricacies of coding styles, patterns and language features they employed and that might not be part of your daily toolbox. This is where 'there's just a lot of it' tends to becomes problematic. CLOS is a topic on its own. I loved it myself, as for me it aligned much more with the way my brain wrapped around an object paradigm and I felt the dispatching in what became a more traditional object approach from Smalltalk to Java and C# to be way too restrictive and therefore needing to resort quaint constructs for pretty basic composite things. But I do know this was not the most popular opinion.
erokar 7y ago
This doesn't happen to every language. C# is extreme in this regard. And there are languages that are deliberately conservative about adding new features, like Go, Elixir and even Python to some extent. Though I think Go is too far on the other end of the spectrum, I always prefer languages with a small, simple core. C# seems to just constantly throw everything new in.
- thomasz 7y ago
  It really isn't that extreme. Change happens to almost all widely used languages. Just look how c++, java, js and php have changed in the last 20 years. Furthermore, the designers do not constantly throw in new stuff. The change is rather gradual, and the features that are introduced have all been proven to work in other, more experimental languages, most often whole decades after they were introduced.
  - erokar 7y ago
    C# is certainly on the maximalist end of the spectrum. It already has classes and structs and now adds records. That's at least one, possibly two, too many in my book. But hey, some seem to prefer to have all these different ways of doing things and I'm not the one to tell them what to like or not. I don't have to use C# myself.
    - thomasz 7y ago
      The proposed record types are just regular types with minimal changes to the initialization syntax. It's not like the divide between value types (``struct`` ) and reference types (``class``), which indeed have quite different semantics. You can argue that this is too much, but IMHO you need some way to guarantee that value types will behave like primitives without introducing a massive burden on the gc.

pjmlp 7y ago

Which is why after some industry experience, one learns to be cynic with the next cycle of "simple" languages. Programming languages are software products as well, and to stay relevant they need to cover use cases that make developers "buy" them.

UK-Al05 7y ago
I'm the opposite I'm cynic over languages simply adding more and more stuff. The new languages are simple like original languages started out but with a different set of simple principles that have learned about from the previous generation. Languages are just as much about they exclude, as well as what they include.
- pjmlp 7y ago
  Go is the latest example that starting simple and not adding features just doesn't work, if one wants to stay relevant on the market of programming languages.
  - arethuza 7y ago
    I used Common Lisp for a number of years, which probably is the most sublime example of a "behemoth of opaque incantations" - I never really saw that as a problem though.
    - pjmlp 7y ago
      Me neither. Those features are there for a reason, everyone's 10% aren't the same, yet the language (product) needs to provide a solution for 100% of the user base.
    - PeterStuer 7y ago
      While CL as described in Guy Steele's green book might have been expansive for it's time, It was utterly dwarfed by most of the "comprehensive" horizontal programming systems that came later. I'm specifically using 'system' as opposed to 'language' as reference to not just the core language syntax but including the canon APIs knowledge needed to claim a proficiency in developing in the language's ecosystem.
      - arethuza 7y ago
        But that's just because they come with a pile of libraries - the core of C# and .Net aren't that complex, there's just a lot of it. e.g. Compare how classes and objects work in .Net with CLOS and its MOP.
        PeterStuer 7y ago
        But quantity brings its own complexity. When you are writing the code this is usually not a problem as you are selective in your patterns and features you employ. However, when you have to read other's code, you need to be aware of details and intricacies of coding styles, patterns and language features they employed and that might not be part of your daily toolbox. This is where 'there's just a lot of it' tends to becomes problematic. CLOS is a topic on its own. I loved it myself, as for me it aligned much more with the way my brain wrapped around an object paradigm and I felt the dispatching in what became a more traditional object approach from Smalltalk to Java and C# to be way too restrictive and therefore needing to resort quaint constructs for pretty basic composite things. But I do know this was not the most popular opinion.

erokar 7y ago

This doesn't happen to every language. C# is extreme in this regard. And there are languages that are deliberately conservative about adding new features, like Go, Elixir and even Python to some extent. Though I think Go is too far on the other end of the spectrum, I always prefer languages with a small, simple core. C# seems to just constantly throw everything new in.

thomasz 7y ago
It really isn't that extreme. Change happens to almost all widely used languages. Just look how c++, java, js and php have changed in the last 20 years. Furthermore, the designers do not constantly throw in new stuff. The change is rather gradual, and the features that are introduced have all been proven to work in other, more experimental languages, most often whole decades after they were introduced.
- erokar 7y ago
  C# is certainly on the maximalist end of the spectrum. It already has classes and structs and now adds records. That's at least one, possibly two, too many in my book. But hey, some seem to prefer to have all these different ways of doing things and I'm not the one to tell them what to like or not. I don't have to use C# myself.
  - thomasz 7y ago
    The proposed record types are just regular types with minimal changes to the initialization syntax. It's not like the divide between value types (``struct`` ) and reference types (``class``), which indeed have quite different semantics. You can argue that this is too much, but IMHO you need some way to guarantee that value types will behave like primitives without introducing a massive burden on the gc.