Translations from Turing - Revision history

Wtd at 06:57, 12 October 2008

2008-10-12T06:57:51Z

← Older revision		Revision as of 06:57, 12 October 2008
Line 283:		Line 283:

	sayHelloWorld();</pre>		sayHelloWorld();</pre>
		+
		+	== Functions and an argument ==
		+
		+	Of course, we're still just saying "Hello, world!". There's no flexibility. Instead, let's create a procedure "say_hello" which takes one string argument "name" indicating who the procedure should greet. For this example, we'll greet "Bob".
		+
		+	This one will demonstrate specifying a procedure with an argument and then calling it that way.
		+
		+	=== Turing ===
		+
		+	<pre>procedure sayHello(name : string)
		+	put "Hello, " + name + "!"
		+	end sayHello
		+
		+	sayHello("Bob")</pre>
		+
		+	=== C ===
		+
		+	<pre>#include <stdio.h>
		+
		+	void say_hello(const char * name);
		+
		+	int main()
		+	{
		+	say_hello("Bob");
		+	return 0;
		+	}
		+
		+	void say_hello(const char * name)
		+	{
		+	printf("Hello, %s!\n", name);
		+	}</pre>
		+
		+	=== C++ ===
		+
		+	<pre>#include <iostream>
		+	#include <string>
		+
		+	void say_hello(std::string name);
		+
		+	int main()
		+	{
		+	say_hello("Bob");
		+	return 0;
		+	}
		+
		+	void say_hello(std::string name)
		+	{
		+	std::cout << "Hello, " << name, "!" << std::endl;
		+	}</pre>
		+
		+	=== Java ===
		+
		+	<pre>import java.lang.*;
		+	import java.io.*;
		+
		+	public class HelloWorld {
		+	public static void main(String[] args) {
		+	sayHello("Bob");
		+	}
		+
		+	private static void sayHello(String name) {
		+	System.out.println("Hello, " + name + "!");
		+	}
		+	}</pre>
		+
		+	=== C# ===
		+
		+	<pre>using System;
		+
		+	public class HelloWorld
		+	{
		+	public static void Main(string[] args)
		+	{
		+	SayHello("Bob");
		+	}
		+
		+	private static void SayHello(string name)
		+	{
		+	Console.WriteLine("Hello, " + name + "!");
		+	}
		+	}</pre>
		+
		+	=== D ===
		+
		+	<pre>import std.stream;
		+
		+	void main()
		+	{
		+	sayHello("Bob");
		+	}
		+
		+	void sayHello(char[] name)
		+	{
		+	stdout.writefln("Hello, %s!", name);
		+	}</pre>
		+
		+	=== Perl ===
		+
		+	<pre>say_hello("Bob");
		+
		+	sub say_hello {
		+	my $name = shift;
		+	print "Hello, $name!\n";
		+	}</pre>
		+
		+	=== Python ===
		+
		+	<pre>def say_hello(name):
		+	print "Hello, %(name)s!" % {"name": name}
		+
		+	say_hello("Bob")</pre>
		+
		+	=== Ruby ===
		+
		+	<pre>def say_hello(name)
		+	puts "Hello, #{name}!"
		+	end
		+
		+	say_hello("Bob")</pre>
		+
		+	=== O'Caml ===
		+
		+	<pre>let say_hello name =
		+	print_endline ("Hello, " ^ name ^ "!")
		+
		+	say_hello "Bob"</pre>
		+
		+	=== Eiffel ===
		+
		+	<pre>class HELLO_WORLD
		+	creation {ANY} make
		+	feature {ANY}
		+	make is
		+	do
		+	say_hello("Bob")
		+	end
		+	feature {NONE}
		+	say_hello(name : STRING) is
		+	do
		+	std_output.put_string("Hello, " + name + "!")
		+	std_output.put_new_line
		+	end
		+	end</pre>
		+
		+	=== Pascal ===
		+
		+	This one should work, but FreePascal is giving me a syntax error
		+
		+	<pre>program Strings;
		+	var
		+	procedure SayHello(Name : String);
		+	begin
		+	WriteLn(Name)
		+	end;
		+	begin
		+	SayHello('Bob')
		+	end.</pre>
		+
		+	=== Ada ===
		+
		+	Strings in Ada are tricky enough that I've left this one out
		+
		+	=== Javascript ===
		+
		+	<pre>function sayHello(name) {
		+	document.write("Hello, " + name + "!");
		+	}
		+
		+	sayHello("Bob");</pre>

	== Credits ==		== Credits ==

	Author: [[Wtd]]		Author: [[Wtd]]

Wtd at 06:51, 12 October 2008

2008-10-12T06:51:12Z

← Older revision		Revision as of 06:51, 12 October 2008
Line 109:		Line 109:
	<pre>// This is a comment		<pre>// This is a comment
	document.write("Hello, world!<br/>");</pre>		document.write("Hello, world!<br/>");</pre>
		+
		+	== A procedure ==
		+
		+	Now, abstracting the "Hello, world!" into a procedure called "say_hello_world".
		+
		+	''Note:'' That name may appear slightly different depending on the naming conventions of a language. Where possible, forward declarations are used.
		+
		+	=== Turing ===
		+
		+	<pre>procedure sayHelloWorld
		+	put "Hello, world!"
		+	end sayHelloWorld
		+
		+	sayHelloWorld</pre>
		+
		+	=== C ===
		+
		+	<pre>#include <stdio.h>
		+
		+	void say_hello_world();
		+
		+	int main()
		+	{
		+	say_hello_world();
		+	return 0;
		+	}
		+
		+	void say_hello_world()
		+	{
		+	puts("Hello, world!");
		+	}</pre>
		+
		+	=== C++ ===
		+
		+	<pre>#include <iostream>
		+
		+	void say_hello_world();
		+
		+	int main()
		+	{
		+	say_hello_world();
		+	return 0;
		+	}
		+
		+	void say_hello_world()
		+	{
		+	std::cout << "Hello, world!" << std::endl;
		+	}</pre>
		+
		+	=== Java ===
		+
		+	<pre>import java.lang.*;
		+	import java.io.*;
		+
		+	public class HelloWorld {
		+	public static void main(String[] args) {
		+	sayHelloWorld();
		+	}
		+
		+	private static void sayHelloWorld() {
		+	System.out.println("Hello, world!");
		+	}
		+	}</pre>
		+
		+	=== C# ===
		+
		+	<pre>using System;
		+
		+	public class HelloWorld
		+	{
		+	public static void Main(string[] args)
		+	{
		+	SayHelloWorld();
		+	}
		+
		+	private static void SayHelloWorld()
		+	{
		+	Console.WriteLine("Hello, world!");
		+	}
		+	}</pre>
		+
		+	=== D ===
		+
		+	<pre>import std.stream;
		+
		+	void main()
		+	{
		+	sayHelloWorld();
		+	}
		+
		+	void sayHelloWorld()
		+	{
		+	stdout.writeLine("Hello, world!");
		+	}</pre>
		+
		+	=== Perl ===
		+
		+	<pre>say_hello_world;
		+
		+	sub say_hello_world {
		+	print "Hello, world!";
		+	}</pre>
		+
		+	=== Python ===
		+
		+	<pre>def say_hello_world():
		+	print "Hello, world!"
		+
		+	say_hello_world()</pre>
		+
		+	=== Ruby ===
		+
		+	<pre>def say_hello_world
		+	puts "Hello, world!"
		+	end
		+
		+	say_hello_world</pre>
		+
		+	=== O'Caml ===
		+
		+	<pre>let say_hello_world () =
		+	print_endline "Hello, world!"
		+
		+	say_hello_world ()</pre>
		+
		+	=== Eiffel ===
		+
		+	<pre>class HELLO_WORLD
		+	creation {ANY} make
		+	feature {ANY}
		+	make is
		+	do
		+	say_hello_world
		+	end
		+	feature {NONE}
		+	say_hello_world is
		+
		+	do
		+	std_output.put_string("Hello, world!")
		+	std_output.put_new_line
		+	end
		+	end</pre>
		+
		+	=== Pascal ===
		+
		+	<pre>program HelloWorld;
		+	var
		+	procedure SayHelloWorld;
		+	begin
		+	WriteLn('Hello, world!')
		+	end;
		+	begin
		+	SayHelloWorld
		+	end.</pre>
		+
		+	=== Ada ===
		+
		+	<pre>with Ada.Text_IO; use Ada.Text_IO;
		+	procedure Hello_World is
		+	procedure Say_Hello_World is
		+	begin
		+	Put_Line("Hello, world!");
		+	end Say_Hello_World;
		+	begin
		+	Say_Hello_World;
		+	end Hello_World;</pre>
		+
		+	=== Javascript ===
		+
		+	<pre>function sayHelloWorld() {
		+	document.write("Hello, world!");
		+	}
		+
		+	sayHelloWorld();</pre>

	== Credits ==		== Credits ==

	Author: [[Wtd]]		Author: [[Wtd]]

Wtd at 06:41, 12 October 2008

2008-10-12T06:41:03Z

← Older revision		Revision as of 06:41, 12 October 2008
Line 109:		Line 109:
	<pre>// This is a comment		<pre>// This is a comment
	document.write("Hello, world!<br/>");</pre>		document.write("Hello, world!<br/>");</pre>
		+
		+	== Credits ==
		+
		+	Author: [[Wtd]]

Wtd at 06:38, 12 October 2008

2008-10-12T06:38:06Z

New page

== Hello, world! ==

=== Turing ===

<pre>% This is a comment
put "Hello, world!"</pre>

=== C ===
<pre>/* This a comment */

#include <stdio.h>

int main()
{
puts("Hello, world!");
return 0;
}</pre>

=== C++ ===
<pre>// This is a comment

#include <iostream>

int main()
{
std::cout << "Hello, world!" << std::endl;
return 0;
}</pre>

=== Java ===
<pre>// This is a comment

import java.lang.*;
import java.io.*;

public static void HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}</pre>

=== C# ===
<pre>// This is a comment

using System;

public class HelloWorld
{
public static void Main(string[] args)
{
Console.WriteLine("Hello, world!");
}
}</pre>

=== D ===
<pre>// This is a comment

import std.stream;

void main()
{
stdout.writeLine("Hello, world!");
}</pre>

=== Perl ===
<pre># This a comment
print "Hello, world!\n";</pre>

=== Python ===
<pre># This a comment
print "Hello, world!"</pre>

=== Ruby ===
<pre># This a comment
puts "Hello, world!"</pre>

=== O'Caml ===
<pre>(* This a comment *)
print_endline "Hello, world!"</pre>

=== Eiffel ===
<pre>-- This is a comment
class HELLO_WORLD
creation {ANY} make
feature {ANY}
make is
do
std_output.put_string("Hello, world!")
std_output.put_new_line
end
end</pre>

=== Pascal ===
<pre>(* This a comment *)
program HelloWorld;
begin
WriteLn('Hello, world!')
end.</pre>

=== Ada95 ===
<pre>-- This is a comment
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello_World is
begin
Put_Line("Hello, world!");
end Hello_World;</pre>

=== Javascript ===
<pre>// This is a comment
document.write("Hello, world!<br/>");</pre>