Linked by Thom Holwerda on Tue 15th Jan 2013 21:24 UTC
General Development "I was really excited to write this article, because it gave me an excuse to really think about what beautiful code is. I still don't think I know, and maybe it's entirely subjective. I do think the two biggest things, for me at least, are stylistic indenting and maximum const-ness. A lot of the stylistic choices are definitely my personal preferences, and I'm sure other programmers will have different opinions. I think the choice of what style to use is up to whoever has to read and write the code, but I certainly think it's something worth thinking about. I would suggest everyone look at the Doom 3 source code because I think it exemplifies beautiful code, as a complete package: from system design down to how to tab space the characters." John Carmack himself replies in the comments.
Thread beginning with comment 549047
To view parent comment, click here.
To read all comments associated with this story, please click here.
RE[5]: Good article
by henderson101 on Wed 16th Jan 2013 17:45 UTC in reply to "RE[4]: Good article"
Member since:

With regards to "WithEvents" - yes probably. But that's not what the MSDN says. As far as I can see, it's required when the "handles" clause is being used. That's not really legacy then.

VB.NET is completely type safe.

No it's not... not in the "you can't use the wrong type because it won't compile" sense of the notion. VB will happily munge and cast between integral types and Decimal/Double. VB will silently cast a Boolean to an integer. This should not compile, but it does:

Dim X as Boolean

Function WFT as Boolean
Return X
End Function

Switch Case Y
Case WTF ''This could be anything

Also, the switch statement with a boolean is probably going to evaluate to zero,

Yeah, probably. But when you have to run code to verify that fact, it's screaming "walk away" to me.

because that's what a bool of false (default value for the bool value type) evaluates to when converted to an int.

And the compiler silently casts the Bool to an Integer. That might be how VB6 worked, but VB.Net uses the CLR and so an explicit cast is required. How helpful VB.

Oh, and rewinding to "type safe".. try turning off Option Strict and Option Explicit and see how much worse you can make stuff... you don't even need to declare the return types of Functions... VB just guesses for you and silently casts the result to the type you assign the result to. Even with it on, you can still do everything else I mention. The first thing I do with VB code these days is look at the project properties and if it isn't already set, build it with Option Explicit and Option Strict turned on and fix all the errors. It is far, far too common to still find shops using VB.Net as if it was VB6.

Reply Parent Score: 2

RE[6]: Good article
by Nelson on Wed 16th Jan 2013 18:24 in reply to "RE[5]: Good article"
Nelson Member since:

I agree with you that VB is terrible, but it doesn't make it type-unsafe because of it.

I think casting is more of a gray area and VB.NET definitely has more ambiguity. Its harder to know at a glance if something is correct.

C# does some implicit casting too, if you define an implicit operator overload. I'm sure VB.NET does something similar to manage to stay within the CLR sandbox.

What VB.NET does imho, is wrap bad ideas around syntax. Examples being like you said implicit conversions (which imo have always been a bad idea no matter the language) and implicit late binding.

VB.NET takes late binding, implicit typing, and implicit casts and muddies the waters into this incomprehensible soup of syntax.

However, it is still easy for VB developers to pick up VB.NET . That's always been the reason imo for VB.NET's existence. I'd never write any meaningful amount of code using it.

I think any time someone uses dynamic in C#, late binding in VB.NET or find yourself using some of these more weird features, they need to step back and think about what the hell they're doing.

Reply Parent Score: 2

RE[7]: Good article
by lucas_maximus on Wed 16th Jan 2013 19:24 in reply to "RE[6]: Good article"
lucas_maximus Member since:

I agree that VB syntax isn't the best.

I have mostly written C#, Java, PHP and JavaScript. I have never coded in classic VB, So I tend to write VB like C#.

We have a lot of points in our code base (that is mostly inherited), where Try ... Catch is mis-used, and that is one of the better things I have to deal with.

* Functions doing more than one thing and multiple return values of the same type (usually string) which mean different things depending on how it is used.

* Very misleading variable names.

* Try ... Catch misused.

* Lack of understanding for some key OOP principles, a classic being two different types having say the first 5 properties and methods being exactly the same and having 2 or 3 properties that are different ... it is screaming to use inheritance, but it was just muddled together.

I could go on, but my main point was that any one of these problems aren't down to the language but down to lack of understanding of principles. I don't think any language magically fixes those.

Reply Parent Score: 2

RE[6]: Good article
by henderson101 on Fri 18th Jan 2013 13:47 in reply to "RE[5]: Good article"
henderson101 Member since:

And don't get me started on "Modules"... Global static classes that are automagically pulled in to the scope of all classes in the same namespace... without the need to specify the module name. Ack!

Reply Parent Score: 2