Object Pascal (thing)

The language of the Borland Delphi programming environment was called Object Pascal, until it got a name change in 2002 or so to just plain Delphi. It is the linear descendant of Borland Turbo Pascal. In fact, it is backwards compatible, and thus keeps a couple of misfeatures and flaws accumulated over the years in Pascal and Turbo Pascal.

Delphi's Object Pascal is a strongly typed compiled language that produces windows executables (and COM servers, DLLs, ActiveX controls, Control panel Applets etc.) and lately also x86 Linux binaries using Kylix.

It is a proprietry system with a single implementation from one vendor: Borland/Inprise.

“Object Pascal, a set of object-oriented extensions to standard Pascal, is the language of Delphi.” – Delphi help.

Of course, it also has many non-OO extensions over the primeval Pascal that Brian Kernighan disliked so much which make it a better, more rounded and complete language, and which effectively remove all the disadvantages of pascal

For instance, you can do the pointer arithmetic and type coercion that are occasionaly needed to interface with the operating system API or in the guts of a class. There are also dynamic arrays and other goodies that were not in the original Pascal.

One of nicest things about Object Pascal is that unless you have to interact with a primeval C API (e.g. Win32) unsafe typecasts can be avoided almost completely.

Seeing as Pascal is a purely procedural programming language, Object-Pascal supports both procedural and object-oriented programming styles, and the pragmatic grey area that uses both as needed.

Some of the constructs supported by Delphi 5 and later are:

• Single inheritance rooted at a common root class called TObject
• Java-style multiple inheritance i.e. inheritance of one or more interfaces in addition to one class, aka Mixin classes. This was introduced in Delphi 3
• Method overloading and default parameters
• Structured exception handling with try..except and try..finally blocks. All exceptions are objects.
• assert as a built-in language function
• Implementation of the Uniform Access Principle using properties.

Object-Pascal does not have any concept of operator overloading or templates.

Operator overloading I don’t miss. It is just syntactic sugar and has bitten me on occasion in C++. However as I code yet another list class, I occasionally find myself wanting templates.

Object-Pascal is not garbage-collected, for instance, a typical code fragment may read:

procedure UseStrings;
var
  lcStrings: TStringList; // an object var is actually a ptr to an instance, initially nil. 
begin
  lcStrings := TStringList.Create; // assign the var to a new instance
  try // this also demonstrates the try.. finally block. It works like in Python

    // use the strings

  finally // like in Python, there is also a try..except block to catch exceptions
    lcStrings.Free; // manually release the created instance whatever happens
  end;
end;

It is worth noting that the TComponent class and it's descendants (i.e. all the visual controls) have the concept of an Owner TComponent to which they can be attached and which will free them when it is freed. This is why you can iterate through the child controls of a form or panel, and why controls on forms laid out in the IDE do not require manual freeing.

See also Why pascal is not my favorite programming language and Why pascal sucks These talk of the disadvantages of standard Pascal, almost all of which have been fixed by Object Pascal. That is, Object Pascal does not share many of the disadvanages of pascal.

See also Differences between C and Borland Delphi and When to use a semicolon in Pascal.

---

With regards to sdd's comment that Some critics do not even consider Delphi to be a real programming language, as it is a RAD system or visual programming language, hiding most of pascal under menus

My opinion is that Delphi is not a programming language, it is a RAD suite that includes a programming language (Borland's version of Object Pascal).

This language is very real, to the extent that if you really want to to, you can generate all the source files yourself using a text editor, invoke a commandline compiler called dcc.exe upon them, which will produce an executable. You can make DLL libraries, GUI or commandline apps this way. I should know, I've done it.

The fact that you have aditional tools does not detract from the realness of the compiler for anyone except the terminally superficial.

In fact, one of the tenets of delphi is that anything that can be done visually can be done in code. In general, the visual tools are Delphi code.