Conventional Programming Languages Research Articles

An AADL Contract Language Supporting Integrated Model- and Code-Level Verification

Model-based systems engineering approaches support the early adoption of a model - a collection of abstractions - of the system under development. The system model can be augmented with key properties of the system including formal specifications of system behavior that codify portions of system and unit-level requirements. There are obvious gaps between the model with formally specified behavior and the deployed system. Previous work on component contract languages has shown how behavior can be specified in models defined using the Architecture Analysis and Design Language (AADL) - a SAE International standard (AS5506C). That work demonstrated the effectiveness of model-level formal methods specification and verification but did not provide a strong and direct connection to system implementations developed using conventional programming languages. In particular, there was no refinement of model-level contracts to programming language-level contracts nor a framework for formally verifying that program code conforms to model-level behavioral specifications. To address these gaps and to enable the practical application of model-contract languages for verification of deployed high-integrity systems, this paper describes the design of the GUMBO AADL contract language that integrates and extends key concepts from earlier contract languages. The GUMBO contract language (GCL) is closely aligned to a formal semantics of the AADL run-time framework, which provides a platform- and language- independent specification of AADL semantics. We have enhanced the HAMR AADL code generation framework to translate model-level contracts to programming language-level contracts in the Slang high-integrity language. We demonstrate how the Logika verification tool can automatically verify that Slang-based AADL component implementations conform to contracts, both at the code-level and model-level. Slang-based implementations of AADL systems can be executed directly or compiled to C for deployments on Linux or the seL4 verified microkernel.

Utilizing ChatGPT to assist CAD design for microfluidic devices.

ChatGPT is a generative AI model that has garnered tremendous public interest due to its ability to solve diverse problems through high-level reasoning and analysis. Among its features is an ability to create and debug code. While this capability has been explored with conventional programming languages such as Python, it has yet to be applied to computer-aided design (CAD). In this work, we utilized GPT-4 to create functional microfluidic components using OpenSCAD, an open-source CAD software package. Through an iterative dialogue, GPT-4 created functional designs for a helix/spiral, a valve, a t-junction, and a serpentine channel. This concept could facilitate CAD in the future for both technical and non-technical users and can be reasonably extended to other fields.

MSEMT: An Advanced Modelica Library for Power System Electromagnetic Transient Studies

Electromagnetic Transient (EMT) simulation tools are typically developed using conventional procedural programming languages. On the other hand, modern high-level and equation-based programming languages, such as Modelica, are currently available. Modelica allows formulating models that are easy to develop, maintain and understand by expressing what needs to be computed without stating how it should be computed. This paper presents a Modelica-based simulator for electromagnetic transients. It is demonstrated that this approach offers significant advantages for developing sophisticated models. Computational performance and accuracy are compared to a conventional EMT-type simulation tool.

UDF to SQL translation through compositional lazy inductive synthesis

Many data processing systems allow SQL queries that call user-defined functions (UDFs) written in conventional programming languages. While such SQL extensions provide convenience and flexibility to users, queries involving UDFs are not as efficient as their pure SQL counterparts that invoke SQL’s highly-optimized built-in functions. Motivated by this problem, we propose a new technique for translating SQL queries with UDFs to pure SQL expressions. Unlike prior work in this space, our method is not based on syntactic rewrite rules and can handle a much more general class of UDFs. At a high-level, our method is based on counterexample-guided inductive synthesis (CEGIS) but employs a novel compositional strategy that decomposes the synthesis task into simpler sub-problems. However, because there is no universal decomposition strategy that works for all UDFs, we propose a novel lazy inductive synthesis approach that generates a sequence of decompositions that correspond to increasingly harder inductive synthesis problems. Because most realistic UDF-to-SQL translation tasks are amenable to a fine-grained decomposition strategy, our lazy inductive synthesis method scales significantly better than traditional CEGIS. We have implemented our proposed technique in a tool called CLIS for optimizing Spark SQL programs containing Scala UDFs. To evaluate CLIS, we manually study 100 randomly selected UDFs and find that 63 of them can be expressed in pure SQL. Our evaluation on these 63 UDFs shows that CLIS can automatically synthesize equivalent SQL expressions in 92% of the cases and that it can solve 2.4× more benchmarks compared to a baseline that does not use our compositional approach. We also show that CLIS yields an average speed-up of 3.5× for individual UDFs and 1.3× to 3.1× in terms of end-to-end application performance.

BIM Visual Programming Tools Applications in Infrastructure Projects: A State-of-the-Art Review

The Building Information Modeling (BIM) methodology improves architectural and infrastructure projects by digitizing their processes throughout their life cycle stages, such as design, construction, management, monitoring, and operation. In recent years, the automation of these processes has been favored by the use of visual programming (VP) tools that have replaced conventional programming languages for visual schemes. The use of these tools in architectural projects is becoming increasing popular. However, this is not the case in infrastructure projects, for which the use of VP algorithms remains scarce. The aim of this work is to encourage both scholars and engineers to implement VP tools in infrastructure projects. For this purpose, this work reviews, for the first time in the literature, the state-of-the-art and future research trends of VP tools in infrastructure projects.

Advanced Computational Techniques in Structural Analysis.

MATLAB is used in engineering to design and simulate the behavior of structures under various circumstances, such as climate, loading conditions, and degrees of freedom. To select the best material for the job, comparison and analysis of the behavior of various materials are carried out. Slope, deflections, shear force, and bending moment diagrams for statically indeterminate structures may be produced using a few lines of code, saving time and effort. Optimization entails a series of decisions to be made at various stages with the ultimate aim of getting the best outcomes from the circumstance and making the subject more efficient from an engineering standpoint. A collection of variables, classified as design variables, restrictions, and goal functions, characterize any engineering system or problem. All of these figures add up to an optimization issue that MATLAB can address. Scripting such programs in MATLAB requires an in-depth theoretical knowledge of structural behavior and analysis. The language has tools and built-in arithmetic functions that enable us to look at a lot of possibilities and come up with a solution more quickly than we could with spreadsheets or conventional programming languages like C, C++, Java, Fortran, and others. This article provides a review of cost optimization methods for bridge superstructures, as well as an analysis of statically determinate beams.

Shopper: A System for Executing and Simulating Expressive Plans

We present Shopper, a plan execution engine that facilitates experimental evaluation of plans and makes it easier for planning researchers to incorporate replanning. Shopper interprets the LTML plan language, which extends PDDL in two major ways: with more expressive control structures, and with support for semantic web services modeled on OWL-S. LTML's command structures include not only conventional ones such as branching, iteration, and procedure calls, but also features needed to handle HTN plans, such as precondition-filtered method choice. Unlike conventional programming languages, LTML supports interaction with the agent's belief store, so that its execution semantics line up with those assumed by planners. LTML actions extend PDDL actions in having outputs as well as effects, which means that they can support actions that sense the world; an important special case of this is semantic web services, which reveal information about a state hidden from the agent. To support experimentation as well as action in the real world, Shopper accommodates multiple, swappable implementations of its primitive action API. For example, one may interact with real web services through SOAP and WSDL, or with simulated web services through local procedure calls. We describe novel features of LTML, the interpretation strategy, swappable back-ends, and the implementation.

ARSITEKTUR CONTAINER DOCKER PADA APLIKASI EXPERT ASSIST DENGAN TEKNOLOGI NODE.JS, EXPRESS FRAMEWORK & CLOUD DATABASE NoSQL MONGODB ATLAS

In the world of software development, the crusial thing we must do is design the architecture. We can said the system is good if it has a good architecture too, because the system architecture will affect the performance of applications itself, from the architecture we can also read what technology is used until security aspect. The main problems that i want to solve are two things, first the problem in the process of software development which will be solve by implementing Docker container architecture & Node.JS and second problems is in society that will be solve by the Expert Assist application. In the case of software development the problems is often when developing applications the architecture is not scalable, conflicts between applications in the system, services that are still centralized, application portability issues, security optimization problems and different environments between the development and production server that will affect developer productivity, problems about not independent and robustless app, resource efficiency and the problem with blocking code that appear in server side conventional programming languages. The problem in society is the difficulty to finding a mentor who can help us to solve the problems we have, that is why Expert Assist application was made. Expert Assist is a web based online platform that will help all people in various fields to finding a mentor who is an expert in his field because not all problems can be solved by independent research or self-taught, if the problem is very complex we need someone who can help us to provide advice in order to solve our problem.

Transitioning from introductory block-based and text-based environments to professional programming languages in high school computer science classrooms

Block-based programming languages are becoming increasingly common in introductory computer science classrooms across the K-12 spectrum. One justification for the use of block-based environments in formal educational settings is the idea that the concepts and practices developed using these introductory tools will prepare learners for future computer science learning opportunities. This view is built on the assumption that the attitudinal and conceptual learning gains made while working in the introductory block-based environments will transfer to conventional text-based programming languages. To test this hypothesis, this paper presents the results of a quasi-experimental classroom study in which programming novices spent five-week using either a block-based or text-based programming environment. After five weeks in the introductory tool, students transitioned to Java, a conventional text-based programming language. The study followed students for 10 weeks after the transition. Over the course of the 15-week study, attitudinal and conceptual assessments were administered and student-authored programs were collected. Conceptual learning, attitudinal shifts, and changes in programming practices were analyzed to evaluate how introductory modality impacted learners as they transitioned to a professional, text-based programming language. The findings from this study build on earlier work that found a difference in performance on content assessments after the introductory portion of the study (Weintrop & Wilensky, 2017a). This paper shows the difference in conceptual learning that emerged after five weeks between the block-based and text-based conditions fades after 10 weeks in Java. No differences in programming practices were found between the two conditions while working in Java. Likewise, differences in attitudinal measures that emerged after working in the introductory environments also faded after 10 weeks in Java, resulting in no difference between the conditions after 15 weeks. The contribution of this work is to advance our understanding of the benefits and limits of block-based programming tools in preparing students for future computer science learning. This paper presents the first quasi-experimental study of the transfer of knowledge between block-based and text-based environments in a high school setting. The lack of significant differences between the two introductory programming modalities after learners transition to professional programming languages is discussed along with the implications of these findings for computer science education researchers and educators, as well as for the broader community of researchers studying the role of technology in education.

Checking Object-Z Formal Specification with Z/EVES automatically

Formal specifications can only be used when matching or non-colliding. In the conventional programming language, program integrity is checked at runtime. However, formal specification descriptions cannot be implemented in general. The grammar analysis and semantic checking of a tool sometimes invalidate conformance checks. Therefore, it is difficult to verify the consistency of formalization norms. In this paper, we propose a method to generate theorem proof for Object-Z norms. The purpose is to obtain clear confidence by verifying the consistency of norms. Finally, we use the theorem prover Z/EVES to analyze and verify theorems.

Analysis Tools for Large Connectomes.

New reconstruction techniques are generating connectomes of unprecedented size. These must be analyzed to generate human comprehensible results. The analyses being used fall into three general categories. The first is interactive tools used during reconstruction, to help guide the effort, look for possible errors, identify potential cell classes, and answer other preliminary questions. The second type of analysis is support for formal documents such as papers and theses. Scientific norms here require that the data be archived and accessible, and the analysis reproducible. In contrast to some other “omic” fields such as genomics, where a few specific analyses dominate usage, connectomics is rapidly evolving and the analyses used are often specific to the connectome being analyzed. These analyses are typically performed in a variety of conventional programming language, such as Matlab, R, Python, or C++, and read the connectomic data either from a file or through database queries, neither of which are standardized. In the short term we see no alternative to the use of specific analyses, so the best that can be done is to publish the analysis code, and the interface by which it reads connectomic data. A similar situation exists for archiving connectome data. Each group independently makes their data available, but there is no standardized format and long-term accessibility is neither enforced nor funded. In the long term, as connectomics becomes more common, a natural evolution would be a central facility for storing and querying connectomic data, playing a role similar to the National Center for Biotechnology Information for genomes. The final form of analysis is the import of connectome data into downstream tools such as neural simulation or machine learning. In this process, there are two main problems that need to be addressed. First, the reconstructed circuits contain huge amounts of detail, which must be intelligently reduced to a form the downstream tools can use. Second, much of the data needed for these downstream operations must be obtained by other methods (such as genetic or optical) and must be merged with the extracted connectome.

Implementing Support for Pointers to Private Data in a General-Purpose Secure Multi-Party Compiler

Recent compilers allow a general-purpose program (written in a conventional programming language) that handles private data to be translated into a secure distributed implementation of the corresponding functionality. The resulting program is then guaranteed to provably protect private data using secure multi-party computation techniques. The goals of such compilers are generality, usability, and efficiency, but the complete set of features of a modern programming language has not been supported to date by the existing compilers. In particular, recent compilers PICCO and the two-party ANSI C compiler strive to translate any C program into its secure multi-party implementation, but they currently lack support for pointers and dynamic memory allocation, which are important components of many C programs. In this work, we mitigate the limitation and add support for pointers to private data and consequently dynamic memory allocation to the PICCO compiler, enabling it to handle a more diverse set of programs over private data. Because doing so opens up a new design space, we investigate the use of pointers to private data (with known as well as private locations stored in them) in programs and report our findings. Aside from dynamic memory allocation, we examine other important topics associated with common pointer use such as reference by pointer/address, casting, and building various data structures in the context of secure multi-party computation. This results in enabling the compiler to automatically translate a user program that uses pointers to private data into its distributed implementation that provably protects private data throughout the computation. We empirically evaluate the constructions and report on the performance of representative programs.

A Module-System Discipline for Model-Driven Software Development

Model-driven development is a pragmatic approach to software development that embraces domain-specific languages (DSLs), where models correspond to DSL programs. A distinguishing feature of model-driven development is that clients of a model can select from an open set of alternative semantics of the model by applying different model transformation. However, in existing model-driven frameworks, dependencies between models, model transformations, and generated code artifacts are either implicit or globally declared in build scripts, which impedes modular reasoning, separate compilation, and programmability in general. We propose the design of a new module system that incorporates models and model transformations as modules. A programmer can apply transformations in import statements, thus declaring a dependency on generated code artifacts. Our design enables modular reasoning and separate compilation by preventing hidden dependencies, and it supports mixing modeling artifacts with conventional code artifacts as well as higher-order transformations. We have formalized our design and the aforementioned properties and have validated it by an implementation and case studies that show that our module system successfully integrates model-driven development into conventional programming languages.

Programming without Programming Languages (New Graphic Poliglot Сoncept)

For the first time since 1947 it is proposed to use a simpler and mathematically more rigorous concept of programming with the graphs loaded only through horizontal arcs with characters, functions and expressions of elementary mathematics. Such graph is a polyglot, it has ISO 8631/1989 standard, and is the only one that can be used effectively throughout the life cycle of program design and use. Conventional programming languages are not needed. The new concept has 100+ times better characteristics with regard to visualization, simplicity, and compactness, as well as the speed of entering into the computer. Processes of error-free design of algorithms, programs, and data structures, evidence of their correctness, self-documenting and documenting of motivation of decisions made are significantly simplified, improved and accelerated. The resulting programs are more effective on the memory footprint and execution time. The larger and the more complex is the program project, the greater is the effect of applying the new concept. The new concept is so simple that it makes it possible to program for ANYONE, not just for programmers. We do not know analogue of the new concept. This article describes the history of developing and proving the new concept, its description, advantages, implemented graphical programming environment, and perspectives for its application.

Relation between Alice software and programming learning: A systematic review of the literature and meta‐analysis

AbstractThis paper presents the results of a systematic review of the literature, including a meta‐analysis, about the effectiveness of the use of Alice software in programming learning when compared to the use of a conventional programming language. Our research included studies published between the years 2000 and 2014 in the main databases. We gathered 232 papers. Taking into account the selection criteria to make the meta‐analysis, we retained six papers with a quasi‐experimental design, with 464 participants in total. To combine the results we used the random effect model. It resulted in an effect size of 0.54 (Cohen's d) with a confidence interval between 0.34 and 0.74.We concluded that until now there have been few experimental results on the effectiveness of Alice programming language to introduce students in learning how to program. The results we found were the expression of different experimental treatments and distinguished teaching methods which made the comparison of the results obtained more subtle. However, the existing experimental results that were submitted to the meta‐analysis allowed us to assume with a certain margin of safety that a teaching strategy that uses Alice should obtain more effective results than the use of a conventional programming language.

Construction of Concurrent Programs Based on a Modeling and Simulation Formalism

This paper proposes a framework for developing a concurrent program using the discrete event system specification (DEVS) formalism. Within the proposed framework, a concurrent program is modeled by the DEVS formalism, and the modeling result is validated through simulation in a DEVS abstract simulator environment, called DEVSim++. Then, the validated modeling results are translated to multi-threaded program codes written in a conventional programming language. For that, each DEVS model which specifies behavior of a component is converted to a single thread, called an atomic thread, and every connection information between the components are clustered together and converted to a data structure, called a port mapping table. This paper also proposes an efficient solution which combines several atomic threads into a new thread, called a combined thread.

Semantic framework for mapping object-oriented model to semantic web languages.

The article deals with and discusses two main approaches in building semantic structures for electrophysiological metadata. It is the use of conventional data structures, repositories, and programming languages on one hand and the use of formal representations of ontologies, known from knowledge representation, such as description logics or semantic web languages on the other hand. Although knowledge engineering offers languages supporting richer semantic means of expression and technological advanced approaches, conventional data structures and repositories are still popular among developers, administrators and users because of their simplicity, overall intelligibility, and lower demands on technical equipment. The choice of conventional data resources and repositories, however, raises the question of how and where to add semantics that cannot be naturally expressed using them. As one of the possible solutions, this semantics can be added into the structures of the programming language that accesses and processes the underlying data. To support this idea we introduced a software prototype that enables its users to add semantically richer expressions into a Java object-oriented code. This approach does not burden users with additional demands on programming environment since reflective Java annotations were used as an entry for these expressions. Moreover, additional semantics need not to be written by the programmer directly to the code, but it can be collected from non-programmers using a graphic user interface. The mapping that allows the transformation of the semantically enriched Java code into the Semantic Web language OWL was proposed and implemented in a library named the Semantic Framework. This approach was validated by the integration of the Semantic Framework in the EEG/ERP Portal and by the subsequent registration of the EEG/ERP Portal in the Neuroscience Information Framework.

Programming languages for circuit design.

This chapter provides an overview of a programming language for Genetic Engineering of Cells (GEC). A GEC program specifies a genetic circuit at a high level of abstraction through constraints on otherwise unspecified DNA parts. The GEC compiler then selects parts which satisfy the constraints from a given parts database. GEC further provides more conventional programming language constructs for abstraction, e.g., through modularity. The GEC language and compiler is available through a Web tool which also provides functionality, e.g., for simulation of designed circuits.

Laboratory automation in a functional programming language.

After some years of use in academic and research settings, functional languages are starting to enter the mainstream as an alternative to more conventional programming languages. This article explores one way to use Haskell, a functional programming language, in the development of control programs for laboratory automation systems. We give code for an example system, discuss some programming concepts that we need for this example, and demonstrate how the use of functional programming allows us to express and verify properties of the resulting code.

Using Fuzzy Logic in Business

Nowadays, the trader is forced to navigate a plethora of information about the products it has to offer. For the customer, some characteristics of a product are more important than others. The salesperson must consider this information. Therefore, sales-people often use computers in order to serve customers quickly. Conventional programming languages are based on Boolean logic. They are well suited to develop systems whose behaviour can be well represented by mathematical models. However, in terms of developing systems that mimic human-like decision-making, mathematical models fall short. Human judgment and evaluation neither follows Boolean logic, nor any other conventional mathematical discipline.This paper seeks to show the benefits of using fuzzy logic in trading. It shows a simple and very fast system that demonstrates how to select a suitable lawn mower, according to customer requirements and preferences. The proposed system can then be used on any offered range. The benefits of such a system are then confronted with the opinions of sales-people themselves.