Comment by cm2187 | Hacker News Reader

Comment by cm2187 | Hacker News Reader

Parent Full thread

How is it far more complex than C#? Both have been designed at about the same time and VB.net has broken backward compatibility precisely to get rid of legacy design decisions. But both have evolved since. And yes you can use a generic and non generic version of a class. Yes you have old style async and new async/await versions of methods. Yes you have explicit typing vs type inference with two ways to do the same thing. And yes you can use lync as an expression or as chained functions. How is that different from C#? Both have evolved pretty much side by side and have as much legacy.

The one thing in my opinion that has been preserved from VB6 and is dangerous as ambiguous semantically is the following:

  Dim x as Integer

Means declare a variable x and instantiate it to zero

  For i = 1 to 10
    Dim x as integer
    x += 1
  Next

The second line means declare x as integer but only instantiate it to zero the first iteration, the second iteration the instruction will be ignored.

That to me is unintuitive.

> How is it far more complex than C#?

Basically you answered your own question. VB.NET has all the same features as C#, evolved over the same time, but VB.NET has a bunch of additional "crap" held over from a language and environment that it isn't compatible with anymore. That's how it's more complex.

You didn't even consider in your example that you declare variables with the keyword "Dim". Do you even know why? It's meaning has almost been lost to history and makes little sense for what it's used for now.

How is "Dim" worse than "var"???

In fact even before type inference I always thought that Dim was a better idea. It was kind of absurd to be forced to write your type twice.

  Dim D as New Dictionary(Of String, String)

vs

  Dictionary<string, string> D = new Dictionary<string, string>();

> How is "Dim" worse than "var"???

Var means variable.

In VB6/VBA, the Dim New syntax actually had different semantics; it would create the instance on first access instead of when the Dim statement was executed. It also had the fun side-effect that setting the variable to Nothing would destroy the instance but anytime you accessed that variable it would just create a new one. Irrelevant now, I guess, but still a nice bit of trivia.

You don't write your type twice in C# either. So, the second example would be:

    var d = new Dictionary<string, string>();

`Dim` is worse than `var` because nobody uses the word "Dimension" when they're talking about variables.

As I said, var was introduced with type inference. Before type inference you had to declare it twice, which you never had to do in VB, even in VB6.

Right, but it was introduced to C# over 8 years ago so it's a bit of a moot point, wouldn't you say?

`Dim`, a poorly worded keyword by today's standards, is a perfect example of the kind of leftover crap that C# doesn't have today that VB still does have.

Try defining an instance member with var in C#

Reply on news.ycombinator.com