A familial specification language for database application systems

This book consists of 35 chapters presenting different theoretical and practical aspects of Intelligent Information and Database Systems. Nowadays both Intelligent and Database Systems are applied in most of the areas of human activities which necessitates further research in these areas. In this book various interesting issues related to the intelligent information models and methods as well as their advanced applications, database systems applications, data models and their analysis and digital multimedia methods and applications are presented and discussed both from the practical and theoretical points of view. The book is organized in four parts devoted to intelligent systems models and methods, intelligent systems advanced applications, database systems methods and applications and multimedia systems methods and applications. The book will be interesting forpractitioners and researchers, especially graduate and PhD students of information technology and computer science, as well more experienced academics and specialists interested in developing and verification of intelligent information, database and multimedia systems models, methods and applications. The readers of this volume are enabled to find many inspiring ideas and motivating practical examples that will help them in the current and future work.

An important goal in interactive computer graphics is to provide users with both quick system responses for basic graphics functions and enough computing power for complex calculations. One solution is to have a distributed graphics system in which a minicomputer and a powerful large computer share the work. The most versatile type of distributed system is an intelligent satellite system in which the minicomputer is programmable by the application user and can do most of the work while the large remote machine is used for difficult computations. At New York University, the hardware was configured from available equipment. The level of system intelligence resulted almost completely from software development. Unlike previous work with intelligent satellites, the resulting system had system control centered in the satellite. It also had the ability to reconfigure software during realtime operation. The design of the system was done at a very high level using set theoretic language. The specification clearly illustrated processor boundaries and interfaces. The high-level specification also produced a compact, machine-independent virtual graphics data structure for picture representation. The software was written in a systems implementation language; thus, only one set of programs was needed for both machines. A user can program both machines in a single language. Tests of the system with an application program indicate that is has very high potential. A major result of this work is the demonstration that a gigantic investment in new hardware is not necessary for computing facilities interested in graphics.

BackgroundRobust, extensible and distributed databases integrating clinical, imaging and molecular data represent a substantial challenge for modern neuroscience. It is even more difficult to provide extensible software environments able to effectively target the rapidly changing data requirements and structures of research experiments. There is an increasing request from the neuroscience community for software tools addressing technical challenges about: (i) supporting researchers in the medical field to carry out data analysis using integrated bioinformatics services and tools; (ii) handling multimodal/multiscale data and metadata, enabling the injection of several different data types according to structured schemas; (iii) providing high extensibility, in order to address different requirements deriving from a large variety of applications simply through a user runtime configuration.MethodsA dynamically extensible data structure supporting collaborative multidisciplinary research projects in neuroscience has been defined and implemented. We have considered extensibility issues from two different points of view. First, the improvement of data flexibility has been taken into account. This has been done through the development of a methodology for the dynamic creation and use of data types and related metadata, based on the definition of “meta” data model. This way, users are not constrainted to a set of predefined data and the model can be easily extensible and applicable to different contexts. Second, users have been enabled to easily customize and extend the experimental procedures in order to track each step of acquisition or analysis. This has been achieved through a process-event data structure, a multipurpose taxonomic schema composed by two generic main objects: events and processes. Then, a repository has been built based on such data model and structure, and deployed on distributed resources thanks to a Grid-based approach. Finally, data integration aspects have been addressed by providing the repository application with an efficient dynamic interface designed to enable the user to both easily query the data depending on defined datatypes and view all the data of every patient in an integrated and simple way.ResultsThe results of our work have been twofold. First, a dynamically extensible data model has been implemented and tested based on a “meta” data-model enabling users to define their own data types independently from the application context. This data model has allowed users to dynamically include additional data types without the need of rebuilding the underlying database. Then a complex process-event data structure has been built, based on this data model, describing patient-centered diagnostic processes and merging information from data and metadata. Second, a repository implementing such a data structure has been deployed on a distributed Data Grid in order to provide scalability both in terms of data input and data storage and to exploit distributed data and computational approaches in order to share resources more efficiently. Moreover, data managing has been made possible through a friendly web interface. The driving principle of not being forced to preconfigured data types has been satisfied. It is up to users to dynamically configure the data model for the given experiment or data acquisition program, thus making it potentially suitable for customized applications.ConclusionsBased on such repository, data managing has been made possible through a friendly web interface. The driving principle of not being forced to preconfigured data types has been satisfied. It is up to users to dynamically configure the data model for the given experiment or data acquisition program, thus making it potentially suitable for customized applications.

The authors present the Delphi project, which deals with the design and implementation of a software engineering environment (SEE) to enhance software productivity, in particular, one that targets information systems (IS) for business data processing problems. A set of specification languages was designed to specify the IS in a modular manner. Collectively, these languages are called the data processing specification outlining language (DPSOL). DPSOL is customizable, executable, extensible, and translatable and can be used in rapid prototyping or in automatic translation to a target 3GL/environment. The authors present the expressive power of DPSOL to specify the IS, and its automated process of checking referential integrity and computational consistency. The approach is translational (using templates) instead of transformational. Templating is a powerful concept in automatic programming, at least for IS. The templates can be edited and modified to generate customized 3GL source code. Moreover, documentation can also be automatically generated.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The specification language is a critical component of the hardware-software co-design process since it is used for functional validation and as a starting point for hardware-software partitioning and co-synthesis. The paper proposes the Java programming language as a specification language for hardware-software systems. Java has several characteristics that make it suitable for system specification. However static control and data flow analysis of Java programs is problematic because Java classes are dynamically linked. The paper provides a general solution to the problem of statically analyzing Java programs using a technique that pre-allocates most class instances and aggressively resolves memory aliasing using global analysis. The output of the analysis is a control data flow graph for the input specification. The results for sample designs show that the analysis can extract fine to coarse-grained concurrency for subsequent hardware-software partitioning and co-synthesis steps of the hardware-software co-design process to exploit.

For many real-time applications (e.g. command, control, and communications), parallel computers offer a natural computing platform. However, very little attention has been paid to the specification requirements of real-time systems implemented on parallel machines. Towards this end, we propose a specification language PRETSEL (Parallel Real-Time Specification Language). The PRETSEL specification language is based on a traditional two-level view of parallel computing whereby a parallel computation is viewed as a collection of interacting (data) parallel algorithms. This view is naturally reflected in PRETSEL syntax where at the lower level various constructs are provided for the specification of a data-parallel real-time algorithm (data-parallelism). At the upper level another set of constructs is provided to combine such tasks in a variety of way (task-parallelism). Furthermore, the PRETSEL language allows for the specification of performance requirements. PRETSEL is currently being evaluated for real-time avionics applications. We describe the syntax and operational semantics of PRETSEL and establish results relating the functional and the temporal behaviors.

Definition and Implementation of a Data Model for Computer-aided Control Engineering

The development of an Electronic Health Record (EHR) system requires a well-defined data set and a robust data model to support complex clinical workflows, interoperability, and data quality. Many existing EHR implementations lack standardized and integrated data models, resulting in redundancy, semantic inconsistency, and limited support for secondary data use. This study aims to develop a comprehensive EHR data model based on a Minimum Data Set (MDS) that systematically represents medical service processes across emergency, outpatient, inpatient, and surgical care. The proposed approach involves the design of a conceptual, logical, and physical data model. Business processes were first analysed to identify relationships among clinical and administrative data classes, which were then transformed into a conceptual data model. The logical data model was developed through database normalization and schema definition, while the physical data model was constructed to represent the actual database structure for implementation. The results demonstrate a structured EHR data model comprising 21 interrelated data classes that reflect real-world medical service workflows. The conceptual data model establishes clear entity relationships, supporting data consistency and interoperability. The logical data model provides a normalized SQL-based schema that minimizes redundancy and enhances data integrity, while the physical data model enables efficient data storage and access. A prototype EHR system was implemented to evaluate the feasibility of the proposed data model, showing stable performance, usability, and alignment with functional requirements. This study concludes that a standardized EHR data model derived from an MDS can effectively support comprehensive clinical documentation, interoperability, and future scalability. The proposed model provides a strong foundation for developing national or institutional EHR systems and can serve as a reference for further EHR data standardization efforts.

This paper provides a brief survey of languages used for developing operating systems. The paper discusses the issues involved in deciding on the use of a higher level language, including the technical, management, psychological factors, and the advantages and disadvantages. The major part of the paper discusses specific languages which have been used, and the major systems which have been developed using them. General comments and future trends are indicated, with a discussion of desirable characteristics, the non-universality of a single systems programming language, system specification languages, machine independence, and operating system writing systems. An appendix lists languages known to have been used for writing either compilers and/or operating systems, and indicates references for them.

The asynchronous nature of the dataflow model of computation allows the exploitation of maximum inherent parallelism in many application programs. However, before the dataflow model of computation can become a viable alternative to the control flow model of computation, one has to find practical solutions to some problems such as efficient handling of data structures. The paper introduces a new model for handling data structures in a dataflow environment. The proposed model combines constant time access capabilities of vectors as well as the flexibility inherent in the concept of pointers. This allows a careful balance between copying and sharing to optimize the storage and processing overhead incurred during the operations on data structures. The mode) is compared by simulation to other data structure models proposed in the literature, and the results are good.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The Unified Modeling Language - UML - is the most used specification language, and the way the world models not only application structure, behavior, and architecture, but also business process and data structure. In this paper, we aim to demonstrate a system development methodology by generating the UML diagrams from the requirements of the Automatic Banking Machine (ABM) System and discuss their relationships, differences and suitability. The high-level requirements of the system are specified by using use-case diagram, activity diagram, state chart diagram, collaboration diagram, sequence diagram, and component diagram, and the low-level requirements of each component using class diagrams. We briefly introduce each diagram, their usage, their advantages and some limitations, and then we discuss the relationships and differences between two or more diagrams, and suitability for modeling the different parts of the system.

In this thesis, we explore techniques for the development and verification of programs in a high-level, expressive, and safe programming language. Our programs can express problems over unbounded domains and over recursive and mutable data structures. We present an implementation language flexible enough to build interesting and useful systems. We mostly maintain a core shared language for the specifications and the implementation, with only a few extensions specific to expressing the specifications. Extensions of the core shared language include imperative features with state and side effects, which help when implementing efficient systems. Our language is a subset of the Scala programming language. Once verified, programs can be compiled and executed using the existing Scala tools. We present algorithms for verifying programs written in this language. We take a layer-based approach, where we reduce, at each step, the program to an equivalent program in a simpler language. We first purify functions by transforming away mutations into explicit return types in the functions' signatures. This step rewrites all mutations of data structures into cloning operations. We then translate local state into a purely functional code, hence eliminating all traces of imperative programming. The final language is a functional subset of Scala, on which we apply verification. We integrate our pipeline of translations into Leon, a verifier for Scala. We verify the core functional language by using an algorithm already developed inside Leon. The program is encoded into equivalent first-order logic formulas over a combination of theories and recursive functions. The formulas are eventually discharged to an external SMT solver. We extend this core language and the solving algorithm with support for both infinite-precision integers and bit-vectors. The algorithm takes into account the semantics gap between the two domains, and the programmer is ultimately responsible to use the proper type to represent the data. We build a reusable interface for SMT-LIB that enables us to swap solvers transparently in order to validate the formulas emitted by Leon. We experiment with writing solvers in Scala; they could offer both a better and safer integration with the rest of the system. We evaluate the cost of using a higher-order language to implement such solvers, traditionally written in C/C++. Finally, we experiment with the system by building fully working and verified applications. We rely on the intersection of many features including higher-order functions, mutable data structures, recursive functions, and nondeterministic environment dependencies, to build concise and verified applications.

This paper presents the design of a non-standard database system for geoscientific applications. The system offers an object-oriented database language with an extensible set of geometric data types; in application programs, the database language is available as an embedded data sublanguage, and sets of objects read from the database can be manipulated by operations offered in abstract data type modules. A special NF2 database kernel is to provide the basis for an efficient implementation.

This paper illustrates a prototype system, called GPRS, supporting the Generalized Production Rules (GPR) data-base language. The GPR language integrates, in a unified framework, active rules, which allow the specification of event driven computations on data, and deductive rules, which can be used to derive intensional relations in the style of logic programming. The prototype realizes the operational semantics of GPR using a unique rule-evaluation engine. The data model of reference is object based and the system is implemented on top of an object oriented DBMS. Hence, the GPRS prototype represents a concrete proposal of an advanced DBMS for complex objects that provides both active and deductive styles of rule programming. © 1997 John Wiley & Sons, Inc.

A fundamental building block in any graph algorithm is a graph container - - a data structure used to represent the graph. Ideally, a graph container enables efficient access to the underlying graph, has low space usage, and supports updating the graph efficiently. In this paper, we conduct an extensive empirical evaluation of graph containers designed to support running algorithms on large graphs. To our knowledge, this is the first apples-to-apples comparison of graph containers rather than overall systems, which include confounding factors such as differences in algorithm implementations and infrastructure. We measure the running time of 10 highly-optimized algorithms across over 20 different containers and 10 graphs. Somewhat surprisingly, we find that the average algorithm running time does not differ much across containers, especially those that support dynamic updates. Specifically, a simple container based on an off-the-shelf B-tree is only 1.22× slower on average than a highly optimized static one. Moreover, we observe that simplifying a graph-container Application Programming Interface (API) to only a few simple functions incurs a mere 1.16× slowdown compared to a complete API. Finally, we also measure batch-insert throughput in dynamic-graph containers for a full picture of their performance. To perform the benchmarks, we introduce BYO, a unified framework that standardizes evaluations of graph-algorithm performance across different graph containers. BYO extends the Graph Based Benchmark Suite (Dhulipala et al. 18), a state-of-the-art graph algorithm benchmark, to easily plug into different dynamic graph containers and enable fair comparisons between them on a large suite of graph algorithms. While several graph algorithm benchmarks have been developed to date, to the best of our knowledge, BYO is the first system designed to benchmark graph containers.