General-purpose Programming Language Research Articles

Run-time environment for the SARL agent-programming language: the example of the Janus platform

SARL is a general-purpose agent-oriented programming language. This language aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralization, reactivity, autonomy and dynamic reconfiguration that are usually considered as essential for implementing agent-based applications. Every programming language specifies an execution model. For SARL, this run-time model is supported by a SARL run-time environment. The goals of this paper are to highlight the key principles for creating a SARL run-time environment, and its concrete implementation into the Janus agent platform.

Chromar, a language of parameterised agents

Modelling in biology becomes necessary when systems are complex. However, the more complex the systems are, the harder models become to read and write. The most common ways of writing models are by writing reactions on species (discrete objects), or by writing rate equations for the populations of such species. One problem with such approaches is that the number of species is often so large that the model cannot be realistically enumerated. Another problem is that the number of species and reactions often fixed by default, whereas new variations of species and reactions are constantly being improvised by evolution in the long-term and moment to moment by the changing chemical environments and compartments living organisms inhabit and create within.Here we develop a modelling language Chromar that provides an extension to the representation of reactions, in which objects, called agents, carry attributes with associated types — for example, Leaf agents all have a mass attribute. Dynamics are given by stochastic rules defined on groups of agents — for example all agents of a specific type — and so enumerating the dynamics of each agent is not necessary. This compact representation addresses the first problem. Having a more compact representation can also help make models a tool for knowledge representation and exchange instead of just simulation. Further, if we think of agents as the analogue of species in reactions, then creating a new agent of some type effectively creates a new species, thereby addressing the second problem.We then develop an extension of Chromar equipped with deterministically changing time-dependent values (fluents) and aggregate values computed from the state of the system (observables). Fluents are useful for describing the context of the system, which is rarely static; observables are useful in abstracting away details of system behaviour and providing a way to observe the system during simulation.Finally, we develop an embedding of Chromar (and its extensions) in the programming language Haskell and demonstrate its applicability via two examples. Embedding Chromar in a general purpose programming language such as Haskell eases some of the constraints of modelling languages while still maintaining the naturalness of a domain-specific language.

Exploration of modularity and reusability of domain-specific languages: an expression DSL in MetaMod

Language-oriented programming (LOP) advocates a way of creating software systems that starts from the development of a domain-specific language (DSL). The DSL is geared towards solving computational problems in a particular domain. Developers then use the DSL to express configurations, rules, algorithms or knowledge for this particular domain at higher levels of abstraction than those achievable with a general-purpose programming language. Achieving the vision of LOP requires methods to ease the creation and the reuse of DSLs. One of the most likely technologies to achieve the vision of LOP are the projectional language workbenches because of the flexibility they add in DSL notation and DSL modularity. Modularity, in particular, is a key factor in easing the creation and reuse of DSLs. We have previously designed a new method and associated meta-tools, called MetaMod, for the creation of modular and reusable DSLs. The goal in this article is to demonstrate what the advantages of MetaMod are in terms of creating modular and reusable DSLs compared to the state-of-the-art projectional language workbench Jetbrains MPS. To this end, we took a comprehensive expression language, the iets3 expression DSL written in Jetbrains MPS, and redefined a fragment of it in MetaMod; we use part of this reimplemented expression language as a running example in the article. This allowed us to make a better comparison with creating DSLs in MPS. Moreover, in the process, we also highlighted the main features of MetaMod concerning modularity and reuse. As a result of the comparison we underline the main advantage that MetaMod brings in the implementation of modular and reusable DSLs, that is, the possibility to create smaller, more conceptually cohesive DSLs. This makes DSLs more fit for reuse. Furthermore, we present an extensive overview of related work regarding features of language tools for creating modular and reusable DSLs.

Web technology in automated information and modeling systems for metallurgical processes

The software in information systems used by engineering personnel at metallurgical enterprises is considered. Such software operates automated workstations, support systems for decision making, information and modeling systems, expert systems, and so on. Typically, the software takes the form of desktop applications written in high-level programming languages (Visual C#, Visual Basic, etc.). The analysis of technological information from the enterprise’s database-management server entails the solution of programming problems, systems of differential equations, and mathematical-physics problems, for example. Such problems are unsolvable by the standard general-purpose programming languages. Therefore, the development of information and modeling systems requires access to outside software, such as Microsoft Excel and MATLAB. Interaction with Microsoft Excel depends on COM Interop technology, which requires the installation of Microsoft Office on each client computer. Interaction with MATLAB requires the preliminary assembly of a library in MATLAB Compiler and its connection to the program. MATLAB Runtime freeware must be installed on the client computer. However, desktop applications using Windows Forms do not meet the requirements of industrial information systems in terms of functionality, accessibility, and cross-platform compatibility. Accordingly, new technologies must be found for the creation of information systems. The best approach is the construction of web applications based on the ASP.NET MVC framework, which permits the transfer of mathematical libraries and modules for interaction with Microsoft Excel and MATLAB from Windows Forms, without modification. The structure of the web application employed in the development of information-system software is described. The web page employed has the following functional regions: the logo and title of the current page, the session-status menu, the function menu, group operations, notifications, and the working area.

A Discrete Event Simulation for Hierarchical Mobile IPv6

In recent years’ simulators like the open source tool ns-2, and commercial software’s like OPNET have included Mobile IPv6 extensions in order to provide analysis for advanced Mobile IPv6 system development. Although these simulators are among the significant simulators, however, they have a tendency to be specific to hardware, vast integrated components, complex and the need of licensing cost for commercial simulators. To strike an ideal balance in gauging these tradeoffs and to further complement the repository of simulators, this study deliberates the details of a general-purpose programming language based Discrete Event Simulation for Hierarchical Mobile IPv6. This paper has incorporated a call admission control algorithm as an example to validate the simulator for Hierarchical Mobile IPv6. A Fuzzy Inference System based call admission control has been used as a benchmark deployment algorithm. The base model has been extensively analyzed and the set of parameters (simulation and non-simulation parameters), events, performance metrics and other fundamental elements has been derived. The Fuzzy Inference based call admission control is studied and evaluated against the benchmark model. The results demonstrate that the developed discrete event simulator has effectively produced the benchmark results and verified that the new simulator has effectively become a dependable selection for Hierarchical Mobile IPv6 performance analysis.

Dependent Types for Multi-Rate Flows in Synchronous Programming

Synchronous programming languages emerged in the 1980s as tools for implementing reactive systems, which interact with events from physical environments and often must do so under strict timing constraints. In this report, we encode inside ATS various real-time primitives in an experimental synchronous language called Prelude, where ATS is a statically typed language with an ML-like functional core that supports both dependent types (of DML-style) and linear types. We show that the verification requirements imposed on these primitives can be formally expressed in terms of dependent types in ATS. Moreover, we modify the Prelude compiler to automatically generate ATS code from Prelude source. This modified compiler allows us to solely rely on typechecking in ATS to discharge proof obligations originating from the need to typecheck Prelude code. Whereas ATS is typically used as a general purpose programming language, we hereby demonstrate that it can also be conveniently used to support some forms of advanced static checking in languages equipped with less expressive types.

Using internal domain-specific languages to inherit tool support and modularity for model transformations

Model-driven engineering (MDE) has proved to be a useful approach to cope with today’s ever-growing complexity in the development of software systems; nevertheless, it is not widely applied in industry. As suggested by multiple studies, tool support is a major factor for this lack of adoption. In particular, the development of model transformations lacks good tool support. Additionally, modularization techniques are inevitable for the development of larger model transformations to keep them maintainable. Existing tools for MDE, in particular model transformation approaches, are often developed by small teams and cannot keep up with advanced tool support for mainstream general-purpose programming languages, such as IntelliJ or Visual Studio. Internal DSLs are a promising solution to these problems. In this paper, we investigate the impact of design decisions of an internal DSL to the reuse of tool support and modularization concepts from the host language. We validate our findings in terms of understandability, applicability, tool support, and extensibility using three case studies from academia, a model-driven engineering platform, and the industrial automation domain where we apply an implementation of an internal model transformation language on the .NET platform. The results confirm the value of inherited modularity and tool support while conciseness and understandability are still competitive.

Challenging the Myth of Presentation in Digital Editions

Are the data of an edition means to a particular and privileged presentation, or is the presentation a side effect? Because of the changing nature of computer systems, with constant progression in hardware and software, the encoded texts are the most important long-term outcome of the project—the representation of the knowledge— and presentation within a particular application is destined to become obsolete relatively quickly. However, it is most often the presentation output, rather than the source data, which is published and shared. We believe this is largely because there is currently no way of expressing, in the source encoding, aspects of presentation which are seen by editors as a crucial part of their work. Given a framework for encoding processing expectations for a variety of output formats, editors would be much more inclined to share the encoded files as their prime output, and intentions for presentation would be much more likely to survive repeated technology transitions as processing tools develop and change. We believe the collision between the individuality of research and the quest for common tools that aid in the creation of digital editions will be solved not by creating another piece of specialized publishing software but rather by creating a general framework for processing TEI documents and similar, modular solutions for other tasks in the publishing workflow. Such an abstraction layer admittedly still requires some fluency in computer technologies, but far less than for setting up a publication system from scratch in a general-purpose programming language.

Indexed codata types

Indexed data types allow us to specify and verify many interesting invariants about finite data in a general purpose programming language. In this paper we investigate the dual idea: indexed codata types, which allow us to describe data-dependencies about infinite data structures. Unlike finite data which is defined by constructors, we define infinite data by observations. Dual to pattern matching on indexed data which may refine the type indices, we define copattern matching on indexed codata where type indices guard observations we can make. Our key technical contributions are three-fold: first, we extend Levy's call-by-push value language with support for indexed (co)data and deep (co)pattern matching; second, we provide a clean foundation for dependent (co)pattern matching using equality constraints; third, we describe a small-step semantics using a continuation-based abstract machine, define coverage for indexed (co)patterns, and prove type safety. This is an important step towards building a foundation where (co)data type definitions and dependent types can coexist.

Cygrid: A fast Cython-powered convolution-based gridding module for Python

Data gridding is a common task in astronomy and many other science disciplines. It refers to the resampling of irregularly sampled data to a regular grid. We present cygrid, a library module for the general purpose programming language Python. Cygrid can be used to resample data to any collection of target coordinates, although its typical application involves FITS maps or data cubes. The FITS world coordinate system standard is supported. The regridding algorithm is based on the convolution of the original samples with a kernel of arbitrary shape. We introduce a lookup table scheme that allows us to parallelize the gridding and combine it with the HEALPix tessellation of the sphere for fast neighbor searches. We show that for $n$ input data points, cygrids runtime scales between O(n) and O(n log n) and analyze the performance gain that is achieved using multiple CPU cores. We also compare the gridding speed with other techniques, such as nearest-neighbor, and linear and cubic spline interpolation. Cygrid is a very fast and versatile gridding library that significantly outperforms other third-party Python modules, such as the linear and cubic spline interpolation provided by SciPy.

DAE Tools: equation-based object-oriented modelling, simulation and optimisation software

In this work, DAE Tools modelling, simulation and optimisation software, its programming paradigms and main features are presented. The current approaches to mathematical modelling such as the use of modelling languages and general-purpose programming languages are analysed. The common set of capabilities required by the typical simulation software are discussed, and the shortcomings of the current approaches recognised. A new hybrid approach is introduced, and the modelling languages and the hybrid approach are compared in terms of the grammar, compiler, parser and interpreter requirements, maintainability and portability. The most important characteristics of the new approach are discussed, such as: (1) support for the runtime model generation; (2) support for the runtime simulation set-up; (3) support for complex runtime operating procedures; (4) interoperability with the third party software packages (i.e. NumPy/SciPy); (5) suitability for embedding and use as a web application or software as a service; and (6) code-generation, model exchange and co-simulation capabilities. The benefits of an equation-based approach to modelling, implemented in a fourth generation object-oriented general purpose programming language such as Python are discussed. The architecture and the software implementation details as well as the type of problems that can be solved using DAE Tools software are described. Finally, some applications of the software at different levels of abstraction are presented, and its embedding capabilities and suitability for use as a software as a service is demonstrated.

Effect of yerba mate (Ilex paraguariensis) on bone tissue

In the article, we propose an incremental algorithm for calculating the inversion of the confluent Vandermonde matrix and triangular factorization of this inversion. We implemented all the incremental operations, i.e. adding, deleting and changing the single matrix parameter to avoid repeating the same calculations again and again. Besides, contrary to other works in this field, the article derives an explicit analytic formula for the calculation of the triangular factorization of the confluent Vandermonde matrix inversion. Additionally, we propose a solution to these two problems with the use of a system of linear recursive equations. The results of this article do not require any symbolic calculations. Therefore they can be performed by a numerical algorithm implemented in any general-purpose programming language.

Dependent types and multi-monadic effects in F*

We present a new, completely redesigned, version of F*, a language that works both as a proof assistant as well as a general-purpose, verification-oriented, effectful programming language. In support of these complementary roles, F* is a dependently typed, higher-order, call-by-value language with _primitive_ effects including state, exceptions, divergence and IO. Although primitive, programmers choose the granularity at which to specify effects by equipping each effect with a monadic, predicate transformer semantics. F* uses this to efficiently compute weakest preconditions and discharges the resulting proof obligations using a combination of SMT solving and manual proofs. Isolated from the effects, the core of F* is a language of pure functions used to write specifications and proof terms---its consistency is maintained by a semantic termination check based on a well-founded order. We evaluate our design on more than 55,000 lines of F* we have authored in the last year, focusing on three main case studies. Showcasing its use as a general-purpose programming language, F* is programmed (but not verified) in F*, and bootstraps in both OCaml and F#. Our experience confirms F*'s pay-as-you-go cost model: writing idiomatic ML-like code with no finer specifications imposes no user burden. As a verification-oriented language, our most significant evaluation of F* is in verifying several key modules in an implementation of the TLS-1.2 protocol standard. For the modules we considered, we are able to prove more properties, with fewer annotations using F* than in a prior verified implementation of TLS-1.2. Finally, as a proof assistant, we discuss our use of F* in mechanizing the metatheory of a range of lambda calculi, starting from the simply typed lambda calculus to System F-omega and even micro-F*, a sizeable fragment of F* itself---these proofs make essential use of F*'s flexible combination of SMT automation and constructive proofs, enabling a tactic-free style of programming and proving at a relatively large scale.

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

In the article, we propose an incremental algorithm for calculating the inversion of the confluent Vandermonde matrix and triangular factorization of this inversion. We implemented all the incremental operations, i.e. adding, deleting and changing the single matrix parameter to avoid repeating the same calculations again and again. Besides, contrary to other works in this field, the article derives an explicit analytic formula for the calculation of the triangular factorization of the confluent Vandermonde matrix inversion. Additionally, we propose a solution to these two problems with the use of a system of linear recursive equations. The results of this article do not require any symbolic calculations. Therefore they can be performed by a numerical algorithm implemented in any general-purpose programming language.

A contribution on the modular modelling of multibody systems

Over the past half-century, the increasing use of computational tools for mathematical modelling and simulation was responsible for significant advances in the area of Multibody System Dynamics. However, there is still a high dependence on the use of proprietary software in this area. Noticing that most of the complex multibody systems share many components and subsystems, this paper aims to propose a modular modelling methodology in which the starting points are some already known mathematical models of subsystems and the corresponding descriptions of the constraints existing among them. The proposed algorithm is based on the computation of some orthogonal complements of Jacobian matrices, derived from the constraint equations among the subsystems, leading to a minimal system of equations without requiring the use of undetermined multipliers or generalized constraint forces. Such an algorithm can be implemented using general-purpose (eventually open source) software packages or programming languages. Another remarkable advantage of this methodology stems from the fact that even when different (Classical or Analytical Mechanics) formalisms have been used in the modelling of subsystems, it is still possible to use the proposed algorithm. Well-known examples and a rederivation of the Whipple bicycle model are used to illustrate applications of this novel methodology.

Analysis in Brief of History and Difference between C and C++ Programming Languages

C is a powerful system, programming language, and C++ is an excellent general purpose programming language with modern bells and whistles. In this report I intend to first explain the history of C & C++. Secondly, I will discuss in brief the difference between C&C++ in many homes.

Model querying with query models

Model querying is an integral part of Model-Driven Engineering. Developers query models when specifying model transformations, when defining model constraints, or simply when they need to extract some information from the model. Model queries are often specified in a general-purpose programming language, with developers just navigating models through their programming interfaces. OCL is the best known model query language, and while successful, it is difficult to express complex structural properties featured in target model elements. In this paper we describe a model query facility that aims at easing the description of structural features in a query. In our approach, developers model their queries by reusing fragments of the target model to specify the invariant parts of the template, augmented with variables and special relations to specify what can vary. The query itself conforms to a meta-model that extends the meta-model under-query. By reusing the queried meta- model developers can reduce the mental overhead that comes from using a different language to specify the queries. We have developed a proof of concept tool for the Eclipse Modeling Framework (EMF) that (1) generates a query meta-model from a target meta- model, (2) allows the construction of queries using a graphical, graph-based editor and (3) executes the queries by translating them to a set of logic predicates that are then evaluated using an extension of the logic-based query language Ekeko.

Live programming in the LogicBlox system

The emerging category of self-service enterprise applications motivates support for "live programming" in the database, where the user's iterative data exploration triggers changes to installed application code and its output in real time. This paper discusses the technical challenges in supporting live programming in the database and presents the solution implemented in the LogicBlox commercial system. The workhorse architectural component is a "meta-engine" that incrementally maintains metadata representing application code, guides its compilation into an internal representation in the database kernel, and orchestrates maintenance of materialized views based on those changes. Our approach mirrors LogicBlox's declarative programming model and describes the maintenance of application code using declarative meta-rules; the meta-engine is essentially a "bootstrap" version of the database engine proper. Beyond live programming, the meta-engine turns out effective for a range of static analysis and optimization tasks. Outside of the database context, we speculate that our design may even provide a novel means of building incremental compilers for general-purpose programming languages.

A high-level language for rule-based modelling.

Rule-based languages such as Kappa excel in their support for handling the combinatorial complexities prevalent in many biological systems, including signalling pathways. But Kappa provides little structure for organising rules, and large models can therefore be hard to read and maintain. This paper introduces a high-level, modular extension of Kappa called LBS-κ. We demonstrate the constructs of the language through examples and three case studies: a chemotaxis switch ring, a MAPK cascade, and an insulin signalling pathway. We then provide a formal definition of LBS-κ through an abstract syntax and a translation to plain Kappa. The translation is implemented in a compiler tool which is available as a web application. We finally demonstrate how to increase the expressivity of LBS-κ through embedded scripts in a general-purpose programming language, a technique which we view as generally applicable to other domain specific languages.

An interactive SQL relational interface for querying main-memory data structures

Query formalisms and facilities have received significant attention in the past decades resulting in the development of query languages with varying characteristics; many of them resemble sql. Query facilities typically ship as part of database management systems or, sometimes, bundled with programming languages. For applications written in imperative programming languages, database management systems impose an expensive model transformation. In-memory data structures can represent sophisticated relationships in a manner that is efficient in terms of storage and processing overhead, but most general purpose programming languages lack an interpreter and/or an expressive query language for manipulating interactive queries. Issuing interactive ad-hoc queries on program data structures is tough. This work presents a method and an implementation for representing an application's arbitrary imperative programming data model as a queryable relational one. The Pico COllections Query Library (pico ql) uses a domain specific language to define a relational representation of application data structures and an sql interface implementation. Queries are issued interactively and are type safe. We demonstrate our relational representation for objects and the library's usefulness on three large c++ projects. pico ql enhances query expressiveness and boosts productivity compared to querying via traditional programming constructs.