OOP Comparative Study

Object Oriented Programming:

A Comparative StudyBy: Darren Tan

Abstract

Object-Oriented Programming: A Comparative Study2012

In this study the researcher presents a survey on Object-Oriented programming languages – FreeBasic, Falcon, PERL, Python and C#. The survey involves a comparative study of these programming languages with respect to the following parameters like: Reusability, Portability, Reliability, Readability, Efficiency, Availability of compilers and tools, Familiarity and Expressiveness. At the end, a study of these languages has been made by considering – program length, programming effort, run time efficiency, memory consumption, and reliability as criteria, by running a single program by using the above said languages.

1. IntroductionIn the midst of the year 1950s, different

programming aspects were introduced as ideas that represent each programmer’s behavior towards the use of software and hardware. The programmers presented each concept and thought that would be compound and highly adaptable for the user. Each notion proved to be sufficient and flexible that would be later developed as the Programming Paradigm as it is today.

Fundamental principles of respective Programming Paradigm were later enriched with the suggestion of adding in each method and routine that wouldn’t be multifaceted for the user; so that each pattern would have its own configuration of identifying each dominant qualities and behavioral process. In one of its Paradigm they coined the term Object Oriented Programming.

Object oriented programming (OOP) was primarily used as a programming methodology in the early years. It was categorized as one of the key aspects to represent the use of objects and

messages as the basis of computation. Ideally, the object oriented programming approach inspires the user to place information where it is not directly accessible by the rest of the program. Instead, the information is placed in a specially written task which is called methods. Methods are bundled in the data or either inherited from class objects. These act as the intermediaries for retrieving or modifying the data they control. The programming construct that combines data with a set of methods for accessing and managing those data is called an object.

In which it resolve its own identity and features such as introducing multiple inheritance, polymorphism, and encapsulation. In the early and mid 1990s, when the idea was brought up to support varied procedure; it became generally obtainable. It was further enhance by the use of graphical user interface (GUI), which rely heavily upon on object oriented programming procedures.

Today, there are many programming languages that support the OOP features and there are others that have limited features. Object oriented programming language supposed to make it easy for the user; interact, resolve any problem or algorithm without making much complication. In a given scenario I ran an application that is programmed about a calculus problem with using limited features that is already adapted on the programming language. Hence, there are matters that the library of the source needs to know its definition before using such method is required. Some comes from separate package while other relies on the installed plugin.

FreeBasic


FreeBasic is an open source/free 32-Bit compiler object oriented language that originates from BASIC. It appeared in 2004 and was influenced by QuickBASIC and C languages. It fully support many C libraries, many features have been added like pointers, preprocessor, macros, which cannot be found in other BASIC compilers.

Initially, FreeBASIC emulated QBASIC syntax as closely as possible. However, as the language evolved, breaking away from this was necessary. As a result, FreeBASIC now offers several language dialects. Features include support for types as objects, operator overloading, function overloading, namespaces and others. End-of-line characters indicate the termination of programming statements. Multiple statements may be written on a single line by separating each statement with a colon. FreeBASIC supports block commenting as well as end of line remarks. Full line comments are made with an apostrophe ', while blocks of commented code begin with /' and end with '/.

FreeBASIC provides built-in, QuickBASIC compatible graphics support through FBgfx, which is automatically included into programs that make a call to the SCREEN command. Its backend defaults to OpenGL on GNU/Linux and DirectX on Microsoft Windows. This abstraction makes FBgfx graphics code cross-platform compatible. However, FBgfx is not hardware accelerated.

Users familiar with external graphics utilities such as OpenGL or the Windows API can use them without interfering with the built-in graphics library.

Falcon

Falcon is an open source, multi-paradigm programming language. Falcon translates computer source code to virtual machine instructions for evaluation. The virtual machine is thought both as a stand-alone interpreter and for integration in third-party embedding applications. Falcon is what is commonly known as a scripting language; program source code is simply referred as the "script". The script is organized into lines that are executed one after another (empty lines being ignored). Every line is interpreted as a command, or more properly, as a statement. Falcon provides six integrated programming paradigms: procedural, object oriented, prototype oriented, functional, tabular and message oriented.

The Falcon programming language features: an inheritance model, class-static members, property initializers and instance constructor. Multiple inheritance is supported under the condition that at most one underlying ancestor class is reflecting native data. Access to base class members is supported. Instance structure is fixed and immutable, but due to Falcon's functional nature where functions are seen as just a special kind of data, it is possible to set instance members to plain data or functions (making them methods) dynamically. Functional sequences can be assigned to properties, in which case they become functional methods for the given OOP instance.

Falcon supports stand-alone objects, which can be either classless or derived by class ancestors, which are instantiated and readied before the Virtual Machine executes the main script. Instance Resolution order is tracked by the Falcon Linker to ensure proper initialization of stand-alone objects, which may refer one another


in program modules. Class instances can be created through functional sequences, as instancing a class is morphologically equivalent to calling its symbol, and so, evaluating a functional sequence whose first element is a class has the effect of creating an instance. Falcon OOP model is completed by operator overloading, which allows to create classes on which the mathematical and logical operators have a special behavior.

PERL

Perl is a general-purpose programming language originally developed for text manipulation, but as of 2010 is used for a wide range of tasks including system administration, web development, network programming, games, bioinformatics, and GUI development.

The language is intended to be practical (easy to use, efficient, complete) rather than beautiful (tiny, elegant, minimal). Its major features include support for multiple programming paradigms (procedural, object-oriented, and functional styles), reference counting memory management (without a cycle-detecting garbage collector), built-in support for text processing, and a large collection of third-party modules. Perl is implemented as a core interpreter, written in C, together with a large collection of modules, written in Perl and C. The interpreter is 150,000 lines of C code and compiles to a 1 MB executable on typical machine architectures. Alternatively, the interpreter can be compiled to a link library and embedded in other programs. There are nearly 500 modules in the distribution, comprising 200,000 lines of Perl and an additional 350,000 lines of C code. (Much of the C code in the modules consists of character-encoding tables.)

The interpreter has an object-oriented architecture. All of the elements of the Perl language—scalars, arrays, hashes, coderefs, filehandles—are represented in the interpreter by C structs. Operations on these structs are defined by a large collection of macros, typedefs, and functions; these constitute the Perl C API. The Perl API can be bewildering to the uninitiated, but its entry points follow a consistent naming-scheme, which provides guidance to those who use it. Perl also takes features from shell programming. All variables are marked with leading sigils, which unambiguously identify the data type (for example, scalar, array, hash) of the variable in context. Importantly, sigils allow variables to be interpolated directly into strings. Perl has many built-in functions that provide tools often used in shell programming (although many of these tools are implemented by programs external to the shell) such as sorting, and calling on system facilities.

Perl is often used as a glue language, tying together systems and interfaces that were not specifically designed to interoperate, and for "data munging", that is, converting or processing large amounts of data for tasks such as creating reports. In fact, these strengths are intimately linked. The combination makes Perl a popular all-purpose language for system administrators, particularly because short programs can be entered and run on a single command line. Perl code can be made portable across Windows and Unix; such code is often used by suppliers of software (both COTS and bespoke) to simplify packaging and maintenance of software build- and deployment-scripts.

Graphical user interfaces (GUIs) may be developed using Perl. For example, Perl/Tk is commonly used to enable user interaction with Perl


scripts. Such interaction may be synchronous or asynchronous, using callbacks to update the GUI. For more information about the technologies involved, see Tk, Tcl and WxPerl.

Python

Python is a general-purpose, interpreted high-level programming language whose design philosophy emphasizes code readability. Python was conceived in the late 1980s and its implementation was started in December 1989 by Guido van Rossum at CWI in the Netherlands as a successor to the ABC language (itself inspired by SETL) capable of exception handling and interfacing with the Amoeba operating system. Python supports multiple programming paradigms, primarily but not limited to object-oriented, imperative and, to a lesser extent, functional programming styles. It features a fully dynamic type system and automatic memory management, similar to that of Scheme, Ruby, Perl, and Tcl. Like other dynamic languages, Python is often used as a scripting language, but is also used in a wide range of non-scripting contexts. Using third-party tools, Python code can be packaged into standalone executable programs. Python interpreters are available for many operating systems.

Python has been successfully embedded in a number of software products as a scripting language, including in finite element method software such as Abaqus, 3D animation packages such as Blender, Cinema 4D, Lightwave, Houdini, Maya, modo, MotionBuilder, Softimage, the visual effects compositor Nuke, and 2D imaging programs like GIMP, Inkscape, Scribus and Paint Shop Pro. GNU GDB uses Python as a pretty printer to show complex structures such as C++ containers. ESRI is

now promoting Python as the best choice for writing scripts in ArcGIS. It has even been used in several video games, and has been adopted as first of the three available programming languages in Google App Engine, the other two being Java and Go.

Thanks to being a scripting language with module architecture, syntax simplicity and rich text processing tools, Python is often used for Natural language processing tasks. Python has also been used in Artificial Intelligence tasks.

C#

C# is a multi-paradigm programming language encompassing strong typing, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines. The name "C sharp" was inspired by musical notation where a sharp indicates that the written note should be made a semitone higher in pitch. This is similar to the language name of C++, where "++" indicates that a variable should be incremented by 1. C# is intended to be a simple, modern, general-purpose, object-oriented programming language.

During the development of the .NET Framework, the class libraries were originally written using a managed code compiler system called Simple Managed C (SMC). In January 1999, Anders Hejlsberg formed a team to build a new language at the time called Cool, which stood for "C-like Object Oriented Language". Microsoft had considered keeping the name "Cool" as the final name of the language, but chose not to do so for trademark reasons. By the time the .NET project was publicly announced at the July 2000


Professional Developers Conference, the language had been renamed C#, and the class libraries and ASP.NET runtime had been ported to C#. The most recent version is C# 4.0, which was released on April 12, 2010.

C# is an object-oriented language, but C# further includes support for component-oriented programming. Contemporary software design increasingly relies on software components in the form of self-contained and self-describing packages of functionality. Key to such components is that they present a programming model with properties, methods, and events; they have attributes that provide declarative information about the component; and they incorporate their own documentation. C# provides language constructs to directly support these concepts, making C# a very natural language in which to create and use software components. Several C# features aid in the construction of robust and durable applications: Garbage collection automatically reclaims memory occupied by unused objects; exception handling provides a structured and extensible approach to error detection and recovery; and the type-safe design of the language makes it impossible to have uninitialized variables, to index arrays beyond their bounds, or to perform unchecked type casts.

2. CRITERIA FOR GOOD LANGUAGE

To begin the language selection process, it is important to establish some criteria for what makes a language good. A good language choice should

provide a path into the future in a number of important ways:

Its definition should be independent of any particular hardware or operating system

Its definition should be standardized, and compiler implementations should comply with this standard.

It should support software engineering technology, discouraging or prohibiting poor practices, and promoting or supporting maintenance activities.

It should effectively support the application domain(s) of interest.

It should support the required level of system reliability and safety.

Its compiler implementations should be commensurate with the current state of technology.

Appropriate software engineering-based supporting tools and environments should be available.

Effectively satisfying the above criteria is not easy, and it may require using different languages in different situations. However, as these points are violated, additional risk is involved with near-term development, as well as future technology changes. Key risks encountered as each of these criteria is violated are:

If a language is not independent of a particular platform, portability is severely compromised. Hardware and software options are also limited, both for the original system and for future upgrades.

If compiler implementations do not comply with a standard language definition,


compiler-unique solutions are created. This also severely compromises portability, as well as options for future upgrades.

To the extent that poor practices are used in software development, both development and debugging times will be extended, and poor code characteristics will make both testing and maintenance a nightmare.

Poor support for the application domain will compromise the ease of development, as well as performance and readability characteristics of the code.

If reliability is compromised, the system will not only perform below expectations, but it will also become much more costly across its lifetime. If safety is compromised, life and property will be endangered.

An out-of-date compiler is inferior and difficult to use, producing substandard code which is difficult to create and maintain. It can also prohibit the use of key language features.

The lack of appropriate automated development support compromises developer productivity and system quality.

3. CRITERIA FOR LANGUAGE COMPARISON

We consider the following feature criteria:

Reusability: Does the language support effective reuse of program units? If so, the project can be accelerated by reusing tried-and-tested program units; it might also develop new program units

suitable for future reuse. Relevant concepts here are packages, abstract types, classes, and particularly generic units.

Portability: Does the language help or hinder writing of portable code? In other words, can the code be moved from one platform to a dissimilar platform without major changes?

Reliability: Is the language designed in such a way that programming errors can be detected and eliminated as quickly as possible? Errors detected by compile-time checks are guaranteed absent in the running program, which is ideal. Errors detected by run-time checks are guaranteed to cause no harm other than throwing an exception (or at worst terminating the program), which is second-best. Errors not detected at all can cause unlimited harm (such as corrupting data) before the program crashes. While reliability is always important, it is absolutely essential in safety-critical systems.

Efficiency: Is the language capable of being implemented efficiently? Some aspects of object-oriented programming entail run-time overheads, such as class tags and dynamic dispatch. Run-time checks are costly (although some compilers are willing to suppress them, at the programmer’s own risk). Garbage collection is also costly, slowing the program down at unpredictable times. Interpretive code is about ten times slower than native machine code. If critical parts of the program must be highly efficient, does the language allow them to be tuned by resort to low-level coding, or by calls to procedures written in a lower-level language?

Readability: Does the language help or hinder good programming practice? A language that enforces cryptic syntax, very short identifiers, default declarations, and an absence of type information


makes it difficult to write readable code. The significant point is that code is read (by its author and other programmers) more often than it is written.

Availability of compilers and tools: Are good-quality compilers available for the language? A good-quality compiler enforces the language’s syntax and type rules, generates correct and efficient object code, generates run-time checks (at least as an option) to trap any errors that cannot be detected at compile time, and reports all errors clearly and accurately. Also, is a good-quality integrated development environment (IDE) available for the language? An IDE enhances productivity by combining a program editor, compiler, linker, debugger, and related tools into a single integrated system.

Familiarity: Are the available programmers already familiar with the language? If not, is high-quality training available, and will the investment in training justify itself in future projects?

Expressiveness: This factor reflects the ability of a language to express complex computations or complex data structures in appealing, intuitive ways.

4. EVALUATION OF PROGRAMMING LANGUAGES

a. FreeBasic

Its definition should be independent of any particular hardware or operating system.

FreeBasic is completely independent with any particular hardware and operating system.


Since FreeBasic is a compiler itself, it has many IDE choices that differs with each implementation features. For example, there is an IDE that mainly focuses on GUI while other mainly focuses on run-time process and scripting.


Compared to QBASIC, FreeBasic supports operator overloading, functional overloading, namespaces.


Codes compiled in FreeBASIC can be reused in most x86 native development environments, although in 64 bit areas, it hasn’t took much of an improvement.


FreeBasic has limited features to support system reliability. It’s a new BASIC dialect language and has not been studied that much about its safety and behavior.


FreeBasic is one of the trends for making 2d application, console application and games; but its limited resources has a hindrance of not collectively


producing such method where it does not support some mobile technologies.


In its release FreeBasic has cope with some of the environment and support GUI application.

Readability: Its naturalness is a benefit and highly readable for any programmer. It increases productivity significantly. It improves code maintainability with ease.

Maintainability: Maintains cleanliness of codes such as it adapts the common features of an OOP without any complication whatsoever.

Mixed language support: FreeBasic was originated from QBASIC and C language. Because of this, it fully supports the script and packages that was previously held by both QBASIC and C language.

Portability: FreeBasic is dependent on itself when it comes to compiling but cannot execute application in real time process. Though, it is a complete stand-alone program.

Reliability: It is reliable when it comes to its IDE like FBIDE. It detects error during compilation process.

Reusability: Scripts and codes of FreeBasic can be used for future purposes and still maintain library uses like from its predecessor: QBASIC/BASIC and C language.

Safety: FreeBasic is prone when use to high critical systems is. But can be advisable in low-level and middle-level uses.

Standardization: FreeBasic is standardized from its predecessor: BASIC, due its relatively identical of its syntax and semantics and use of methods and library.

Support for modern engineering methods: It is built to support different method and practices; it adjusts to its ancestor to become advisable and easy to use without any complication.

b. Falcon


Falcon supports multi-platform or cross-platform attribute that run on different operating system.


Falcon has not yet been standardized.


Although it’s new in programming methodology; Falcon is a stand-alone system and it is embedded into other software engineering technology. It is continually being maintained and forbids poor practices.


Once more, Falcon is embedded to other software tools and server side dynamic pages that targets multiple application domains. It covers some of the known used software technology but still in progress to widely conduct a broad implementation.



Falcon is reliable and safe. It quickly identifies the requirements and tools to operate it (if used in previous generation of computer technology). Falcon is implicit and has dynamic type checking to allow single line block checking if it is not recognized.


Due to its constant improvement, Falcon has been able to meet the state of technology until today. Although it still lacks libraries and methods.


Falcon has great tools ad packages and is adaptable to other environment because of its attribute.

Readability: Though, Falcon does not aim in general readability. It focuses on expressiveness that is more in logical and algorithmic approach. Can be recommended for oriented programmers that has used C/C++.

Maintainability: Falcon accommodates classes and multiple inheritance, where it has the bystander method of line block that maintains the definition of your program.

Mixed language support: Falcon was influenced from C and C++. It is able to support known languages like VB.net and C# that has embedded scripting functions of Falcon, but still limited in some ways.

Portability: Falcon is portable. It can be used in any Operating System and has been implemented on a linux based OS as one of its default primary program.

Reliability: Falcon does not have encapsulation function that will be a little complicated to use for OOP users. Even though, it is reliable for its algorithm and expressiveness.

Reusability: However, Falcon is immutable and fixed. It cannot be altered because its static explicit.

Safety: Falcon has high safety procedural method. It has thread safe feature which prohibits global functions.

Support for modern engineering methods: Falcon was made to support stand-alone objects, which can be either classless or derived by class ancestors, which are instantiated and readied before the Virtual Machine executes the main script.

c. PERL


Perl is completely independent of any particular hardware or operating system.


Since its creation, Perl has not yet been standardized by the ISO because of its large implementation.



Perl is moderately used nowadays and has been supporting other software technology. It does not allow poor practices. Though, Perl is still undergoing some changes and development to become more liable to users.


Until now, Perl is still fast in web development. It delivers and meets full expectation. It has been present to some application domains.


Most of the features of Perl support system reliability. However, for safety deliverable aspects; it is still going through some development of clearing out the bugs and fixing some process to strengthen the security.


With the current state of technology today, Perl continue to rise and dominate the server side scripting area wherein it is able to balance the needs of web developers.


Perl has introduced supporting tools, mostly are in Web based technology. Still, they are currently doing some methods if it is applicable to be included in mobile based software.

Readability: Perl is highly readable; it can be understood with ease.

Maintainability: Being embedded with an OOP feature; Perl supports GUI functions and tools.

Mixed language support: Perl supports multiple inheritance method and improved logical perception and sustainability of the program.

Portability: Perl is portable and completely independent on its platform. It has been tested in numerous Operating System.

Reliability: Perl is reliable in different forms of web developing; it has different structures which can be maintainable.

d. Python


Python is independent in any particular hardware or operating system.


Python is De Facto standard via Python Enhancement Proposals (PEP). PEPs are standardized design documents providing general info related to Python, including plans, explanations, design bases, and descriptions for language features.


Python support different kind of software technology. It is intact with the modern use in multiple ways such as in its compatibility and use with Android OS.



In its state, Python proved to be dominant not only it is a cross-platform program; it is able to provide services on different OOP language that could either be included in their framework or library.


Python is system reliable and has safe-critical systems which makes it strong and clear with its usage. Henceforth, this was adapted and carried to the integrated development environment.


Because of its reputation, Python has been commonly used in different aspects of technology. Wherein it grows rapidly and was upheld on its top performance.


Moreover, Python has been a part of different software technology and environment like: Applications, Games, Frameworks, Graphical usage and Editors.

Readability: Python is highly readable. It accepts that needs to be defined and only well-defined by its environment. It works closely to English language with a perception of a dictionary.

Maintainability: It maintains cleanliness of codes and it adapts to known features of an OOP without any problem whatsoever.

Mixed language support: Though, Python supports multiple inheritance and polymorphism method. It also strengthens the use of packages and editors.

Portability: Python is purely portable. It was created to be convenient and easy to use. Libraries and packages can simply be imported.

Reliability: Python has reference counting and garbage collection which helps minimizes the operation and memory allocation when executing.

Reusability: Support for reusability requires support for code clarity, maintainability and portability. It can adjust to other characteristic features. Python has duck-typing method which largely covers the motive of every aspect used.

Safety: Python is safe among users. It is property based and dynamically typed. It also restricts allocation and de-allocation of memory.

e. C#


C# is primarily platform independent. Although, it is only implemented for Windows.


The C# language definition and the CLI are standardized under ISO and Ecma standards that provide reasonable and non-discriminatory licensing protection from patent claims.



C# supports software engineering technology and its framework. It prohibits poor practices to allow users to grow competent.


C# supports application domains that are associated with .NET framework.


For its system reliability, c# is strongly dependable. It is implicit with optional explicit typing. It is safe and checks code syntax in compile time process.


C# commensurate with the current state of technology; for its continuous growth it adapts different kinds of libraries, utilities and even installed tools that is not familiarized by C#.


Since the current release of C# 3.0, it now supports framework of lambda expressions, extension methods, and anonymous types.

Readability: The syntax of C# is understandable and readable, though it might take time to understand at first; since it is not static based like other language does.

Maintainability: Maintains cleanliness of codes such as it adapts most features of an OOP without any complication whatsoever.

Mixed language support: C# supports different tools and objects. It helps other language like Perl and Python in server side scripting and implements its plugin and tools.

Reliability: It is reliable and able to determine the missing tools and dll files; that need to be reconfigured and implemented.

Reusability: Syntax and semantics as part of the requirements of its reusability. It allows conversion of codes from previous versions to the current version.

Safety: C# is high on safety critical procedures. Common Intermediate Language (CIL) and Common Language Runtime (CLR) help it to maintain productivity and execution. It has a garbage collector and it also identifies null values and unused operators.

Support for modern engineering methods: C# was built to become more sociable to the users. Compare to C++ and C, C# has a Windows application making that freely allows the use of GUI. It supports web development and script. C# has the set features of OOP.

5. RESULTS

The same program (i.e. an implementation of the same set of requirements) is considered for each language. Hence, the comparison is narrow but homogeneous. Several different aspects are investigated, such as program length, programming effort, run time efficiency, memory consumption, and reliability.


LINKED LIST

A Linked list is a data structure consisting of a group of nodes which together represent a sequence. Under the simplest form, each node is composed of a datum and a reference (in other words, a link) to the next node in the sequence; more complex variants add additional links. This structure allows for efficient insertion or removal of elements from any position in the sequence.

Syntax

A. FreeBasic

//FreeBasic_LinkedList

#Include Once "linkedList.bas"

Dim As linkedList myList

myList.addItem(1)

myList.addItem(2)

myList.addItem(3)

Print "Linked list demo:"

Print " Items in list: " + Str(myList.numItems)

Print " Item #1: " + Str(myList.getItem(0))



Print ""

myList.removeItem(1)

Print "Removed the second item."

Print " Now: Items in list: " + Str(myList.numItems)



Print ""

myList.insertItem(6, 1)

Print "Inserted 6 between the first and second items. "





Print ""

myList.removeAll

Print " Removed All. "


Sleep

B. Falcon

var1="1"

var2="2"

var3="3"

myList=List(var1,var2,var3)

printl ("Linked list demo:")

printl ("Items in List: " + myList.len())

for elem in myList

forfirst

>>"Item #1: ", elem + "\n"

continue

end

formiddle: >>"Item #2: " + elem + "\n"

forlast: >>"Item #3: " + elem + "\n"

end

printl ("")


myList.popFront()

myList.popFront()

myList.pushFront(var1)

printl("Removed the second item. ")

for elem in myList

forfirst

>>"Item #1: ", elem + "\n"

continue

end


end

printl ("")

myList.pop()

myList.push("6")

myList.push(var3)

printl("Inserted 6 between the first and second items.")

for elem in myList

forfirst

>>"Item #1: ", elem + "\n"

continue

end

formiddle: >>"Item #2: " + elem + "\n"


end

printl ("")

myList.clear()

printl("Removed All")

printl(" Now Items in the list: "+ myList.len())

C. Perl

@myList= ("1","2","3");

print "Linked list demo\n";

print " Items in the list: ";

print scalar(@myList);

print "\n";

print " Item #1: $myList[0]\n";



print "\n";

@removed_items = splice( @myList, 1, 1 );

print "Removed the second item.\n";



print "\n";

splice( @myList, 1, 0, 6 );

print "Inserted 6 between the first and second items. ";

print "\n";




print "\n";

@removed_items = splice( @myList, 0, scalar(@myList) );

print " Removed All. \n";

D. Python

myList=["1","2","3"]

print "Linked list demo: "


print ' Items in list: ' , len(myList)

print ' Item #1: ' , myList[0]



print ""

myList.pop(1)

print "Removed the second item. "

print ' Now: Items in list: ', len(myList)



print ""

myList.insert(1,"6")

print "Inserted 6 between the first and second items. "




print ""

del myList[0:3]

print " Removed All. "

print ' Now: Items in list: ', len(myList)

E. C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

LinkedList<string> myList = new LinkedList<string>();

myList.AddFirst("1");

myList.AddLast("2");

myList.AddLast("3");

Console.WriteLine("Linked list demo:");

Console.WriteLine(" Items in list: " + myList.Count);

Console.WriteLine(" Item #1: " + myList.ElementAt(0));



Console.WriteLine(" ");

myList.Remove(myList.ElementAt(1));

Console.WriteLine("Removed the second item.");

Console.WriteLine(" Now: Items in list: " + myList.Count);



Console.WriteLine(" ");

myList.AddAfter(myList.First, "6");

Console.WriteLine("Inserted 6 between the first and second items. ");

Console.WriteLine(" Now: Items in list: " + myList.Count);

Console.WriteLine(" Item #1: " + myList.ElementAt(0)); Console.WriteLine(" Item #2: " + myList.ElementAt(1));

Console.WriteLine(" Item #3: " + myList.ElementAt(2)); Console.WriteLine(" ");

for (int i = myList.Count - 1; i >=0; i--)

{


myList.Remove(myList.ElementAt(i));

}

Console.WriteLine(" Removed All ");

Console.WriteLine(" Now: Items in list " + myList.Count);

Console.Read();

}

}

}

Output:

This is the output of the program that I used with the linked list structure in FreeBasic, Falcon, Perl, Python and C #.

Analysis

In FreeBasic, I provided another class from source-file library for the Linked list that would benefit the use of its function.

In Falcon, there was no Linked list function and no library. Though it has a double linked list function; but the problem is there is no condition of inserting between 2 numbers. It only inserts and erase in the front and the last index value.

In Perl, I have no difficulty with it; since it already comes with a list function.

In Python, there was no problem either. It has the procedure and method that is needed.

In C#, it has the built-in structural method that would easily identify the type of procedure to use.


CPU Memory (In Megabytes) Comments

FreeBasic 0.5 7.45

Does not yet have enough libraries. But it can adapt easily to other method and pass data with ease. Easy to use.

Falcon 0.18N/A

(Command Line Interpreter)

Used the default packages, find it difficult to setup and implement module. Not easy to use.

Perl 0.2 N/A(Command Line Interpreter)

Used the default packages. Easy to use.

Python 0.6 13.5 Used the default packages. Easy to use.

C# 0.8 15.3 Used the default packages. Easy to use.

6. CONCLUSION

FreeBasic is somehow new to the BASIC dialect language. It doesn’t have enough library modules, but it has the basic needs for applying mathematical algorithm and logical reasoning. It has dynamic allocation and can store temporary allocation which avoids memory consumption. It also adapted methods and function of BASIC and C. When used in other areas, it will prove to be simple and efficient as a first try in programming in any OS.

Falcon was created from a simple project named HASTE that was developed in 2002. It is fast and secure. It can also be embedded in different programming languages that can be used for scripting. However, Falcon is difficult to handle in terms of importing library module and passing data variables. Falcon can be dominant, it restricts access of unknown value and it supports declaration of Unicode variable

Perl is high-level programming language; that is dynamic and user friendly. It can be used for graphics programming, system administration, network programming, finance, bioinformatics, and other applications. It aims to become of the best language and ascertained to be in its top performance. It has

less run time efficiency and compilation process.

Python was influenced by ABC, ALGOL 68, C, C++, Dylan, Haskell and (etc.). Its purpose is to be highly readable to user as possible. In OOP features, Python allows user to define their types using class that can make an instance of itself. Unlike other languages, it supports complex number like 3.28+j that can be used for algorithmic capability. Modern software technology has Python embedded in them and still increasing immensely.


C# is one of the dominant languages in Windows since its release. It derives from C and C++. C# has the ability to import any .dll files that are installed in the system and make use of it simply. C# is weak when it comes to compiling an application, since the application that was made from C# required updated framework in order to execute it. By using Visual .Net, C# is worth using for GUI application as it is very strict and has high level modifier. C# is only available in Windows OS.

7. REFERENCES[1] “The C# Programming Language”, Anders Hejlsberg, Scott Wiltamuth and Peter Golde

[2]. “Object-Oriented Perl”

Source: http://blob.perl.org/books/beginning-perl/3145_Chap11.pdf

[3]. “Linked List Basics”, Nick Parlanter

[4]. “Comparison of Programming Languages”,

Souce: http://en.wikipedia.org/wiki/Comparison_of_programming_languages

[5]. “The Falcon Survival Guide”, Giancarlo Niccolai

[6]. “Python Programming: An Introduction to Computer Science”, John M. Zelle

[7]. “A Beginner’s Guide to FreeBasic”, Richard D. Clark and Ebben Feagan

http://blob.perl.org/books/beginning-perl/3145_Chap11.pdf

http://blob.perl.org/books/beginning-perl/3145_Chap11.pdf

http://en.wikipedia.org/wiki/Comparison_of_programming_languages

http://en.wikipedia.org/wiki/Comparison_of_programming_languages

Technology

OOP Comparative Study