Programming Languages (programming + languages)

Distribution by Scientific Domains

Selected Abstracts

MATLAB as an introductory programming language

M. A. Wirth
Abstract This paper explores the use of MATLAB for teaching the fundamental constructs of programming languages to engineering and science students. It was found that the time taken for students to learn programming can be reduced by up to 50%, paving the way for using the language to solve problems. © 2006 Wiley Periodicals, Inc. Comput Appl Eng Educ 14: 20,30, 2006; Published online in Wiley InterScience (; DOI 10.1002/cae.20064 [source]

A definition of and linguistic support for partial quiescence

Billy Yan-Kit Man
Abstract The global quiescence (GQ) of a distributed computation (or distributed termination detection) is an important problem. Some concurrent programming languages and systems provide GQ detection as a built-in feature so that programmers do not need to write special synchronization code to detect quiescence. This paper introduces partial quiescence (PQ), which generalizes quiescence detection to a specified part of a distributed computation. PQ is useful, for example, when two independent concurrent computations that both rely on GQ need to be combined into a single program. The paper describes how we have designed and implemented a PQ mechanism within an experimental version of the JR concurrent programming language, and have gained experience with several representative applications. Our early results are promising qualitatively and quantitatively. Copyright © 2007 John Wiley & Sons, Ltd. [source]

JaMP: an implementation of OpenMP for a Java DSM

Michael Klemm
Abstract Although OpenMP is a widely agreed-upon standard for the C/C++ and Fortran programming languages for the semi-automatic parallelization of programs for shared memory machines, not much has been done on the binding of OpenMP to Java that targets clusters with distributed memory. This paper presents three major contributions: (1) JaMP is an adaptation of the OpenMP standard to Java that implements a large subset of the OpenMP specification with an expressiveness comparable to that of OpenMP; (2) we suggest a set of extensions that allow a better integration of OpenMP into the Java language; (3) we present our prototype implementation of JaMP in the research compiler Jackal, a software-based distributed shared memory implementation for Java. We evaluate the performance of JaMP with a set of micro-benchmarks and with OpenMP versions of the parallel Java Grande Forum (JGF) benchmarks. The micro-benchmarks show that OpenMP for Java can be implemented without much overhead. The JGF benchmarks achieve a good speed-up of 5,8 on eight nodes. Copyright © 2007 John Wiley & Sons, Ltd. [source]

GAUGE: Grid Automation and Generative Environment,

Francisco Hernández
Abstract The Grid has proven to be a successful paradigm for distributed computing. However, constructing applications that exploit all the benefits that the Grid offers is still not optimal for both inexperienced and experienced users. Recent approaches to solving this problem employ a high-level abstract layer to ease the construction of applications for different Grid environments. These approaches help facilitate construction of Grid applications, but they are still tied to specific programming languages or platforms. A new approach is presented in this paper that uses concepts of domain-specific modeling (DSM) to build a high-level abstract layer. With this DSM-based abstract layer, the users are able to create Grid applications without knowledge of specific programming languages or being bound to specific Grid platforms. An additional benefit of DSM provides the capability to generate software artifacts for various Grid environments. This paper presents the Grid Automation and Generative Environment (GAUGE). The goal of GAUGE is to automate the generation of Grid applications to allow inexperienced users to exploit the Grid fully. At the same time, GAUGE provides an open framework in which experienced users can build upon and extend to tailor their applications to particular Grid environments or specific platforms. GAUGE employs domain-specific modeling techniques to accomplish this challenging task. Copyright © 2005 John Wiley & Sons, Ltd. [source]

Checking ownership and confinement

Alex Potanin
Abstract A number of proposals to manage aliasing in Java-like programming languages have been advanced over the last five years. It is not clear how practical these proposals are, that is, how well they relate to the kinds of programs currently written in Java-like languages. To address this problem, we analysed heap snapshots from a corpus of Java programs. Our results indicate that object-oriented programs do in fact exhibit symptoms of encapsulation in practice, and that proposed models of uniqueness, ownership, and confinement can usefully describe the aliasing structures of object-oriented programs. Understanding the kinds of aliasing present in programs should help us to design formalisms to make explicit the kinds of aliasing implicit in object-oriented programs. Copyright © 2004 John Wiley & Sons, Ltd. [source]

The value of environmental modelling languages for building distributed hydrological models

Derek Karssenberg
Abstract An evaluation is made of the suitability of programming languages for hydrological modellers to create distributed, process-based hydrological models. Both system programming languages and high-level environmental modelling languages are evaluated based on a list of requirements for the optimal programming language for such models. This is illustrated with a case study, implemented using the PCRaster environmental modelling language to create a distributed, process-based hydrological model based on the concepts of KINEROS-EUROSEM. The main conclusion is that system programming languages are not ideal for hydrologists who are not computer programmers because the level of thinking of these languages is too strongly related to specialized computer science. A higher level environmental modelling language is better in the sense that it operates at the conceptual level of the hydrologist. This is because it contains operators that identify hydrological processes that operate on hydrological entities, such as two-dimensional maps, three-dimensional blocks and time-series. The case study illustrates the advantages of using an environmental modelling language as compared with system programming languages in fulfilling requirements on the level of thinking applied in the language, the reusability of the program code, the lack of technical details in the program, a short model development time and learnability. The study shows that environmental modelling languages are equally good as system programming languages in minimizing programming errors, but are worse in generic application and performance. It is expected that environmental modelling languages will be used in future mainly for development of new models that can be tailored to modelling aims and the field data available. Copyright © 2002 John Wiley & Sons, Ltd. [source]

Simplified solution of developing laminar forced flow between parallel plates

Esmail M. A. Mokheimer
Abstract A simplified simulation for developing laminar forced flow in the entrance region between two parallel plates is presented. This simulation is based on an implicit finite difference numerical representation of a boundary layer model describing the flow in the entry region. This boundary layer model comprises the two conservation equations of mass and momentum. A non-iterative implicit numerical scheme is developed to convert the partial differential form of these governing equations into algebraic equations. The resultant algebraic equations have been solved simultaneously via a simplified simulation using spreadsheet programs as well as a Fortran code for the sake of comparison. The numerically obtained developing axial velocity profile at large distance downstream of the entrance shows excellent agreement with the available fully developed analytical profile. Comparison between the abilities of the spreadsheet simulation with other high-level programming languages is outlined. Copyright © 2002 John Wiley & Sons, Ltd. [source]

Half a Century of Public Software Institutions: Open Source as a Solution to Hold-Up Problem

We argue that the intrinsic inefficiency of proprietary software has historically created a space for alternative institutions that provide software as a public good. We discuss several sources of such inefficiency, focusing on one that has not been described in the literature: the underinvestment due to fear of hold-up. An inefficient hold-up occurs when a user of software must make complementary investments, when the return on such investments depends on future cooperation of the software vendor, and when contracting about a future relationship with the software vendor is not feasible. We also consider how the nature of the production function of software makes software cheaper to develop when the code is open to the end users. Our framework explains why open source dominates certain sectors of the software industry (e.g., programming languages), while being almost non existent in some other sectors (e.g., computer games). We then use our discussion of efficiency to examine the history of institutions for provision of public software from the early collaborative projects of the 1950s to the modern "open source" software institutions. We look at how such institutions have created a sustainable coalition for provision of software as a public good by organizing diverse individual incentives, both altruistic and profit-seeking, providing open source products of tremendous commercial importance, which have come to dominate certain segments of the software industry. [source]

Guaranteed inconsistency avoidance during software evolution

Keith Gallagher
Abstract The attempt to design and integrate consistent changes to an existing system is the essence of software maintenance. Software developers also confront similar problems: there are changes during testing and the release of new system builds. Whether in development or maintenance, changes to evolving systems must be made consistently; that is, without damaging correct computations. It is difficult for the programmer to ascertain the complete effect of a code change; the programmer may make a change to a program that is syntactically and semantically legal, but which has ripples into the parts of the program that were intended to remain unchanged. Using the standard denotational semantics for procedural programming languages, this paper formalizes decomposition slicing, which identifies interferences between software components and isolates the components to be changed. We enumerate the conditions for changing one component in ways that will guarantee that changes to it will not interact inconsistently and prove that changes made under these conditions are sound. Thus, the programmer can then execute changes secure in the knowledge that the semantics of the new system are guaranteed to be consistent with the projection of the semantics of the original for which it behaved correctly. Validating that the changes do not interfere not only guarantees consistency with respect to previous unchanging behaviors, but can also be achieved with a complexity proportional to the size of the change to be made. Copyright © 2003 John Wiley & Sons, Ltd. [source]