Object-oriented description of queueing systems for flow control studies

Object oriented (OO) is the most accepted object modeling languages nowadays. Although OO languages are successful in modeling real world entities, nevertheless, there is little to no support for modeling state of object precisely in code. To overcome this problem, a new general purpose programming language is proposed that is built on two paradigms which are typestate-oriented and permission-based. One of the most vital factor for every language to be accepted and effective for users is having an enhanced standard library and clearly one of the most important parts is Input and Output (I/O) Application Programming Interface (API). One of a new programming language is Plaid language. Since the Plaid is at its early stage of development, I/O features provided by the Plaid standard library are very basic and limited. This paper presents I/O API that we have developed for the Plaid based on the features provided by Java I/O API. For the evaluation we used two metrics which are the number of features provided by I/O API, and the number of exceptions eliminated by using Plaid and typestate-oriented programming language.

Instead of writing SQL queries directly, programmers often prefer writing all their code in a general purpose programming language like Java and having their programs be automatically rewritten to use database queries. Traditional tools such as object-relational mapping tools are able to automatically translate simple navigational queries written in object-oriented code to SQL. More recently, techniques for translating object-oriented code written in declarative or functional styles into SQL have been developed. For code written in an imperative style though, current techniques are still limited to basic queries. JReq is a system that is able to identify complex query operations like aggregation and nesting in imperative code and translate them into efficient SQL queries. The SQL code generated by JReq exhibits performance comparable with hand-written SQL code.

This overview of C++ presents the key design, programming, and language-technical concepts using examples to give the reader a feel for the language. C ++ is a general-purpose programming language with a bias towards systems programming that supports efficient low-level computation, data abstraction, object-oriented programming, and generic programming.

Object oriented programming approach for quality improvement based on systematic diagram method

This paper reconsiders the threat posed by Shacham's -- a technique by which W-xor-X-style hardware protections are evaded via carefully crafted stack frames that divert control flow into the middle of existing variable-length x86 instructions -- creating short new instructions streams that then return. We believe this attack is both more general and a greater threat than the author appreciated. In fact, the vulnerability is not limited to the x86 architecture or any particular operating system, is readily exploitable, and bypasses an entire category of malware protections. In this paper we demonstrate general return-oriented programming on the SPARC, a fixed instruction length RISC architecture with structured control flow. We construct a Turing-complete library of code gadgets using snippets of the Solaris libc, a general purpose programming language, and a compiler for constructing return-oriented exploits. Finally, we argue that the threat posed by return-oriented programming, across all architectures and systems, has negative implications for an entire class of security mechanisms: those that seek to prevent malicious computation by preventing the execution of malicious code.

Chapter 33 - From Novice to expert

Volumes of information available from network information services have been increasing considerably in recent years. Users' satisfaction with an information service depends very much on the quality of the network information retrieval (NIR) system used to retrieve information. The construction of such a system involves two major development areas: user interface design and the implementation of NIR protocols.In this paper we describe and discuss the possibilities of using formal methods of protocol converter design to construct the part of an NIR system client that deals with network communication. If this approach is practicable it can make implementation of NIR protocols more reliable and amenable to automation than traditional designs using general purpose programming languages. This will enable easy implementation of new NIR protocols custom-tailored to specialized NIR services, while the user interface remains the same for all these services.Based on a simple example of implementing the Gopher protocol client we conclude that the known formal methods of protocol converter design are generally not directly applicable for our approach. However, they could be used under certain circumstances when supplemented with other techniques which we propose in the discussion.

Choosing the Event-B formal method to model and develop distributed railway interlocking systems can give us a great advantage over the general purpose programming languages, especially in case of the safety analysis of these systems. Despite its many benefits, Event-B suffers from an efficient reuse mechanism, which is highly disadvantageous in the development of large interlocking systems. In this paper we propose a structured approach to modelling and developing large geographical interlocking systems, combining the communication models of session types with the railway entity models of Event-B. This work combines Event-B with a component-based reuse strategy realized with session types and consists of an Event-B extension with communication primitives to enable communication between the railway entities, a projection of session type specifications and a verification mechanism for these specifications to ensure global safety by the local verification of entities.

This article surveys principles for the design and development of microcomputer-based instructional software. A set of design guidelines based upon existing research are outlined. Three approaches to authoring software are examined: general purpose programming languages, author languages, and authoring systems. The tradeoffs in using these three approaches are outlined. The implications of research in automated instructional development systems and intelligent tutoring systems are discussed.

Chemistry imposes formidable requirements on application developers. One of the toughest is the manipulation of chemical structures as first-class data structures. General purpose programming language don’t fulfil this requirement, so the responsibility falls to a peculiar layer of software.

Information appliances (IAs) are able to interact and share information with each other using their communication abilities. However, current inter-IA interaction development using the general purpose programming language, e.g., C/C++ and Java approach, involves lots of time for system development process, i.e., (1) program writing, (2) source code compilation, (3) executable code loading, and (4) executable code distribution. In this paper, we introduce the concept of instantaneous reflection of inter-IA interaction development to help fast inter-IA interaction development without going through the above 4 processes. In this paper, we have designed an Inter-IA Interaction Development Platform (I^2DP) that enables instantaneous reflection of inter-IA interaction development using the high level script language approach. Main components of the I^2DP platform architecture include (ⅰ) IAs and (ⅱ) Administration Gateway that is responsible for the inter-entity communication and execution of inter-IA interactions. The core of I^2DP consists of (ⅰ) Service Invocation Protocol (SIP), which is a control protocol for IAs, and (ⅱ) Service Interaction Script language (SIS), which is a script language that can specify inter-IA interactions. As a result, instantaneous reflection of inter-IA interaction development using high level script language can be achieved in I^2DP.

The popular slogan “write once, run anywhere” effectively renders the expressive capabilities of the JAVA programming framework for developing, deploying, and reusing target-independent applets. Its generality and simplicity has driven most attention of the compiler technology community to developing just-in-time and runtime compilation techniques, local and compositional optimization algorithms. When it comes to real-time JAVA and to the implementation of embedded software, this approach is however far from satisfactory, especially in hard real-time system design (e.g. airborne systems) where conformance to real-time specifications is critical. We show that synchronous design tools, and particularly the design workbench POLYCHRONI, allow for a complete modeling of embedded software written in a high-level and general purpose programming language such as JAVA. The synchronous approach provides a formal engineering model and methodology, using global transformation and optimization techniques, that allow for a JAVA program written once to be mapped on any distributed target architecture. We present a technique to import a resource constrained, multi-threaded, RT JAVA program, together with its runtime system API, into POLYCHRONI. We put this modeling technique to work by considering a formal, refinement-based, design methodology that allows for a correct by construction remapping of the initial threading architecture of a given JAVA program on either a single-threaded target or a distributed architecture. This technique allows to generate stand-alone (Jvm-less) executables and to remap threads onto a given distributed architecture or a prescribed target real-time operating system. As a result, it allows for a complete separation between the virtual threading architecture of the functional-level system design (in JAVA) and its actual, real-time and resource constrained implementation.

Development of a web-resource today is a very frequent and not always simple task. Especially if we are not talking about a static one-page website, but about a dynamic web application with an unlimited number of pages, as well as the ability to withstand heavy loads, typical of such projects. To solve these problems, there are very few ready-made solutions. Of the best ones, perhaps, only WebDSL can be distinguished, but even it has a number of drawbacks inherited from the Java project implementation language, such as, for example, low flexibility, high performance costs and the need to install a java-machine. The development process was carried out using a relatively low-level C++ general purpose programming language, which saved the project from the problems that its competitors faced, ensured high interpreter performance and cross-platform system-wide. The authors described in detail the selected means of the meta-management of the access rights of the BlockSet project, as well as the syntax of their use in the declarative highly abstract subject-oriented language BML, using simple and accessible examples to demonstrate the conciseness, but the constructiveness of the selected syntax solutions. The results obtained are of great value, as they significantly simplify the further process of administering a web resource, which is also one of the main tasks of the BlockSet project. Thus, the BML language, together with the system of access rights, provides flexible, powerful, and at the same time fairly simple and understandable methods for organizing the required system, which corresponds to the project’s paradigms on flexibility and a low threshold of entry, and also significantly optimizes the development process.

Since Computer Science students are used to applying both General Purpose Programming Languages (GPPLs) and Domain-Specific Languages (DSLs), Generative Artificial Intelligence based on Language Models (LMs) can help them on automatic tasks, allowing them to focus on more creative tasks and higher skills. However, the teaching and evaluation of technical tasks in Computer Science can be inefficient and prone to errors. Thus, the main objective of this article is to explore the performance of LMs compared to that of undergraduate Computer Science students in a specific case study: designing and implementing RESTful APIs DSLs. This research aims to determine if LMs can enhance the efficiency and accuracy of these processes. Our case study involved 39 students and 5 different LMs that must use the two DSLs we also designed for their task assignment. To evaluate performance, we applied uniform criteria to student and LMs-generated solutions, enabling a comparative analysis of accuracy and effectiveness. With a case study comparing performance between students and LMs, this article contributes to checking to what extent LMs are able to carry out software development tasks involving the use of new DSLs specially designed for highly specific settings in a similar way as well-qualified Computer Science students are able to. The results underscore the importance of welldefined DSLs and effective prompting processes for optimal LM performance. Specifically, LMs demonstrated high variability in task execution, with two GPT-based LMs achieving similar grades to those scored by the best of the students for every task, obtaining 0.78 and 0.92 on a normalized scale [0, 1], with 0.23 and 0.14 Standard Deviation for ChatGPT-4 and ChatGPT-4o respectively. After the experience, we can conclude that a well-defined DSL and a proper prompting process, providing the LM with metadata, persistent prompts, and a good knowledge base, are crucial for good LM performance. When LMs receive the right prompts, both large and small LMs can achieve excellent results depending on the task.

Hyperledger Sawtooth is a general purpose blockchain project featuring pluggable consensus mechanisms and smart contracts that can be written in any general purpose programming language. We introduce a design pattern that enables communication between smart contracts for Hyperledger Sawtooth. The pattern is called Inter-Family Communication and we apply it to build a general crypto-asset framework where assets can be controlled by secondary smart contracts. The pattern is designed secure with formal models for Hyperledger Sawtooth and relevant concepts to the Inter-family Communication design pattern.