Comparison of programming languages (basic instructions)

Comparison of programming languages is a common topic of discussion among software engineers. Basic instructions of several programming languages are compared here.

Variable declaration

How to declare variable x as the following types:

Integers

	8 bit (byte)		16 bit (short integer)		32 bit		64 bit (long integer)		Arbitrarily precise (bignum)
	Signed	Unsigned	Signed	Unsigned	Signed	Unsigned	Signed	Unsigned
C (C99)	int8_t x; or signed char x;	uint8_t x; or unsigned char x;	int16_t x; or short x;*	uint16_t x; or unsigned short x;*	int32_t x; or long x;* or int x;*	uint32_t x; or unsigned long x;* or unsigned int x;*	int64_t x; or long long x;*	uint64_t x; or unsigned long long x;*
C++ (STL)	signed char x;	unsigned char x;	short x;*	unsigned short x;*	long x;* or int x;*	unsigned long x;* or unsigned int x;*
C#	sbyte x;	byte x;	short x;	ushort x;	int x;	uint x;	long x;	ulong x;
Java	byte x;			char x;					java.math.BigInteger x;
Common Lisp	(setf x value)
Scheme	(define x value)
Pascal (Free Pascal)	var x: shortint;	var x: byte;	var x: smallint; or var x: integer;	var x: word;	var x: longint;	var x: longword;	var x: int64;	var x: qword;
Visual Basic		Dim x As Byte	Dim x As Integer		Dim x As Long
Visual Basic .NET	Dim x As SByte		Dim x As Short	Dim x As UShort	Dim x As Integer	Dim x As UInteger	Dim x As Long	Dim x As ULong
Python					x = value				x = value
JavaScript
S-Lang	x = value;
FORTRAN 77			INTEGER X
PHP	$x = value;		$x = value;		$x = value;		$x = value;		$x = string; (BCMath) or $x = gmp_init(value); (GMP)
Perl	$x = value;								use Math::BigInt; $x = Math::BigInt->new(string);
Ruby	x = value
Windows PowerShell	$x = value; or New-Variable -Name x -Value value -Description description
OCaml					let x «: int32» = value or let x «: int» = value*		let x «: int64» = value		open Big_int;; let x «: big_int» = value
Haskell (GHC)	import Int «x :: Int8» x = value	import Word «x :: Word8» x = value	import Int «x :: Int16» x = value	import Word «x :: Word16» x = value	import Int «x :: Int32» x = value or «x :: Int» x = value	import Word «x :: Word32» x = value or «x :: Word» x = value	import Int «x :: Int64» x = value	import Word «x :: Word64» x = value	«x :: Integer» x = value

Floating point

	Single precision	Double precision
C (C99)	float x;	double x;
C++ (STL)
C#
Java
Common Lisp	(setf x value)
Scheme	(define x value)
Pascal (Free Pascal)	var x: real;	var x: extended;
Visual Basic	Dim x As Single	Dim x As Double
Visual Basic .NET
Python		x = value
JavaScript		var x = value; or var x = new Number (value);
S-Lang	x = valuef;	x = value;
FORTRAN 77	REAL X	DOUBLE PRECISION X
PHP	$x = value;
Perl
Ruby	x = value
Windows PowerShell	$x = value; or New-Variable -Name x -Value value -Description description
OCaml		let x «: float» = value
Haskell (GHC)	«x :: Float» x = value	«x :: Double» x = value

Complex numbers

	Integer	Floating point
C (C99)		type complex x;
C++ (STL)	«std::»complex<type> x;
C#
Java
Common Lisp	(setf x #C(re im)) or (setf x (complex re im))
Scheme	(define x re+imi)
Pascal
Visual Basic
Visual Basic .NET
Perl		use Math::Complex; ... $x = re + im*i; or $x = cplx(re, im);
Python		x = re + imj or x = complex(re, im)
JavaScript
S-Lang		x = re + imi; or x = re + imj;
FORTRAN 77		COMPLEX X
Ruby
Windows PowerShell
OCaml		open Complex;; let x = { re = re; im = im }
Haskell (GHC)	import Complex x = re :+ im

Other variable types

	Text		Boolean	Object/Universal
	Character	String
C (C99)	char x;	char x[length]; or char *x;	bool x;	void *x;
C++ (STL)		«std::»string x;
C#		string x;	bool x;	object x;
Java		String x;	boolean x;	Object x;
Common Lisp	(setf x #\character)	(setf x "string")	(setf x value)
Scheme	(define x #\character)	(define x "string")	(define x value)
Pascal	var x: char;	var x: string;	var x: boolean;
Visual Basic		Dim x As String	Dim x As Boolean	Dim x As Variant
Visual Basic .NET	Dim x As Char			Dim x As Object
Python	x = value	x = "string" or x = 'string'	x = value
JavaScript	var x = value;	var x = "string"; or var x = new String("value");	var x = value; or var x = new Boolean (value);	var x = new Object (); or var x = {}; or var x = {property1: value1, property2: value2, ... };
S-Lang	x = value;	x = "string";	x = value;
FORTRAN 77	CHARACTER*1 X	CHARACTER*length X	LOGICAL X
PHP	$x = value;	$x = "string"; or $x = 'string';	$x = value;
Perl
Ruby	x = value	x = "string"	x = value
Windows PowerShell	$x = [char]UnicodeCharacterCode; or $x = [char]"character"; or $x = [char]'character'; or $x = "character"[0]; or $x = 'character'[0]	$x = "string"; or $x = 'string'	$x = value
OCaml	let x «: char» = value	let x «: string» = value	let x «: bool» = value	let x = value
Haskell (GHC)	«x :: Char» x = value	«x :: String» x = value	«x :: Bool» x = value

Array declaration

Further information: Comparison of programming languages (array)

How to declare x as an array whose components do not have any particular defined values (where array dimensions can be explicitly defined) :

	one-dimensional array	multi-dimensional array
C (C99)	type x[size];	type x[size1][size2]...;
C++ (STL)	type x[size]; or «std::»vector<type> x(size);
C#	type[] x = new type[size];	type[,,...] x = new type[size1,size2,...];
Java	type[] x = new type[size];	type[][]... x = new type[size1][size2]...;
JavaScript	var x = new Array («size»); or var x = new Array (elements); or var x = [«elements»];	var x = new Array (array1, array2, ...); or var x = [array1, array2,...];
Common Lisp	(setf x (make-array size))	(setf x (make-array '(size1 size2 ...)))
Scheme	(define x (make-vector size))
Pascal	var x: array[first..last] of type;	var x: array[first1..last1] of array[first2..last2] ... of type; or var x: array[first1..last1, first2..last2, ...] of type;
Visual Basic	Dim x(size) As type	Dim x(size1, size2,...) As type
Visual Basic .NET
Python	x = []	x = , [], [], ...]
S-Lang	x = type[size];	x = type[size1, size2, ...];
FORTRAN 77	type X(size)	type X(size1, size2,...)
PHP	$x = array(elements);	$x = array(array(elements), array(elements), ...);
Perl	@x = (elements); or $ref = [elements];	@x = ([elements], [elements], ...);
Ruby	x = Array.new(size)
Windows PowerShell	$x = New-Object 'type[]' size; or «[type[]]»$x = @()	$x = New-Object 'type[,,...]' size1,size2,...; or «[type[,,...]]»$x = @(@(), @(), @(), ...)
OCaml	let x = Array.make size initval
Haskell (GHC)	x = Array.array (0, size-1) list_of_association_pairs	x = Array.array ((0, 0,...), (size1-1, size2-1,...)) list_of_association_pairs

Control flow

Statements in guillemets (« … ») are optional.

Conditional statements

	if	else if	select case
C (C99)	if (condition) {instructions} «else {instructions}»	if (condition) {instructions} else if (condition) {instructions} ... «else {instructions}»	switch (variable) {case case1: instructions «break;» ... «default: instructions»}
C++ (STL)
Java
JavaScript
PHP
C#			switch (variable) {case case1: instructions; jump statement;... «default: instructions; jump statement;»}
Windows PowerShell		if (condition) { instructions } elseif (condition) { instructions } ... «else { instructions }»	switch (variable) {case1 { instructions «break;» } ... «default { instructions }»}
Perl	if (condition) {instructions} «else {instructions}» or unless (notcondition) {instructions} «else {instructions}»	if (condition) {instructions} elsif (condition) {instructions} ... «else {instructions}» or unless (notcondition) {instructions} elsif (condition) {instructions} ... «else {instructions}»	use feature "switch"; ... given (variable) {when (case1) { instructions } ... «default { instructions }»}
Ruby	if condition instructions «else instructions» end	if condition instructions elsif condition instructions ... «else instructions» end	case variable when case1 then instructions ... «else instructions» end
Common Lisp	(when condition instructions) or (if condition (progn instructions) «(progn instructions)»)	(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)»)	(case (variable) (case1 instructions) (case2 instructions) ... «(t instructions)»)
Scheme	(when condition instructions) or (if condition (begin instructions) «(begin instructions)»)	(cond ((condition1) instructions) ((condition2) instructions) ... «(else instructions)»)	(case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)»)
Pascal	if condition then begin instructions end «else begin instructions end»;	if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»;	case variable of case1: instructions; ... «else: instructions » end;
Visual Basic	If condition Then instructions «Else instructions» End If	If condition Then instructions ElseIf condition Then instructions ... «Else instructions» End If	Select Case variable Case case1 instructions ... «Case Else instructions» End Select
Visual Basic .NET
Python	if condition : Tab instructions «else: Tab ↹ instructions»	if condition : Tab ↹ instructions elif condition : Tab ↹ instructions ... «else: Tab ↹ instructions»
S-Lang	if (condition) { instructions } «else { instructions }»	if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }»	switch (variable) { case case1: instructions } { case case2: instructions } ...
FORTRAN 77	IF condition THEN instructions «ELSE instructions» ENDIF	IF condition THEN instructions ELSEIF condition THEN instructions ... «ELSE instructions» ENDIF	index = f(variable)      GOTO ( c1, c2, ... cn) index ... c1  instructions
OCaml	if condition then expression «else expression» or if condition then begin instructions end «else begin instructions end»	if condition then expression else if condition then expression ... «else expression» or if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»	match value with pattern1 -> expression | pattern2 -> expression ... «| _ -> expression»
Haskell (GHC)	if condition then expression else expression or when condition (do instructions) or unless notcondition (do instructions)	if condition then expression else if condition then expression ... else expression	case value of {pattern1 -> expression; pattern2 -> expression ... «; _ -> expression»}
	if	else if	select case

Loop statements

The bold is the literal code. The non-bold is interpreted by the reader. Statements in guillemets (« … ») are optional.

	while	do while	for i = 1 to N	foreach
C (C99)	while (condition) { instructions }	do { instructions } while (condition)	for («type» i = 0; i < N; i++) { instructions }
C++ (STL)				«std::»for_each(start, end, function)
C#				foreach (type item in set) { instructions }
Java				for (type item : set) { instructions }
JavaScript			for (i = 0; i < N; i++) { instructions }	for ( property in object) { instructions }
PHP			for ($i = 0; $i < N; $i++) { instructions }	foreach (set as item) { instructions } or foreach (set as key => item) { instructions }
Windows PowerShell			for ($i = 0; $i -lt N; $i++) { instructions }	foreach (item in set) { instructions using item }
Perl	while (condition) { instructions } or until (notcondition) { instructions }	do { instructions } while (condition) or do { instructions } until (notcondition)	for ($i = 0; $i < N; $i++) { instructions } or for«each» «$i» (0 .. N-1) { instructions }	for«each» «$item» (set) { instructions }
Ruby	while condition instructions end or until notcondition instructions end	begin instructions end while condition or begin instructions end until notcondition	1.upto(n) { |i| instructions } or 0.step(n - 1, 1) { |i| instructions }	set.each { |item| instructions }
Common Lisp	(do () (notcondition) instructions)		(dotimes (i N) instructions) or (do ((i 0 (1+ i))) ((>= i N)) instructions)	(dolist (item set) instructions)
Scheme	(do () (notcondition) instructions) or (let loop () (if condition (begin instructions (loop))))	(let loop () (instructions (if condition (loop))))	(do ((i 0 (+ i 1))) ((>= i N)) instructions) or (let loop ((i 0)) (if (< i N) (begin instructions (loop (+ i 1)))))	(for-each (lambda (item) instructions) list)
Pascal	while condition do begin instructions end	repeat instructions until notcondition;	for i := 1 «step 1» to N do begin instructions end;
Visual Basic	Do While condition instructions Loop or Do Until notcondition instructions Loop	Do instructions Loop While condition or Do instructions Loop Until notcondition	For i = 1 To N «Step 1» instructions Next i
Visual Basic .NET			For i «As type» = 1 To N «Step 1» instructions Next i	For Each item As type In set instructions Next item
Python	while condition : Tab ↹ instructions «else: Tab ↹ instructions»		for i in range(0, N): Tab ↹ instructions «else: Tab ↹ instructions»	for item in set: Tab ↹ instructions «else: Tab ↹ instructions»
S-Lang	while (condition) { instructions } «then optional-block»	do { instructions } while (condition) «then optional-block»	for (i = 0; i < N; i++) { instructions } «then optional-block»	foreach item(set) «using (what)» { instructions } «then optional-block»
FORTRAN 77			DO nnnn I = 1,N instructions nnnn CONTINUE
OCaml	while condition do instructions done		for i = 0 to N-1 do instructions done	Array.iter (fun item -> instructions) array List.iter (fun item -> instructions) list
Haskell (GHC)			Control.Monad.forM_ [0..N-1] (\i -> do instructions)	Control.Monad.forM_ list (\item -> do instructions)

Exceptions

Further information: Exception handling syntax

The bold is the literal code. The non-bold is interpreted by the reader. Statements in guillemets (« … ») are optional.

	throw	handler	assertion
C (C99)	longjmp(state, exception);	switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... }	assert(condition);
C++ (STL)	throw exception;	try { instructions } catch «(exception)» { instructions } ...
C#		try { instructions } catch «(exception)» { instructions } ... «finally { instructions }»	Debug.Assert(condition);
Java			assert condition;
JavaScript		try { instructions } catch (exception) { instructions } «finally { instructions }»	?
PHP		try { instructions } catch (exception) { instructions } ...	assert(condition);
S-Lang		try { instructions } catch «exception» { instructions } ... «finally { instructions }»	?
Windows PowerShell		trap «[exception]» { instructions } ... instructions	?
Perl	die exception;	eval { instructions }; if ($@) { instructions }	?
Ruby	raise exception	begin instructions rescue exception instructions ... «else instructions» «ensure instructions» end
Common Lisp	(error exception)	(handler-case (progn instructions) (exception instructions) ...)	?
Scheme (R6RS)	(raise exception)	(guard (con (condition instructions) ...) instructions)	?
Pascal	raise Exception.Create()	try Except on E: exception do begin instructions end; end;	?
Visual Basic			?
Visual Basic .NET	Throw exception	Try instructions Catch «exception» «When condition» instructions ... «Finally instructions» End Try	Debug.Assert(condition)
Python	raise exception	try: Tab ↹ instructions except «exception»: Tab ↹ instructions ... «else: Tab ↹ instructions» «finally: Tab ↹ instructions»	assert condition
FORTRAN 77			?
OCaml	raise exception	try expression with pattern -> expression ...	assert condition
Haskell (GHC)	throw exception or throwError expression	catch tryExpression catchExpression or catchError tryExpression catchExpression	assert condition expression

Other control flow statements

	exit block(break)	continue	label	branch (goto)	return value from generator
C (C99)	break;	continue;	label:	goto label;
C++ (STL)
C#					yield return value;
Java	break «label»;	continue «label»;
JavaScript
PHP	break «levels»;	continue «levels»;
Perl	last «label»;	next «label»;	label:	goto label;
Common Lisp
Scheme
Pascal	break;	continue;
Visual Basic	Exit block			GoTo label
Visual Basic .NET		Continue block
Python	break	continue			yield value
S-Lang	break;	continue;
FORTRAN 77			a number in columns 1 to 5	GOTO label
Ruby	break	next
Windows PowerShell	break« label»	continue
OCaml
Haskell (GHC)

Function declaration

Statements in guillemets (« … ») are optional. See reflection for calling and declaring functions by strings.

	basic/void function	value-returning function	required main function
C (C99)	void foo(«parameters») { instructions }	type foo(«parameters») { instructions ... return value; }	int main() { instructions } or int main(int argc, char *argv[]) { instructions }
C++ (STL)
C#			static void Main(«string[] args») { instructions } or static int Main(«string[] args») { instructions }
Java			public static void main(String[] args) { instructions } or public static void main(String... args) { instructions }
JavaScript	function foo(«parameters») { instructions } or var foo = function («parameters») {instructions } or var foo = new Function («"parameter", ... ,"last parameter"» "instructions");	function foo(«parameters») { instructions ... return value; }
Common Lisp		(defun foo (parameters) instructions)
Scheme		(define (foo parameters) instructions) or (define foo (lambda (parameters) instructions))
Pascal	procedure foo(«parameters»); «forward;» begin instructions end;	function foo(«parameters»): return's type; begin ... foo := value; ... end;	begin instructions end.
Visual Basic	Sub Foo(«parameters») instructions End Sub	Function Foo(«parameters») As type instructions ... Foo = value ... End Function	Sub Main() instructions End Sub
Visual Basic .NET		Function Foo(«parameters») As type instructions ... Return value End Function	Sub Main(«ByVal CmdArgs() As String») instructions End Sub or Function Main(«ByVal CmdArgs() As String») As Integer instructions End Function
Python	def foo(«parameters»): Tab ↹ instructions	def foo(«parameters»): Tab ↹ ... Tab ↹ return value
S-Lang	define foo («parameters« ;qualifiers»») { instructions }	define foo («parameters« ;qualifiers»») { instructions ... return value; }	public define slsh_main () { instructions }
FORTRAN 77	SUBROUTINE FOO«(parameters)» instructions END	type FUNCTION FOO«(parameters)» ... FOO = value ... END	PROGRAM main
PHP	function foo(«parameters») { instructions }	function foo(«parameters») { instructions ... return value; }
Perl	sub foo { «my (parameters) = @_;» instructions }	sub foo { «my (parameters) = @_;» instructions... «return» value; }
Ruby	def foo«(parameters)» instructions end	def foo«(parameters)» instructions expression resulting in return value end or def foo«(parameters)» instructions return value end
Windows PowerShell	function foo «(parameters)» { instructions }; or function foo { «param(parameters)» instructions }	function foo «(parameters)» { instructions … return value }; or function foo { «param(parameters)» instructions … return value }
OCaml		let «rec» foo parameters = expression or let foo = fun parameters -> expression
Haskell		foo parameters = expression or foo parameters = do ... return value	«main :: IO ()» main = do instructions

Type conversions

	string to integer	string to long integer	string to floating point	integer to string	floating point to string
C (C99)	integer = atoi(string);	long = atol(string);	float = atof(string);	sprintf(string, "%i", integer);	sprintf(string, "%f", float);
C++ (STL)	«std::»istringstream(string) >> number;			«std::»ostringstream o; o << number; string = o.str();
C#	integer = int.Parse(string);	long = long.Parse(string);	float = float.Parse(string); or double = double.Parse(string);	string = number.ToString();
Java	integer = Integer.parseInt(string);	long = Long.parseLong(string);	float = Float.parseFloat(string); or double = Double.parseDouble(string);	string = Integer.toString(integer);	string = Float.toString(float); or string = Double.toString(double);
JavaScript	integer = parseInt(string); or integer = new Number(string) or integer = string*1;		float = parseFloat(string); or float = new Number (string) or float = string*1;	string = number.toString (); or string = new String (number); or string = number+"";
Common Lisp	(setf integer (parse-integer string))		(setf float (read-from-string string))	(setf string (princ-to-string number))
Scheme	(define number (string->number string))			(define string (number->string number))
Pascal	integer := StrToInt(string);		float := StrToFloat(string);	string := IntToStr(integer);	string := FloatToStr(float);
Visual Basic	integer = CInt(string)	long = CLng(string)	float = CSng(string) or double = CDbl(string)	string = CStr(number)
Visual Basic .NET
Python	integer = int(string)	long = long(string)	float = float(string)	string = str(number)
S-Lang	integer = atoi(string);	long = atol(string);	float = atof(string);	string = string(number);
FORTRAN 77	READ(string,format) integer		READ(string,format) float	WRITE(string,format) number
PHP	integer = intval(string); or integer = (int)string;		float = floatval(string); or float = (float)string;	string = "number"; or string = strval(number); or string = (string)number;
Perl				string = "integer"; or string = sprintf("%d", integer);	string = "float"; or string = sprintf("%f", float);
Ruby	integer = string.to_i		float = string.to_f	string = number.to_s
Windows PowerShell	integer = [int]string	long = [long]string	float = [float]string	string = [string]number; or string = "number"; or string = (number).ToString()
OCaml	let integer = int_of_string string		let float = float_of_string string	let string = string_of_int integer	let string = string_of_float float
Haskell (GHC)	number = read string			string = show number

Standard Input and Standard Output

	read from	write to
	stdin	stdout	stderr
C (C99)	scanf(format, &x); or fscanf(stdin, format, &x);	printf( format, x); or fprintf(stdout, format, x);	fprintf(stderr, format, x );
C++	«std::»cin >> x;	«std::»cout << x;	«std::»cerr << x; or «std::»clog << x;
C#	x = Console.Read(); or x = Console.ReadLine();	Console.Write(«format, »x); or Console.WriteLine(«format, »x);	Console.Error.Write(«format, »x); or Console.Error.WriteLine(«format, »x);
Java	x = System.in.read();	System.out.print(x); or System.out.printf(format, x); or System.out.println(x);	System.err.print(x); or System.err.printf(format, x); or System.err.println(x);
JavaScript Web Browser implementation		document.write(x)
JavaScript Active Server Pages		Response.Write(x)
JavaScript Windows Script Host	x = WScript.StdIn.Read(chars) or x = WScript.StdIn.ReadLine()	WScript.Echo(x) or WScript.StdOut.Write(x) or WScript.StdOut.WriteLine(x)	WScript.StdErr.Write(x) or WScript.StdErr.WriteLine(x)
Common Lisp	(setf x (read-line))	(princ x) or (format t format x)	(princ x *error-output*) or (format *error-output* format x)
Scheme (R6RS)	(define x (read-line))	(display x) or (format #t format x)	(display x (current-error-port)) or (format (current-error-port) format x)
Pascal	read(x); or readln(x);	write(x); or writeln(x);
Visual Basic	Input« prompt,» x	Print x or ? x
Visual Basic .NET	x = Console.Read() or x = Console.ReadLine()	Console.Write(«format, »x) or Console.WriteLine(«format, »x)	Console.Error.Write(«format, »x) or Console.Error.WriteLine(«format, »x)
Python	x = raw_input(«prompt»)	print x or sys.stdout.write(x)	print >>sys.stderr, x or sys.stderr.write(x)
S-Lang	fgets (&x, stdin)	fputs (x, stdout)	fputs (x, stderr)
FORTRAN 77	READ(5,format) variable names	WRITE(6,format) expressions
PHP	$x = fgets(STDIN); or $x = fscanf(STDIN, format);	print x; or echo x; or printf(format, x);	fprintf(STDERR, format, x);
Perl	$x = <>; or $x = <STDIN>;	print x; or printf format, x;	print STDERR x; or printf STDERR format, x;
Ruby	x = gets	puts x or printf(format, x)
Windows PowerShell	$x = Read-Host«« -Prompt» text»; or $x = [Console]::Read(); or $x = [Console]::ReadLine()	x; or Write-Output x; or echo x	Write-Error x
OCaml	let x = read_int () or let s = read_line () or Scanf.scanf format (fun x ... -> ...)	print_int x or print_endline s or Printf.printf format x ...	prerr_int x or prerr_endline s or Printf.eprintf format x ...
Haskell (GHC)	x = readLn or x <- getLine	print x or putStrLn x	hPrint stderr x

Reading command-line arguments

	Argument values	Argument counts	Program name / Script name
C (C99)	argv[n]	argc	first argument
C++
C#	args[n]	args.Length	Assembly.GetEntryAssembly().Location;
Java		args.length	same as name of class
JavaScript Windows Script Host implementation	WScript.Arguments(n)	WScript.Arguments.length	?
Common Lisp	?	?	?
Scheme (R6RS)	(list-ref (command-line) n)	(length (command-line))	first argument
Pascal	ParamStr(n)	ParamCount	first argument
Visual Basic	Command		?
Visual Basic .NET	CmdArgs(n)	CmdArgs.Length	[Assembly].GetEntryAssembly().Location
Python	sys.argv[n]	len(sys.argv)	first argument
S-Lang	__argv[n]	__argc	first argument
FORTRAN 77			?
PHP	$argv[n]	$argc	first argument
Perl	$ARGV[n]	scalar(@ARGV)	$0
Ruby	ARGV[n]	ARGV.size	$0
Windows PowerShell	$args[n]	$args.Length	$MyInvocation.MyCommand.Name
OCaml	Sys.argv.(n)	Array.length Sys.argv	first argument
Haskell (GHC)	System.getArgs !! n	length System.getArgs	System.getProgName

Execution of commands

	Shell command	Execute program
C	system(command);	execl(path, args); or execv(path, arglist);
C++
C#	System.Diagnostics.Process.Start(path, argstring);
Visual Basic	Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)
Visual Basic .NET	Microsoft.VisualBasic.Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn») or System.Diagnostics.Process.Start(path, argstring)
Java	Runtime.exec(command); or new ProcessBuilder(command).start();
JavaScript Windows Script Host implementation	WScript.CreateObject ("WScript.Shell").Run(command «, WindowStyle» «, isWaitOnReturn»);
Common Lisp	(shell command)
Scheme	(system command)
OCaml	Sys.command command
Haskell (GHC)	System.system command
Perl	system(command) or $output = `command`	exec(path, args)
Python	os.system(command)	subprocess.Popen(command) or os.execv(path, args)
S-Lang	system(command)
Windows PowerShell	[Diagnostics.Process]::Start(command)	«Invoke-Item »program arg1 arg2 …