Está en la página 1de 9

Scala, Haskell and Fantom Programming


Raymark D. Dulce (200712952)

January 01, 2011

Scala Programming Language

What is Scala?
Scala is a multi-paradigm programming language designed to integrate
features of object-oriented programming and functional programming. The
name Scala stands for ”scalable language”, signifying that it is designed to
grow with the demands of its users.
Scala is a general purpose programming language designed to express
common programming patterns in a concise, elegant, and type-safe way. It
smoothly integrates features of object-oriented and functional languages, en-
abling Java and other programmers to be more productive.

History of Scala

The design of Scala started in 2001 at the cole Polytechnique F d rale

de Lausanne (EPFL) by Martin Odersky, following on from work on Funnel,
a programming language combining ideas from functional programming and
Petri nets. Odersky had previously worked on Generic Java and javac, Sun’s
Java compiler.
Scala was released late 2003 / early 2004 on the Java platform, and on
the .NET platform in June 2004. A second version of the language, v2.0, was
released in March 2006. As of November 2010, the latest release is version

Platforms and License

Scala runs on the Java platform(Java Virtual Machine) and is compatible

with existing Java programs. It also runs on Java Platform, Micro Edition
Connected Limited Device Configuration. Scala has the same compilation
model as Java and C-sharp, so Scala code can call Java libraries (or .NET
libraries in the .NET implementation).
Scala’s operational characteristics are the same as Java’s. The Scala
compiler generates byte code that is nearly identical to that generated by
the Java compiler. In fact, Scala code can be decompiled to readable Java
code, with the exception of certain constructor operations.
To the JVM, Scala code and Java code are indistinguishable. The only
difference is a single extra runtime library, scala-library.jar. The Scala soft-
ware distribution, including compiler and libraries, is released under a BSD

Seamless integration with JAVA

Existing Java code and programmer skills are fully re-usable. Scala pro-
grams run on the Java VM, are byte code compatible with Java so you can
make full use of existing Java libraries or existing application code. You can
call Scala from Java and you can call Java from Scala, the integration is
Moreover, you will be at home with familiar development tools, Eclipse,
NetBeans or Intellij for example, all of which support Scala.

Scala is object-oriented

Scala is a pure object-oriented language in the sense that every value is

an object. Types and behavior of objects are described by classes and traits.
Classes are extended by subclassing and a flexible mixin-based composition
mechanism as a clean replacement for multiple inheritance.

Scala is functional

Scala is also a functional language in the sense that every function is

a value. Scala provides a lightweight syntax for defining anonymous func-
tions, it supports higher-order functions, it allows functions to be nested, and
supports currying. Scala’s case classes and its built-in support for pattern
matching model algebraic types.

Scala is statically typed

Scala is equipped with an expressive type system that enforces statically

that abstractions are used in a safe and coherent manner. In particular, the
type system supports:

• generic classes

• variance annotations

• upper and lower type bounds

• inner classes and abstract types as object members

• compound types

• explicitly typed self references

• views, and

• polymorphic methods.

Scala is extensible

In practice, the development of domain-specific applications often requires

domain-specific language extensions. Scala provides a unique combination
of language mechanisms that make it easy to smoothly add new language
constructs in form of libraries:

• any method may be used as an infix or postfix operator, and closures

are constructed automatically depending on the expected type (target

• A joint use of both features facilitates the definition of new statements

without extending the syntax and without using macro-like meta pro-
gramming facilities.

The Hello World Program

object HelloWorld
def main(args: Array[String])
println("Hello, world!")

Haskell Programming Language

What is Haskell?
Haskell is an advanced purely-functional programming language. An
open-source product of more than twenty years of cutting-edge research, it
allows rapid development of robust, concise, correct software.
Haskell is a computer programming language. In particular, it is a poly-
morphically statically typed, lazy, purely functional language, quite different
from most other programming languages. The language is named for Haskell
Brooks Curry, whose work in mathematical logic serves as a foundation for
functional languages.
Haskell is based on the lambda calculus, hence the lambda we use as a
logo. It is a standardized, general-purpose purely functional programming
language, with non-strict semantics and strong static typing.

History of Haskell

Haskell 1.0

The first version of Haskell (Haskell 1.0) was defined in 1990.

Haskell 98

In late 1997, the series culminated in Haskell 98, intended to specify a sta-
ble, minimal, portable version of the language and an accompanying standard
library for teaching, and as a base for future extensions. In February 1999,
the Haskell 98 language standard was originally published as The Haskell
98 Report. In January 2003, a revised version was published as Haskell 98
Language and Libraries: The Revised Report.
Haskell Prime

In early 2006, the process of defining a successor to the Haskell 98 stan-

dard, informally named Haskell’, was begun. This is an ongoing incremental
process to revise the language definition, producing a new revision once per
year. The first revision, named Haskell 2010, was announced in Nov. 2009.

Haskell 2010

Haskell 2010 adds the Foreign Function Interface (FFI) to Haskell, allow-
ing for bindings to other programming languages, fixes some syntax issues
(changes in the formal grammar) and bans so-called n-plus-k-patterns, that
is, definitions of the form fak (n+1) = (n+1) * fak n are no longer allowed.
It introduces the Language-Pragma-Syntax-Extension which allows for des-
ignating a haskell source as Haskell 2010 or requiring certain Extensions to
the Haskell Language. The names of the extensions introduced in Haskell
2010 are DoAndIfThenElse, HierarchicalModules, EmptyDataDeclarations,
FixityResolution, ForeignFunctionInterface, LineCommentSyntax, Pattern-
Guards, RelaxedDependencyAnalysis, LanguagePragma, NoNPlusKPatterns.

Why use Haskell?

Haskell offers you:

• Substantially increased programmer productivity

• Shorter, clearer, and more maintainable code.

• Fewer errors, higher reliability.

• A smaller semantic gap between the programmer and the language.

• Shorter lead times.

The Hello World Program

"Hello, World!"
putStrLn "Hello World"
main = putStrLn "Hello, World!"

Fantom Programming Language

What is Fantom?

Fantom is a general purpose object-oriented programming language that

runs on the JRE, .NET CLR, and Javascript. The language supports func-
tional programming through closures and concurrency through the Actor
Fantom takes a middle of the road approach to its type system, blend-
ing together aspects of both static and dynamic typing. Like C-sharp and
Java, Fantom uses a curly brace syntax. Fantom is designed as a practical
programming language to make it easy and fun to get real work done.
Fantom is an exciting new language that targets the Java VM and the
CLR. It borrows it’s Syntax from Java but also adds many features and
syntactic sugar created or borrowed from .NET,Groovy,Python,Erlang etc.
It is familiar to a Java / .Net programmer but is much less painful to use (no

History of Fantom

The original name of the Fantom programming language was Fan, named
after the neighborhood where the creators live in Richmond, Virginia. After
gaining some popularity, members of the community raised concerns about
the searchability of the name. In November 2009, the name of the project
was officially changed from Fan to Fantom.


Fantom’s type system is simple by design. All variables are statically

typed, as they are in C-sharp and Java. Fantom rejects generic types due to
their complexity, but it does have a set of built-in generic types: List, Map,
and Func. Fantom can also take on the feel of a dynamically typed language
through dynamic calls and automatic downcasting. Fantom has an easy to
use reflection API and metaprogramming capabilities.


In Fantom, the unit of deployment is called a pod. Pods take on the role of
namespaces, packages, and modules. They are stored as .pod files, which are
zip files containing the FCode (the Fantom bytecode), the documentation,
and resource files necessary to run the pod. A pod can define any number of
types for use in other libraries and applications. A pod name fully qualifies
a type name. For example, fwt::Widget is distinct from webapp::Widget. If
a pod contains a type named Main, then it can be executed on the command
line with:fan ¡podName¿ The Fantom build system can package a set of Pods
into a Jar archive through build::JarDist.


Fantom is created to write software that can seamlessly run on both the
Java VM and the .NET CLR. The reality is that many software organiza-
tions are committed to one or the other of these platforms. Even dynamic
languages like Python and Ruby are getting hosted on one of these VMs.

Familiar Syntax

Java and C-sharp programmers will feel at home with Fantom’s evolu-
tionary syntax.

Elegant APIs

Quite obsessive about providing all the key features required for a stan-
dard library, but with much less surface area than the APIs found in Java or

Object Oriented

Fantom follows the .NET model of value types. The three special types
Bool, Int, and Float are value types which are implemented as primitives in
Java and value types in .NET. These types have all the same performance
characteristics of using boolean, long, and double in Java or C-sharp. Unlike
Java these types cleanly subclass from Obj to create a unified class hier-
archy. The compiler automatically implements boxing and unboxing when

Funtional Programming

Fantom was designed from the ground up to support functions as first

class objects. Closures are a key feature of the language, and all the APIs
are written to use functions and closures where appropriate. Functions and
closures are baked in.

Declarative Programming

Fantom incorporates declarative programming right into the language.

Fantom supports a literal syntax for lists, maps, ranges, uris, and durations.
Fantom also includes a text serialization syntax which is human readable
and writable. The serialization syntax is a clean subset of the programming
language - so you can paste a serialization file right into your source code as
an expression.


Fantom tackles concurrency using a couple techniques:

• Immutability is built into the language (thread safe classes)

• Static fields must be immutable (no shared mutable state)

• Actors model for message passing (Erlang style concurrency)

The Hello World Program

class HelloWorld
static Void main()
echo("Hello, World!")

También podría gustarte