1,676 research outputs found
Formally Specifying and Proving Operational Aspects of Forensic Lucid in Isabelle
A Forensic Lucid intensional programming language has been proposed for
intensional cyberforensic analysis. In large part, the language is based on
various predecessor and codecessor Lucid dialects bound by the higher-order
intensional logic (HOIL) that is behind them. This work formally specifies the
operational aspects of the Forensic Lucid language and compiles a theory of its
constructs using Isabelle, a proof assistant system.Comment: 23 pages, 3 listings, 3 figures, 1 table, 1 Appendix with theorems,
pp. 76--98. TPHOLs 2008 Emerging Trends Proceedings, August 18-21, Montreal,
Canada. Editors: Otmane Ait Mohamed and Cesar Munoz and Sofiene Tahar. The
individual paper's PDF is at
http://users.encs.concordia.ca/~tphols08/TPHOLs2008/ET/76-98.pd
Object-Oriented Intensional Programming: Intensional Classes Using Java and Lucid
This article introduces Object-Oriented Intensional Programming (OO-IP), a
new hybrid language between Object-Oriented and Intensional Programming
Languages in the sense of the latest evolutions of Lucid. This new hybrid
language combines the essential characteristics of Lucid and Java, and
introduces the notion of object streams which makes it is possible that each
element in a Lucid stream to be an object with embedded intensional properties.
Interestingly, this hybrid language also brings to Java objects the power to
explicitly express and manipulate the notion of context, creating the novel
concept of intensional object, i.e. objects whose evaluation is
context-dependent, which are here demonstrated to be translatable into standard
objects. By this new approach, we extend the use and meaning of the notion of
intensional objects and enrich the meaning of object streams in Lucid and
semantics of intensional objects in Java.Comment: 27 pages, 8 listings, 2 tables, 5 figure
Synchronous Modeling of Data Intensive Applications
In this report, we present the first results of a study on the modeling of data-intensive parallel applications following the synchronous approach. More precisely, we consider the Gaspard extension of Array-OL, which is dedicated to System-on-Chip codesign. We define an associated synchronous dataflow equational model that enables to address several design correctness issues (e.g. verification of frequency / latency constraints) using the formal tools and techniques provided by the synchronous technology. We particularly illustrate a synchronizability analysis using affine clock systems. Directions are drawn from these bases towards modeling hierarchical applications, and adding control automata involving verification
Intensional Cyberforensics
This work focuses on the application of intensional logic to cyberforensic
analysis and its benefits and difficulties are compared with the
finite-state-automata approach. This work extends the use of the intensional
programming paradigm to the modeling and implementation of a cyberforensics
investigation process with backtracing of event reconstruction, in which
evidence is modeled by multidimensional hierarchical contexts, and proofs or
disproofs of claims are undertaken in an eductive manner of evaluation. This
approach is a practical, context-aware improvement over the finite state
automata (FSA) approach we have seen in previous work. As a base implementation
language model, we use in this approach a new dialect of the Lucid programming
language, called Forensic Lucid, and we focus on defining hierarchical contexts
based on intensional logic for the distributed evaluation of cyberforensic
expressions. We also augment the work with credibility factors surrounding
digital evidence and witness accounts, which have not been previously modeled.
The Forensic Lucid programming language, used for this intensional
cyberforensic analysis, formally presented through its syntax and operational
semantics. In large part, the language is based on its predecessor and
codecessor Lucid dialects, such as GIPL, Indexical Lucid, Lucx, Objective
Lucid, and JOOIP bound by the underlying intensional programming paradigm.Comment: 412 pages, 94 figures, 18 tables, 19 algorithms and listings; PhD
thesis; v2 corrects some typos and refs; also available on Spectrum at
http://spectrum.library.concordia.ca/977460
Cartesian Programming: The TransLucid Programming Language
The TransLucid programming language is a low-level intensional language, designed to be sufficiently rich for it to be the target language for translating the common programming paradigms into it, while still being fully declarative. The objects manipulated by TransLucid, called hyperdatons, are arbitrary-dimensional infinite arrays, indexed by multidimensional tuples of arbitrary types. We present the syntax, denotational and operational semantics for a simple TransLucid system, consisting of 1) a header detailing how expressions should be parsed, 2) a set of libraries of types, and operations thereon, defined in a host language, 3) a set of TransLucid equations, and 4) a TransLucid demand to be evaluated. The evaluation of a demand for an (identifier, context) pair is undertaken using eduction, where previously computed pairs are stored in a cache called a warehouse. The execution ensures that only those dimensions actually encountered during the execution of an expression are taken into account when caching intermediate results
Using the General Intensional Programming System (GIPSY) for Evaluation of Higher-Order Intensional Logic (HOIL) Expressions
The General Intensional Programming System (GIPSY) has been built around the
Lucid family of intensional programming languages that rely on the higher-order
intensional logic (HOIL) to provide context-oriented multidimensional reasoning
of intensional expressions. HOIL combines functional programming with various
intensional logics to allow explicit context expressions to be evaluated as
first-class values that can be passed as parameters to functions and return as
results with an appropriate set of operators defined on contexts. GIPSY's
frameworks are implemented in Java as a collection of replaceable components
for the compilers of various Lucid dialects and the demand-driven eductive
evaluation engine that can run distributively. GIPSY provides support for
hybrid programming models that couple intensional and imperative languages for
a variety of needs. Explicit context expressions limit the scope of evaluation
of math expressions (effectively a Lucid program is a mathematics or physics
expression constrained by the context) in tensor physics, regular math in
multiple dimensions, etc., and for cyberforensic reasoning as one of the
use-cases of interest. Thus, GIPSY is a support testbed for HOIL-based
languages some of which enable such reasoning, as in formal cyberforensic case
analysis with event reconstruction. In this paper we discuss the GIPSY
architecture, its evaluation engine and example use-cases.Comment: 14 pages; 8 figure
Model Transformations from a Data Parallel Formalism towards Synchronous Languages
The increasing complexity of embedded system designs calls for high-level specification formalisms and for automated transformations towards lower-level descriptions. In this report, a metamodel and a transformation chain are defined from a high-level modeling framework, Gaspard, for data-parallel systems towards a formalism of synchronous equations. These equations are translated in synchronous data-flow languages, such as Lustre, Lucid synchrone and Signal, which provide designers with formal techniques and tools for validation. In order to benefit from the methodological advantages of re-usability and platform-independence, a Model-Driven Engineering approach is applied
OO-IP hybrid language design and a framework approach to the GIPC
Intensional Programming is a declarative programming paradigm in which expressions are evaluated in an inherently multidimensional context space. The Lucid family of programming languages is, to this day, the only programming languages of true intensional nature. Lucid being a functional language, Lucid programs are inherently parallel and their parallelism can be efficiently exploited by the adjunction of a procedural language to increase the granularity of its parallelism, forming hybrid Lucid languages. That very wide array of possibilities raises the need for an extremely flexible programming language investigation platform to investigate on this plethora of possibilities for Intensional Programming. That is the purpose of the General Intensional Programming System (GIPSY), especially, the General Intensional Programming Compiler (GIPC) component. The modularity, reusability and extensibility aspects of the framework approach make it an obvious candidate for the development of the GIPC. The framework presented in this thesis provides a better solution compared to all other techniques used to this day to implement the different variants of intensional programming. Because of the functionality of hybrid programming support in the GIPC framework, a new OO-IP hybrid language is designed for further research. This new hybrid language combines the essential characteristics of IPL and Java, and introduces the notion of object streams which makes it is possible that each element in an IPL stream could be an object with embedded intensional properties. Interestingly, this hybrid language also brings to Java objects the power which can explicitly express context, creating the novel concept of intensional objects, Le. objects whose evaluation is context-dependent, which are therein demonstrated to be translatable into standard objects. By this new feature, we extend the use and meaning of the notion of object and enrich the meaning of stream in IPL and semantics of Java. At the same time, during the procedure to introduce intensional objects and this OO-IP hybrid language, many factors are considered. These factors include how to integrate the new language with the GIPC framework design and the issues related to its integration in the current GIPSY implementation. Current semantic rules show that the new language can work well with the GIPC framework and the GIPSY implementation, which is another proof of the validity of our GIPC framework design. Ultimately, the proposed design is put into implementation in the GIPSY and the implementation put to test using programs from different application domains written in this new OO-IP languag
- …