There are many programming languages in the world today.Each language has
their advantage and disavantage. In this paper, we will discuss ten programming
languages: C++, C#, Java, Groovy, JavaScript, PHP, Schalar, Scheme, Haskell and
AspectJ. We summarize and compare these ten languages on ten different
criterion. For example, Default more secure programming practices, Web
applications development, OO-based abstraction and etc. At the end, we will
give our conclusion that which languages are suitable and which are not for
using in some cases.

With the advent of numerous languages it is difficult to realize the edge of
one language in a particular scope over another one. We are making an effort,
realizing these few issues and comparing some main stream languages like Java,
Scala, C++, Haskell, VB .NET, AspectJ, Perl, Ruby, PHP and Scheme keeping in
mind some core issues in program development.

Previous deforestation and supercompilation algorithms may introduce
accidental termination when applied to call-by-value programs. This hides
looping bugs from the programmer, and changes the behavior of a program
depending on whether it is optimized or not. We present a supercompilation
algorithm for a higher-order call-by-value language and prove that the
algorithm both terminates and preserves termination properties. This algorithm
utilizes strictness information to decide whether to substitute or not and
compares favorably with previous call-by-name transformations.

Page switching is a technique that increases the memory in microcontrollers
without extending the address buses. This technique is widely used in the
design of 8-bit MCUs. In this paper, we present an algorithm to reduce the
overhead of page switching. To pursue small code size, we place the emphasis on
the allocation of functions into suitable pages with a heuristic algorithm,
thereby the cost-effective placement of page selection instructions. Our
experimental results showed the optimization achieved a reduction in code size
of 13.2 percent.

In the context of Service-Oriented Computing, applications can be developed
following the REST (Representation State Transfer) architectural style. This
style corresponds to a resource-oriented model, where resources are manipulated
via CRUD (Create, Request, Update, Delete) interfaces. The diversity of CRUD
languages due to the absence of a standard leads to composition problems
related to adaptation, integration and coordination of services.

We identify a class of programs manipulating lists of data items for which
checking functional equivalence and pre/post verification conditions is
decidable. Lists are modeled as data words, (unbounded) sequences of data
values, tagged with symbols from a finite set, over a potentially infinite data
domain that supports only the operations of equality and ordering. First, we
introduce streaming data-word transducers that map input data words to output
data words in a single left-to-right pass in linear time.

PRISM is an extension of Prolog with probabilistic predicates and built-in
support for expectation-maximization learning. Constraint Handling Rules (CHR)
is a high-level programming language based on multi-headed multiset rewrite
rules.

Static analysis is a powerful technique for automatic verification of
programs but raises major engineering challenges when developing a full-fledged
analyzer for a realistic language such as Java. This paper describes the Sawja
library: a static analysis framework fully compliant with Java 6 which provides
OCaml modules for efficiently manipulating Java bytecode programs.

Lecture notes for the Comparative Studies of Programming Languages course,
COMP6411, taught at the Department of Computer Science and Software
Engineering, Faculty of Engineering and Computer Science, Concordia University,
Montreal, QC, Canada. These notes include a compiled book of primarily related
articles from the Wikipedia, the Free Encyclopedia, as well as Comparative
Programming Languages book and other resources, including our own. The original
notes were compiled by Dr. Paquet.

The work presented in this thesis seeks to improve programmer productivity in
the following ways:

- by reducing the amount of code that has to be written to construct an
application;

- by increasing the reliability of the code written; and

Static analysis by abstract interpretation aims at automatically proving
properties of computer programs. To do this, an over-approximation of program
semantics, defined as the least fixpoint of a system of semantic equations,
must be computed. To enforce the convergence of this computation, widening
operator is used but it may lead to coarse results. We propose a new method to
accelerate the computation of this fixpoint by using standard techniques of
numerical analysis. Our goal is to automatically and dynamically adapt the
widening operator in order to maintain precision.

A parametric analysis is an analysis whose input and output are parametrized
with a number of parameters which can be instantiated to abstract properties
after analysis is completed. This paper proposes to use Cousot and Cousot's
Cardinal power domain to capture functional dependencies of analysis output on
its input and obtain a parametric analysis by parametrizing a non-parametric
base analysis. We illustrate the method by parametrizing a $\pos$ based
groundness analysis of logic programs to a parametric groundness analysis.

We discuss a programming language for real-time audio signal processing that
is embedded in the functional language Haskell and uses the Low-Level Virtual
Machine as back-end. With that framework we can code with the comfort and type
safety of Haskell while achieving maximum efficiency of fast inner loops and
full vectorisation. This way Haskell becomes a valuable alternative to special
purpose signal processing languages.

Garbage collectors are notoriously hard to verify, due to their low-level
interaction with the underlying system and the general difficulty in reasoning
about reachability in graphs. Several papers have presented verified
collectors, but either the proofs were hand-written or the collectors were too
simplistic to use on practical applications. In this work, we present two
mechanically verified garbage collectors, both practical enough to use for
real-world C# benchmarks.

The dependency core calculus (DCC), a simple extension of the computational
lambda calculus, captures a common notion of dependency that arises in many
programming language settings. This notion of dependency is closely related to
the notion of information flow in security; it is sensitive not only to data
dependencies that cause explicit flows, but also to control dependencies that
cause implicit flows. In this paper, we study variants of DCC in which the data
and control dependencies are decoupled.

The design of embedded control systems is mainly done with model-based tools
such as Matlab/Simulink. Numerical simulation is the central technique of
development and verification of such tools. Floating-point arithmetic, that is
well-known to only provide approximated results, is omnipresent in this
activity. In order to validate the behaviors of numerical simulations using
abstract interpretation-based static analysis, we present, theoretically and
with experiments, a new relational abstract domain dedicated to floating-point
variables.

The call-by-need lambda calculus provides an equational framework for
reasoning syntactically about lazy evaluation. This paper examines its
operational characteristics.

By a series of reasoning steps, we systematically unpack the standard-order
reduction relation of the calculus and discover a novel abstract machine
definition which, like the calculus, goes "under lambdas." We prove that
machine evaluation is equivalent to standard-order evaluation.

This article presents a complete scheme for the development of Critical
Embedded Systems with Multiple Real-Time Constraints. The system is programmed
with a language that extends the synchronous approach with high-level real-time
primitives. It enables to assemble in a modular and hierarchical manner several
locally mono-periodic synchronous systems into a globally multi-periodic
synchronous system. It also allows to specify flow latency constraints. A
program is translated into a set of real-time tasks.

The SPaCIFY project, which aims at bringing advances in MDE to the satellite
flight software industry, advocates a top-down approach built on a
domain-specific modeling language named Synoptic. In line with previous
approaches to real-time modeling such as Statecharts and Simulink, Synoptic
features hierarchical decomposition of application and control modules in
synchronous block diagrams and state machines. Its semantics is described in
the polychronous model of computation, which is that of the synchronous
language Signal.

The Second International Workshop on Programming Language Approaches to
Concurrency and Communication-cEntric Software (PLACES) was co-located with
ETAPS 2009 in the city of York, England. The workshop took place on Sunday 22nd
March 2009. The workshop focused on the challenges raised by the changing
landscape of computer software. Traditionally, most software was written for a
single computer with one CPU.

Parser generators generate translators from language specifications. In many
cases, such specifications contain semantic actions written in the same
language as the generated code. Since these actions are subject to little
static checking, they are usually a source of errors which are discovered only
when generated code is compiled.

This paper investigates session programming and typing of benchmark examples
to compare productivity, safety and performance with other communications
programming languages. Parallel algorithms are used to examine the above
aspects due to their extensive use of message passing for interaction, and
their increasing prominence in algorithmic research with the rising
availability of hardware resources such as multicore machines and clusters.

Transactional events (TE) are an extension of Concurrent ML (CML), a
programming model for synchronous message-passing. Prior work has focused on
TE's formal semantics and its implementation. This paper considers programming
idioms, particularly those that vary unexpectedly from the corresponding CML
idioms. First, we solve a subtle problem with client-server protocols in TE.
Second, we argue that CML's wrap and guard primitives do not translate well to
TE, and we suggest useful workarounds. Finally, we discuss how to rewrite CML
protocols that use abort actions.

A challenge for programming language research is to design and implement
multi-threaded low-level languages providing static guarantees for memory
safety and freedom from data races. Towards this goal, we present a concurrent
language employing safe region-based memory management and hierarchical locking
of regions. Both regions and locks are treated uniformly, and the language
supports ownership transfer, early deallocation of regions and early release of
locks in a safe manner.

This volume contains selected papers presented at the 9th International
Workshop on Reduction Strategies in Rewriting and Programming, WRS2009, which
was held in Brasilia on the 28th June 2009, associated to RTA 2009 (the 20th
International Conference on Rewriting Techniques and Applications) at RDP, the
Federated Conference on Rewriting, Deduction and Programming. Reduction
strategies define which (sub)expression(s) should be selected for evaluation
and which rule(s) should be applied.

In this report, we show how to use the Simple Fluent Calculus (SFC) to
specify generic tracers, i.e. tracers which produce a generic trace. A generic
trace is a trace which can be produced by different implementations of a
software component and used independently from the traced component. This
approach is used to define a method for extending a java based CHRor platform
called CHROME (Constraint Handling Rule Online Model-driven Engine) with an
extensible generic tracer.

In this paper we introduced an algebraic semantics for process algebra in
form of abstract data types. For that purpose, we developed a particular type
of algebra, the seed algebra, which describes exactly the behavior of a process
within a labeled transition system. We have shown the possibility of
characterizing the bisimulation of two processes with the isomorphism of their
corresponding seed algebras. We pointed out that the traditional concept of
isomorphism of algebra does not apply here, because there is even no one-one
correspondence between the elements of two seed algebras.

Pattern-matching programming is an example of a rule-based programming style
developed in functional languages. This programming style is intensively used
in dialects of ML but is restricted to algebraic data-types. This restriction
limits the field of application. However, as shown by Giavitto and Michel at
RULE'02, case-based function definitions can be extended to more general data
structures called topological collections. We show in this paper that this
extension retains the benefits of the typed discipline of the functional
languages.

Pure Lucid programs are concurrent with very fine granularity. Sequential
Threads (STs) are functions introduced to enlarge the grain size; they are
passed from server to workers by Communication Procedures (CPs) in the General
Intensional Programming System (GIPSY). A JLucid program combines Java code for
the STs with Lucid code for parallel control. Thus first, in this thesis, we
describe the way in which the new JLucid compiler generates STs and CPs. JLucid
also introduces array support.

A unit test is a method for verifying the accuracy and the proper functioning
of a portion of a program. This work consists to study the relation and the
approaches to test Object-Oriented Programming (OOP) programs and to propose a
metamodel that enables the programmer to write the tests while writing the
source code to be tested by exploiting the key features of OOP programming
languages such as inheritance, polymorphism, etc.

ActorScript is a general purpose programming language for implementing
massive local and nonlocal concurrency. It is differentiated from other
concurrent languages by the following: * Identifiers (names) in the language
are referentially transparent, i.e., in a given scope an identifier always
refers to the same thing. * Everything in the language is accomplished using
message passing including the very definition of ActorScript itself. * Binary
XML and JSON are fundamental, being used for structuring both data and
messages.

This thesis concerns the implementation of Lambda Prolog, a higher-order
logic programming language that supports the lambda-tree syntax approach to
representing and manipulating formal syntactic objects. Lambda Prolog achieves
its functionality by extending a Prolog-like language by using typed lambda
terms as data structures that it then manipulates via higher-order unification
and some new program-level abstraction mechanisms. These additional features
raise new implementation questions that must be adequately addressed for Lambda
Prolog to be an effective programming tool.

Coding standards and good practices are important for all software projects,
whatever programming languages they employ. Arguably, Prolog programming can
benefit from a disciplined approach more than programming in other languages.
Despite this, no widely accepted standards and practices seem to have emerged
up to now. The present paper aims at being a first step towards filling this
gap.

A great variety of static analyses that compute safety properties of
single-thread programs have now been developed. This paper presents a
systematic method to extend a class of such static analyses, so that they
handle programs with multiple POSIX-style threads. Starting from a pragmatic
operational semantics, we build a denotational semantics that expresses
reasoning a la assume-guarantee. The final algorithm is then derived by
abstract interpretation. It analyses each thread in turn, propagating
interferences between threads, in addition to other semantic information.

Software products evolve over time. Sometimes they evolve by adding new
features, and sometimes by either fixing bugs or replacing outdated
implementations with new ones. When software engineers fail to anticipate such
evolution during development, they will eventually be forced to re-architect or
re-build from scratch. Therefore, it has been common practice to prepare for
changes so that software products are extensible over their lifetimes.

We propose a method for automatically generating abstract transformers for
static analysis by abstract interpretation. The method focuses on linear
constraints on programs operating on rational, real or floating-point variables
and containing linear assignments and tests. In addition to loop-free code, the
same method also applies for obtaining least fixed points as functions of the
precondition, which permits the analysis of loops and recursive functions. Our
algorithms are based on new quantifier elimination and symbolic manipulation
techniques.

Game semantics has been used with considerable success in formulating fully
abstract semantics for languages with higher-order procedures and a wide range
of computational effects. Recently, nominal games have been proposed for
modelling functional languages with names. These are ordinary, stateful games
cast in the theory of nominal sets developed by Pitts and Gabbay. Here we take
nominal games one step further, by developing a fully abstract semantics for a
language with nominal general references.

We propose a methodology for the automatic verification of safety properties
of controllers based on dynamical systems, such as those typically used in
avionics. In particular, our focus is on proving stability properties of
software implementing linear and some non-linear controllers. We develop an
abstract interpretation framework that follows closely the Lyapunov methods
used in proofs at the model level and describe the corresponding abstract
domains, which for linear systems consist of ellipsoidal constraints.