VB Hedz....Where do you work?

that site has eircom colours. DIE!!

Wouldn't worry too much about the course having done "only vb at the moment". If it's taught well then the key lessons will be about good programming practices that translate into other languages.

Unfortuantely VB is often taught badly. Courses and books seem to often go roughly:

1. Forms + the built in controls
2. Basic language features
3. Other controls
4. Using ActiveX Components that aren't controls.
5. Building controls
6. Classes (near the end!) 101
7. Building ActiveX components that aren't controls
8. Interface-based Polymorphism.

The only justification for this is it matches the chronological order in which features were added to VB.
Ideally they should go more like:

1. Basic language features.
2. Classes
3. Interface-based polymorphism.
4. Forms (as a special kind of class).
5. Using ActiveX components that aren't controls (as a special kind of class).
6. Building ActiveX components(as a special kind of class).
7. Using Controls (as a special kind of class).
8. Building Controls(as a special kind of class).

A lot of common miscomprehensions would be gone.

Aside: Someone mention a 'good' reason to use polymorphism.

Seriously? Isn't this like "a 'good' reason for eating food instead of living of chewing gum you find on the street"?

VB uses polymorphism extensively. That's why when you update a DLL you don't break every program that uses it. It's also why you can have functions that take a parameter of type Form and use it whether it's actually DialogForm1 or DialogForm2.

Okay, here's an exemplum of explicit polymorphism actually in a program:

Index (amongst other things) allows one to edit documents that conform to a certain XML structure.

This structure is, by necessity, complex in terms of what is allowed where, and many elements allow mixed content (that means a mixture of elements and text to any non-XML/non-HTML ppl).

Obviously I have classes modelling the various types of element, and classes modelling text nodes.

A non polymorphic design would make many tasks that all of these elements have to perform in slightly different ways (serialising to XML, drawing to a Device Context, receiving a new child element, etc.) could be done in a variety of mechanisms, all of which suffer severely from efficiency and/or maintenance issues.

About the cleanest such mechanism that doesn't use late-binding (far to slow for something like this were dozens of calls would be needed in one window-update) would be something like:

Sub DrawNode(ByVal Node As Object, ByVal hDC As OLE_HANDLE, ByRef CurDrawPos as Point)
	If TypeOf Node Is Paragraph Then
		DrawBlockNode Node, hDC, CurDrawPos
	ElseIf TypeOf Node Is ListItem Then
		Ellipse hDC, CurDrawPos.x, CurDrawPox.y, CurDrawPos.x + 10, CurDrawPos.y + 10
		CurDrawPos.x = CurDrawPos.x + 15
		DrawBlockNode Node, hDC, CurDrawPos
	ElseIf TypeOf Node Is Text
		Dim tDraw As Text
		Set tDraw = Node
		DrawText hDC, tDraw.Contents, Len(tDraw.Contents), DrawRectFromPoint(CurDrawPos), FORMAT
	' Lots More Such TypeOf Tests
	'....
End Sub

That's a gross simplification helped by the DrawBlockNode sub (which presumably has to either to similar testing if it isn't to use late-bound mechanisms to obtain the children of the node to call DrawNode on each of them) and also by ignoring a few issues which mean that a naïve call to DrawText wouldn't actually work in practice.
In comparison polymorphism would allow us to rewrite the above function as:

Sub DrawNode(ByVal Node As DocNode, ByVal hDC As OLE_HANDLE, ByRef CurDrawPos as Point)
	Node.Draw hDC, CurDrawPos
End Sub

And leave it up to code in each node to deal with the issues of how this happens (most of them by faking inheritance with delegation so they can share much of the code).
Not only is the above a lot clearer, easier to deal with when a new node has been added, and less prone to error. But it's also more efficient as a series of RTTI tests (TypeOf) have been replaced with a polymorphic call (behinds the scenes this becomes a call through a function pointer).

In fact in the real code I don't use hDC, but a polymorphic wrapper called DeviceContext which allows me to use RAII to obtain the handle.
RAII is very important here, firstly because so much work happens with the hDC that there are dozens of places where an exception could conceivably happen and ensuring clean-up any other way would require very complex error-handling code. Also the clean-up required differs on how the hDC was obtained, so I have different classes (ScreenDC, ClientDC, PaintDC) which all have the polymorphic interface DeviceContext, but which carry out different methods for obtaining and destroying or releasing the hDC.

I always though that was more to do with binary compatibility than polymorphism?

It's both:

CoolClass is provided by CoolCom(v 1.0)

CoolCom(v 2.0) adds methods to CoolClass.

CoolClass in v2.0 in cannot have binary compatibility with CoolClass in v1.0. Hence stuff breaks.

Instead v2.0 can have CoolClass2 which implements the interface of CoolClass. To older code that uses CoolClass CoolClass2 will remain cool. To new code CoolClass2 is even cooler because of the new methods.

*backflip and dismount* Ta da!

Originally posted by Morphéus
but PLEASE dont hijack my thread to discuss VB programming niceties.

The diversions came naturally from "what kind of projects are you doing or have you done?". This is a programming board, the only point for having a thread like this is it allows one to look at what can be done with the language, and what makes sense to attempt in the language.

so i wanted to see if there were (A) any VB programmers and (B) rather self gratuitously where u worked in the hope i might strike up an interesting conversation along the lines of"oh your an unemployed fellow VBer, hmmm i know of someone looking for someone like you!" or "hey try whipping your CV off here" etc,

This is not a recruitment board. You can hardly compain if the discussion doesn't go in a directly that aids you to do something this board is not for.

it just makes me mad....:mad: and when i get mad... things get bro.... "FZZZZT...CRASH....SMASH....WHACK".....ken...

and when i get mad users get banned