Visual Basic.CodeCompared.To/Pascal

Module becomes program, the body sits between begin and end, and the program ends with end. — a full stop, not a semicolon. Console.WriteLine becomes WriteLn, built in with nothing to import. Strings use single quotes. Both languages descend from the same family of readable, keyword-delimited syntax, and it shows immediately.

There is no $"...". WriteLn takes any number of arguments of any type and prints them in order, which covers most cases. The unusual one is the write specifier: Ratio:0:2 means "minimum width 0, two decimal places", replacing {ratio:F2}. Format from SysUtils is String.Format, using C-style %s and %d with the arguments in a bracketed array.

Pascal identifiers are case-insensitive, exactly as Visual Basic's are, so customerName and CustomerName are one name and the compiler does not care which you type. That removes the single most dangerous silent difference on every other page under this anchor. Convention is PascalCase for almost everything, with a T prefix on type names (TPerson) and an F prefix on private class fields (FName).

A Pascal routine declares its constants, types and variables in const, type and var blocks before the begin, never interleaved with statements. So a Dim written halfway down a Sub has to move up. It is more rigid than Dim-anywhere and has one real benefit: every name a routine uses is visible in one place at the top. The type block is where you name your own types, which the collections section uses heavily.

End If, End Sub and End Module all become end, and a block of more than one statement must be wrapped in begin ... end — a single statement needs neither. The rule that catches everyone: a semicolon is a separator, not a terminator, so there is no semicolon before else. ElseIf becomes two words. Then survives in lower case.

' becomes //. Both { ... } and (* ... *) are block comments — the second exists for keyboards that lacked braces, and both are still accepted. Because {$...} is a compiler directive rather than a comment, a brace comment starting with $ means something: {$mode objfpc} is how a file selects its dialect. There is no XML documentation convention; Lazarus reads the comment immediately above a declaration.

= means equality and nothing else, and <> is inequality — both exactly as you write them today, and a relief after C#'s ==/!=. Assignment is :=, which is where Pascal took the ambiguity out. Writing Left = 6 as a statement is a compile error rather than a silent assignment, which is the same protection C# gets from requiring a bool condition.

Short→SmallInt, Integer→Integer, Long→Int64, Double→Double, Single→Single, Boolean→Boolean, Char→Char with single quotes. The notable one is Currency: a fixed-point type with four decimal places, stored as a scaled 64-bit integer — not identical to Decimal (fewer digits, fixed rather than floating scale) but a real money type, which Go, Rust, JavaScript and Java all lack.

Pascal strings are 1-based, like the Microsoft.VisualBasic string functions and unlike Substring. Mid(text, 1, 6) becomes Copy(Text, 1, 6) with the same numbers; InStr becomes Pos, also 1-based and also returning 0 when not found; Len becomes Length, UCase becomes UpperCase. Text[1] indexes a character directly. Concatenation is +, and strings are managed and reference-counted, so no manual freeing is needed for them.

CInt→StrToInt, CStr→IntToStr, CDbl→StrToFloat, CBool→StrToBool, all from SysUtils. Integer.TryParse becomes TryStrToInt, with the same shape: a Boolean result and an output parameter. There is also StrToIntDef, which takes a fallback and needs no output parameter at all. Of every target on this anchor this is the closest correspondence, because both languages evolved the same idea independently.

array[1..5] means indices 1 through 5, and you may pick any bounds at all: array[1900..2100] indexed by year is idiomatic Pascal. LBound and UBound become Low and High, and using them rather than literals is the convention, so a bound change never breaks a loop. Anyone still missing Option Base 1 from VB6 has it back — properly, per array, rather than per file.

array of T with no bounds is a dynamic array, sized by SetLength and always starting at 0. That inconsistency with fixed arrays is a genuine wart, and Low/High is why it rarely bites. There is no Add: growing means SetLength then assigning, or Insert from SysUtils. For a real list with methods, Free Pascal ships TList, TStringList and the generic TFPGList / TList<T> — and those are objects, so the memory section applies to them.

Structure ... End Structure becomes record ... end, and assignment copies the whole value in both. A plain record is data only, so the behaviour becomes a standalone routine — which is why the example passes the point in rather than calling a method on it. Records can carry methods, but only with {$modeswitch advancedrecords} turned on, and even then declaration and implementation stay separate. A record needs no constructor and no New: declaring the variable is enough, and it needs no freeing.

Select Case x becomes case x of, Case labels become value:, Case 2, 3 keeps its comma, and Case 4 To 6 becomes 4..6. Case Else becomes a bare else. No branch falls through, as in Visual Basic. The one limitation: a Pascal case works only on ordinal types — integers, characters, enumerations, booleans — so Select Case on a String has to become an if chain.

For i = 1 To 5 becomes for Index := 1 to 5 do, inclusive at both ends, so no off-by-one to convert. Step -1 becomes downto; other step sizes have no form and need a while. For Each becomes for x in collection do. And Do ... Loop Until becomes repeat ... until, which needs no inversion and no begin/end — the repeat and until bracket the block themselves.

With obj ... End With becomes with Obj do begin ... end, and it does the same job — though note the members are written without a leading dot. C#, Python, Ruby, Go, Rust and JavaScript all lack it entirely; only Pascal has it, which is unsurprising given that Visual Basic borrowed the idea from the same tradition. Modern Pascal style is wary of it for the same reason modern Visual Basic style is: a nested with makes it genuinely unclear which object a bare name belongs to.

Sub becomes procedure and Function ... As Integer becomes function ... : Integer, with the return type after a colon exactly where As Integer sits. Return value becomes Result := value, which will feel familiar to anyone who remembers VB6's Add = 5; there is also an Exit statement for an early return. Parameters sharing a type share the annotation, and const on a parameter promises not to modify it and lets the compiler avoid a copy.

ByRef becomes var when the value goes in and comes back, and out when it is purely an output — the same distinction C# draws. ByVal is the default and needs no keyword. Unlike C#, the call site writes nothing: Twice(Number) looks like an ordinary call, exactly as in Visual Basic, so you must read the declaration to know. Note div and mod, which the next section covers, and Exit(False) as an early return with a value.

A default value makes a parameter optional, and the Optional keyword disappears — the same as everywhere else on this anchor. Overloading works too, but each overload must be marked overload, otherwise the second declaration is an error rather than an overload. Named arguments do not exist: greeting:= has no counterpart, so a middle argument cannot be skipped.

A class declares its members in the type block and implements them afterwards, which is more typing than Visual Basic's single block and makes the public shape of a class readable in one place. Public Sub New becomes constructor Create, called as TPerson.Create(...) — on the type, not with a New keyword. Me becomes Self. Visibility sections (private, protected, public, published) group members rather than marking each one.

A property declares what to read and what to write, and either may be a field directly or a method. So read FCelsius write SetCelsius is a plain read with a validated write, and a property with only read is ReadOnly Property. Callers write Reading.Celsius := 100, identical to Visual Basic. There is a fourth visibility, published, which makes a property visible to the Lazarus form designer — the mechanism the object inspector is built on.

Inherits Shape becomes class(TShape), Overridable becomes virtual, Overrides becomes override, MustOverride becomes virtual; abstract, and MyBase becomes inherited. As in .NET a method is not overridable unless marked, and a class extends one class. Interfaces exist too — IGreeter = interface and class(TObject, IGreeter) — and are reference-counted, which interacts with the memory rules in the next section.

There is no garbage collector. Every object created with Create must be released with Free, and forgetting is a memory leak rather than an error. The universal idiom is the one above: Create, then try ... finally Free, so the object is released even if the block raises. Records, strings, dynamic arrays and interfaces are all managed automatically — it is only class instances you own. A Visual Basic programmer who has never thought about lifetime has to start, and it is the main thing to budget learning time for.

Freeing the list does not free what is in it. Either release each item yourself, as above, or use a container that owns its contents: TObjectList.Create(True) takes an OwnsObjects flag and frees each item when it is freed, and the Lazarus component model does the same — a control added to a form is freed with the form. The discipline is to decide, for every object, who owns it, and to write that down. It is the habit that makes the absence of a collector manageable rather than frightening.

Try→try, Catch e As T→on E: T do, End Try→end. Order still matters, most specific first, and E.Message reads the same. The wrinkle: Pascal has no try...except...finally in one block, so a routine needing both nests a try..except inside a try..finally, as above. That is why the memory section's try..finally Free is always its own block.

Throw New becomes raise ...Create(...), and Inherits Exception becomes class(Exception) from SysUtils. MyBase.New becomes inherited Create, or CreateFmt for a formatted message. Convention prefixes exception class names with E rather than suffixing Exception. The one thing to know given the previous section: a raised exception object is freed automatically when the handler finishes, so this is the one Create you must not Free.

Imports becomes uses, and names come into scope unqualified — Max, not Math.Max — with later units in the list winning a name clash. A unit has an interface section listing what the outside world may use and an implementation section holding the bodies plus anything private. That split is more explicit than Public/Private on each member, and it gives you a readable summary of a unit's API at the top of its own file.

Lazarus is a free, open-source IDE with a drag-and-drop form designer, an object inspector, and double-click-to-write-an-event-handler — the VB6 and WinForms workflow, on a compiler nobody owns. The LCL is the control library; Label1.Caption := 'Hello' is Label1.Text = "Hello". It cross-compiles to Windows, macOS, Linux and Raspberry Pi from the same source, and the output is one native binary with no runtime to install. Packages come from the Online Package Manager rather than NuGet.

Pascal makes exactly the distinction Visual Basic makes: / always produces a Real, and div is integer division. So \ becomes div, / stays /, and Mod becomes mod — no truncation trap, no silently changed meaning. Assigning the result of / to an Integer is a compile error rather than a rounding, which is Option Strict On behaviour by default. Every other target on this anchor except Python gets this wrong for a Visual Basic reader; Pascal does not.

A semicolon separates statements rather than terminating them, so there is never one immediately before else — the if...then...else is a single statement and a semicolon would end it early. The same applies before until and before the final end, though a semicolon there is harmless because it separates from an empty statement. Free Pascal's error for this is Fatal: Syntax error, ";" expected but "ELSE" found, which is the compiler being about as helpful as it can be.

Leaving out the Free compiles cleanly, runs correctly, and leaks — three objects here, thousands in a long-running service. Nothing warns you at build time. Two things make this tractable: the try ... finally Free idiom applied without exception, and Free Pascal's -gh heaptrc option, which prints every unfreed block with its allocation stack when the program exits. Turn it on in debug builds from day one; it is the closest thing to a collector you get.

A Pascal string is indexed from 1, a dynamic array from 0, and a fixed array from whatever bounds you declared. That inconsistency is the source of most off-by-one bugs in Pascal code, and there is a second trap on top of it: Low and High are reliable on arrays and misleading on strings — the output above shows them reporting 0 and 255, the ShortString capacity range, rather than 1 and the length. So use Low/High for arrays and 1 to Length(Text) for strings. (In Delphi's mobile compilers strings became 0-based, which caused enough trouble that Free Pascal did not follow.)

IsNumeric becomes TryStrToInt, Now is Now (the same name, from SysUtils), My.Computer.FileSystem becomes SysUtils and FileUtil. The larger point: there is no .NET. No System.Text.Json, no HttpClient, no LINQ, no async/await, no NuGet. Free Pascal's RTL and the Lazarus component library are broad and mature, but they are a different library with different names, and any code that leans on a .NET-specific type has to be rewritten rather than translated.