Wimpy programmers are scared of things like old borland objects or records allocated on the heap.. while any semi-good or good programmer can handle them without a problem.

Wimpy programmers are also extremely scared of any object allocated on the stack because perfect classes contain everything allocated on the heap. In fact, wimpy programmers don't even know what the heap and stack are.. they just know what a class and maybe an integer is.. but not much else.

Good programmers make use of the stack when speed is important.. good programmers even make use of global variables in the right conditions. Somewhat wimpy programmers abandon global variables all the time and always use or pretend that they are using thread safe code (even if the application will never ever see a thread in its entire life, and even if avoiding the global variable just creates other global variables, such as a global class).

Good programmers also don't put all their methods and routines into classes just for the sake of putting them in classes. Good programmers know that the word 'reuse' means 'global functions available'. Examples are the sysutils and system units which people reuse and abstract from every day.

Good programmers aren't afraid of using pointers and old borland objects. Some people complain that they will not use KOL/MCK because it requires dereferencing of the pointer to access the object (actually many times dereferencing is not needed if using Delphi, but in Mode OBJFPC the dereference is sometimes needed). I can see not using KOL/MCK for other reasons.. such as if it doesn't work on linux/bsd and it currently doesn't support much else than the WinAPI (although attempts have been made for kylix). But to not use KOL because.. it is too hard to use.. well, this means the programmer should be fired.

If a programmer can't handle pointers or objects that aren't quite like classes, then he should become a graphics designer and get a job using HTML as his main programming language. This way, with HTML and graphics, he doesn't have to worry about pointers or anything like that.

All programmers should learn also how to do object oriented coding without using any objects.. in order to educate themselves about how objects really work. When one is forced to do OOP code without using any OOP code (and if the programmer pulls it off) then the programmer is good because he is not a wimp. In fact, the reason Windows 95 and Windows 98 and Linux were such hot selling operating systems was because they use no OOP.. they just use API's that everyone can tap into. Objects cannot always easily be tapped into when someone makes the assumption that some code is private and some code is published and some is protected and some is virtual, etc. etc.

In fact many times code should be public and more global than we think. This is one of the reasons why the Cee language is really popular, and I'm not fan of it even though it does the job. Good programmers make code public but warn people that it should really be private, and should only be used publicly if it is for some unanticipated situation (and many times, authors of API's must not make assumptions and must not anticipate what the end user or end developer will be doing with the API.. think of millions of applications that were built with the WinAPI, for example).

Good programmers should be able to parse any data without using a single regular expression.. and good programmers should be able to build a simple parser without any wildcards or regexes in one sitting without difficulty. This doesn't mean that good programmers avoid regexes all the time.. it just means that good programmers know how to parse too.. not just how to 'search and replace things with help from mommy'.

Good programmers can still use safe languages too...and they should! But good programmers should always get their feet wet in a dangerous language or at least turn on the dangerous mode in their language every so often.. so that they can keep their brain up. Otherwise their brain will become limp and wimpy. Without using a dangerous language the programmer becomes a little weakling.

And yes, freepascal is a dangerous language, unlike .NET, C#, and Java. In addition to freepascal, even ComponentPascal (a modula2/oberon style language) allows you to escape the safe language and go into dangerous mode in order to interface with C headers and C libs. In fact, even Standard Pascal had pointers (i.e. heap based records allocated on the fly).. dangerous things.