Traditional Programming Languages Research Articles

Event-based implicit invocation decentralized in Ada

Nowadays more and more attraction is drawn by the event-based implicit invocation --- one of useful architectural patterns, because of its loose coupling between components in the architecture and reactive integration in software systems. Analyzing object-oriented interaction with objects, this paper, based upon the principle of software architecture, presents an approach on event-based object model with Ada exception handler. Consequently it is possible for us to improve, with adding specific architectural patterns, traditional programming languages into architectural description languages.

Object-oriented modelling and specification using SHE

Industry is facing a crisis in the design of complex hardware/software systems. Due to the increasing complexity, the gap between the generation of a product idea and the realisation of a working system is expanding rapidly. To manage complexity and to shorten design cycles, industry is forced to look at system-level languages towards specification and design. The (formal) system-level modelling language called POOSL is very expressive and is able to model dynamic hard real-time behaviour and to (visually) capture static (architecture and topology) structure in an object-oriented fashion. The language integrates a process part, based on the process algebra CCS, with a data part, based on the concepts of traditional object-oriented programming languages and it is equipped with a formal semantics. Currently, a number of automated software tools (model editing, simulator and compiler tools) are available in an environment called SHESim. These tools allow visual entry of structure and topology of the system, whereas dynamic behaviour of individual processes is expressed in an expressive imperative language. The formal semantics of POOSL provides a solid basis for the application of verification and performance analysis techniques and establishing a rigorous connection to existing analysis tools.

Event-based implicit invocation decentralized in Ada

Nowadays more and more attraction is drawn by the event-based implicit invocation—one of useful architectural patterns, because of its loose coupling between components in the architecture and reactive integration in software systems. Analyzing object-oriented interaction with objects, this paper, based upon the principle of software architecture, presents an approach on event-based object model with Ada exception handler. Consequently it is possible for us to improve, with adding specific architectural patterns, traditional programming languages into architectural description languages.

Notable design patterns for domain-specific languages

The realisation of domain-specific languages ( dsls) differs in fundamental ways from that of traditional programming languages. We describe eight recurring patterns that we have identified as being used for dsl design and implementation. Existing languages can be extended, restricted, partially used, or become hosts for dsls. Simple dsls can be implemented by lexical processing. In addition, dsls can be used to create front-ends to existing systems or to express complicated data structures. Finally, dsls can be combined using process pipelines. The patterns described form a pattern language that can be used as a building block for a systematic view of the software development process involving dsls.

Application of knowledge management for hazard analysis in the Australian dairy industry

Generic performance measures have emerged as appropriate tools for assessing the performance of the Hazard Analysis Critical Control Point (HACCP). These measures provide information for staffing decisions and budgetary development in the food manufacturing industry. They are also used to configure variations for costing, pricing, packaging and other functions. The HACCP performance measures have become powerful tools in the management of modern food manufacturers, in particular the dairy industry. The majority of decisions and rules used for assessing the performance of the HACCP method are too complex to capture in the form of a traditional programming language. Conventional information systems automate simple and rigid bookkeeping functions but knowledge management tools automate complex decision making and processes requiring judgement, and therefore are appropriate for automating the people‐based knowledge of the HACCP performance assessment method. A new technique is presented to automate the HACCP performance assessment method using knowledge processing.

Verifying properties of process definitions

It seems important that the complex processes that synergize humans and computers to solve widening classes of societal problems be subjected to rigorous analysis. One approach is to use a process definition language to specify these processes and to then use analysis techniques to evaluate these definitions for important correctness properties. Because humans demand flexibility in their participation in complex processes, process definition languages must incorporate complicated control structures, such as various concurrency, choice, reactive control, and exception mechanisms. The underlying complexity of these control abstractions, however, often confounds the users' intuitions as well as complicates any analysis. Thus, the control abstraction complexity in process definition languages presents analysis challenges beyond those posed by traditional programming languages. This paper explores some of the difficulties of analyzing process definitions. We explore issues arising when applying the FLAVERS finite state verification system to processes written in the Little-JIL process definition language and illustrate these issues using a realistic auction example. Although we employ a particular process definition language and analysis technique, our results seem more generally applicable.

Teaching computer graphics and robotics using symbolic computation software

An approach to teaching undergraduate courses in computer graphics and robotics is presented. Objects in two and three dimensions of various shapes are involved in the study of graphics and robotics. The representation and manipulation of these objects constitute important topics of discussion in these courses. Students will evince keen interest in learning the material if instructors supplement classroom lectures with demonstrations and homework assignments using a symbolic computing program for solving problems. In this article, it is shown how Maple can be used for solving a wide range of problems arising in robotics and graphics, each with different requirements in terms of the software tools required. Fast prototype development, concept illustration, and graphical solution verification are facilitated by the use of a symbolic computing system such as Maple, and these cannot be accomplished with the same ease using traditional programming languages such as C or FORTRAN. © 2000 John Wiley & Sons, Inc. Comput Appl Eng Educ 8: 18–30, 2000

A customisable memory management framework for C++

Automatic garbage collection relieves programmers from the burden of managing memory themselves and several techniques have been developed that make garbage collection feasible in many situations, including real time applications or within traditional programming languages. However, optimal performance cannot always be achieved by a uniform general purpose solution. Sometimes an algorithm exhibits a predictable pattern of memory usage that could be better handled specifically, delaying as much as possible the intervention of the general purpose collector. This leads to the requirement for algorithm specific customisation of the collector strategies. We present a dynamic memory management framework which can be customised to the needs of an algorithm, while preserving the convenience of automatic collection in the normal case. The Customisable Memory Manager (CMM) organises memory in multiple heaps. Each heap is an instance of C++ class which abstracts and encapsulates a particular storage discipline. The default heap for collectable objects uses the technique of mostly copying garbage collection, providing good performance and memory compaction. Customisation of the collector is achieved exploiting object orientation by defining specialised versions of the collector methods for each heap class. The object-oriented interface to the collector enables coexistence and coordination among the various collectors as well as integration with traditional code unaware of garbage collection. The CMM is implemented in C++ without any special support in the language or the compiler. The techniques used in the CMM are general enough to be applicable also to other languages. The performance of the CMM is analysed and compared to other conservative collectors for C/C++ in various configurations. © 1998 John Wiley & Sons, Ltd.

Evaluating the Usability of Robot Programming Toolsets

The days of specifying missions for mobile robots using traditional programming languages such as C++ and LISP are coming to an end. The need to support operators lacking programming skills coupled with the increasing diversity of robot run-time operating systems is moving the field toward high-level robot programming toolsets that allow graphical mission specification. This paper ex plores the issues of evaluating such toolsets as to their usability. We first examine how usability criteria are established and perfor mance target values are chosen. The methods by which suitable experiments are created to gather data relevant to the usability criteria are then presented. Finally, methods to analyze the data gathered to establish values for the usability criteria are discussed. The MissionLab toolset is used as a concrete example throughout the article to ground the discussions, but the methods and techniques are generalizable to many such systems.

Security issues surrounding programming languages for mobile code

JAVA is claimed to be a system programming language having a number of advantages over traditional programming languages. These advantages stem from the fact that it is a platform - independent language, thus promising truly network oriented computing as long as a nearly universal system for distributing applications. On the other hand, although being an interpreted, much simpler, scripting language, Safe-Tcl was proposed as an executable contents type of MIME and thus as the standard language for executable contents within email. Consequently, both languages claim to be suitable for transmitting executable content over the Internet, in other words manipulating mobile code. However, the ability to download, integrate, and execute code from a remote computer raises serious concerns about JAVA's as well as Safe-Tcl's effect on network security. In this paper, the potential security risks of mobile code are discussed, a brief introduction to both programming languages is given, and the details of each of the proposed security mechanisms are presented. Finally a comparison of the two security models is given, centered upon the efficiency and flexibility of current implementations as well as upcoming extensions.

Patient Dependency Knowledge-Based Systems.

The ability of Patient Dependency Systems to provide information for staffing decisions and budgetary development has been demonstrated. In addition, they have become powerful tools in modern hospital management. This growing interest in Patient Dependency Systems has renewed calls for their automation. As advances in Information Technology and in particular Knowledge-Based Engineering reach new heights, hospitals can no longer afford to ignore the potential benefits obtainable from developing and implementing Patient Dependency Knowledge-Based Systems. Experience has shown that the vast majority of decisions and rules used in the Patient Dependency method are too complex to capture in the form of a traditional programming language. Furthermore, the conventional Patient Dependency Information System automates the simple and rigid bookkeeping functions. On the other hand Knowledge-Based Systems automate complex decision making and judgmental processes and therefore are the appropriate technology for automating the Patient Dependency method. In this paper a new technique to automate Patient Dependency Systems using knowledge processing is presented. In this approach all Patient Dependency factors have been translated into a set of Decision Rules suitable for use in a Knowledge-Based System. The system is capable of providing the decision-maker with a number of scenarios and their possible outcomes. This paper also presents the development of Patient Dependency Knowledge-Based Systems, which can be used in allocating and evaluating resources and nursing staff in hospitals on the basis of patients' needs.

Actors and scripts: Object-oriented simulation of enterprise systems

Simulation is one of the most frequently used techniques for modeling manufacturing and other systems found in modern enterprises. Most simulation models are built with either a traditional programming language such as FORTRAN or a simulation software package written in a traditional programming language. These tools have their limitations. Object-oriented technology has seen increasing application in many fields and promises a more flexible and efficient approach to simulating business systems. However, many professionals engaged in modeling systems in enterprises are not yet familiar with the technology. This article provides a succinct introduction to object-oriented concepts and presents an intuitive methodology for building object-oriented simulation models. The methodology, which is based on the ideas of actors and scripts, is illustrated with queuing models. The advantages and limitations of the methodology are discussed.

Flick

An interface definition language ( IDL ) is a nontraditional language for describing interfaces between software components. IDL compilers generate "stubs" that provide separate communicating processes with the abstraction of local object invocation or procedure call. High-quality stub generation is essential for applications to benefit from component-based designs, whether the components reside on a single computer or on multiple networked hosts. Typical IDL compilers, however, do little code optimization, incorrectly assuming that interprocess communication is always the primary bottleneck. More generally, typical IDL compilers are "rigid" and limited to supporting only a single IDL , a fixed mapping onto a target language, and a narrow range of data encodings and transport mechanisms. Flick , our new IDL compiler, is based on the insight that IDL s are true languages amenable to modern compilation techniques. Flick exploits concepts from traditional programming language compilers to bring both flexibility and optimization to the domain of IDL compilation. Through the use of carefully chosen intermediate representations, Flick supports multiple IDL s, diverse data encodings, multiple transport mechanisms, and applies numerous optimizations to all of the code it generates. Our experiments show that Flick-generated stubs marshal data between 2 and 17 times faster than stubs produced by traditional IDL compilers, and on today's generic operating systems, increase end-to-end throughput by factors between 1.2 and 3.7.

The Effects of HyperCard Programming on Teacher Education Students’ Problem-Solving Ability and Computer Anxiety

The purpose of this study was to investigate whether a lengthened HyperCard treatment could promote problem-solving ability and reduce computer anxiety. It built upon a previous study by Reed and Liu (1994), which examined the comparative effects of the BASIC programming language and the HyperCard authoring language on students’ problem solving and computer anxiety. The Reed and Liu study found that after being exposed to the programming instruction for approximately 54 hrs, the problem-solving skills of the BASIC group improved significantly, whereas the problem-solving skills of the HyperCard group did not. This present research sought to answer the question “Can HyperCard promote problem solving if the treatment is lengthened and more of the programming components of HyperCard are included?” This study replicated a similar treatment, but lengthened the HyperCard instruction from 54 to 150 hrs of exposure to the language. The results showed that the lengthened treatment on HyperCard programming had an effect on problem solving. Students’ problem-solving scores increased significantly from pretreatment to the posttreatment. The most significant increase occurred between midtreatment and posttreatment, when students were involved in intense HyperCard programming. Students’ computer anxiety was reduced significantly, and a possible relationship between problem solving and computer anxiety was suggested. The implications of these findings with relation to teaching authoring languages such as HyperCard and traditional programming languages like BASIC were discussed.

Programming with non-determinism in deductive databases

While non-determinism has long been established as a key concept in logic pro-gramming, its importance in the context of deductive databases was recognized only recently. This paper provides an overview of recent results on this topic with the aim of providing an introduction to the theory and practice of non-determinism in deductive databases. In particular we (i) recall the main results linking non-deterministic constructs in database languages to the theory of data complexity and the expressibility hierarchy of query languages; (ii) provide a reasoned introduction to effective programming with non-deterministic constructs; (iii) compare the usage of non-deterministic constructs in languages such as LDL++ to that of traditional logic programming languages; (iv) discuss the link between the semantics of logic programs with non-deterministic constructs and the stable-model semantics of logic programs with negation.

The next 10,000/sub 2/ years. I

Forecasts technological breakdowns and breakthroughs for the next 16 (10,000 to the base 2) years. Change has always been a part of recent history. Indeed, Earth-shaking change occurs about every 150-200 years. It takes about 50 years to make the transition from the old to the new, and we are nearing the end of just such a 50-year period. Change is caused by both technological breakthroughs and technological breakdowns. In the current 50-year transition, the breakthrough is in networking and software development, and the breakdown is in processor (VLSI) technology. Both forces will propel the high-tech world into a new model of computing by the year 2012. The new model will be based on a networked, global megacomputer that obeys the Gustafson-Barsis speedup law instead of the Amdahl law of parallelism. The next century's information superhighway will actually be a network of cable TV operators, not telephone companies. A new era of programming that eliminates traditional programming languages (and scolds the software engineering community for failure) will arise and lead to a software economy-an electronic commerce dominated by software artisans.

A formal approach to reactive systems software: A telecommunications application in Esterel

Esterel is a formally-defined language designed for programming reactive systems; namely, those that maintain a permanent interaction with their environment. The ATT this implementation has been tested in the 5ESS switch simulator. Furthermore, it has been formally verified that this implementation satisfies some safety properties stated by 5ESS software development. Our experience indicates that Esterel is suitable for programming industrial-strength reactive systems, and affords significant advantages in software development over more traditional programming languages used in industrial settings.

Generation of design verification tests from behavioral VHDL programs using path enumeration and constraint programming

A method for generation of design verification tests from behavior-level VHDL programs is presented. The method generates stimuli to execute desired control-flow paths in the given VHDL program. This method is based on path enumeration, constraint generation and constraint solving techniques that have been traditionally used for software testing. Behavioral VHDL programs contain multiple communicating processes, signal assignment statements, and wait statements which are not found in traditional software programming languages. Our model of constraint generation is specifically developed for VHDL programs with such constructs. Control-flow paths for which design verification tests are desired are specified through certain annotations attached to the control statements in the VHDL programs. These annotations are used to enumerate the desired paths. Each enumerated path is translated into a set of mathematical constraints corresponding to the statements in the path. Methods for generating constraint variables corresponding to various types of carriers in VHDL and for mapping various VHDL statements into mathematical relationships among these constraint variables are developed. These methods treat spatial and temporal incarnations of VHDL carriers as unique constraint variables thereby preserving the semantics of the behavioral VHDL programs. Constraints are generated in the constraint programming language CLP(R) and are solved using the CLP(R) system. A solution to the set of constraints so generated yields a design verification test sequence which can be applied for executing the corresponding control path when the design is simulated. If no solution exists, then it implies that the corresponding path can never be executed. Experimental studies pertaining to the quality of path coverage and fault coverage of the verification tests are presented. >

An environment for interpreter-based programming language projects

This paper discusses the programming language course and presents an approach to some of the pedagogical challenges presented. We aim to expose students to all the concepts central to a traditional programming language course but also give experience with the implementation of various languages. To this end, we are developing a software environment, MULE, which supports this teaching goal. This paper gives an overview of MULE and discusses our recent experiences using MULE as a teaching tool.

Integrating pointer variables into one-way constraint models

Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into one-way constraint models and indicates how these constraints can be usefully employed in user interfaces. Pointer variables allow constraints to model a wide array of dynamic application behavior, simplify the implementation of structured objects and demonstrational systems, and improve the storage and efficiency of constraint-based applications. This article presents two incremental algorithms—one lazy and one eager— for solving constraints with pointer variables. Both algorithms are capable of handling (1) arbitrary systems of one-way constraints, including constraints that involve cycles, and (2) editing models that allow multiple changes between calls to the constraint solver. These algorithms are fault tolerant in that they can handle and recover gracefully from formulas that crash due to programmer error. Constraints that use pointer variables have been implemented in a comprehensive user interface toolkit, Garnet, and our experience with applications written in Garnet have proven the usefulness of pointer variable constraints. Many large-scale applications have been implemented using these constraints.