Is Visual Basic a Good Beginner's Language?

Austin Milbarge asks: "Ever since the .NET framework came along a few years ago, Microsoft had promised VB developers that their language would finally be taken seriously. To be honest, I never understood why some non-VB developers thought of VB as a 'toy' language, but that is for another article. Anyways, Microsoft made good on their promise and transformed VB from an easy to learn language into an object oriented power house, with lots of OOP functionality thrown in. The old VB has been discontinued, and the new VB is no longer a simple language. With all the fancy changes, is VB still the great beginner's language it once was? Would you recommend it to a beginner over C#?"

Comments

And in other questions...

[edremy]

Dear Republican National Committee: Would Hillary be a good president?

Dear Osama Bin Laden: Would you like to come to my bar mitzvah?

Dear Eagles fans: Would you be willing to sign Terrell Owens again?

If I may make a suggestion...

[martinultima]

I'd personally like to suggest trying out Python. Not only is it more powerful than, and just as easy to code as – in fact, often considerably easier than – Visual Basic, it also has the advantage of running on many other operating systems such as Linux and Mac OS X. It can take a little while to get the hang of, but once you know what you're doing it's effortless (take a look for yourself at a couple things I hacked together, for example).

And yes, despite being a Linux hacker now I once did use Visual Basic, and I have to say it took way longer to learn VB than it did Python.

In the next episode of Ask Slashdot...

[Bogtha]

With all the fancy changes, is VB still the great beginner's language it once was? Would you recommend it to a beginner over C#?"

"Is kicking puppies still a great way of attracting women, or do you recommend kittens these days?"

VB was never a great beginner's language. It's wrong all over. The only thing that got it a reputation for being a "great beginner's language" was that you could draw the GUI in later versions * before you actually learnt how to write code, so you could get visually pleasing results immediately, whereas the competition at the time meant you actually had to learn how to use a GUI API (and consequently, how to write code) first.

You want a good beginners language, look at Python. It's been used successfully in teaching environments for a while now. It enforces good practices like indentation and prohibits easy sources of bugs, like if foo = bar: O'Reilly have an article about Python for teaching programming that you might be interested in.

* Yeah, the first versions of Visual Basic ran on DOS and didn't have the GUI builders that later versions did. I'm not quite sure what qualified them as basic of the "visual" variety, it's not like you had to type your code in with your eyes shut in other basics.

It's decent.

[FishWithAHammer]

VB4 was my first "real" programming language (I used QBASIC for years, but that doesn't really count). Since then I've used VB5, VB6, and VB.NET; I am also fluent with C/C++, Java, PHP, and a few other languages.

The long and the short of it is this: VB ain't bad.

People will say that Visual Basic is "unstructured," and they're clueless. People will say that Visual Basic is slow, and they're one step up from clueless (VB5 and VB6 compiled to native code and could, when used correctly, rival Win32 C++ applications for speed; VB.NET compiles to the same CLR the rest of the .NET crap does).

My personal view of the Win32 API is that the inventor didn't like people. Window creation is needlessly masochistic. VB takes that hassle away. I've written applications where the entire backend of the program is in C++ and used the VB interface just to call C++ DLL functions. It's doable. It works pretty well.

Basically--VB is a viable language if you want to get something done *now* and don't care all that much about whether it's pretty. Would I use it for game programming? No (once was enough, a 2D RPG for a school project in sophomore year of high school). Would I use it to write something quick and dirty that I need immediately? Sure, and I'll be done before a C++ coder even has a window up and running.

VB also has some pretty nice features that YFTL lacks. You can run the program without compiling it, in interpreted mode--very useful for bug-ferreting. Its class system pre VB.NET was baroque at best, but its built-in garbage collection/memory allocation on-the-fly and the fact that all arrays could be dynamic without external references made it fun to mess with.

~Ed

Re:still C

[beavis88]

*sniff* brings back memories of my first C program

% ./a.out
Segmentation Fault
%

VB.NET is just C# with different keywords

[Stephen Williams]

VB.NET is not the same language as the VB of yesteryear. It's semantically the same as C#, just with a somewhat VB-like syntax to ease VB programmers into working with .NET.

If you're learning to code using the .NET framework from scratch, I can see no reason to choose VB.NET over C#, unless you happen to like VB-like keywords more than Java-like keywords.

-Stephen

And now for something completely different...

[jcwynholds]

Python has been suggested. I also fall in the camp that say that python is probably the best learner language. Interpreter is freely available for all popular platforms. Python has enough of the niceties of VB (no strong types, easy array/dictionary construction, etc) while having enough features of a "real" programming language (shared memory, forking, etc) to teach about the concepts.

Developing in an IDE like VS obfuscates and distances the programmer from the code. It's a necessary evil for developing some things. But throwing a learning user at the bubbly GUI to figure out the wizards for him/herself is akin to putting a new pilot in the seat of a 747. There is just too much there that would seem confusing.

For these three reasons I would suggest python:

1. All you need is a free (as in speech) interpreter and your favorite text editor.

2. Documentation, howtos, sample code is easily available (there are plenty of good VB help sites out there, but I have found many many many fantastic samples of python).

3. The syntax of VB and python would seem similar enough to a beginner.

Re:Visual Studio and Visual Basic

[object88]

On the other hand, I would not recommend a beginner to use Visual Studio or any of the IDE where you drag-and-drop to program.

Yeah, because programming boilerplate includes, class, main, and event handling code (which does nothing on its own) is really going to get someone hooked. Screw that. Give that code to a new programmer for free and let them add in something that does something fun, obvious, and interesting right away. That's how you'll get 'em hooked.

Look at it this way... no-one got hooked on pot because they liked making bongs.

Re:Why not both?

[AKAImBatman]

Rapid Application Development. Tools like Visual Basic and other 4GL langauges were intended to improve software development speed and accuracy by providing tools whereby the computer automatically did as much of the work as possible. The most common type of RAD tool was GUI Builders like Visual Basic. (Though there were quite a few for database development, networking, gaming, and other areas.)

The primary issue with such tools is that they tend to fail spectacularly as soon as they get outside their intended area of use. Visual Basic, for example, came along just in time to be abused for Client/Server development. Since VB wasn't designed with networking in mind, it was often faster and easier to do the code in C (and later Java). VB's life as a GUI front-end was extended thanks to the ability to link in COM+/ActiveX controls for more complex tasks, but GUIs eventually morphed into far more complex variants that the GUI Builder couldn't easily support. (Ever notice how you can spot a Visual Basic application visually?)

At that point, most serious programmers realized that they were taking longer to hack VB to do what they wanted rather than just coding it from scratch in another language. So they gave up on it and moved back to C/C++/Delphi and the new-kid-on-the-block, Java.

Re:Yes.

[MythoBeast]

Sixty hours? A year? You make this amount of practice sound like a lot of time. I'm fifteen years into C++ and I hack kernel and could write my own compiler. Nonetheless, I'm still learning about some of the things it can do.

I'm not a programmer because I love to program, I program to do a function, to make some part of my job easier.

This is a truly key statement in his post. You have to ask yourself what you want to do with programming. If you want to write software that'll do interesting things for your own personal use, then VB is probably about right. It won't produce elegant code, but it will produce simple functionality fairly quickly, and you can build your own tools with it. In a society where computer illiteracy is becoming as problematic as written illiteracy, this kind of programming language definitely has a place.

On the other hand, if you want to produce programs for OTHER people to use, you shouldn't flinch at spending a year learning how to make a programming language do what you want it to do. It's like mechanical or civil engineering. If you want to build a shed out back or a trebuchet then go ahead and pickup some parts at Home Depot and start nailing things together. If you want to design anything that ANYONE ELSE is going to use, like an office building or an automobile, then you had better figure out how to use something a little more sophisticated than 2x4's.

A lot of people will come back with the argument that there should be something easier to learn than C or C++ for the beginners, but in my experience that's a flawed argument. Learning a language is an investment in time, and most people are unwilling to discard that investment. Instead, they've bolted on afterthoughts to the programming languages to make them more functional. For that reason, VB6 was always a horse designed by a committee. If you want to learn how to program like a professional then start with a professional language.

The one exception is Assembly Language. Every time I try to teach people how to program I start by teaching them the Twelve Instruction Programming System (TwIPS), which is a simplified subset of assembly. With this they learn the bare bones of what any piece of software does, how algorithms function inside a computer, and what the instructions are really doing.

And when they get around to learning C++ they find it considerably less tedious than if they had hit it directly.

Where to begin?

[Theatetus]

This question is wrong in so many ways...

• VB is badly OO and confuses the language and the library too much.
• VB is badly OO and OO is a bad paradigm to first learn to program in (and those two wrongs don't make a right).
• VB ties you down to using Windows, and Windows is a bad environment to learn to program in.
• VB does memory management the wrong way from a learning perspective. Rather than specifying allocators and destructors when neccessary you simply let objects fall out of scope.
• VB does not have first-class functions and cannot fake them: function manipulation and functional paradigms (whether direct or through hacks to fake it like function pointers or true reflection) is crucial to learning to program well and should be started as early as possible.
• VB teaches bad, verbose naming and programming habits.

Good beginners languages are:

• Logo (still the best)
• Scheme
• Forth
• Ruby
• Python

These all allow you to do basic, functionally-oriented programming and then "graduate", if need be, to large-scale OO stuff.

I would say Common Lisp is the best, but if you start programming using Lisp you'll never truly appreciate it because you assume all languages are that well-designed.

Re:Bad idea

[Just Some Guy]

OK, that's just mean.

I totally disagree. Difficult? Complicated? Sure, but not mean. People who have learned assembler are the ones who understand why

for(int y=0; y<ysize; y++) {
for(int x=0; x<xsize; x++) {
do_something_to_pixel(x,y);
}
}

will usually run faster than

for(int x=0; x<ysize; x++) {
for(int y=0; y<xsize; y++) {
do_something_to_pixel(x,y);
}
}

even though both are conceptually identical. There are many things that seem perfectly reasonable in high-level languages that turn out to be a really bad idea once you learn what's going on in the hardware. I'm sure it's possible to learn that stuff without hitting the metal a few times, but I've never, not one single time, ever met someone who's done so.

Re:No.

[Decaff]

Once they get to the point where they start prefixing every function with a module name, then its time to introduce them to OOP and Java.

I disagree. This is the wrong way to introduce OOP, as it treats it as some sort of high level way of managing code rather than as a fundamental technique that can be used at all levels. My view is that the best way is to teach something like Smalltalk or Ruby initially in a procedural style, and then show that everything in the language is an object, with methods and properties. Then, perhaps, the compromises made in a language like Java can be explained. One thing that should definitely be avoided is C - for goodness sake teach a safe language like Pascal instead. Beginners should not be dealing with pointers to memory (most developers never need to anyway).

OOP needs to be taught at the start, not as an optional add-on.

Re:Bad idea

[dedazo]

Mmmkay, since I've noticed that you're some sort of shining star around here and your insight tends to get modded up regularly, I'll try to be as polite as possible, even though my first instinct is to say you're full of it.

Your first problem is that you're mashing VB6 and VB.NET. They, for all the similarities in syntax, are really completely different languages with a completely different runtime going underneath. Now, since this is a question about a "beginners language", it's unlikely that someone would mistakenly rant off about VB6, since it has been largely deprecated. Anyone starting with "VB" now would use VB.NET, with or without the pretty IDE. I think that's clear enough from most of the posts I've seen so far in this article.

Some of your points are valid vis-a-vis VB6. It was completely tied to the IDE (the preprocessor infact was the IDE) and it supported a semi-OO model, which is like saying "a little bit pregnant", but regardless, most of these limitations were related to the fact that VB6 was essentially a COM server and consumer platform. The lack of implementation inheritance is a good example of that - since COM is a binary spec, it does not support it. Polymorphism and aggregation OTOH, which permeate COM, were. So pre-VB.NET, "Visual Basic" was both hobbled and all the better off for being tied to intrinsically to the COM spec. VB6 didn't behave like it did because someone at Microsoft didn't have anything better to do, it did because it had to play by the rules - the rules of COM. You could either understand these limitations (if they were to you) and live with them, or just use C++. By the time Microsoft released ATL, COM-centric coding in C++ became extremely easy - I always chuckle at the quitessential "yeah I know C++ and VB sucks, but I don't know a replacement for the GetObject() function and my life suxx0rz" claim from people who think it's really cool to bash VB because it has a large following of hobby developers that know nothing about software design, as if it was impossible to do anything meaningful with it. But I digress.

Along comes VB.NET, which is essentially the VB6 syntax ported to the .NET CLR. Like the other "mainstream" languages that target the CLR/CLI, VB.NET is essentially a full OO implementation, unless you're willing to call Python or Java "toys" because they don't support multiple inheritance or the concept of friend classed as implemented by C++.

So you have a fully OO language (for all practical purposes) with generics, operator overloading, partial classes, etc. that can be easily decoupled from the IDE - all you need is a text editor and the compiler, though most people prefer the IDE route. It just happens to look like BASIC. Other than that, I think it's a good beginner's language. Wouldn't you agree?

That's as far as VB currently goes... the rest of your rant is just the usual bashing a platform that is no longer supported or in active development, nor understood (obviously) by people like you.

Re:Visual Basic is horrible; use Python

[dancpsu]

The reasoning behind this is that C teaches a lot of basic (easy and complex ) things such a variable and memory, functions, types, stucture, control flow...After new programmers have done it the hard way, Python is great to...

Why would you want to start with "the hard way"? Bringing students into a EECS program might benefit from starting out with C or even assembler, but for anything else it is overkill. Python teaches variables, functions, structure, and control flow as well, so I don't see the disadvantage of starting with Python. The main thing that Python does not teach is memory management and some of the more interesting bugs that C can produce.

The main reason to introduce a student to more than one language is to begin without the more complex parts of languages like object oriented code, and even structured code. The nice thing about python is that you can start with procedural code, continue through structured code, and end up at object oriented code, introducing only a few concepts at a time.

With C, you have the problem of explaining the main() function or doing handwaving before you get around to explaining functions. With Java, you have the problem of classes even before you get to a main function. When even the most basic program requires structured or object oriented code, you have a problem teaching it to beginners. Take the following examples:

Java:

class myfirstjavaprog
{
public static void main ( String args[] )
{
System.out.println ( "Hello World!" ) ;
}
}

Student asks:

What is a class?, What is that funny looking bracket?, What is public?, What is static?, What is void for?, What is main?, What are the parenthesis for?, What is a String?, What is args?, How come there are funny square brackets?, What is system?, What does the dot do?, What is out?, What is println?, Why are there quotes there?, What does the semicolon do?, How come it's all indented like that?.

C:

#include <stdio.h>

main() {
printf ( "Hello, World!\n" ) ;
}

Student asks:

What is #include?, What are the greater than and less than signs doing there?, What is stdio.h?, What is main? What are the parenthesis for?, What is the funny bracket for?, What is printf?, Why is hello world in quotes?, What is the backslash-N doing at the end?, What is the semicolon for?

Python:

print "Hello World"

Student asks:

What is print?, Why is hello world in quotes?

Get the picture?

Re:still C

[ignavus]

Oh, you mean...?

#include <stdio.h>

int main() {
    printf("Segmentation Fault\n");
    return 1;
}

Re:Why not both?

[I'm Don Giovanni]

C?? Pleas...

If you want to learn the *fundamentals* of programming, Structure and Interpretation of Computer Programs is the best book I've seen, and it deals not at all with "memory management", "efficient use of resources", or other archane crap (since it uses Scheme :p). The issues that you're talking about are becoming more and more irrelevant, just as machine-language programming did (for 99.9999% of source code).

Not that Scheme itself is used much beyond the academic. But a lot if its ideas are showing up in modern programming platforms that are much in use (memory management, closures, etc). I wouldn't tout scheme as a "beginning programming language" but I'd tout it as a "programming language to learn the fundamentals of programs for a potential CS major". I'd tout C for neither.

This is crap.

[sultanoslack]

Sorry, but this is a very wrong view of what computer science or programming really are. There are three things being mixed up here which are largely separate bodies of knowledge and any decent computer science program separates them out as such.

• Algorithms - This is the core of Computer Science; learning to think like a programmer and to break problems down into logical chunks is tantamount to becoming a computer scientist. With this at the core, a language should then be chosen that most facilitates this. When I started college 10 years ago we used Pascal in our lab for our algorithms courses (which notably were just about implementing the theory we covered in the course), and that at the time was a very sane choice. Java's a pretty sane choice these days. Lots of things are really, but something like C forces people trying to learn how to think in algorithms to be side tracked by all of the tedious low level junk. (For reference, I'm a low-level C systems programmer at a large software company, so this isn't some "C sucks" wankery.)

• Computer Organization - This is usually cross listed in electrical or computer engineering, and for good reason. This is where you figure out how hardware works. C and assembler (RISC works fine here) are appropriate in such a course. As this course naturally follows introductory algorithms courses, you can here put the theoretical constructs learned there in context.

• Operating Systems - Memory management doesn't belong in either of the above and certainly saying that you learn "memory management" with C is pretty silly. You learn how to malloc and free stuff. Whoopee. "Memory management", in any sort of interesting way, is better treated in an Operating Systems course where you can track what exactly is happening down from the programming language, into the OS and finally at the hardware side. It can be put in context of what actually happens when you call malloc and what that means. Fundamentally, you don't understand anything more about memory management from a basic C course than if somebody tells you in a Java course "When you use 'new' some memory will be allocated, and when you're done with that object there's a thing called a garbage collector that will eventually come and give that memory back." Memory management is a non-trivial topic and one that certainly goes deeper than simple allocation.

So, is VB suitable for any of this? Not really. VB is kind of orthogonal. Like you said, it's fine for someone who needs to solve certain sets of tasks, but doesn't want or need to bother with really understanding deeper concepts.