Access VBA is a non-OOP language with some OOP features. It offers both Subs and Functions. A Sub does not return a value while a Function does. When Subs and Functions are used in a class module, they become the methods of the class.

Sub SayHello(ByVal pName As String)

  MsgBox ("Hello " & pName)

End Sub

Function Add(pN1 As Integer, pN2 As Integer) As Integer

  Add = pN1 + pN2

End Function

 Access VBA Custom Routines (Sub, Function)

ASP Classic is a non-OOP language with some OOP features. It offers both Subs and Functions. A Sub does not return a value while a Function does. When Subs and Functions are used in a defined class, they become the methods of the class.

Sub SayHello(ByVal pName)
  Response.Write "Hello " + pName + "!<br>"
End Sub
 
Function Add(ByRef pN1, ByRef pN2)
  Add = pN1 + pN2
End Function

 ASP Classic Custom Routines (Sub, Function)

C# requires () in both the function declaration, and when it's invoked. Leave off the parens to signify a property.

ReturnType RoutineName()

void SayHello(String pName)
{
  MessageBox.Show("Hello " + pName);
}
 

int Add(int a, int b) 
{
  return a + b;
}

C++ is a hybrid language and as such offers global functions and class methods. A function must come before it's usage or you can prototype the function.

void sayHello(string pName) {
  cout << "Hello " + pName + "\n";
};

int add(int p1, int p2) {
  int result;

  result = p1 + p2;
  return result;
};

 C++ Custom Routines

ObjectPAL is a non-OOP language (an object-based language) that offers custom methods and custom procedures. When you create a custom method, you associate it with an existing object like a button, form, or library.

When calling a custom method or procedure that has a by reference parameter (uses var), then you cannot use a literal value. this is different than in many other languages which do allow you to pass literals by reference.

method sayHello(var pName String)
 msgInfo("", "Hello " + pName)
endMethod
 

method add(p1 Number, p2 Number) Number
 Return p1 + p2
endMethod

 ObjectPAL Custom Routines (method, procedure)  

Delphi is a hybrid language so you can create either class methods (functions and procedures) or you can create global functions and procedures. When a function or procedure is part of a class, it is a class method.

[function/procedure] RoutineName : ReturnType;

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

Note: Contrast Delphi with Delphi Prism which is an OOP language (everything is within a class). Both Delphi and Delphi Prism are based on Object Pascal but implement OOP features differently and have some syntax differences too.

procedure SayHello(pName: String);
begin
  ShowMessage('Hello ' + pName);
end;

function Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

 Delphi Custom Routines (procedure, function)

In Prism, everything is within a class (just like with C#, VB.Net, and Java). So you create class methods using the method keyword. Alternatively, you can use procedure or function if you want the compiler to enforce returning or not returning a value.

[function/procedure] RoutineName : ReturnType; 

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

method Form1.IntroduceYourself;
begin
  MessageBox.Show("Hello, I do not have a name yet.");
end; 
 
procedure Form1.SayHello(pName: String);
begin
  MessageBox.Show("Hello " + pName);
end;

function Form1.Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

 Delphi Prism Custom Routines (method, procedure, function)

Because java is an OOP language, all custom routines belong to a specific class and are therefore referred to as methods.

All methods in Java must return something so even with procedures, you return a "void".

public void sayHello(String pName) {
  System.out.println("Hello" + pName);
}

 

public int add(int p1, int p2) {

  return p1 + p2;

}

Perl uses subs and parameters are referenced in a special array. All arguments passed to a subroutine are stored in a special @_ array. To retrieve the arguments, you have to look inside the array and extract them.

sub sayHello {
 my ($pName) = $_[0];
 print("Hello $pName!");
}

sub add {
 my ($p1) = $_[0];
 my ($p2) = $_[1];
 return $p1 + $p2;
}

 Perl Custom Routines (sub)

PHP uses functions and loosely typed parameters. Function definitions can come before or after their usage so my preference when mixing PHP in with a mostly HTML page is to put the functions after the </html> tag.

function sayHello($pName) {
 echo "Hello " . $pName . "<br>";
}

function add($p1, $p2) {
 return $p1 + $p2;
}

 PHP Custom Function (function)

VB Classic is a non-OOP language with some OOP features. It offers both Subs and Functions. A Sub does not return a value while a Function does. When Subs and Functions are used in a class module, they become the methods of the class.

Sub DoSomething(ByVal pMessage As String)

  MsgBox (pMessage)

End Sub

Function GetAge(ByRef pFullname As String) As Integer

  GetAge = 7

End Function

 VB Classic Custom Routines (Sub, Function)

VB.Net is a fully OOP language so both Subs and Functions are methods of a class. A Sub does not return a value while a Function does.

Syntax Example:   Private Sub DoSomething(ByVal pMsg As String) '...some code. End Sub Private Function GetAge(ByVal x As String) As Integer GetAge = 7 End Function