I like Visual Basic.NET because…
A professional picks a tool for logical reasons. As a professional business programmer, I pick VB.NET. Before I expound further on my choice, you should know whether or not I am qualified to have an opinion. Certified in C# and Visual Basic.NET, I was lucky enough to be chosen as Microsoft MVP in Visual Basic.NET in 2006. I founded and head up a 1500+ member .NET User Group in Charlotte, the Enterprise Developers Guild (www.DevelopersGuild.org). We routinely have eighty to a hundred attendees at our monthly meetings.
Frame of Reference
What is my frame of reference? Raised as a Navy Air brat, I naturally spent several years as a Naval Flight Officer. Early in a brief service career, I got a classified briefing on the computer systems the made the A-6 Intruder such a potent weapons system. My immediate thought was if that’s what DOD can do with a special purpose computer, what is being done with IBM Big Iron in the civilian world? EDS recruited me after I left the service and I got a chance to find out. The SED (Systems Engineering Development) program provided excellent training in computer fundamentals by teaching me how hardware, operating systems and compilers work.
Several decades of software development required that I master many software development environments – “Mastered” as in have been well paid to learn and use extensively. Here is a brief list with some parenthetical observations:
Mainframe Basic Assembler (fundamental), mainframe and PC COBOL (productive, very small executables), numerous Basic dialects (minis then PCs), Pascal (sweet!), Turbo Pascal (fast!), Object Pascal (fast and sweet!), dBase, Clipper, FoxPro for Windows (outstanding!), Visual Basic 1 (evaluated), 2 (evaluated), 3 (finally adopted), 4 and 5 (paid well), MS Access VBA (productive), Delphi (awesome OO!), VB 6 (very classy), light C++ (awkward), Java (excellent teaching tool for OO introduction), VB.Net and the Framework (hard to beat!), C# (still awkward).
That’s the short list. I also became proficient in numerous scripting, utility and reporting environments and several command languages for various operating systems. Let’s not forget the specialized data entry devices in the late seventies.
Much of my experience is with what I call small unit tactics. My teams usually consist of five to ten developers. Most of my applications serve hundreds of users with usually less than a hundred simultaneous connections. As I said, I am a business applications programmer. A lot of my experience is in the financial sector, but also includes law enforcement, health care, accounting and some manufacturing. Many of my engagements involved large volume database processing and reporting before we called it Business Intelligence.
It is safe to say that I am a software development expert – a seasoned veteran. My career teaches three huge lessons:
1) Bottom line (productivity) beats technology hands down
2) The only constant is change
3) Whatever you code, somebody has to change.
For the last year I have been working in C# because that’s the opportunities presented in my local market. To paraphrase Dan Appleman from his early VB.Net book, if someone wants to pay you to code C# it is your professional duty to take the money. Frankly I don’t remember if Mr. Appleman made the point, but a contractor often makes more money doing a C# application because it takes longer than doing the same work in VB. I have not seen any rate differential in favor of C#.
C# is one of the legacy languages in my list. It has roots firmly planted in 8-bit processors when 640K was “all the memory anyone would ever need” and parallel processing was not massive, it wasn’t even a consideration. C and all its derivatives are case-sensitive because saving a pass through the compiler was important on an 8-bit UNIX box. When was that? Was it the seventies or the eighties? Memory management dominated C thinking before C# again because it enabled a simple compiler. Pointers are beyond me. I learned how to code pointers so I could debug but vowed never to use them. Talk about a maintenance nightmare… can you say “memory leak”?
We got over memory management in the sixties. Case sensitivity has never been an issue outside of the C world that I remember. Squirrelly brackets are unique to C and its legacies. So are “||” instead of “OR” and “!” instead of “NOT”. There’s a reason for that. Most of us quit bit shifting after we left Assembler.
Learning your second language with a significant syntax difference is hard and scary. Imagine going from Assembler to COBOL before you knew very much! After you have mastered your second language, your third is easier. Your fourth comes fast and then you’re on your way. As Ken Spencer, North Carolina Microsoft MVP/RD is quick to point out: “Learning twenty-five or so languages teaches you what’s important.” It also teaches you what to look for.
Going from C to C++ is more like a version migration since the syntax is expanded, not changed. Java introduces libraries so there is definitely a learning curve, but syntax remains comfortable for C programmers. At least it gets us out the memory management madness everybody else left in the early seventies. C# introduces a new Framework, but should be a fairly easy step into the Microsoft world for Java programmers.
The Framework is really what .NET is all about. It is a superb addition to our tool set and proves why Object Oriented development is works. “Talk about your code reuse...” Developing in .NET is 80% Framework and 20% language. Even VB professionals must master C# so we can use all the code sample resources available on the Internet.
C Derivatives Popularity
So if I’m “right” about VB, why are the C derivatives so popular? It’s free. Beginning in the eighties universities built their computer degree programs around UNIX and C because it was cheap. New graduates wanted to stay with what they knew. Business types and new programmers fell for the “transportable” myth. Basic and COBOL are supposed to portable too, but anybody with any real experience had already found out the “transportability” limits your options and kills productivity. The Pascal P-Machine came closest to achieving the transportability goal. If you know what a P-machine is, you are either a historian or a very seasoned veteran. Yes, I know about Mono. Have you ever used it? I haven’t. I’m more interested in Borland Kylix, the Linux Delphi. I haven’t used it either.
For developers with a wide range of language ability, the C family is counter-intuitive. It may be mathematical, but mathematical program proofs are a bigger myth than transportability in the real world. It is supposed to generate small, fast executables. That may have been true pre-Framework, but C# uses what Tennessee Microsoft MVP/RD Billy Hollis calls the VB.Net runtime – the CLR.
Actually the tightest code I ever generated on a PC was with Realia COBOL. “Back in the day” I got a utility program done in half an hour and generated a 48K executable using Realia COBOL. That’s right – Kilobytes NOT Megabytes. So except for memory management and pointers (ugh!), COBOL gets at least as close to the metal as C does. Shocking isn’t it. About that same time the smallest Clipper application I could get was 250K plus. Of course the runtime is baked into the Clipper EXE. COBOL compiles down to Assembler.
Did you notice the claim of half an hour to write a simple utility? It was primarily a table lookup and my COBOL was very rusty, but no language does simple tables better than COBOL. It would take me an hour or so to do the same thing in VB.Net today, but it would probably have a Windows interface and at least tool tips for help. Yes, our tools are more productive, but all of us, including the check-signers, expect a lot more from an application today.
Expecting more is what Visual Studio and the Framework is all about. We are doing more, so the high productivity gains we have achieved in the last twenty years have barely let us keep up our productivity levels – maybe.
The check-signers don’t care about tools and technology. They want low-learning curve Windows and web applications that solve business problems. The business side can’t judge what the best tools and techniques are and shouldn’t be bothered with that unless our recommendations are going to impact the budget. It is up to software professionals to use the best tools for the job at hand. By making it easy for us, Microsoft has had great success in getting us to choose SQL Server, Visual Studio, ASP whatever, VB.Net and C#.
Why Visual Basic?
So why do I like Visual Basic? My first introduction was VB 1.0. I passed. I looked again at VB 2.0 and passed again. When VB 3.0 shipped the product uptake was breath-taking. Now we had something! With the exception of FoxPro for Windows, it was the most productive Windows development environment available at the time.
VB.NET is strictly a pragmatic decision for me. First, let me remind you I’m coding C# forty hours a week. I only get to do VB.Net when I’m coding for myself, maybe ten or fifteen hours a week. I actually went through a dry spell where I didn’t do anything significant in VB for several months. I had convinced myself that I was as productive in C# as I was in VB, but not so. When I got back into a VB project, it gave me at least a 10% boost and it may be as high as 20%. VB.Net is definitely the language of choice for all my own work.
So why am I more productive? Everything I have come to expect in a computer language is there and easy to find. Why is there no numeric check built into C#? Where’s the “With” statement? Where are nifty “My” functions? “End If” works for me. “Select Case” feels right, “Switch” is awkward. I like “Next”. I really do not understand why we don’t have a “CAST” function in C# and VB.NET like the one in Delphi, but “DirectCast” comes close, so I’ll have to be happy until I take time to roll my own with generics.
Case insensitivity in VB is certainly a help. When I type in a variable name, VB cases it correctly giving me a direct visual signal that I got the name right. When I first saw that feature in Apple /// Business Basic I was in love! Remember, intellisense is a “new” thing; I’m talking deep into the last century here. Yeah, I know you get a squiggly under an undefined variable name in C#, but I have lots of techniques for generating squiggles in my code so that is not always definitive.
VB scans. In C# I really have to pay attention to find things. With most languages -- COBOL, dBase derivatives, Pascal derivatives, and VB derivatives – I can quickly scan a section of code and detect flaws or lines of interest. I expected that skill to come with C# after a month or two, but it hasn’t yet. The language is just awkward. The “!” is certainly a thrill to someone who has read “NOT” in countless languages. I really like the “?” operator. NOT! (Now that’s the way to use “!” with “not”).
VB scans. That makes it easier to maintain. Now obviously you can write bad code in any language, but you don’t hear about re-writing a routine to put in a maintenance change in VB nearly as often as you do with C#. We ran into the re-write instead of fix phenomenon in Assembler because even good code could be so hard to understand, but we were ashamed when it happened. C# programmers have no shame, they just “refactor”; me included. VB programmers generally don’t re-write working code. We might enhance it, but we don’t have time or budget to re-write working code. We just have too much to get done. Check-signers would really like that aspect of VB if they knew what was going on.
So that’s why I like VB.NET
After decades of experience and countless computer languages, Visual Basic.NET is a simple decision for me. I must be productive (Lesson 1). I need to adopt new Framework classes and techniques quickly (Lesson 2). I need to produce code that I or any professional can easily maintain (Lesson 3).
To use a John Wayne line from a vintage Western movie – “You do what you want. Most people usually do.” Just don’t ask me to maintain C#. Oh wait; I make more money because C# takes longer and I can just “refactor”.
Bill Jones Jr.
MCP C#, VB and MVP VB.NET
Enterprise Developers Guild
Charlotte MSDN User Group