OOP Comparative Study

Object Oriented
Programming:
A Comparative Study
By: Darren Tan

Abstract

Object-Oriented Programming: A Comparative Study

2012

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.

Introduction

In 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

2012

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


2012

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


2012

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, objectoriented 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


2012

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,


2012

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.

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.

We consider the following feature criteria:

Efficiency: Is the language capable of being
implemented efficiently? Some aspects of objectoriented 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?

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

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

 The lack of appropriate automated

development support compromises
developer productivity and system quality.

3.

CRITERIA FOR LANGUAGE
COMPARISON


2012

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

FreeBasic is completely independent with
any particular hardware and operating system.
 Its definition should be standardized, and

compiler implementations should comply with
this standard.
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.
 It should support software engineering

technology, discouraging or prohibiting poor
practices, and promoting or supporting
maintenance activities.
Compared to QBASIC, FreeBasic supports
operator overloading, functional overloading,
namespaces.
 It should effectively support the application

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.
 It should support the required level of system

reliability and safety.
4.

EVALUATION OF
PROGRAMMING LANGUAGES
a.

FreeBasic

 Its definition should be independent of any

particular hardware or operating system.

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.
 Its compiler implementations should be

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

2012

producing such method where it does not support
some mobile technologies.
 Appropriate software engineering-based

supporting tools and environments should be
available.
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 standalone 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 crossplatform attribute that run on different operating
system.

this standard.
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.

2012

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.

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

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

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


2012

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.

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

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

this standard.
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.

2012

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.


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.

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

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.

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

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

e.

C#


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

this standard.
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.


2012

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.

technology.
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#.

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


2012

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.

Print "Inserted 6 between the first and second items. "
Print " Now: Items in list: " + Str(myList.numItems)
Print " Item #1: " + Str(myList.getItem(0))

Print ""

myList.removeAll
Print " Removed All. "

Syntax

Sleep

A.

FreeBasic

//FreeBasic_LinkedList
#Include Once "linkedList.bas"

B.

Falcon

Dim As linkedList myList

var1="1"

myList.addItem(1)

var2="2"

myList.addItem(2)

var3="3"

myList.addItem(3)

myList=List(var1,var2,var3)

Print "Linked list demo:"

printl ("Linked list demo:")

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

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


for elem in myList


forfirst


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

Print ""

continue

myList.removeItem(1)

end

Print "Removed the second item."

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


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


end

Print ""
myList.insertItem(6, 1)

printl ("")


2012
myList.popFront()

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

myList.popFront()
myList.pushFront(var1)

print "Linked list demon";

printl("Removed the second item. ")

print " Items in the list: ";

for elem in myList

print scalar(@myList);

forfirst

print "n";

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

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

continue


end


end

print "n";

printl ("")

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

myList.pop()

print "Removed the second item.n";

myList.push("6")


myList.push(var3)


printl("Inserted 6 between the first and second items.")
for elem in myList

print "n";

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

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

continue

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

end

print "n";

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




end

print "n";

printl ("")

@removed_items = splice( @myList, 0, scalar(@myList) );
print " Removed All. n";

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

C.

Perl

D.

Python

myList=["1","2","3"]
print "Linked list demo: "


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

{

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

class Program


{


static void Main(string[] args)
{
LinkedList<string> myList = new LinkedList<string>();

print ""

myList.AddFirst("1");

myList.pop(1)

myList.AddLast("2");

print "Removed the second item. "

myList.AddLast("3");

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

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


Console.WriteLine(" Items in list: " + myList.Count);
Console.WriteLine(" Item #1: " + myList.ElementAt(0));

print ""


myList.insert(1,"6")


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

Console.WriteLine(" ");


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


Console.WriteLine("Removed the second item.");
Console.WriteLine(" Now: Items in list: " + myList.Count);

print ""


del myList[0:3]


print " Removed All. "


print ' Now: Items in list: ', len(myList)
myList.AddAfter(myList.First, "6");

E.

C#

Console.WriteLine("Inserted 6 between the first and second items.
");
Console.WriteLine(" Now: Items in list: " + myList.Count);

using System;
using System.Collections.Generic;
using System.Linq;

Console.WriteLine(" Item

#3:

"

+

using System.Text;
for (int i = myList.Count - 1; i >=0; i--)
namespace ConsoleApplication1

{

myList.ElementAt(2));


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


2012

CPU
FreeBasic

0.5

7.45

Falcon

0.18

N/A
(Command Line Interpreter)

Perl

0.2

N/A
(Command Line Interpreter)

Python

0.6

13.5

C#

6.

Memory (In Megabytes)

0.8

15.3

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

Comments
Does not yet have enough
libraries. But it can adapt easily
to other method and pass data
with ease. Easy to use.
Used the default packages, find it
difficult to setup and implement
module. Not easy to use.
Used the default packages. Easy
to use.
to use.
to use.

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.


2012

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/beginningperl/3145_Chap11.pdf

[3]. “Linked List Basics”, Nick Parlanter
[4]. “Comparison of Programming Languages”,
Souce:
http://en.wikipedia.org/wiki/Comparison_of_programm
ing_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

OOP Comparative Study

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to OOP Comparative Study

Similar to OOP Comparative Study (20)

Recently uploaded

Recently uploaded (20)

OOP Comparative Study