General-purpose Programming Language Research Articles

I3QL

An incremental computation updates its result based on a change to its input, which is often an order of magnitude faster than a recomputation from scratch. In particular, incrementalization can make expensive computations feasible for settings that require short feedback cycles, such as interactive systems, IDEs, or (soft) real-time systems. This paper presents i3QL, a general-purpose programming language for specifying incremental computations. i3QL provides a declarative SQL-like syntax and is based on incremental versions of operators from relational algebra, enriched with support for general recursion. We integrated i3QL into Scala as a library, which enables programmers to use regular Scala code for non-incremental subcomputations of an i3QL query and to easily integrate incremental computations into larger software projects. To improve performance, i3QL optimizes user-defined queries by applying algebraic laws and partial evaluation. We describe the design and implementation of i3QL and its optimizations, demonstrate its applicability, and evaluate its performance.

AN EVENT DRIVEN SIMULATION FOR ADAPTIVE GENTLE RANDOM EARLY DETECTION (AGRED) ALGORITHM

Simulations are used to find optimum answers for pr oblems in wide areas. Active queue management algorithms such as RED, GRED, typically use simulators like ns2 which is an open source simulator or OPNET, OMNET which are commercial simulators. However, beside the benefits of using simulators like having defined modules, parameters. There are probl ems such as complexity, large integrated components and licensing cost. To have an ideal balance in men tioned benefits and problems and to further complement the repository of simulators, this study presents t he description of a general-purpose programming language based discrete event simulation for active queue ma nagement. This research has focused at developing a discrete event simulator to implement one of active queue management algorithms which is called AGRED. The results showed that the developed simulator has successfully produced the same results with an ave rage deviation of 1.5% as previous simulator in AGRED.

A Discrete Event Framework for OFDMA Relay-Based Cellular Networks

The cooperation of Relay-Based Cellular Network (RBCN) and Orthogonal Frequency-Division Multiple Access (OFDMA) techniques provide rich of promising solutions especially in terms of Radio Resource Management (RRM). However, the main challenge of this cooperation is managing the resources in a dynamic system in the midst of co-channel interference. Allocating of the RRM associated schemes have been developed to overcome these interferences and to operate the relays in a dynamic and opportunistic manner. The deployments of these RRM schemes have enormous matrices of combination analyzing these performances are of vital essence. There are different simulator tools to address these needs such as NS2, OPNet, OMNet++, etc. An effort to enrich these repositories of simulators is to provide a discrete customization of analyzing the main aim of the study. A discrete event simulation for RBCN evaluation using a general-purpose programming language has been solved. The performance analysis orientation is on Signal-to Interference-plus-Noise Ratio (SINR) algorithm with specific focus on the transmission reliability of relays for channel fading in terms of spectral efficiency for downlink of OFDMA relay-based cellular networks. The developed simulator has been extensively tested and has proven to be a valid and substantial simulator.

Code Refinement of Stencil Codes

A straightforward implementation of an algorithm in a general-purpose programming language does usually not deliver peak performance: Compilers often fail to automatically tune the code for certain hardware peculiarities like memory hierarchy or vector execution units. Manually tuning the code is firstly error-prone as well as time-consuming and secondly taints the code by exposing those peculiarities to the implementation. A popular method to avoid these problems is to implement the algorithm in a Domain-Specific Language (DSL). A DSL compiler can then automatically tune the code for the target platform. In this article we show how to embed a DSL for stencil codes in another language. In contrast to prior approaches we only use a single language for this task which offers explicit control over code refinement. This is used to specialize stencils for particular scenarios. Our results show that our specialized programs achieve competitive performance compared to hand-tuned CUDA programs while maintaining a convenient coding experience.

A blueprint for system-level performance modeling of software-intensive embedded systems

Exploration of design alternatives and estimation of their key performance metrics such as latency and energy consumption is essential for making the proper design decisions in the early phases of system development. Often, high-level models of the dynamic behavior of the system are used for the analysis of design alternatives. Our work presents a blueprint for building efficient and re-usable models for this purpose. It builds on the well-known Y-chart pattern in that it gives more structure for the proper modeling of interaction on shared resources that plays a prominent role in software-intensive embedded systems. We show how the blueprint can be used to model a small yet illustrative example system with the Uppaal tool, and with the Java general-purpose programming language, and reflect on their respective strengths and weaknesses. The Java-based approach has resulted in a very flexible and fast discrete-event simulator with many re-usable components. It currently is used by TNO-ESI and Oce-Technologies B.V. for early model-based performance analysis that supports the design process for professional printing systems.

Architectural Design Patterns for Language Parsers

Processing the textual scripts of computer languages is an important field in software development, which has been growing in popularity, recently. It is applied both for general-purpose programming languages and for domain-specific languages. There is a wide range of typical algorithms and patterns that are used to syntactically parse formal languages, each having specific characteristics and implying different software architectures. If we develop parsers at a higher abstraction level, it simplifies the problem domain and facilitates developing more robust software quicker, but there are always some tradeoffs to consider. The main guideline of this paper is abstraction: how to increase it in different patterns, how it helps parser development and what kind of tradeoffs are implied. The presented architectural design patterns are organized in a pattern catalog ordered by their abstraction level. This catalog is intended to assist developers in the industry in designing efficient parser software.

Delite

Developing high-performance software is a difficult task that requires the use of low-level, architecture-specific programming models (e.g., OpenMP for CMPs, CUDA for GPUs, MPI for clusters). It is typically not possible to write a single application that can run efficiently in different environments, leading to multiple versions and increased complexity. Domain-Specific Languages (DSLs) are a promising avenue to enable programmers to use high-level abstractions and still achieve good performance on a variety of hardware. This is possible because DSLs have higher-level semantics and restrictions than general-purpose languages, so DSL compilers can perform higher-level optimization and translation. However, the cost of developing performance-oriented DSLs is a substantial roadblock to their development and adoption. In this article, we present an overview of the Delite compiler framework and the DSLs that have been developed with it. Delite simplifies the process of DSL development by providing common components, like parallel patterns, optimizations, and code generators, that can be reused in DSL implementations. Delite DSLs are embedded in Scala, a general-purpose programming language, but use metaprogramming to construct an Intermediate Representation (IR) of user programs and compile to multiple languages (including C++, CUDA, and OpenCL). DSL programs are automatically parallelized and different parts of the application can run simultaneously on CPUs and GPUs. We present Delite DSLs for machine learning, data querying, graph analysis, and scientific computing and show that they all achieve performance competitive to or exceeding C++ code.

A feature model of actor, agent, functional, object, and procedural programming languages

The number of programming languages is large and steadily increasing. However, little structured information and empirical evidence is available to help software engineers assess the suitability of a language for a particular development project or software architecture.We argue that these shortages are partly due to a lack of high-level, objective programming language feature assessment criteria: existing advice to practitioners is often based on ill-defined notions of ‘paradigms’ [3, p. xiii] and ‘orientation’, while researchers lack a shared common basis for generalisation and synthesis of empirical results.This paper presents a feature model constructed from the programmer's perspective, which can be used to precisely compare general-purpose programming languages in the actor-oriented, agent-oriented, functional, object-oriented, and procedural categories. The feature model is derived from the existing literature on general concepts of programming, and validated with concrete mappings of well-known languages in each of these categories. The model is intended to act as a tool for both practitioners and researchers, to facilitate both further high-level comparative studies of programming languages, and detailed investigations of feature usage and efficacy in specific development contexts.

Beyond parallel programming with domain specific languages

Today, almost all computer architectures are parallel and heterogeneous; a combination of multiple CPUs, GPUs and specialized processors. This creates a challenging problem for application developers who want to develop high performance programs without the effort required to use low-level, architecture specific parallel programming models (e.g. OpenMP for CMPs, CUDA for GPUs, MPI for clusters). Domain-specific languages (DSLs) are a promising solution to this problem because they can provide an avenue for high-level application-specific abstractions with implicit parallelism to be mapped directly to low level architecture-specific programming models; providing both high programmer productivity and high execution performance. In this talk I will describe an approach to building high performance DSLs, which is based on DSL embedding in a general purpose programming language, metaprogramming and a DSL infrastructure called Delite. I will describe how we transform DSL programs into efficient first-order low-level code using domain specific optimization, parallelism and locality optimization with parallel patterns, and architecture-specific code generation. All optimizations and transformations are implemented in Delite: an extensible DSL compiler infrastucture that significantly reduces the effort required to develop new DSLs. Delite DSLs for machine learning, data querying, graph analysis, and scientific computing all achieve performance competitive with manually parallelized C++ code.

Input and Output Application Programming Interface for Plaid Standard Library

Object oriented (OO) is the most accepted object modeling languages nowadays. Although OO languages are successful in modeling real world entities, nevertheless, there is little to no support for modeling state of object precisely in code. To overcome this problem, a new general purpose programming language is proposed that is built on two paradigms which are typestate-oriented and permission-based. One of the most vital factor for every language to be accepted and effective for users is having an enhanced standard library and clearly one of the most important parts is Input and Output (I/O) Application Programming Interface (API). One of a new programming language is Plaid language. Since the Plaid is at its early stage of development, I/O features provided by the Plaid standard library are very basic and limited. This paper presents I/O API that we have developed for the Plaid based on the features provided by Java I/O API. For the evaluation we used two metrics which are the number of features provided by I/O API, and the number of exceptions eliminated by using Plaid and typestate-oriented programming language.

Probabilistic relational verification for cryptographic implementations

Relational program logics have been used for mechanizing formal proofs of various cryptographic constructions. With an eye towards scaling these successes towards end-to-end security proofs for implementations of distributed systems, we present RF*, a relational extension of F*, a general-purpose higher-order stateful programming language with a verification system based on refinement types. The distinguishing feature of F* is a relational Hoare logic for a higher-order, stateful, probabilistic language. Through careful language design, we adapt the F* typechecker to generate both classic and relational verification conditions, and to automatically discharge their proofs using an SMT solver. Thus, we are able to benefit from the existing features of F*, including its abstraction facilities for modular reasoning about program fragments. We evaluate RF* experimentally by programming a series of cryptographic constructions and protocols, and by verifying their security properties, ranging from information flow to unlinkability, integrity, and privacy. Moreover, we validate the design of RF* by formalizing in Coq a core probabilistic λ calculus and a relational refinement type system and proving the soundness of the latter against a denotational semantics of the probabilistic lambda λ calculus.

IDE Support of String-Embedded Languages

Complex information systems are often implemented by using more than one programming language. Sometimes this variety takes a form of one host and one or few string-embedded languages. Textual representation of clauses in a string-embedded language is built at run time by a host program and then analyzed, compiled or interpreted by a dedicated runtime component (database, web browser etc.) Most general-purpose programming languages may play the role of the host; one of the most evident examples of the string-embedded language is the dynamic SQL which was specified in ISO SQL standard and is supported by the majority of DBMS. Standard IDE functionality such as code completion or syntax highlighting can really helps the developers who use this technique. There are several tools providing this functionality, but they all process only one concrete string-embedded language and cannot be easily extended for supporting another language. We present a platform which allows to easily create tools for string-embedded language processing.

Stochastic simulation of assembly line for optimal sequence using Petri Nets (PN)

The assembly of any product or machine is highly complex. The order of sequence affects the make span time of assembly and thus the throughput. Which part should come in what order and what tasks will be performed together, how many work stations are required etc. are very crucial in obtaining the optimal line. The number of work stations, what task constitute the work station, which precede and what is in succession will affect the time to accomplish the task and also the utilization of resources i.e. manpower and machines both. There may be many solutions available to assembly line but it has to be validated. It is therefore argued to simulate the proposed solutions. The solution based on average data will not represent the actual plant performance. It is inevitable to have a promising technique to arrive at pragmatic result and brings down the assumptions to minimal. The stochastic nature of setup times, no operation times will affect the performance of the plant. The stochastic task timings are being used to represent real conditions and compare the performance of different alternative sequences of assembly. The assembly of finished product is the outcome of work break down (WBD), their sequence of assembly based on multiple precedence relationships. It is a highly challenging job for engineers to find the optimal sequence so that the utilization of machines and throughput are maintained high. The possible sequences of assemblies are tested and the sequence that yields maximum output must be selected. Hence one has to find the solution based on dynamic conditions. This paper is an attempt to first get solution using optimization techniques using linear programming problem (LPP) or heuristics. Then simulate those sets on Petri Nets. The Petri Net is an interactive, simple and yet very powerful technique to represent the problem graphically and coding the same using general purpose programming language for validating the same for intended result. Real time patterns using best fit, statistical interferences, probability density functions (pdf), discrete distributed systems(DDS), or stochastic modeling can be used to simulate problem to measure performance of assembly line.

Recursive numerical recipes for the high efficient inversion of the confluent Vandermonde matrices

In the article, we propose a recursive algorithm for calculating the inversion of the confluent Vandermonde matrix. Besides, contrary to other works in this field, the article derives an explicit analytic formula for the calculation of the inverse of the confluent Vandermonde matrix. The results of this article do not require any symbolic calculations and therefore can be performed by a numerical algorithm implemented in any general-purpose programming language. Moreover, a ready-to-use C++ full implementation of the recursive algorithm is attached.

Synchronous programming in audio processing

The adequacy of a programming language to a given software project or application domain is often considered a key factor of success in software development and engineering, even though little theoretical or practical information is readily available to help make an informed decision. In this article, we address a particular version of this issue by comparing the adequacy of general-purpose synchronous programming languages to more Domain-Specific Languages (DSLs) in the field of computer music. More precisely, we implemented and tested the same lookup table oscillator example program, one of the most classical algorithms for sound synthesis, using a selection of significant synchronous programming languages, half of which designed as specific music languages—Csound, Pure Data, SuperCollider, ChucK, Faust—and the other half being general synchronous formalisms—Signal, Lustre, Esterel, Lucid Synchrone and C with the OpenMP Stream Extension (Matlab/Octave is used for the initial specification). The advantages of these two approaches are discussed, providing insights to language designers and possibly software developers of both communities regarding programming languages design for the audio domain.

Introduction to the Python programming language

This workshop introduces the Python programming language to the participants. Python is a general-purpose programming language that can be used to teach programming concepts. Participants will lear...

Hardware implementations of software programs based on hierarchical finite state machine models

Advances in microelectronic devices have dissolved the boundary between software and hardware. Faster hardware circuits that enable significantly greater parallelism to be achieved have encouraged recent research efforts into high-performance computation in electronic systems without the direct use of processing cores. Standard multi-core processors undoubtedly introduce a number of constraints, such as pre-defined operand sizes and instruction sets, and limits on concurrency and parallelism. This paper suggests a way to convert methods and functions that are defined in a general-purpose programming language into hardware implementations. Thus, conventional programming techniques such as function hierarchy, recursion, passing arguments and returning values can be entirely implemented in hardware modules that execute within a hierarchical finite state machine with extended capabilities. The resulting circuits have been found to be faster than their software alternatives and this conclusion is confirmed by numerous experiments in a variety of application areas.

Resource management policies for real-time Java remote invocations

A way to deal with the increasing cost of next generation real-time applications is to extend middleware and high-level general-purpose programming languages, e.g. Java, with real-time support that reduces development, deployment, and maintenance costs. In the particular path towards a distributed real-time Java technology, some important steps have been given into centralized systems to produce real-time Java virtual machines. However, the integration with traditional remote invocation communication paradigms is far from producing an operative solution that may be used to develop final products. In this context, the paper studies how The Real-Time Specification for Java (RTSJ), the leading effort in real-time Java, may be integrated with Java’s Remote Method Invocation (RMI) in order to support real-time remote invocations. The article details a specific approach towards the problem of producing a predictable mechanism for the remote invocation–the core communication mechanism of RMI–via having control on the policies used in the remote invocation. Results obtained in a software prototype help understand how the key entities defined to control the performance of the remote invocation influence in the end-to-end response time of a distributed real-time Java application.

DESIGN AND IMPLEMENTATION OF AN EDITOR/INTERPRETER FOR A VISUAL LOGIC PROGRAMMING LANGUAGE

The design and implementation of a programming environment including an editor, a debugger and an interpreter engine for Lograph, a general-purpose visual logic programming language, is discussed. The rationale for user-interface design decisions is presented, the goal of which is to increase cognitive support for the creation, exploration and debugging of Lograph programs. The design of the interpreter engine allows for animation of execution in the debugger. The engine takes full advantage of an efficient implementation of Prolog, and operates on a Prolog translation of Lograph programs and queries. The translated Lograph programs are probed with instrumentation code at appropriate places so that applications of Lograph rules are reported to the visual interface of the Lograph debugger as a side effect of the execution of a program.

Testbricks: software framework for IEEE standard 1641 test programs

A test program compliant with the Signal and Test Definition (STD) IEEE Std 1641 has two parts: definition of the signals and programming. The standard does not define a programming language for the programmatic part, and any commercial off-the-shelf (COTS) programming language that fulfils annex G requirements can be used. This protects the standard against obsolescence, but it has a drawback because there is no COTS programming language for the specific domain of STD test programs. Previous works have explored several options to add STD signals to general purpose programming languages but these techniques add complexity and decrease productivity compared to a domain specific solution. Testbricks is the result of several years of investigation to create a software framework to allow an easy and straightforward development of STD test programs. This paper discusses the framework requirements, explains the key design features, and describes the framework architecture.