Programming Language System Research Articles

Static stages for heterogeneous programming

Heterogeneous hardware is central to modern advances in performance and efficiency. Mainstream programming models for heterogeneous architectures, however, sacrifice safety and expressiveness in favor of low-level control over performance details. The interfaces between hardware units consist of verbose, unsafe APIs; hardware-specific languages make it difficult to move code between units; and brittle preprocessor macros complicate the task of specializing general code for efficient accelerated execution. We propose a unified low-level programming model for heterogeneous systems that offers control over performance, safe communication constructs, cross-device code portability, and hygienic metaprogramming for specialization. The language extends constructs from multi-stage programming to separate code for different hardware units, to communicate between them, and to express compile-time code optimization. We introduce static staging, a different take on multi-stage programming that lets the compiler generate all code and communication constructs ahead of time. To demonstrate our approach, we use static staging to implement BraidGL, a real-time graphics programming language for CPU-GPU systems. Current real-time graphics software in OpenGL uses stringly-typed APIs for communication and unsafe preprocessing to generate specialized GPU code variants. In BraidGL, programmers instead write hybrid CPU-GPU software in a unified language. The compiler statically generates target-specific code and guarantees safe communication between the CPU and the graphics pipeline stages. Example scenes demonstrate the language's productivity advantages: BraidGL eliminates the safety and expressiveness pitfalls of OpenGL and makes common specialization techniques easy to apply. The case study demonstrates how static staging can express core placement and specialization in general heterogeneous programming.

Josephson Effect in the Micron and Submicron YBCO Constrictions Fabricated Using the Femtosecond Laser Technique

A femtosecond laser was used successfully to fabricate planar micron and submicron-sized constrictiontype Josephson junctions on YBa2Cu3O7−x thin films. A simple program using G-code (control systems) programming language was written to control the movement of the sample stage during the etching process. The constriction’s geometry was investigated using both atomic force microscopy (AFM) and scanning electron microscopy (SEM). Electrical transport measurements were performed at different temperatures. Shapiro steps were observed and analyzed. The micron-sized constriction shows a linear relationship for the measured critical current against the temperature which is consistent with the behavior of an S–s’–Stype Josephson junction where “S” stands for a bulk superconductive material that is untouched by the laser and “s”’ is superconducting material whose critical temperature is lower than the value of “S” In the case of the narrower submicronsized constriction, the measured critical current dependence with temperature shows an exponential decay, which is consistent with the behavior of the long S–N–Stype Josephson junction where “N” stands for a normal material. A model is proposed to describe the observed behavior by considering the effect of sample heating during the constriction’s fabrication.

System Programming in Rust

Rust is a new system programming language that offers a practical and safe alternative to C. Rust is unique in that it enforces safety without runtime overhead, most importantly, without the overhead of garbage collection. While zero-cost safety is remarkable on its own, we argue that the superpowers of Rust go beyond safety. In particular, Rust's linear type system enables capabilities that cannot be implemented efficiently in traditional languages, both safe and unsafe, and that dramatically improve security and reliability of system software. We show three examples of such capabilities: zero-copy software fault isolation, efficient static information flow analysis, and automatic checkpointing. While these capabilities have been in the spotlight of systems research for a long time, their practical use is hindered by high cost and complexity. We argue that with the adoption of Rust these mechanisms will become commoditized.

UVM-powered hardware/software co-verification

In traditional verification environment, hardware and software involve isolated design and verification. Due to the demise of Moore's law, the processor's frequency is no longer increasing. This demise of Moore's law and time-to-market pressures drive the wave of new technology where hardware and software are tightly integrated. This is done in order to increase the speed of computation. Moreover, in domains like Data Analytics, data has to be processed in real time and that too at low latency. Solarflare's Application On-load Engine (AOE) represents a platform where an FPGA processing engine integrates with a low latency server for applications that require real time and low latency of data processing. This is where co-verification provides a solution for integration of hardware and software. Universal Verification Methodology (UVM) doesn't support co-verification and uses Direct Programming Interface (DPI) for co-simulation. Vlang, which is built on the top of D, a systems programming language, has complete implementation of UVM version 1.2. In co-verification, emulation of software is run along with the hardware verification where, software is emulated separately on Instruction Set Simulator (ISS).

MathPartner computer algebra

In this paper, we describe general characteristics of the MathPartner computer algebra system (CAS) and Mathpar programming language thereof. MathPartner can be used for scientific and engineering calculations, as well as in high schools and universities. It allows one to carry out both simple calculations (acting as a scientific calculator) and complex calculations with large-scale mathematical objects. Mathpar is a procedural language; it supports a large number of elementary and special functions, as well as matrix and polynomial operators. This service allows one to build function images and animate them. MathPartner also makes it possible to solve some symbolic computation problems on supercomputers with distributed memory. We highlight main differences of MathPartner from other CASs and describe the Mathpar language along with the user service provided.

Solving computational tasks on finite topologies by means of relation algebra and the RelView tool

We present a relation-algebraic approach to solve computational tasks concerning finite topologies. It is based on the modeling of finite topologies via relations and the specification of the notions in question by relation-algebraic expressions and formulae. The latter then are evaluated with the help of the BDD-based specific purpose computer algebra system RelView after a simple translation into the system's programming language. We apply the technique to different problems and show how the solutions behave with regard to running time if implemented and evaluated by RelView. Experiments with RelView led to a new result on minimal subbases for finite topologies, that is proved at the end of the paper.

Femtosecond-laser fabrication of micron and sub-micron sized S-shaped constrictions on high T c superconducting YBa2Cu3O7−x thin films: ablation and lithography issues

We demonstrate the fabrication of micron and sub-micron sized constrictions on high $${T}_{c}$$ superconducting YBa2Cu3O7−x (YBCO) thin films using the femtosecond laser. The lithography process was optimized by programming the movement of the translation stage during etching with G-code (a control systems programming language), controlling the power incident on the sample to a certain degree and by bringing the laser ablation spots close to one another without clipping the constriction. S-shaped constrictions of micron and sub-micron size (smallest being ~858 nm) have been fabricated to be used as the constriction type Josephson junctions. The constrictions made have a variable width, with the width measured at the narrowest point.

Specifying and verifying contract-driven service compositions using commitments and model checking

The paper proposes a novel model checking-based approach towards verifying the compliance of intelligent agent-based web services with contracts regulating their compositions specified in the Business Process Execution Language (BPEL). Unlike the existing approaches in the literature, the main contribution and impact of the introduced approach is the ability to verify intelligent and autonomous composite web services by capturing and describing in details both compliance and violation behaviors, how the system can distinguish between them, and how the system reacts and can be recovered after each violation. The approach encompasses three contributing parts, namely: 1) the marking process of an extended BPEL; 2) the transformation of the extended and marked BPEL to an automata model; and 3) the encoding of the resulting automata model into the Interpreted Systems Programming Language (ISPL), the input language of the MCMAS model checker for intelligent and autonomous multi-agent systems. In the first part, we extend BPEL that specifies the business process of the composition by creating custom activities called labels. We use those labels as means to represent the specifications and mark the points the developer aims to verify. A significant advantage of this labeling is the ability to highlight specific points in the design to be verified and to distinguish compliance behaviors from violations, which makes this verification focused and highly efficient. In the second part, we introduce new transformation rules to transform the extended and marked BPEL to an automata model. This transformation requires a prior modeling of agent-based web services composition using automata definitions. In the third part, we introduce algorithmic translation rules encoding the resulting automata model into ISPL. This translation makes model checking the behavior of our contract-driven compositions possible. A novel characteristic of the proposed approach is the automatic generation of the properties against which the system is verified from the composition’s implementation, which is technically challenging. The verification properties are expressed in the Computation Tree Logic of Commitments (CTLC). Technically, CTLC provides a powerful representation to formally model 1) interactions among multi-agent based web services and 2) compliance and violation behaviors within composite business contracts by making use of communicative commitment operators. CTLC also includes a fulfillment operator which helps formally check the compliance with business contracts and specify the system recovery. A detailed case study from expert and intelligent systems domain along with experimental results are also reported in the paper. Finally, the main impact and significance of the paper on expert and intelligent systems is the ability to use these systems safely since there is a way to verify if the intelligent components behave according to and in compliance with the underlying regulating contracts.

PERANCANGAN APLIKASI MONITORING MANAJEMEN PERPUSTAKAAN PADA SEKOLAH TINGGI ILMU KESEHATAN (STIKES) MAHARATU

Libraries as information providers will have a good performance when supported by adequate management. It is necessary for the management of libraries based on the theory and principles of management. During this time STIKES Library Maharatu have difficulty managing the management and display information about the library quickly, precisely and accurately. because of the poor way of working and the old system is still manual. This will decrease the impact of traffic and bad service. For that created a Monitoring Application Design Library Management STIKES Maharatu using Method System Development Life Cycle (SDLC). For easy reference librarians to produce information on which to base decision-making by the leadership for the progress of the library. Besides, the level of security and data storage will be more secure. By applying the system programming language PHP and uses a MySQL database to produce output tables and graphs collection of books (the year of purchase), services (loans, repayment, visits), and members of the library.

Proceedings of the Workshop on Continuations

The notion of continuation is ubiquitous in many different areas of computer science, including systems programming, programming languages, algorithmics, semantics, logic, and constructive mathematics. In fact the concept of continuation nicely realizes sophisticated control mechanisms, which are widely used in a variety of applications. Since we cannot escape control features, it becomes a challenge to provide them with sound reasoning principles. Indeed there is much research activity on understanding, representing, and reasoning about elaborated non-local control structures, in particular in declarative programming languages such as functional and logic languages. The proceedings of the Workshop on Continuations 2015, held in London in April 2015, illustrate some of the afore mentioned topics and hopefully they will inspire further research work on the subject.

A differential approach to undefined behavior detection

This article studies undefined behavior arising in systems programming languages such as C/Cpp. Undefined behavior bugs lead to unpredictable and subtle systems behavior, and their effects can be further amplified by compiler optimizations. Undefined behavior bugs are present in many systems, including the Linux kernel and the Postgres database. The consequences range from incorrect functionality to missing security checks. This article proposes a formal and practical approach that finds undefined behavior bugs by finding “unstable code” in terms of optimizations that leverage undefined behavior. Using this approach, we introduce a new static checker called Stack that precisely identifies undefined behavior bugs. Applying Stack to widely used systems has uncovered 161 new bugs that have been confirmed and fixed by developers.

System Programming Drawbacks

A system programming language usually refers to a programming language used for system programming; such languages are designed for writing system software, which usually requires different development approaches when compared to application software. System software is computer software designed to operate and control the computer hardware, and to provide a platform for running application software. System software includes software categories such as operating systems, utility software, device drivers, compilers, and linkers. In contrast with application languages, system programming languages typically offer more-direct access to the physical hardware of the machine: an archetypical system programming language in this sense was BCPL. System programming languages often lack built in input/output facilities because a system-software project usually develops its own input/output or builds on basic monitor I/O or screen management services facilities. The distinction between languages for system programming and applications programming became blurred with widespread popularity of PL/I, C and Pascal.

A Differential Approach to Undefined Behavior Detection

This article studies undefined behavior arising in systems programming languages such as C/C++. Undefined behavior bugs lead to unpredictable and subtle systems behavior, and their effects can be further amplified by compiler optimizations. Undefined behavior bugs are present in many systems, including the Linux kernel and the Postgres database. The consequences range from incorrect functionality to missing security checks. This article proposes a formal and practical approach that finds undefined behavior bugs by finding “unstable code” in terms of optimizations that leverage undefined behavior. Using this approach, we introduce a new static checker called S tack that precisely identifies undefined behavior bugs. Applying S tack to widely used systems has uncovered 161 new bugs that have been confirmed and fixed by developers.

Adding distribution and fault tolerance to Jason

In this article we describe an extension of the multi-agent system programming language Jason with constructs for distribution and fault tolerance. This extension is completely integrated into Jason in the sense that distributing a Jason multi-agent system does not require the use of another programming language. This contrasts with the standard Java based Jason implementation, which often requires writing Java code in order to distribute Jason-based agent systems. These extensions to Jason are being implemented in eJason, an Erlang-based implementation of Jason.We introduce two different fault tolerance mechanisms that allow fault detection and recovery. A low-level agent monitoring mechanism allows a monitoring agent to detect, and possibly recover, when another agent experiences difficulties such as e.g. hardware failures or due to network partitioning.More novel is the second fault tolerance mechanism, supervision, whereby one agent acts as a supervisor to a second agent. The supervision mechanism is in addition to handling low-level faults such as the above, also capable of detecting higher-level failures such as e.g. “event overload” (an agent is incapable of timely handling all its associated events and plans) and “divergence” (an agent is not completing any iteration of its reasoning cycle). Moreover, mechanisms exist for another agent to inform a supervisor that one of its supervised agents is misbehaving.Although these extensions are inspired by the distribution and fault tolerance mechanisms of Erlang, due to the agent perspective, the details are quite different. For instance, the supervisor mechanism of eJason is much more capable than the supervisor behaviour of Erlang, corresponding to the more abstract/higher-level perspective offered by agent-oriented programming (Jason) compared with process-oriented programming (Erlang).As another example, from the perspective of agent programming we consider it natural to support the flexibility of the supervision trees, i.e. allow the evolution of supervision relations over time. For instance, the supervisor of an agent, as well as the supervision policy maintained for that same agent, may vary as the system evolves.

Optimization Model for Fire Station Location Based on GIS and Python: A Case Study in North Cyprus

In this paper, the location selection process related to fire stations in Famagusta city is enhanced by applying Quantum Geographic Information Systems (QGIS) and Python programming language. This procedure leads to obtaining the optimum emergency service location based on the minimization of response time. This study aims to commence service coverage modeling in a consistent demand region, with road availability considerations. In addition, this study focuses on the capability of GIS to create service areas by means of the travel time regions in a facility location model. Another purpose of this research is to maximize the overall service area of the determined number of facilities and to state the capability of GIS for establishing the suitable service areas of fire stations in Famagusta city so as to achievie a maximal overall service area from a specific fire station facility to other locations. The best location for only one fire station is determined which is placed around the signalized intersection joining Mustafa Kemal Boulevard and Topçular Boulevard in Famagusta (node 230).

A Second Replicated Quantitative Analysis of Fault Distributions in Complex Software Systems

To contribute to the body of empirical research on fault distributions during development of complex software systems, a replication of a study of Fenton and Ohlsson is conducted. The hypotheses from the original study are investigated using data taken from an environment that differs in terms of system size, project duration, and programming language. We have investigated four sets of hypotheses on data from three successive telecommunications projects: 1) the Pareto principle, that is, a small number of modules contain a majority of the faults (in the replication, the Pareto principle is confirmed), 2) fault persistence between test phases (a high fault incidence in function testing is shown to imply the same in system testing, as well as prerelease versus postrelease fault incidence), 3) the relation between number of faults and lines of code (the size relation from the original study could be neither confirmed nor disproved in the replication), and 4) fault density similarities across test phases and projects (in the replication study, fault densities are confirmed to be similar across projects). Through this replication study, we have contributed to what is known on fault distributions, which seem to be stable across environments.

General purpose parallel programing using new generation graphic processors: CPU vs GPU comparative analysis and opportunities research

OpenCL, a modern parallel heterogeneous system programming language, enables problems to be partitioned and executed on modern CPU and GPU hardware, this increases performance of such applications considerably. Since GPU's are optimized for floating point and vector operations and specialize in them, they outperform general purpose CPU's in this field greatly. This language greatly simplifies the creation of applications for such heterogeneous system since it's cross-platform, vendor independent and is embeddable , hence letting it be used in any other general purpose programming language via libraries. There is more and more tools being developed that are aimed at low level programmers and scientists or engineers alike, that are developing applications or libraries for CPU’s and GPU’s of today as well as other heterogeneous platforms. The tendency today is to increase the number of cores or CPU‘s in hopes of increasing performance, however the increasing difficulty of parallelizing applications for such systems and the even increasing overhead of communication and synchronization are limiting the potential performance. This means that there is a point at which increasing cores or CPU‘s will no longer increase applications performance, and even can diminish performance. Even though parallel programming and GPU‘s with stream computing capabilities have decreased the need for communication and synchronization (since only the final result needs to be committed to memory), however this still is a weak link in developing such applications.

The sorting of competing metadata models in digital asset management

This paper broadly covers how UPS set up metadata models (otherwise known as catalogue records) for digital preservation of archival assets in a digital asset management (DAM) system. The resulting models helped the UPS DAM win an award for best ‘Archives, Preservation, and/or Storage Solution’ at the 2010 DAMMY awards. While the standards are clear on the preferred programming language for digital preservation systems, the standards for describing assets in these systems are incredibly diverse. The process UPS used to generate and evolve their own metadata models is outlined, along with solutions to common problems in DAM metadata modelling and collection acquisition. How these models make assets searchable and sustain user interest in the DAM is discussed. When designing metadata models, the UPS DAM team advises working in XML to meet preservation standards, and improvising off the 12 Dublin Core (DCMI) attributes to build custom models that meet the needs of specific user bases.

Description of EduCOM: A graphical modeling and programming language for teaching and learning digital communication systems

AbstractThis paper presents EduCOM, a graphical language for teaching and learning digital communication systems. In EduCOM students build graphical models (i.e., block diagrams) of digital communication transmitters, channels, and receivers. Then EduCOM creates the shell of a C/C++ code realization of the graphical model, but it leaves the implementation of each block empty so that students are required to implement the functionality of the blocks in a low‐level programming language such as C/C++. Therefore, EduCOM goes beyond passive drag–drop‐connect style activities and forces students to think more deeply about each operation performed on the signals in the system, and preliminary assessment results with a small set of students bear this point out. Students indicated that the mixture of graphical modeling and low‐level programming provided by EduCOM is an improvement over pure graphical modeling or pure low‐level programming in helping them learn about communication systems. © 2009 Wiley Periodicals, Inc. Comput Appl Eng Educ 19: 697–707, 2011

Continuation-Passing C, compiling threads to events through continuations

In this paper, we introduce Continuation Passing C (CPC), a programming language for concurrent systems in which native and cooperative threads are unified and presented to the programmer as a single abstraction. The CPC compiler uses a compilation technique, based on the CPS transform, that yields efficient code and an extremely lightweight representation for contexts. We provide a proof of the correctness of our compilation scheme. We show in particular that lambda-lifting, a common compilation technique for functional languages, is also correct in an imperative language like C, under some conditions enforced by the CPC compiler. The current CPC compiler is mature enough to write substantial programs such as Hekate, a highly concurrent BitTorrent seeder. Our benchmark results show that CPC is as efficient, while using significantly less space, as the most efficient thread libraries available.