Compilers and Programming Languages

This laboratory project report details the design and implementation of a simplified desktop-based retail management application named "Minimarket Cihuy". Developed strictly in the C programming language using the Code::Blocks IDE, the system offers an integrated solution for inventory tracking and transaction logging. Key functionalities include interactive administrative login, automated item additions, pricing queries, data deletion, real-time sales reporting, and permanent data persistence via sequential file handling (.txt). To ensure performance efficiency within small-scale trading operations, the application leverages structural array data abstractions, Insertion Sort algorithms, and optimized Binary Search implementations.

Over the last few years, the question of reasoning about aspectoriented programs has been addressed by a number of authors. In this paper, we present a rely-guarantee approach to such reasoning. The rely-guarantee approach has proven extremely successful in reasoning about concurrent and distributed programs. We show that some of the key problems encountered in reasoning about aspectoriented programs are similar to those encountered in reasoning about concurrent programs; and that the rely-guarantee approach, appropriately modified, helps address these problems. We illustrate our approach with a simple example.

This paper presents a programming language interface, a complete scripting language, to describe composable compiler transformations. These transformation programs can be written, shared and reused by non-expert application and library developers. From a compiler writer's perspective, a scripting language interface permits rapid prototyping of compiler algorithms that can mix levels and compose different sequences of transformations, producing readable code as output. From a library or application developer's perspective, the use of transformation programs permits expression of clean high-level code, and a separate description of how to map that code to architectural features, easing maintenance and porting to new architectures. We illustrate this interface in the context of CUDA-CHiLL, a sourceto-source compiler transformation and code generation framework that transforms sequential loop nests to high-performance GPU code. We show how this high-level transformation and code generation language can be used to express: (1) complex transformation sequences, exemplified by a single loop restructuring construct used to generate a series of tiling and permute commands; and, (2) complex code generation sequences to produce CUDA code from a high-level specification. We demonstrate that the automatically-generated code either performs closely or outperforms two hand-tuned GPU library kernels from Nvidia's CUBLAS 2.2 and 3.2 libraries.

The need of faster life has caused the exponential growth in No. of vehicles on streets. The adverse effects include frequent traffic congestion, less time efficiency, unnecessary fuel consumption, pollution, accidents, etc. One of most important solution for resolving these problems is efficient transportation management system. Data science introduces different techniques and tools for overcoming these problems and to improve the data quality and forecasting inferences. The proposed long-term forecasting model can predict numerical values of effective attributes for a particular day on half-hourly basis, at least 24 hours prior to the time of prediction. The proposed forecasting model for short-term analysis will be having access to data as close as 30-minute difference from the time of prediction. Our proposed solution has integrated use of Holt-Winters (HW) method along with comparability schemes for seasonal approach. Long-Term and Short-Term Traffic Forecasting Using Holt-Wint...

This dissertation is structured into seven chapters, whose summary is presented below: I Introduction: introduces the topic of this dissertation by briefly presenting the inherent challenges of developing applications that efficiently explore the performance of heterogeneous servers, and introduces the main objective, which is to efficiently schedule irregular workloads among heterogeneous devices. Section 1.2 presents the scientific motivation and the contribution. II Heterogeneous Servers: this chapter presents the concept of an heterogeneous server, introduces the NUMA 6 architecture in the cluster node and briefly introduces how the accelerators operate in distributed memory. This chapter also presents the current multicore and many-core devices and describes their features. III Scheduling Data and Workloads: this chapter describes the state of the art on the inherent complexity of scheduling data and workloads on heterogeneous platforms. This chapter also presents a list of key frameworks to aid the scheduling in the homogeneous and heterogeneous platforms. IV Scientific Workloads: presents and describes the type of scientific workloads that this work addresses and presents the selected scientific case study for this dissertation. V An Adaptive Scheduler for an Heterogeneous Server: introduces and describes the implemented dynamic adaptive heterogeneous scheduler and its key features to support irregular workloads. VI Experimental results and discussion: presents and describes the selected testbed to validate the efficiency of the scheduler, and discusses the experimental performance results. VII Conclusions: concludes the dissertation with suggestions for future work.

I've been paged at 2 a.m. because "the app feels slow." No stack trace. No crash. Just vibes. That's usually when we discover nobody ever defined what fast actually means. That's the hole benchmark software testing is supposed to fill. Early in my career, we shipped a feature-heavy release to prod. All unit tests were green. Load tests? "We'll do it later." Traffic doubled after a marketing push, CPU spiked, latency crept from 200ms to 1.8s, and users bailed. Postmortem verdict: no baseline. No benchmark. Just assumptions. We fixed the bug, but the real failure was the process. If you don't measure performance against a known standard, you're not engineering. You're guessing. Tools like Keploy exist because guessing doesn't scale.

In this paper we present an interpretive approach for accurate and cost-e ective performance prediction in a high performance computing environment, and describe the design of a compile-time HPF/Fortran 90D performance prediction framework based on this approach. The performance prediction framework has been implemented as a part of the HPF/Fortran 90D application development environment that integrates it with a HPF/Fortran 90D compiler and a functional interpreter. The current implementation of the environment framework is targeted to the iPSC/860 hypercube multicomputer system. A set of benchmarking kernels and application codes have been used to validate the accuracy, utility, and usability of the performance prediction framework. The use of the framework for selecting appropriate HPF/Fortran 90D compiler directives, for application performance debugging and for experimentation with run-time and system parameters is demonstrated.

The NPAC kernel runtime, developed in the PCRC (Parallel Compiler Runtime Consortium) project, is a runtime library with special support for the High Performance Fortran data model. It provides array descriptors for a generalized class of HPF-like distributed arrays, support for parallel access to their elements, and a rich library of collective communication and arithmetic operations for manipulating these arrays. The library has been successfully used as a component in experimental HPF translation systems. With prospects for early appearance of fully-featured, ecient HPF compilers looking questionable, we discuss a class of more easily implementable data-parallel language extensions that preserve many of the attractive features of HPF, while providing the programmer with direct access to runtime libraries such as the NPAC PCRC kernel. PCRC Java interface MPI Distributed data and control ad++ interface (Adlib) Kernel run-time Communication and arithmetic ranges Distributed Groups Distributed control ''where'' Process ''on''

The augmented version of C programming language is presented. The language was completed with a series of low-level and highlevel facilities to enlarge the language usage spectrum to various computing systems, operations, users. The ambiguities and inconsistencies have been resolved by managing problematic and undefined languages elements through an interpretation and management similar to that used in the case of other C syntax based languages. The proposed augmentative completeness elements, through @C approach, preserve the spirit of C language and its basic characteristics through compatibility with the standard version but also allow rejuvenation and bring C language to the present programming languages state of the art.

Bugs can be found in all code and the consequences are usually managed through up grade releases, patches, and restarting operating systems and applications. However, in mission critical systems complete fall over systems are built to assure service continuity. In our research we asked the question, what are the professional risks of bugs in digital forensic tools? Our investigation reviewed three high use professional proprietary digital forensic tools, one in which we identified six bugs and evaluated these bug in terms of potential impacts on an investigator’s work. The findings show that yes major brand name digital forensic tools have software bugs and there is room for improvement. These bugs had potential to frustrate an investigator, to cost time, to lose evidence and to require compensatory strategies. Such software bugs also have the potential for malicious exploitation and anti forensic use.

The augmented JavaScript programming language completed as general computing instrument concept, referred as @JavaScript, is presented. The augmentation consists in the minimalist dialectal completion of the language, keeping compatibility with the standard version, in order to transform the language into a general-purpose language and to expand its use as universal programming instrument suitable in any computing system areas and for any type of computing device. The augmentation includes integrating existing high and low level elements along with introducing new elements in order to be transformed into a bootstrap-type selfhosting language, scalable and flexible in being usable in any type of computing processing and contexts as a ubiquitous instrument, suitable for incorporating natural languages and other present and future computing paradigms.

The Fortran 2018 standard defines syntax and semantics to allow a parallel application to recover from failed images (processes) during execution. This poster presents work to extend the GFortran compiler front end and OpenCoarrays library to support fault tolerant teams of images, enabling use of collective routines after an image failure.

The increasing complexity of modern software systems has intensified interest in the performance trade-offs between Ahead-of-Time (AOT) and Just-in-Time (JIT) compilation. This paper presents a comprehensive empirical study quantifying these trade-offs through systematic benchmarking across diverse computational workloads. Our findings reveal extreme performance differentials: JIT compilation achieves remarkable speedups up to 237,633× for simple numerical operations, while AOT compilation demonstrates superior performance in complex algorithms with speedups up to 13,523×. The study documents specific trade-offs including JIT's compilation overhead (0.16ms to 246.49ms) versus AOT's immediate execution (0.015ms to 20.60ms), and quantifies JIT's memory overhead at 18-50% higher than AOT equivalents. Analysis of warm-up behavior shows JIT requires 3-6 iterations to reach optimal performance, after which it matches or exceeds AOT efficiency. Energy consumption patterns correlate directly with execution times, with optimized implementations achieving up to 99.9% energy reduction. The investigation emphasizes methodological rigor through reproducible measurements in controlled Kaggle environments, employing statistical validation across 30+ iterations per benchmark. Our results demonstrate that neither approach dominates universally; rather, optimal compilation strategy depends on workload characteristics, with JIT excelling in adaptive optimization of repetitive tasks and AOT providing deterministic performance for complex algorithms. The study concludes that hybrid compilation strategies, combining AOT's startup advantages with JIT's long-term optimization potential, offer the most promising path toward efficient, predictable, and scalable performance across diverse computing contexts.

Building reliable software at scale has always been a balancing act. You want performance, but you also need safety. You need concurrency, but without the headaches of data races and memory corruption. For years, we've been told to pick our poison: either use C/C++ and deal with segfaults and security vulnerabilities, or accept the overhead of garbage collection in languages like Java or Go. Rust changes this equation. Through its ownership model and compile-time safety guarantees, Rust manages to deliver both performance and reliability without forcing developers to choose. This paper examines real-world evidence from production systems at companies like AWS, Discord, and Microsoft to understand what Rust actually delivers in practice. The results are striking: 70% fewer memory-related bugs, 60% improvements in tail latency, and significant reductions in operational costs. But more importantly, Rust represents a shift in how we think about software correctness-moving error detection from runtime to compile time, and from testing to type checking. Drawing from industry deployments and my own experience building systems in Rust, this paper explores how Rust's design principles translate into tangible engineering benefits, the challenges teams face during adoption, and practical strategies for integrating Rust into existing software organizations.

We have created CABERNET, a Controlled Nature Language (CNL) based approach to program creation. CABERNET allows programmers to use a simple outline-based syntax. This allows increased programmer efficiency and syntax flexibility. CNLs have successfully been used for writing requirements documents. We propose taking this approach well beyond this to fully functional programs. Through the use of heuristics and inference to analyze and determine the programmer's intent we are able to create fully functional mobile applications. The goal is for programs to be aligned with the way that the humans think rather than the way computers process information. Through the use of templates a CABERNET application can be processed to run on multiple run time environments. Because processing of a CABERNET program file results in native application program performance is maintained.

Recently, there has been a lot of interest in using Java for parallel programming. Efforts have been hindered by lack of standard Java parallel programming APIs. To alleviate this problem, various groups started projects to develop Java message passing systems modelled on the successful Message Passing Interface (MPI). Official MPI bindings are currently defined only for C, Fortran, and C++, so early MPI-like environments for Java have been divergent. This paper relates an effort undertaken by a working group of the Java Grande Forum, seeking a consensus on an MPI-like API, to enhance the viability of parallel programming using Java.

This paper presents an e-Design framework for knowledge management through its application in an engineering design case study. The e-Design framework enables the implementation of integrated design information throughout the entire design process. It facilitates the ease of sharing real time information across multiple individual designers, departments, or organizations as would be required in large scale design efforts. Similarly, it allows for the ease of use of technical tools integral to the design process that small design departments depend upon. Thus, regardless of the scale, the efficiency of engineering design can be improved with the use of the e-Design framework. The many features of the e-Design framework are exemplified through its application in a practical industry design problem. The case study in this paper addresses the utility and ease of use of this framework and provides one potential implementation method. This study involves a representative application of an...

The design of more sustainable products can be best accomplished in a tradeoff-based design process that methodically handles conflicting objectives. Such conflicts are often seen between, environmental impact, cost, and product performance. To support such a process, we propose the development of an environment where sustainability considerations are explicitly introduced early into the design process. This explicitness is provided by integrating the requirements information of sustainability standards and regulations directly into the design process. The emergence of the semantic web provides an interoperable environment in which the context and meaning of knowledge about the relationships among various domains can be shared. This work presents an ontological framework designed to represent both the objectives that pertain to sustainable design and the applicable sustainability standards and regulations. This integrated approach not only can ease the adoption of the standards and ...

Every new design, project, or procedure within a company generates a considerable amount of new information and important knowledge. Furthermore, a tremendous amount of legacy knowledge already exists in companies in electronic and non-electronic formats, and techniques are needed for representing, structuring and reusing this knowledge. Many researchers have spent considerable time and effort developing semantic knowledge management systems, which in theory are presumed to address these problems. Despite significant research investments, little has been done to implement these systems within an industrial setting. In this paper we identify five main requirements to the development of an industry-ready application of semantic knowledge management systems and discuss how each of these can be addressed. These requirements include the ease of new knowledge management software adoption, the incorporation of legacy information, the ease of use of the user interface, the security of the s...

Semantic technologies are playing an increasingly popular role as a means for advancing the capabilities of knowledge management systems. Among these advancements, researchers have successfully leveraged semantic technologies, and their accompanying techniques, to improve the representation and search capabilities of knowledge management systems. This paper introduces a further application of semantic techniques. We explore semantic relatedness as a means of facilitating the development of more ''intelligent'' engineering knowledge management systems. Using semantic relatedness quantifications to analyze and rank concept pairs, this novel approach exploits semantic relationships to help identify key engineering relationships, similar to those leveraged in change management systems, in product development processes. As part of this work, we review several different semantic relatedness techniques, including a meronomic technique recently introduced by the authors. We introduce an aggregate measure, termed ''An Algorithm for Identifying Engineering Relationships in Ontologies,'' or AIERO, as a means to purposely quantify semantic relationships within product development frameworks. To assess its consistency and accuracy, AIERO is tested using three separate, independently developed ontologies. The results indicate AIERO is capable of returning consistent rankings of concept pairs across varying knowledge frameworks. A PCB (printed circuit board) case study then highlights AIERO's unique ability to leverage semantic relationships to systematically narrow where engineering interdependencies are likely to be found between various elements of product development processes.

This paper presents a novel meta-experimental approach to analyzing the debugging capabilities of large language models (LLMs), specifically Claude 3 Opus. Through a carefully designed experiment where the AI system first generates intentionally buggy code and subsequently debugs it without prior knowledge, we document and analyze the systematic debugging methodology employed by modern AI systems. Our experiment involved a Python-based Task Management System containing 12 distinct bug categories, ranging from syntax errors to complex runtime issues. The AI successfully identified and resolved all bugs using a methodical, error-driven approach that mirrors human debugging strategies. Key findings include the AI's ability to: (1) prioritize syntax errors before runtime issues, (2) leverage Python's error messages effectively, (3) implement comprehensive fixes with proper error handling, and (4) validate solutions through automated testing. This research contributes to understanding AI's role in automated software debugging and has implications for the future of AI-assisted software development, code review processes, and programming education.

Codira is a next-generation programming language designed for speed, clarity, and interoperability. This 608-page book introduces the core concepts, syntax, and ecosystem of Codira — written by Tunjay Akbarli, with editorial contribution from Maryna Rybalko. Published by SkyE, 2025.

In this paper we present a work in progress on the formal verification of a process super-visor using the McErlang model checker. The process supervisor is an alternative implemen-tation of the standard supervisor behaviour of Erlang/OTP. This implementation, in use at the ...

Introduction: Lists are used in various software applications including web applications, desktop applications, and Internet of Things (IoT) applications to store different types of items (e.g. country name, product model, and device category). Users can select one or more of these items to perform specific tasks such as filling forms, ordering products, reading device data, etc. In some software applications, lists store a huge number of items to be iterated over in order to know what users have selected. From a software development perspective, there are a number of methods to iterate over list items. Materials and Methods: In this paper, five list iteration methods: Classic For, Enhanced For, Iterator, List Iterator, and For Each have been compared experimentally with each other with regard to their performance (execution time required to iterate over list items). Thus, a number of experimental test scenarios have been conducted to obtain comparable results. Results and Discussio...

Using a sample of 935000 88 pairs collected with the CLEO-lf detector at the Cornell Storage Ring, we have obtained upper limits on the branching ratios for the b ul v processes 8 col 8 p I v, and 8 @+I v. The combined result Using the relationships among the widths for these three modes is B(B p l v) & (1.6-2.7) x 10 at 90% C.L., where the range of values is due to model dependence of the detection e%ciencies. These measurements yield the limits ~V"b/V, t, & 0.08-0. 13.

Implementing artificial neural networks is commonly achieved via high-level programming languages like Python and easy-to-use deep learning libraries like Keras. These software libraries come pre-loaded with a variety of network architectures, provide autodifferentiation, and support GPUs for fast and efficient computation. As a result, a deep learning practitioner will favor training a neural network model in Python, where these tools are readily available. However, many large-scale scientific computation projects are written in Fortran, making it difficult to integrate with modern deep learning methods. To alleviate this problem, we introduce a software library, the Fortran-Keras Bridge (FKB). This two-way bridge connects environments where deep learning resources are plentiful, with those where they are scarce. The paper describes several unique features offered by FKB, such as customizable layers, loss functions, and network ensembles. The paper concludes with a case study that applies FKB to address open questions about the robustness of an experimental approach to global climate simulation, in which subgrid physics are outsourced to deep neural network emulators. In this context, FKB enables a hyperparameter search of one hundred plus candidate models of subgrid cloud and radiation physics, initially implemented in Keras, to be transferred and used in Fortran. Such a process allows the model's emergent behavior to be assessed, i.e. when fit imperfections are coupled to explicit planetary-scale fluid dynamics. The results reveal a previously unrecognized strong relationship between offline validation error and online performance, in which the choice of optimizer proves unexpectedly critical. This in turn reveals many new neural network architectures that produce considerable improvements in climate model stability including some with reduced error, for an especially challenging training dataset.

With the help of some standard results in Geometry, Differential geometry, Spherical Trigonometry and the latitude and longitude of two places on the surface of the earth one can measure the Geodesics of the path joining those places and the direction between two places with respect to the geographical position. The study of geodesics on a sphere aroses in connection with geodesy specially with the solution of triangulation networks. The figure of the earth is well approximated by an oblate ellipsoid, a slightly flattened sphere. A geodesic is the shortest path between two points on a curved surface, analogous to a straight line on a plane surface. Instead of finding networks as a two dimensional problem, these problems are now solved by three dimensional methods. The main objectives of this paper is to find the distances and directions of the sum of different renowned places named Dhaka to Mecca, London to Mecca, NewYork to Mecca and Delhi to Mecca with the help of the knowledge of differential geometry.

The execution of complex distributed applications in exascale systems faces many challenges, as it involves empirical evaluation of countless code variations and application runtime parameters over a heterogeneous set of resources. To mitigate these challenges, the research field of autotuning has gained momentum. The autotuning automates identifying the most desirable application implementation in terms of code variations and runtime parameters. However, the complexity and size of the exascale systems make the autotuning process very difficult, especially considering the number of parameter variations that have to be identified. Therefore, we introduce a novel approach for autotuning exascale applications based on a genetic multi-objective optimization algorithm integrated within the ASPIDE exascale computing framework. The approach considers multi-dimensional search space with support for pluggable objective functions, including execution time and energy requirements. Furthermore,...

This paper explores hybrid data structures designed to overcome bottlenecks in classical data handling. By fusing tree-based hierarchies, hash-based indexing, skiplevel traversal, and stack-ordered access patterns, we introduce five innovative constructs. Each structure is evaluated on theoretical efficiency and Python-based benchmarks-offering a practical toolkit for AI systems, cache architecture, and real-time databases.

This paper discusses a methodology used on an industrial hardware development project to validate various cache-coherence protocol components. The idea is to use a high level model (HLM) written in Murphi for model checking purposes, and then to use the HLM as a checker during dynamic (i.e. simulation based-) validation of the RTL. Such a checker requires a formal notion of what it means for the RTL to implement the HLM. Due to RTL pipelining, concurrency, and different RTL/HLM semantics, an appropriate notion is nonobvious. We employ a notion we call behavioral refinement, and describe a methodology for creating refinement checkers. A novel aspect of our methodology is that all "ingredients" are specified using System Verilog (SV): even the Murphi model itself is compiled into SV. Thus any off-the-shelf SV simulation engine can be used. We report the successful use of our refinement checkers to catch bugs in a real project at Intel and give an example illustrating our methodology.

En los últimos años se ha incrementado la demanda de productos fruto hortícolas que aporten calidad, inocuidad y facilidad de consumo, lo que ha permitido diversificar. Estos alimentos pueden ser mínimamente procesados, tales como las ensaladas listas para consumir, que pueden estar acompañadas con otros ingredientes como el limón, vinagre, aceite, aderezos o salsa que ayudan a exaltar y mejorar el sabor 1 . El aguacate, la granadilla y el maracuyá en estado de madurez comestible, contienen altos niveles de compuestos bioactivos, como vitaminas, antioxidantes fenólicos, además aportan con minerales y fibra. Los parámetros de calidad y la composición química de la pulpa de estas frutas se observan en la tabla 1. Esta información sirve para el desarrollo de nuevos productos, como es el caso de una salsa tipo aderezo.

Resumen En éste trabajo se presenta el desarrollo de un generador de evaluadores de gramáticas de atributos no circulares −NC(1)−. Este generador computa estáticamente toda la información necesaria para que el evaluador generado construya, en tiempo proporcional a la longitud del árbol, procesos concurrentes independientes capaces de producir la evaluación. Esto permite evaluar aprovechando el máximo paralelismo posible sin ningún tipo de sincronización. En éste trabajo se aprovechan dos enfoques: el clásico enfoque secuencial, que determina un orden lineal de evaluación, con el enfoque recientemente propuesto por Wuu Yang para el particionado de mayor refinamiento del grafo de dependencias en regiones disjuntas. El algoritmo desarrollado evita un recorrido adicional sobre el árbol sintáctico y completa el estudio de los detalles para la implementación del evaluador. Este desarrollo se integrará como evaluador alternativo de un generador de procesadores de lenguajes. Este trabajo se...

Las Gramática de Atributos (GA) son un formalismo que poseen el poder descriptivo de las Gramáticas Libres de Contexto (CFG) y la expresividad de los lenguajes funcionales, para definir la semántica de un lenguaje. Las ecuaciones de una GA inducen dependencias entre los atributos que ocurren en la producción. Si una GA contiene dependencias circulares no podrá ser evaluada, ya que no existirá un orden de evaluación consistente. Esto se conoce como el Problema de Circularidad. El test de circularidad es intrínsecamente exponencial, lo que dificulta la implementación de evaluadores eficientes, por lo que comúnmente las herramientas imponen restricciones en las dependencias. En 1998, Wuu Yang caracteriza una nueva familia de GA, denominada Gramáticas de Atributos Multiplanes (MAG) o NC(1), que permiten una mayor expresividad, presentando un algoritmo eficiente para su evaluación. Este trabajo describe magGen: un generador de evaluadores estáticos para la familia MAG.

Agent Based Modeling (ABM) is a computational paradigm for simulating the actions and interactions of autonomous agents (both individual or collective entities such as organizations or groups) to understand the behavior of a system and the underlying laws governing its outcomes. For the conclusions reached via this technique to be valid, the agent population in the ABM should be representative of – and commensurate with – the population size and rule set under study. Moreover, since the systems under study are complex and hence many of their possible behaviors are unknown, simulations should be executed several times to identify average (and representative) behaviors. From a computational perspective, most research reported in the literature has focused on the impact of performance, scalability and visual representations on the quality of the scientific outcomes obtained with ABM.
The present work details an Feature Space Maturity Model (FSMM) which includes significant sections usually overlooked in current ABM frameworks. Advances in Computer Science and the advent of more powerful hardware make it possible to define a reference architecture capable of supporting – at the framework level – robust computational properties, a set of essential features leading to correctness and fidelity to reality. The purpose of this work is manifold. First, it introduces a maturity model for formal assessments of the feature space of ABM and evaluates the five most used ABM frameworks. Second, it proposes a macroscopic analysis of different implementations as a correctness mechanism. Third, it identifies and proposes a reference architecture based on the frameworks reviewed. Finally, it provides a Proof of Concept (POC) implementation based on the reference architecture to evaluate its quality according to the FSMM.

The area of software verification has grown its importance in software engineering. This is a bibliography of verification of a specialized class of softwares called compiler. The citations are sorted year wise in chronological order with most recent years first. The format of each citation is authors; Title; publisher; year. 2003

Multimodal interfaces are becoming increasingly ubiquitous with the advent of mobile devices, accessibility considerations, and novel software technologies that combine diverse interaction media. In addition to improving access and delivery capabilities, such interfaces enable flexible and personalized dialogs with websites, much like a conversation between humans. In this paper, we present a software framework for multimodal web interaction management that supports mixed-initiative dialogs between users and websites. A mixed-initiative dialog is one where the user and the website take turns changing the flow of interaction. The framework supports the functional specification and realization of such dialogs using staging transformations -a theory for representing and reasoning about dialogs based on partial input. It supports multiple interaction interfaces, and offers sessioning, caching, and co-ordination functions through the use of an interaction manager. Two case studies are presented to illustrate the promise of this approach.

This paper describes a human-in-the-loop motion-based simulator interfaced to hybrid-electric power system hardware, both of which were used to measure the duty cycle of a combat vehicle in a virtual simulation environment. The project discussed is a greatly expanded follow-on to the experiment published in . This paper is written in the context of and therefore highlights the enhancements. The most prominent of these enhancements is the integration (in real-time) of the Power & Energy System Integration Lab (P&E SIL) with a motion base simulator by means of a "long haul" connection over the Internet (a geographical distance of 2,450 miles). The P&E SIL is, therefore, able to respond to commands issued by the vehicle's driver and gunner and, in real-time, affect the simulated vehicle's performance. By thus incorporating hardware into a human-in-the-loop experiment, TARDEC engineers were able to evaluate the actual power system as it responds to actual human behavior. After introducing the project, the paper describes the simulation environment which was assembled to run the experiment. It emphasizes the design of the experiment as well as the approach, challenges and issues involved in creating a real-time link between the motion-base simulator and the P&E SIL. It presents the test results and briefly discusses on-going and future work.

Implementing artificial neural networks is commonly achieved via high-level programming languages such as Python and easy-touse deep learning libraries such as Keras. ese software libraries come preloaded with a variety of network architectures, provide autodifferentiation, and support GPUs for fast and efficient computation. As a result, a deep learning practitioner will favor training a neural network model in Python, where these tools are readily available. However, many large-scale scientific computation projects are written in Fortran, making it difficult to integrate with modern deep learning methods. To alleviate this problem, we introduce a software library, the Fortran-Keras Bridge (FKB). is two-way bridge connects environments where deep learning resources are plentiful with those where they are scarce. e paper describes several unique features offered by FKB, such as customizable layers, loss functions, and network ensembles. e paper concludes with a case study that applies FKB to address open questions about the robustness of an experimental approach to global climate simulation, in which subgrid physics are outsourced to deep neural network emulators. In this context, FKB enables a hyperparameter search of one hundred plus candidate models of subgrid cloud and radiation physics, initially implemented in Keras, to be transferred and used in Fortran. Such a process allows the model's emergent behavior to be assessed, i.e., when fit imperfections are coupled to explicit planetary-scale fluid dynamics. e results reveal a previously unrecognized strong relationship between offline validation error and online performance, in which the choice of the optimizer proves unexpectedly critical. is in turn reveals many new neural network architectures that produce considerable improvements in climate model stability including some with reduced error, for an especially challenging training dataset.

This paper presents the use of first-order logic to improve upon currently employed engineering design knowledge management techniques. Specifically, this work uses description logic in unison with Horn logic, to not only guide the knowledge acquisition process but also to offer much needed support in decision making during the engineering design process in a distributed environment. The knowledge management methods introduced are highlighted by the ability to identify modeling knowledge inconsistencies through the recognition of model characteristic limitations, such as those imposed by model idealizations. The adopted implementation languages include the Semantic Web Rule Language, which enables Horn-like rules to be applied to an ontological knowledge base and the Semantic Web's native Web Ontology Language. As part of this work, an ontological tool, OPTEAM, was developed to capture key aspects of the design process through a set of design-related ontologies and to serve as a...