CSC/ECE 517 Fall 2009/wiki1b 2 sk

Contents

1.Introduction

 1.1 Dynamically Typed Languages
 1.2 Statically Typed Languages
     1.2.1 Types of Statically Typed Languages
            1.2.1.1 Manifestly Typed 
            1.2.1.2 Type-inferred      

Introduction

Dynamically Typed Languages
Dynamically typed languages are those in which type checking is done at run-time. In other words, the same entity does not always have the same form during the execution of the program and the type of the object assigned to a variable can be changed at runtime. Variable need not be defined before they are used. Some examples of dynamically typed languages are Ruby, Python, PHP, Smalltalk, Lisp, Prolog, JavaScript, Objective-C. Lisp and Smalltalk were not quite success, but both had a huge influence on later langauages- including many statically typed languages and both are used till today. They form important history of dynamically typed languages.
/* Ruby code sample */
a = [1, 2, 3, 4, "Hi"]

The above code declares array that holds mix of integer and string types. Note that there was no need to specify array type and this would be evaluated automatically during runtime. However such a declaration is not possible in statically typed language like C, C++, Java, etc. doing so would give compile time errors.

Statically Typed Languages
Statically typed languages are those in which type checking is performed during compile-time as opposed to run-time. In static typing, all expressions have their types determined prior to the program being run (typically at compile-time). For example, 1 and (2+2) are integer expressions; they cannot be passed to a function that expects a string, or stored in a variable that is defined to hold dates. In other words, types are associated with variables and not values. This Static typing is a limited form of program verification. Accordingly, it allows many type errors to be caught early in the development cycle.
Some examples of Statically typed languages are Ada, C, C++, C#, JADE, Java, Pascal, Scala.

Types of Statically Typed Languages
Statically typed languages can be either manifestly typed or type-inferred.
     In manifestly typed, the programmer must explicitly write types at certain textual positions (for example, at variable declarations).
Most mainstream statically typed languages fall under the category of manifestly typed. Some of the examples are C++, C# , Java
     In type-inferred, the compiler infers the types of expressions and declarations based on the context.
Many manifestly typed languages support partial type inference. For example, Java and C# both infer types in certain limited cases

Combinations of Dynamic typing and Static typing

There are some statically typed languages that defer certain checks to runtime. On other hand, some dynamically typed languages often perform some checks statically to warn users. The presence of static typing in a programming language does not necessarily imply the absence of all dynamic typing mechanisms. For example, Java, and various other object-oriented languages, while using static typing, require for certain operations (such as downcasting) the support of runtime type tests, which is a form of dynamic typing.

Advantages of Statically Typed v/s Dynamically typed

1.In static type languages, type checking is done at compile time so that helps catching type errors early in developlement life cycle.
2. Once the type of all variables have been checked, the process of type checking is not repeateadly perform over different runs of the same program. In contrast, dynamically typed langauge needs to perform type checking every time program is run.
3. Statically typed program runs faster as overhead of type checking during runtime is already performed during compile time.
4. Dynamic typed program may encounter runtime errors which are difficult to debug and tracking exact location of bug in the program may be difficult.
5. Prgograms developed in statically typed languages are more safe and reliable.
6. Major advantages of dynamically typed languages is reduced development time and their flexibility.
7. Dynamically typed language makes it easier to develop and deploy web applications.

When Statically Typed is preferred over Dynamically typed

Statically Typed
Both statically typed and dynamically typed languages have important role to play. For example, when customer needs extra software reliability and is willing to pay extra cost for the same, such as software for nuclear power plant or an airplane's autopilot function. Static type systems play key role in providing extra software reliability. However statically typed language is an option.

Dynamically Typed
Usually it is fast to develop applications using dynamically typed languages. If rapid application development & deployment, with importance on producing incremental results, is what customer needs then probably using dynamically typed language is a good option.

Developing web applications in statically typed languages is not easy but it is easier to develop web applications in dynamically typed languages.

Dynamically typed language like Perl is suitable for both small and large systems. Python is used in variety of applications. Python is used to implement the software frameworks for major operations research methodologies. Major operations research methodologies could have been implemented in statically typed language and it may perform better than python , but doing so in dynamically typed language like Python makes it easy to develop a DSL-like environment, such as APLEpy (Algebraic Programming Language Extension for Python) and SimPy(Simulation in Python), and build applications on it. Development time in dynamically type language is lesser compared to statically type language. Integrating two applications domains would require explicit consideration and programming effort. In python it can be accomplished with no effort.

A hybrid of two
Another example of dynamically typed language is Lua. Lua helps creating hybrid solutions that combine strengths of statically typed languages with the flexibility of a dynamically typed languages. Lua helps binding existing C/C++ libraries to Lua scripts without the need of compiling and linking C programs. Lua has in-build tools to create bindings or one can write them by hand. For example window device drivers interface functions to recognize the external devices like USB can be added as one function to the Lua environment. Lua can also be integrated into an existing product by embedding Lua. Once Lua is embedded in the existing system, host program contains powerful scripting facility and can create and control as many Lua virtual machines as required. Example using Lua to maintain system configuration data. Handling data through Lua is convenient as its tables are a clean but powerful data description mechanism. Once data is structured, loading and accessing using Lua is very simple and fast.

Comparision using Examples

Comparision of Python Vs Java

Let us consider and compare one of the features such as programmer productivity in both dynamically typed and statically typed languages. Consider an example of dynamically typed programming language 'Python' and a statically typed programming language 'Java'.

The following comparision shows certain features in Python that make it more productive than Java

Java	Python
Statically typed In Java, all variable names along with their types must be explicitly declared. An exception is triggered when one attempts to assign an object of the wrong type to a variable name. This infact means that Java is a statically typed language.	Dynamically typed In Python, there is no need to declare anything. An assignment statement binds a name to an object, and the object can be of any type. If a name is assigned to an object of one type, it may later be assigned to an object of a different type. This infact means that Python is a dynamically typed language.
container objects Java container objects (e.g. Vector and ArrayList) hold objects of the generic type Object, but cannot hold primitives such as int. To store an int in a Vector, one must first convert the int to an Integer. When one retrieves an object from a container, it doesn't remember its type, and must be explicitly cast to the desired type.	container objects Python container objects (e.g. lists and dictionaries) can hold objects of any type, including numbers and lists. When one retrieves an object from a container, it remembers its type, so no casting is required.
Verbose In general, Java is considered as verbose. It uses or contains more words than are necessary	Concise In Python, expressing is done much in a few words which imply clean-cut brevity.

Example code Comparisions

The classic "Hello, world!" program illustrates the relative verbosity of Java as compared to Python.

Hello World example in Java:

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

Hello World example in Python:

print "Hello, world!"

----------------------------------------

print("Hello, world!") # Python version 3

Example with Multiple classes

Consider an application has 20 classes. (More precisely 20 top-level public classes)

In Java:

Each top-level public class must be defined in its own file. If the application has 20 such classes, it has 20 files.

In Python:

Multiple classes can be defined in a single file. If the application has 20 classes, the entire application can be stored in a single file. Although, it would be better to partition it into perhaps 4, 5, or 6 files.

Example using Constructors

Consider an application having Employee class. When an instance of Employee is created, we may pass one, two, or three arguments to the constructor.

In Java: While programming in Java, it means that we write three constructors with three different signatures.

public class Employee
{
    private String myEmployeeName;
    private int    myTaxDeductions = 1;
    private String myMaritalStatus = "single";

    //---constructor #1---
    public Employee(String EmployeName)
    {
        this(employeeName, 1);
    }

    //---constructor #2---
    public Employee(String EmployeName, int taxDeductions)
    {
       this(employeeName, taxDeductions, "single");
    }

    //---constructor #3---
    public Employee(String EmployeName,
           int taxDeductions,
           String maritalStatus)
    {
       this.employeeName    = employeeName;
       this.taxDeductions   = taxDeductions;
       this.maritalStatus   = maritalStatus;
    }
...

In Python: While programming in Python, we need to write only a single constructor, with default values for the optional arguments.

class Employee():

    def __init__(self, 
        employeeName, taxDeductions=1, maritalStatus="single"):
      
        self.employeeName    = employeeName
        self.taxDeductions   = taxDeductions
        self.maritalStatus   = maritalStatus
...

As seen from the above example, in Python, a class has only one constructor. The constructor method is simply another method of the class, but one that has a special name: __init__

Conclusion

Both statically and dynamically typed languages have advantages and disadvantages. Depending on the situation and requirement, one of the language should be used for product development. Sometimes it is best to use mixture of both (as is the case with Lua) to take advantages of both the languages for product development.

Glossary

• Downcasting -   In object-oriented programming, downcasting or type refinement is the act of casting a reference of a base class to one of its derived classes.
• DSL-   Domain Specific Languages.

References

1. http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=04302684
2. http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=04302685
3. http://www.ferg.org/projects/python_java_side-by-side.html
4. http://en.wikipedia.org/wiki/Type_system
5. http://en.wikipedia.org/wiki/Programming_language
6. http://www2.computer.org/plugins/dl/pdf/mags/so/2007/05/s5028.pdf?template=1&loginState=1&userData=anonymousIP%253A%253A65.190.191.228