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

Hailstorm : A Statically-Typed, Purely Functional Language for IoT Applications

With the growing ubiquity of Internet of Things (IoT), more complex logic is being programmed on resource-constrained IoT devices, almost exclusively using the C programming language. While C provides low-level control over memory, it lacks a number of high-level programming abstractions such as higher-order functions, polymorphism, strong static typing, memory safety, and automatic memory management.We present Hailstorm, a statically-typed, purely functional programming language that attempts to address the above problem. It is a high-level programming language with a strict typing discipline. It supports features like higher-order functions, tail-recursion and automatic memory management, to program IoT devices in a declarative manner. Applications running on these devices tend to be heavily dominated by I/O. Hailstorm tracks side effects like I/O in its type system using resource types. This choice allowed us to explore the design of a purely functional standalone language, in an area where it is more common to embed a functional core in an imperative shell. The language borrows the combinators of arrowized FRP, but has discrete-time semantics. The design of the full set of combinators is work in progress, driven by examples. So far, we have evaluated Hailstorm by writing standard examples from the literature (earthquake detection, a railway crossing system and various other clocked systems), and also running examples on the GRiSP embedded systems board, through generation of Erlang

A Context-Aware Architecture for Smart Applications with Enabled Adaptation and Reasoning Capabilities

The term ''smart city'' refers to an instrumented, interconnected, and intelligent city built by leveraging Information and Communication Technologies (ICT). In such a city, a combination of embedded hardware and software involving sensors, actuators, and a host of mobile devices and wearables that are connected to the Internet of Things (IoT) networks will sense data in different contexts and automatically drive desired adaptations through actuators. Through adaptations, city planners, professionals, and researchers aim to optimize resource consumption and cost of providing services while improving the quality of life for the ever increasing urban population. To fully realize this goal, a context-aware and data-centric inference is a necessity. A system is said to be context-aware if it is able to adapt its operations to the current context without explicit user intervention. This thesis proposes a generic context-aware system architecture for development of smart city applications. The proposed architecture puts special emphasis on privacy and security, incorporating mechanisms to protect the system and sensitive information at each layer of the architecture. Furthermore, this architecture integrates with a reasoning component, whose inference engine can be driven by logic or other formalisms. A prototype implementation and a case study done in this thesis indicate the practical merits of the proposed architecture and provide a proof of concept

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, MARFL, and JOOIP bound by the underlying intensional programming paradigm

Functional Programming for Embedded Systems

Embedded Systems application development has traditionally been carried out in low-level machine-oriented programming languages like C or Assembler that can result in unsafe, error-prone and difficult-to-maintain code. Functional programming with features such as higher-order functions, algebraic data types, polymorphism, strong static typing and automatic memory management appears to be an ideal candidate to address the issues with low-level languages plaguing embedded systems. However, embedded systems usually run on heavily memory-constrained devices with memory in the order of hundreds of kilobytes and applications running on such devices embody the general characteristics of being (i) I/O- bound, (ii) concurrent and (iii) timing-aware. Popular functional language compilers and runtimes either do not fare well with such scarce memory resources or do not provide high-level abstractions that address all the three listed characteristics. This work attempts to address this gap by investigating and proposing high-level abstractions specialised for I/O-bound, concurrent and timing-aware embedded-systems programs. We implement the proposed abstractions on eagerly-evaluated, statically-typed functional languages running natively on microcontrollers. Our contributions are divided into two parts - Part 1 presents a functional reactive programming language - Hailstorm - that tracks side effects like I/O in its type system using a feature called resource types. Hailstorm’s programming model is illustrated on the GRiSP microcontroller board.Part 2 comprises two papers that describe the design and implementation of Synchron, a runtime API that provides a uniform message-passing framework for the handling of software messages as well as hardware interrupts. Additionally, the Synchron API supports a novel timing operator to capture the notion of time, common in embedded applications. The Synchron API is implemented as a virtual machine - SynchronVM - that is run on the NRF52 and STM32 microcontroller boards. We present programming examples that illustrate the concurrency, I/O and timing capabilities of the VM and provide various benchmarks on the response time, memory and power usage of SynchronVM

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