CSC/ECE 517 Fall 2009/wiki1b 2 sk

From Expertiza_Wiki
Revision as of 17:48, 20 September 2009 by Ssamind (talk | contribs) (→‎Examples)
Jump to navigation Jump to search

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

2. Combinations of Dynamic typing and Static typing
3. Advantages of Statically Typed v/s Dynamically typed
4. When Statically Typed is preferred over Dynamically typed
5. Examples
6. Conclusion
7. Glossary
8. References


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.


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 (Statically typed) Python (Dynamically 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.

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.


When Statically Typed is preferred over Dynamically 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.

Usaully 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.

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 enviornment. 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.

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.


References

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

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2009/wiki1b_2_sk&oldid=20435"