Anything Forums

Code: Select all

/* C */

#include <stdio.h>

int main()
{
   puts("Hello world!");

   return 0;
}[code]

[code]// C++

#include <iostream>

int main()
{
   std::cout << "Hello world!" << std::endl;

   return 0;
}[code]

[code](* O'Caml *)

print_endline "Hello world!";;[code]

[code]-- Haskell

main = putStrLn "Hello world!"[code]

[code]# Perl

print "Hello world!
";[code]

[code]# Python

print "Hello world!"[code]

[code]# Ruby

puts "Hello world!"[code]

[code]; Scheme

(display "Hello world!")
(newline)[code]

[code]// D

int main()
{
   printf("Hello world!
");

   return 0;
}[code]

[code]// Java

public class HelloWorld
{
   public static void main(String[] args)
   {
      System.out.println("Hello world!");
   }
}[code]

[code]// C#

using System;

public class HelloWorld
{
   public static void Main(string[] args)
   {
      Console.WriteLine("Hello world!");
   }
}[code]

[code]-- Eiffel

class HELLO_WORLD
creation make
feature
   make is
      do
         std_output.put_string("Hello world!")
         std_output.put_new_line
      end
end[code]

[code]-- Ada95

with Ada.Text_IO; use Ada,Text_IO;
procedure Hello_World is
begin
   Put_Line("Hello world!);
end Hello_World;[code] 

[color=#888888][size=85]Archived topic from Iceteks,  old topic ID:3314, old post ID:26951[/size][/color]

Code: Select all

int a;
double b;[code]

"a" is an integer and "b" is a double precision floating point number.

However, the value stored in the variable has no type.

Now, in Python and Ruby it's exactly the opposite.  The value has a type, and the variable doesn't.  The variable is just a name.  I can reuse the name for an entirely different kind of value.

I could assign a value of 5 to "a", then immediately afterwards assign a string to the same variable.

[code]a = 5
a = "hello"[code]

This is perfectly legal in both Python and Ruby (and at least here they have the same syntax).

The way things are enforced in this kind of situation is what's often called "duck typing".  That is, if my code wants a duck, and I give it something that quacks like a duck and walks like a duck, then what I've given it might as well be a duck.  :)

Ruby and Python also feature more friendly syntax than C++.  It's more straightforward.  In C+ the keyword "const" can have about half a dozen different meanings depending on where it is.  This certainly gives the language flexibility, but it comes with a steep learning curve attached, and that steep learning curve can be frustrating.

Both languages make it easier to deal with object-oriented programming, and they feature conveniences for even simpler bits of code.  Want to loop over an array in Python or Ruby, as compared to C++?

C++
[code]int a[] = {3, 4, 5, 1, 2, 9, 8};

for (int i(0); i < 7; ++i)
{
   std::cout << a[i] << std::endl;
}[code]

Python:
[code]a = [3, 4, 5, 1, 2, 9, 8]

for x in a: 
   print a[code]

Ruby:
[code]a = [3, 4, 5, 1, 2, 9, 8]

for x in a 
   puts x
end[code]

Ruby (other option):
[code]a = [3, 4, 5, 1, 2, 9, 8]

a.each { |x| puts x }[code]

Now, O'Caml and Haskell are a bit different.  They are statically-typed like C++, but they infer types based on how you use values.  They also support generics much better than C++, and generally provide lots of syntctic convenience.

They make implementing data structures beautiful.  Let's consider creating a binary tree.

C++
[code]#include <iostream>

template <typename T>
class binary_tree_node
{
   private:
      const T value;
      binary_tree_node<T> * left, * right;
   public:
      binary_tree_node(T init_value)
      : value(init_value)
      , left(NULL), right(NULL)
      { }

      binary_tree_node(T init_value, binary_tree_node<T> * l, binary_tree_node<T> * r)
      : value(init_value)
      , left(l), right(r)
      { }

      ~binary_tree_node()
      {
         if (left) delete left;
         if (right) delete right;
      }

      int length() const
      {
         int len(1);
         if (left) len += left->length();
         if (right) len += right->length();
         return len;
      }
};[code]

O'Caml:
[code]type 'a binary_tree = Empty | Leaf of 'a | Branch of 'a binary_tree * 'a * 'a binary_tree;;

btree_length tree = 
   match tree with
      Empty -> 0
    | Leaf _ -> 1
    | Branch (l, _, r) -> 1 + btree_length l + btree_length r;;[code]

Haskell:
[code]data BinaryTree a = Empty | Leaf a | Branch (BinaryTree a) a (BinaryTree a)

btreeLength Empty = 0
btreeLength (Leaf _) = 1
btreeLength (Branch l _ r) = 1 + btreeLength l + btreeLength r[code]

And for all four, with some exceptions in Haskell's case, you needn't create any source files or do any compilation.  Just type your code at the prompt and hit return. 

[color=#888888][size=85]Archived topic from Iceteks,  old topic ID:3314, old post ID:27078[/size][/color]