WARNING: This is a speculative post. Caveat emptor.
Last week, one of the VB MVPs asked on a private alias what our thinking was about VB10. As I kind of indicated in my previous entry, I don’t think we have a clear idea yet of what’s going to be on the table for the next rev-VB 2008 was kind of an aberration in that LINQ was in gestation long before VB 2005 even shipped. But I can say what’s at least on my mind:
- Hosting or, more generally, opening up the compiler services to the outside world.
- Decreasing lexical “noise” when looking at VB code.
- Increasing the extensibility of the language so that it takes less work to extend the language and can be done by libraries (Ruby is an example of what I’m thinking of here, but only a general example).
- Addressing UNDONE tasks from Orcas (object initializers, statement lambdas).
- Addressing persistent annoyances (line continuations is a good example here).
- Addressing whatever else comes up from the community as we release VB 2008.
I know that I’ve already added the usual caveats above, but I want to make double clear this is just what’s on my mind at the moment-in other words, things that I’m personally thinking about. These are not official team priorities, planned for the next rev, or anything like that. The next version could look radically different than the list above. I should also add that I mostly think about the language, so that’s why this list doesn’t talk about the IDE.
I’d be interested (in keeping with the last bullet point) what people might be specifically in for the next release. What’s at the top of your list these days?
It’s a tall order, but number one on my list is non-nullable reference variables. I know it will take deep support from the libaries so that all indicate if their functions return can nulls, but eliminating null reference exceptions would make me very happy.
Attribute-based compiler hooks would be awesome. It would allow us to bolt-on a lot of additional functionality without tons of boiler-plate code.
DSL/Code Generators: VB 9 has great langauge support for code generators, but it is really, really hard to create one in Visual Studio, especially with multiple-output files. Right now I’m working on a project that takes a small XML block and turns it into about a dozen classes including entities, collections, controls, and search forms. If we could include the code-generator within our solution it wouldbe great.
This last one I think is far more in keeping with the spirit of the .NET platform than the dynamic "monkey patching" of languages like Ruby and Python. Runtime code generation is nice, but it can’t beat being able to see the code it creates in a static context.
Select Case should work over references and types.
Select Case obj
Case is objA
Case is objB
End Select
Select Case Typeof obj
Case is TextBox
Case is CheckBox
Case is CheckBox
End Select
This should be trivial, it just converts to If-Then-Else blocks.
Hello Paul,
First let me say that it is very intriguing to see you asking the community of developers for suggestions on what can be improved. To me, that is just fantastic.
I love the VB language more than anything, and there is not much I would change. I would love to see the question mark thingy in C# work for VB as well. Like this:
Dim strHold as String = (strHold2 = "test") ? "True" : "False"
Now granted that is a useless example, but you get the point.
Another thing I would appreciate is if printing was not such a difficult task. I got a project the other day to convert this VB6 program to .NET and there were Printer.Print calls all over the place. One line of code turned into a rather confusing implementation of the PrintDocument class.
Other than that, I believe the language is wonderful, and I honestly think I will be still using it 10 years from now.
Keep up the great work!
Automatic Properties:
Public Auto Property Test() as Integer
Properties are essential for data-binding even they are not really needed for encapsulation. So why not make them automatic like C# (but without C#’s lame syntax).
Namespace support in the IDE.
Currently it is a royal pain to add namespaces to forms and controls because you have to manually edit the designer files. The namespace should be a property, and it should default to the folder name.
Generics that work with numeric types.
It sucks that I cannot create ImaginaryNumber(Of IBasicMath)
Value Type Inheritance
Ok, I know it won’t be "real inheritance", but none the less I should be able to create
Structure Length
Inherits Double
End Structure
without having to manually map all of the normal methods on Double to wrapper functions in Length.
This really comes into play when one wants to ensure the math is correct by using dimensional analysis or simply wants to avoid metric/imperial conversion errors.
More support for basic line of business tasks.
TextFieldParser is a great start and XML literals are awesome, but VB still doesn’t have a good story for other line of business tasks that we do every day:
ZIP
FTP
POP3
Allow Using construct to have Catch blocks. I’m tired of having to use both or mess around with Finally statements.
Using X as New Resource
Try
Catch ex As DataAccessExeption
End Try
End Using
I’m in two minds about this, but:
1) Language-level support for common libraries.
There have always been specialized BASIC dialects (WordBASIC, AccessBASIC, DarkBASIC) that have had language support for things like joysticks, sound, video, sprite animation, etc. I used to think that this was a bad idea, and accessing libraries via a common object-accessor syntax a la Visual Basic was better. I’m having second thoughts nowadays. I recently had to write a sound-producing app, and found myself missing the SOUND and ENVELOPE commands from BBC BASIC, or even the super-simple PLAY of GWBASIC.
This could fit nicely with your third bullet point. What I would additionally like to see out of the gate is pre-built "command libraries" for ADO.NET WPF and WCF at least.
I suspect that the QuickBASIC-VB6 era Microsoft Basic used to have the non-parenthesized subroutine call syntax to make subroutines "feel" like commands. I miss that feature sometimes.
Oh, and…
2) Comments after line continuation characters. Please ?
and
3) Multi-line comments. PLEASE?
I has working with VB since 1998, I started in version 4.0. In the reality I started learning in BASIC in 1989 in TK 2000, later I passed for the BASICA, but commercially I started with VB 4.0
I like very much to VB, but would like I see some resources in VB 10
* Automatic Properties
* Sensitive Case
*
The only things that come to mind for me are:
* Putting in VB some of the syntactic sugar of C#, like the nice compact single-line if ( a ? b : c ) and the "default value" operator ( ?? ) for nullables. I know we have GetValueOrDefault, but it’s awfully long.
* Not sure if I read it here or elsewhere, but I really like the idea of being able to make keywords lower-case. That’s probably more of an IDE option than a language one, but I think it improves the readability a great deal.
(And yes, I know we have IIf too, but its syntax is kind of ugly IMHO.)
VB doesn’t support anonymous method in VB 8.0 and I haven’t heard the support for it in VB 9.0 either. Although there is workaround for not having anonymous method, it would be very nice to have anonymous method in VB.
I’d like to see more dynamic language features:
1. Dynamic identifiers
2. Dynamic interfaces
The aboves are previous in the plan of VB2008…
3. Dynamic class capability: Add members to objects/classes. Create object from dynamic runtime codes
4. AOP
5. Generic improvements: such as specifilization, generic generic parameters(for example:
Class Foo(Of T)
Private Bar As T(Of Integer)
End Class
)
Hi,
Here are a few suggestions:
1. Develop a new leaner implicit documentation system of sub/function variables for IntelliSense. With less “noise characters” and tighter integration that avoids some duplication and bring down the number of lines (even if the “saved” lines are “just” documentation and not code. For instance, if the two characters `< (without space could replace the clumsy XML style now in use, as shown in the example below. (Multi line can be implemented with underscore and end with >’ It also requires that the method heading can be broken by comments!
Sub DoSomething( `< This sub information shows up in IntelliSense _
Multiline comment >’
ByVal X as In32) `< This variable information shows up in IntelliSense
2. Give VBX enough dynamic possibilities so that VBX can replace VBS and PowerShell as script tool for administrators.
3. Use the new dynamic possibilities to implement a simpler but more powerful System.Windows.Forms and a GUI for it in Visual Studio. Compare the possibilities that IronRuby has with Rails and Groovy has with Grails.
4. Do use Unicode in identifiers so these are valid identifiers: Dim a, d, k’ as Int32, where k’= k prim. It is really time to forget 7 bit ASCII. This would make many lines of code clearer. Further, why not have better editors so that even k2 k(subscript)2 could be legal identifier? Compare with variable names in MathCAD.
5. An optional “Catch” functionality in the uppermost level in sub and functions, so an extra indention is not needed. See the code example. Much time should be saved, if this was the default set up.
Sub DemoWithCathDirect
Try
Do_Something_In_Method
CatchSub ex as Exception
MsgBox(“Exception in ” & Sub.Name)
End Sub
Hi Paul,
basically, there is only one valid argument for C# and against VB that is repeated from C# programmers around the worlds and that (from what I hear) is the single most decisive factor that makes professionals favour C# over VB: People fear that one day, VB.NET will face the same destiny as VB6. Namely, to be ditched. Ending VB6 support has cost enterprises large sums of money and shame on them if they let themselves be fooled twice.
It’s no good promising the kind of discontinuation won’t happen again, all that’s left is to wipe up the spilt milk.
So, this is my most urgent suggestion: Make VB an international standard, just like C#. This way, even if Microsoft should decide to stop working on VB some day in the future, enterprises can be confident that someone else will continue to work on it. I imagine that standardising a language is a huge effort and costs a lot of money; yet, the effort seemed worthwhile for C#. It will be worthwhile for VB for the same reasons.
Hi Paul,
I’d like to see Procedure View IDE back.
Today we have only Full Procedure View in .net IDE.
I’m requesting this since VB.NET 2002, but is always postponed.
A multiple "select case" (it’s possible in COBOL why not in VB 🙂 )
Select Case i also j
Case 1,2;3
Case 3 to 5; 1,2,4,5
case 0;ANY
End Select
First case =>(i =1 or 2) and j=3
Second case =>(3<=i<=5) and (j = 1 or 2 or 4 or 5)
Third case => i=0 (the value of j is not important)
Refactor method to move local variable to the innnermost scope where it is used.
I’ve inherited lots of code with 500+ line functions where all variables are declared at the top of the function. This is a real pain when refactoring since many of the variables are used only at the innermost scope.
I like the idea of line continuation not requireing the underscore. Of course the reason this is so easy in other languages is the explicitly end the line of code – if VB could figure out where the line of code ended allowing unlimited white space that would be cool.
I’d like to see the language generate directly from Power Point slides 🙂
I would like a function that would allow me to export hard coded values like strings into a resource file similar to refactoring, and automatically replace the string/number/date with a reference to that new resource.
I’d like to see the language make the Dim statement optional, if I say "x As Integer", that’s it I’ve Dim’d x.
I most certainly do not want to see case sensitivity – it’s poor practice to differentiate by case alone and being case insensitive avoids that issue.
I’d like to see support for alternative class keywords – ie. Static or Shared do the same thing when used in the same way or Sealed and NotInheritable do the same thing etc.
And to second the request of an earlier response – support for VBx as a true script language to replace the old VBS scripts.
Code Representation Switching- There should be a way where you can flip your code between Word/Keyword Format (Current Uncompiled View, i.e., .vb Files) and Fully Compliant UML which is 100% forward and backward compatible. As well, there would be another Code Representation which would be graphical with a drawn graphical Object relating to each and every Keyword and line of Code. Think of Visio Diagram. It would be analogous to how you can switch to different Views in Microsoft Project. For example, it would be really amazing to be able to see the code you wrote using the Networking Namespace actually show a Graphical Representation of the Network, Computer, TCP/IP Ports, etc.
I really do think that Code should be able to be represented in many different views always backward compatible to the other views, i.e., not just a one way conversion. This allows the mind to see different representations of the same thing and a problem sometimes can be easier to solve when the context is different but the substance is the same. If this doesn’t make sense, I would be glad to create a pseudo Visio example.
I think there should also be an option that automatically goes through your code and fixes Naming Conventions of all Variables and makes them in line with FxCop defined rules. I hate it when I have to work on another person’s code that doesn’t adhere to Naming Conventions.
Along these lines, I hate the way everything in Windows is represented as a File/Folder. I was really looking forward to the new Windows File System which was nixed from Vista. I feel this is one of the stupidest things that has failed to change in all OS. Everything isn’t a File/Folder at its Core and there should be a Standard that deals with this problem across all Operating Systems. I think that System Folders are one of the ugliest things on a Computer Hard Drive. First of all, you cannot just look at it and extrapolate any useful knowledge. I also hate the way certain Keys have been used to mean things so you have to waste your time memorizing what the mean, i.e., the T’This is a Unicode String.’ in SQL Server or @"This is a String." in C#. This is not intuitive, and Geeks who think it is cool to have a vast knowledge of these kind of Semantics make me want to puke. Any time these kinds of things raise their ugly head, they should be immediately eliminated. They only waste time and are not self supporting. In other words, anything in the OS design that needs to be explained, should be a sign there is a better design available that could explain itself to an intelligent person. I know this isn’t VB, yet items such as always leak over into the languages. This is a very tall order, yet once addressed, it will open up understanding of all the levels of abstraction automatically.
I’d like something of a "BlockEvents"
Currently when I load a form, I sometimes need to block events from firing while I load values, right now, I do a global boolean, but it would be nice to have that as something the system could take care of.
An EVAL function similar to JavaScript.
An easier way to build dynamic queries in LINQ.
The option of making variables declared in the Try section available in the Catch and Finally sections…if it’s possible to make it an option. I don’t want to break my current code.
Ability to paste a C# code block into the IDE and have it convert to VB. I could use an on-line converter…but I’m lazy.
Allow this to work… Dim A,B,C as Interger = 0
1. Force MS-Press to include VB samples in their first wave of books about new technology.
For example: there’s no WCF book out there using VB.NET (as of June 2007)
Then force all the high-level authors (which make a living on Microsoft technology) of other publishers to do the same.
2. inlcude all C# features in VB like anonymous methods. In education you permanently have to re-code C# samples to VB.
Use same keywords as alias in both languages: shared, noninheritable, …
3. spend money on the image of VB: it’s not a 2nd class language. It’s not for amateurs and beginners…
Compared to C# VB is easier to learn, faster to write and read and thus cheaper in maintenance I am sure.
Sorry for the long post, the line continuation characters bug me so i’m passionate about seeing their demise (or at least deprication they will have to stay for compat reasons) and have a few suggestions for your consideration if your interested 🙂
I would like to see
1) Anonymous methods
2) Multiple Icon support (i dislike not having the ability to have more than 1 icon accessible by windows, it makes it a pain when assigning icons to file types)
3) Don’t raise a warning if you say "If aVar isnot nothing" claiming it could raise a NullRefEx.
4) Less verbose casting, c# got it right with b = (TypeName)variable and b = variable as TypeName
5) I second the Select case for objects and types like Jonathan Allen suggested
6) As Aaron suggested Dim A,B,C as Interger = 0 style declarations, useful especially if you don’t do #3
7) If line continuation chars remain the only way, allow comments after the continuation (or implement inline comments which should do the same thing)
Now for line continuators (preferably without the need for line terminators) while still avoiding problems of typos causing wrong assumptions.
Dim text as string = {"This is line 1
This is line 2
This is line3"}
Ooh and maybe even have a prefix like how C# uses @ to mean take the string literally, but do the opposite like
Dim text as string = $"This is line 1 n This is line 2 n This is line3"
That would solve a lot of issues i hate having to use concatenation or string.format to insert line breaks in a string.
Calls to Methods over multiple lines should be easy enough
DoSomething(aReallyLong.VariableName.SoYouWantTheCallOverMultiple.Lines,
b,c,d)
As long as the line ends in a comma and the rest of the lines before the ) match the signature its good to go.
You could create an implicit With if the line begins with a . so you could do
tempVar = A.Really.Long.Qualification
.May.BeNiceTo.BreakUp
And then there is the If statement, you could basically treat anything between If and Then as the expression, if the Then doesn’t appear before the end if (or another key word that doesn’t belong) then raise an error.
Allowing comments for each line in a multiline statement would be very nice as well (failing that inline comments like C#s /* */ should do the job just as well and add extra functionality)
Now i have no idea how easy or difficult any of those are but maybe it’ll give you some ideas 🙂
I love the fact VB doesn’t have line terminators, but the line continuation is a real PITA and drives me insane (but then line terminators would probably be worse as you have to put them at the end of every line instead of lines you want to split).
As an IDE improvement to support the demise of line continuation characters, you could change the background color of the lines that constitute 1 programatical line to a light pastel color (maybe only when the caret is on that block of lines) or something to that effect.
I’d like to see a new tool added: A full featured text editor that has VBA as its application programming language.
I see so many full featured text editors out there that has anything but VBA as its application programming language.
Believe me – I have my lazy reasons. Many times I needed to automatate the editing of many flat files and I tire of doing it in VB when a top grade editor comes with all the tools and gizmos to do the job in a few simple steps.
How about it Microsoft? It’s been *many* years now and the market place hasn’t caught on in this area yet for us VB-ers. It would be a really good tool.
Anon methods would be great as well as interface chaining so that you don’t have to try to cast to IDisposable (unless I have totally missed how to do this in vb currently)
Before suggesting anything for VB10, would it be possible to get a link to the VB9 specification, so we can see what is already there? You posted a "What’s In and What’s Out" message a month or two ago, but I have yet to see the actual language specification (although there are lots of documents on MSDN referring one to see the specification for details….)
A simpler cast:
Dim A As Integer = DirectCast(Foo, Integer)
To:
Dim A As Integer = Foo As Integer
If we use type inference, then would be simplier:
Dim A = Foo As Integer (where Foo is Byte, for example)
Dave: Do you mean like how you can have 1 interface inherit another interface, which you can do in 2005 and im sure you can do in 2003 as well.
JCKodel: Im with you on that, except i think the Foo As Integer should be a TryCast like it is in C# not a direct cast.
It’s great to see you speculating openly and inviting feedback on what would be a good addition to VB10.
It’s language /compiler features that are important here: library functionality such as TextFieldParser and YYY can be implemented in the BCL or outside of Microsoft if the BCL implementation doesn’t exist or is unsuitable. Ditto for refactoring functionality. What we need you for is changes to the language and/or compiler.
Specific language features I would like to see:
1. Select Case variant as described by Jonathan – this has bugged me during development more times that I can count.
2. Automatic properties – minor convenience, but nice to have (even with snippets / refactoring)
3. Extended block scoping for Try.Catch.Finally statements as described by Aaron – it is a small but recurring annoyance that I have to increase variable scope to procedure level for the common case where a variable is reused only in the Catch or Finally block.
4. The line continuation character doesn’t normally bother me, but something is needed for string literals (especially in tests) – a string literal escape similar to the new Xml Literal would be invaluable if you could build a string across multiple lines with line continuations and repeated quotes and concatenations. Basically, if you could embed a formatted multi-line SQL statement in code which could be copied directly into Query Analyzer without requiring any modification, the solution would probably be sufficiently flexible.
5. Multi-line comments – minor when we code in an IDE, but still a worthwhile addition.
6. Some means (however convoluted) of extending or plugging your own logic into the compiler would be fantastic, as would integrated support for code generation similar to what can be done with ASP.NET but more integrated.
Even though I lived through the pain of moving / upgrading from VB6 to VB.NET (2003), I’m not really that pushed about standardising VB.NET. It would be nice, but I don’t believe it’s the best use of resources.
Persistent Annoyances:
1. Non-compulsory use of the line continuation character (needed with Linq more than ever)
2. When adding an abbreviated expression from a With block to the watch window, add the abbreviation so I don’t have to do it manually.
Lexical Noise:
1. Array literals e.g. {someString} is a String() that contains one element (someString).
Other Thoughts:
I would like to see VB be a language that once mastered allows you to do what used to take many languages and technologies. LINQ goes a long way toward achieving this. XML literals and XML axis properties are another giant step.
One language to rule them all! 🙂
1. Let VB be VB and change or amend to become C# or any other language. VB became successful because it was easy to use. Ease of use must be paramount in the next versio. Any one who needs object-oriented-polymorphism and other fashionable terms should move on to C3 or something else. Why the uptake of Vb6 was so much —- it was simple!! and VB.net fell flat compared to VB6.
2. Make Add-ins or specialized libraries for Business use, Statistical use etc. which will add specific commands/objects etc to vb, and add to the run-time.
3. Sort of built-in code / Form / query generators. It expedites and simplifies the programmers work. ("Ease of Use")
4. Controls should be auto-aware – winform or web form and similarly.
Some very good ideas here (select case, shorter casting …)
For my part, I don’t like the syntax :
"if MyObjet isnot Nothing then…"
It would be nice to write :
"if MyObject.exist then …"
(or an other better suited word … because my english sucks)
I’d love to see "Dim" go away instead of "private" in the method level.
When commenting an ElseIf or any Case except the first in a Select Case, the comments are indented incorrectly by the Pretty Lister.
Very annoying.
1. As said before, "BlockEvents" tag for when loading the form, so that when I init my form, it doesn’t raise events I want to ignore.
2. VB.NET scripting needs to not require all the constructs VB.NET does. For example, I generally don’t want to write out Class X/End Class when I’m writing a 5 line script. At the same time, I want to be able to create classes when needed.
3. Multiline commenting. Yes, VB.NET’s comment button is cool, but it just doesn’t replace multiline commenting.
4. Provide a better way of casting. While casting may seem clearer with "DirectCast" or "CType" it’s just not as easy to write out. I personally like the idea given by JCKodel with Dim A as Integer = MyByte As Integer
5. This is actually a .net issue, but I would like unsigned types to be supported by .net so they are CLS-compliant.
6. A simple way of converting UML to code (and back again), and not just in the "premium" team edition of VS.
7. Another .net issue, but it really annoys me that string’s don’t support something like this: string1.Remove("StringToRemove"). Also, why doesn’t string.split support splitting by a single string (rather than just an array)?
8. Reverse "@" symbol for VB.net strings, so that we could use C#-like symbol language when having lots of new lines.
Most common annoyment comes from adding "-1" in For statement like in
For i As Integer = 0 To list.Count-1
when C-ers can use the strict comparison to write directly
for(int i=0;i<list.Count;i++)
So what about something like For i As Integer = 0 Until list.Count ?
From what has already been suggested I’d like to +1 :
– Anonymous methods (their lack defeats the purpose of many nice Action or Predicate base methods).
– Cast syntax, I often use Ctype over DirectCast out of pure lazyness.
– Auto properties, while refactoring can do the trick it still clutters needlessly the code. Either that or open the binding to public fields 😉
Unsafe Code Blocks
Casting and using Pointers directly etc etc.
Remove the final Glass ceiling.
Thats all I need in VB10. Stop me using Hacks and let me do this stuff properly.
A simple one: implicit interface implementation…
Can we have the control array back ? Please?
Now that VB is the most popular dot-net language,
http://www.hanselman.com/blog/HanselminutesPodcast92VisualBasicYesterdayTodayAndTomorrowWithPaulVick.aspx
could we please have 1-based arrays and indexes?
for example, to remove the first character of a stringbuilder, let us refer to item number one!
option Count AsInRealLife
.
.
.
dim sb as new stringbuilder
sb.append("abcdefgh")
sb.remove(1, 1)
Horray!
Best regards
CInt(True) has to be 1. having it -1 is just lame.
lowercase keywords, at least as an option. eyes hurt.
I’d like a way to add immediate casting in For loops when dealing with non-Generic collections, like the ListBox control’s Items collection. Currently, I have to do casting on a separate line within the loop.
For Each member As Object In ListBox1.Items
realMember = CType(member, MyRealType)
…
Next member
It would be great to have a new Cast keyword that immediately casts each item as the loop progresses.
For Each realMember Cast As MyRealType In ListBox1.Items
‘ realMember is ready for use in the loop
…
Next member
As you see, I also use CType instead of DirectCast out of habit, as mentioned by another poster. A casting syntax would work for me as well.
I basically want VB.com back.
– Single Document Interface (like VB6 and all versions prior)
– Single procedure view (like VB6 and all versions prior). The full module view is way too much clutter. I’m only coding in one procedure at a time.. why am I being shown everything.
– VB6 style Edit and Continue. The VB2005 version doesn’t work the same as VB6.
– Absolutely DO NOT implement case sensitive variables. myname and MyName are the same words so should always be the same variables. The way C++ makes them different variables is ubsurd.
– Compile to a true assembly language executable. None of this IL stuff. It should at least compile to the same form of executable as VB6.
– Stop pushing web stuff into my front end. If I want to browse the web, I’ll open a browser.
– VB6 style control arrays.
– VB6 style arrays. Meaning non-zero based.
– Return to the whole point of VB in the first place. Somewhere, someone decided that VB.Net should work in such a way so that C++ developers would understand it. As a VB developer from version 1.0 and VBDOS.. I don’t care if a C++ programmer understands the language or how it works. We don’t need pointers in VB. If you want to screw around with pointers, use a different language. Inheritence is a nice concept but has no place in VB.
As posted above;
"1. Let VB be VB and change or amend to become C# or any other language. VB became successful because it was easy to use. Ease of use must be paramount in the next versio. Any one who needs object-oriented-polymorphism and other fashionable terms should move on to C3 or something else. Why the uptake of Vb6 was so much —- it was simple!! and VB.net fell flat compared to VB6. "
Exactly my point. I have used each and every single version of VB.net and each and every time I go back to VB6. Polymorphism is great for the educational world but is the most ubsurd concept ever introduced into real world development.. that sort of thing should never be in VB.
There are still over 3.5 million VB6 users in the world that won’t upgrade until microsoft gives us back our tool set.
We want VB7