A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Pearl)

Idris' Effects library demonstrates how to embed resource dependent algebraic effect handlers into a dependently typed host language, providing run-time and compile-time based reasoning on type-level resources. Building upon this work, Resources is a framework for realising Embedded Domain Specific Languages (EDSLs) with type systems that contain domain specific substructural properties. Differing from Effects, Resources allows a language’s substructural properties to be encoded within type-level resources that are associated with language variables. Such an association allows for multiple effect instances to be reasoned about autonomically and without explicit type-level declaration. Type-level predicates are used as proof that the language’s substructural properties hold. Several exemplar EDSLs are presented that illustrates our framework’s operation and how dependent types provide correctness-by-construction guarantees that substructural properties of written programs hold

Defensive Points-To Analysis: Effective Soundness via Laziness

We present a defensive may-point-to analysis approach, which offers soundness even in the presence of arbitrary opaque code: all non-empty points-to sets computed are guaranteed to be over-approximations of the sets of values arising at run time. A key design tenet of the analysis is laziness: the analysis computes points-to relationships only for variables or objects that are guaranteed to never escape into opaque code. This means that the analysis misses some valid inferences, yet it also never wastes work to compute sets of values that are not "complete", i.e., that may be missing elements due to opaque code. Laziness enables great efficiency, allowing a highly precise points-to analysis (such as a 5-call-site-sensitive, flow-sensitive analysis). Despite its conservative nature, our analysis yields sound, actionable results for a large subset of the program code, achieving (under worst-case assumptions) 34-74% of the program coverage of an unsound state-of-the-art analysis for real-world programs

RML: Runtime Monitoring Language

Runtime verification is a relatively new software verification technique that aims to prove the correctness of a specific run of a program, rather than statically verify the code. The program is instrumented in order to collect all the relevant information, and the resulting trace of events is inspected by a monitor that verifies its compliance with respect to a specification of the expected properties of the system under scrutiny. Many languages exist that can be used to formally express the expected behavior of a system, with different design choices and degrees of expressivity. This thesis presents RML, a specification language designed for runtime verification, with the goal of being completely modular and independent from the instrumentation and the kind of system being monitored. RML is highly expressive, and allows one to express complex, parametric, non-context-free properties concisely. RML is compiled down to TC, a lower level calculus, which is fully formalized with a deterministic, rewriting-based semantics. In order to evaluate the approach, an open source implementation has been developed, and several examples with Node.js programs have been tested. Benchmarks show the ability of the monitors automatically generated from RML specifications to effectively and efficiently verify complex properties

The Role of Variable in Programming: Examples and Methodology

One of the hardest notions to define in programming is the variable and the related command of assignment. In our opinion, it is exactly these difficulties that are responsible for the reluctance towards programming. The reason for this, according to us and others [7], is the multifunctional nature of the variable: it can be used for various purposes. Its concept “in our heads” and in the programming languages is markedly different in this respect

Managing software evolution through midleware and policy-based software adaptation framework

Software evolution is a process that is needed in order for software to remain useful. Thus, software evolution should be properly planned and controlled to prevent its negative impact from affecting any organization. Software adaptation concept is one of the promising ways to control software evolution. In this approach, software is made adaptable to minimize the impact of change. A lot of researches on software adaptation focus on adaptability of mobile based and network application due to its context sensitivity and quality-of-service requirements. However, there is still lack of work in enterprise system domain with multiple delivery channels, which focus on adaptability of its context environment such as the changes introduced to its devices. Hence, the purpose of this research is to develop a middleware and policy-based, adaptation framework to manage negative effects of software evolution in an enterprise system. The main research focus is on the changes introduced at the device layer. The concept of policy is used to specify adaptations requirements. This research provides a framework called Middleware and Policy-Based Framework to Manage Software Evolution (MiPAF), which can be used to develop adaptive software, allowing parameterized and compositional adaptation. Furthermore, the framework can be used by client-server and web-based application. A policy language called MiPAF Policy Language (MPL) is created to be used with the framework. MiPAF is formally specified using Z Notation and the policy language is described using pseudo code. A tool is provided to assist developers in creating the policy. For evaluation of the framework, a set of runtime components were developed and implemented for Unit Trust System (UTS) Front-end and web-based UTS, two industrial-based case studies. The evaluation result shows that MiPAF excellently fulfil all the evaluation criteria described in this thesis

Abstraction over non-local object information in aspect-oriented programming using path expression pointcuts

Aspect-oriented software development (AOSD) consists of a number of technologies that promise a better level of modularization of concerns that cannot be separated in individual modules by using conventional techniques. Aspect-oriented programming (AOP) is one of these technologies. It allows the modularization at the level of software application code. It provides programmers with means to quantify over specific points in the base application code, called join points, at which the crosscutting concern code must be triggered. The quantification is achieved by special selection constructs called pointcuts, while the triggered code that is responsible for adapting the selected join point is provided by special construct called advice. The selection and adaptation mechanisms in aspect-oriented programming depend heavily on the distinguishing properties of the join points. These properties can either be derived from the local execution context at the join point or they are considered to be non-local to the join point. Aspect-oriented systems provide a plenty of pointcut constructs that support accessing the local join point properties, while they rarely support the non-local properties. A large research effort has been achieved to extend current aspectoriented systems in order to solve the problem of non-locality. However, none of these proposals support the non-local object relationships. There are many situations where a good abstraction over nonlocal object information is needed, otherwise, the developers will be obliged to provide complex and error-prone workarounds inside advice body that conceptually do not reflect the semantics of join point selection and mix it with the semantics of join point daptation. Such recurrent situations occur when trying to modularize the object persistence concern. Object persistence, the process of storing and retrieving objects to and from the datastore, is a classical example of crosscutting concern. Orthogonal object persistence meets the obliviousness property of AOP: The base code should not be prepared upfront for persistence. This thesis addresses the shortcomings in current aspect-oriented persistence systems. It shows that the reason for such shortcomings is due to the lack of supporting non-local object information by the used aspect-oriented languages. To overcome this problem, this thesis proposes a new extension to the current pointcut languages called path expression pointcuts that operate on object graphs and make relevant object information available to the aspects. As an explicit and complete construct, a formal semantics and type system have provided. Moreover, an implementation of path expression pointcuts is discussed in the thesis along with its usage to show how the aforementioned problems are resolved