Agentsheets: a medium for creating domain-oriented visual languages

Customized visual representations enable end users to achieve their programming goals. Here, designers work with users to tailor visual programming languages to specific problem domains. We describe a design methodology and a tool for creating domain oriented, end user programming languages that effectively use visualization. We first describe a collaborative design methodology involving end users and designers. We then present Agentsheets, a tool for creating domain oriented visual programming languages, and illustrate how it supports collaborative design by examining experiences from a real language design project. Finally, we summarize the contributions of our approach and discuss its viability in industrial design projects     

Exception handling in the spreadsheet paradigm

Exception handling is widely regarded as a necessity in programming languages today and almost every programming language currently used for professional software development supports some form of it. However, spreadsheet systems, which may be the most widely used type of “programming language” today in terms of number of users using it to create “programs” (spreadsheets), have traditionally had only extremely limited support for exception handling. Spreadsheet system users range from end users to professional programmers and this wide range suggests that an approach to exception handling for spreadsheet systems needs to be compatible with the equational reasoning model of spreadsheet formulas, yet feature expressive power comparable to that found in other programming languages. We present an approach to exception handling for spreadsheet system users that is aimed at this goal. Some of the features of the approach are new; others are not new, but their effects on the programming language properties of spreadsheet systems have not been discussed before in the literature. We explore these properties, offer our solutions to problems that arise with these properties, and compare the functionality of the approach with that of exception handling approaches in other languages     

An Automatic Fusion Mechanism for Variable-Length List Skeletons in SkeTo

Skeletal parallel programming is a promising approach to easy parallel programming in which users can build parallel programs simply by combining parts of a given set of ready-made parallel computation patterns called skeletons. There is a trade-off for this easiness in the form of an efficiency problem caused by the compositional style of the programming. One solution to this problem is fusion transformation that optimizes naively composed skeleton programs by eliminating redundant intermediate data structures. Several parallel skeleton libraries have automatic fusion mechanisms. However, there have been no automatic fusion mechanisms proposed for variable-length list (VLL) skeletons, even though such skeletons are useful for practical problems. The main difficulty is that previous fusion mechanisms are not applicable to VLL skeletons, and so the fusion cannot be completed. In this paper, we propose a novel fusion mechanism for VLL skeletons that can achieve both an easy programming interface and complete fusion. The proposed mechanism has been implemented in our skeleton library, SkeTo, by using the expression templates technique, experimental results have shown that it is very effective.     

Teaching problem solving and structured programming in FORTRAN

This paper describes an approach to teaching problem solving in an introductory programming course using the FORTRAN language. The course is oriented around a set of problems which are used to illustrate a problem solving methodology. Three pedagogic aids (data table, flow diagram, and program system chart) and two control structure extensions to the FORTRAN language are used in order to provide a more convenient framework in which students can practice good problem solving and programming techniques. The control structure extensions facilitate structured programming in FORTRAN. The use of the control structures and the pedagogic aids is illustrated in the solution of a simple statistics problem: the benefits derived from using these aids are also discussed.     

Designing and prototyping data-intensive applications in the Logresand Algres programming environment

The authors present an environment and a methodology for the design and rapid prototyping of data-intensive software applications, i.e., applications which perform substantial retrieval and update activity on persistent data. In the approach, the application is formally specified using Logres, a database language which combines object-oriented data modeling and rule-based programming. These specifications are translated into Algres, an extended relational algebra, thus yielding a rapid executable prototype. Algres programs embedded into a conventional programming language interface may be converted to conventional programs operating on a commercial relational system. This methodology helps automate the conversion from declarative requirements to imperative code, performing several tasks fully automatically and reducing the probability of human errors, while integrity constraints and application specifications are expressed in a declarative language, at a very high level of abstraction     

Design issues in parallel simulation languages

The authors address several key issues in designing languages for parallel discrete-event simulation and survey the state-of-the-art techniques aimed at solving these problems. Attention is given to issues that are specific to parallel simulation, e.g., the parallel synchronization schemes, or issues that have not previously been a problem for sequential simulation, e.g., termination. Various specialized PSLs (parallel simulation languages) may also have quite different design issues. The problem of achieving transparency is addressed. In particular it is observed that a major difficulty in achieving the design criteria is the overhead introduced by the methods for solving the problems considered. In some cases making the design criteria less constrained appears to be unavoidable. The authors also propose several useful high-level language constructs to facilitate modeling in order to have the simulation system deal with the low-level details transparently. They show that extending the capability of an existing programming language is the simplest available technique for designing a PSL     

Critical factors in the evolution of logic programming and Prolog

Logic programming has received much critical attention over the past two decades from both a language perspective and as a methodology for practical problem solving. This paper presents a historical foundation of the approach and examines the development of Prolog since its first implementation. An analysis of the use of Prolog in commercial, research and teaching environments shows that there is an established base of users and that, after a period of rapid growth, the language currently enjoys continuing activity. The key to its success so far is due to its continuing evolution by including features that were not seen as being within the original concept as a pure logic language. Significant features which have contributed to the success of Prolog include integration with other languages, object oriented extensions, constraint representation, parallel execution as well as improved speed and robustness. Applications databases are analysed with respect to type of application, system status, type of developer, hardware platform, country of origin and the Prolog implementation used. Factors contributing to the success of Prolog are identified and likely future developments are explored.     

A design methodology for synthesizing parallel algorithms and architectures

In this paper, a design methodology for synthesizing efficient parallel algorithms and VLSI architectures is presented. A design process starts with a problem definition specified in the parallel programming language Crystal and is followed by a series of program transformations in Crystal, each aiming at optimizing the target design for a specific purpose. To illustrate the design methodology, a set of design methods for deriving systolic algorithms and architectures is given and the use of these methods in the design of a dynamic programming solver is described. The design methodology, together with this particular set of design methods, can be viewed as a general theory of systolic designs (or multidimensional pipelines). The fact that Crystal is a general purpose language for parallel programming allows new design methods and synthesis techniques, properties and theorems about problems in specific application domains, and new insights into any given problem to be integrated readily within the existing design framework.     

High‐level specifications for automatically generating parallel code

The arrival of multicore systems, along with the speed‐up potential available in graphics processing units, has given us unprecedented low‐cost computing power. These systems address some of the known architecture problems but at the expense of considerably increased programming complexity. Heterogeneity, at both the architectural and programming levels, poses a great challenge to programmers. Many proposals have been put forth to facilitate the job of programmers. Leaving aside proposals based on the development of new programming languages because of the effort this represents for the user (effort to learn and reuse code), the remaining proposals are based on transforming sequential code into parallel code, or on transforming parallel code designed for one architecture into parallel code designed for another. A different approach relies on the use of skeletons. The programmer has available set of parallel standards that comprise the basis for developing parallel code while programming sequential code. In this context, we propose a methodology for developing an automatic source‐to‐source transformation in a specific domain. This methodology is instantiated in a framework aimed at solving dynamic programming problems. Using this framework, the final user (a physician, mathematician, biologist, etc.) can express her problem using an equation in Latex, and the system will automatically generate the optimal parallel code for homogeneous or heterogeneous architectures. This approach allows for great portability toward these new emerging architectures and for great productivity, as evidenced by the computational results.Copyright © 2012 John Wiley & Sons, Ltd.     

GAT: Platform for automatic context-aware mobile services for m-tourism

Despite the recent advances in mobile tourism systems, most of the wayfinding applications have still to deal with some problems: a huge amount of tourist information to manage, guidance for indoor and outdoor environments, and the need of users to have programming knowledge about many mobile phone platforms. In this study, we propose the GAT platform to overcome these problems. In GAT, users are able to generate wayfinding applications for indoor and outdoor environments through a web form without the need for programming skills, assisted by a system of automatic generation and update of points of interest.     

Formal program construction by transformations-computer-aided,intuition-guided programming

Formal program construction by transformations is a method of software development in which a program is derived from a formal problem specification by manageable, controlled transformation steps which guarantee that the final product meets the initial specification. This methodology has been investigated in the Munich project CIP (computer-aided intuition-guided programming). The research includes the design of a wide-spectrum language specifically tailored to the needs of transformational programming, the construction of a transformation system to support the methodology, and the study of transformation rules and other methodological issues. Particular emphasis has been laid on developing a sound theoretical basis for the overall approach     

Algorithm optimization using a rule-based system. A case study: The Direct Kinematic Solution in robotics

The computation burden of intensive numerical real-time algorithms is a problem encountered in robotics and many other fields. A cost-effective solution for the implementation of these algorithms requires knowledge of computer architecture, compiler technology and algorithms. A cost-effective numeric processing methodology using a combined hardware-software approach and taking advantage of logic programming tools is presented. The methodology is based on optimizing the numerical calculation process of the algorithm. It also enables the specification of hardware resources. The process uses a rule-based-system (RBS) implemented in the logic programming language Prolog to automatically reduce the number of operations in the numerical execution of the algorithm and optimizes the use of hardware resources. The methodology provides a solution for the problems of handshake overhead and algorithm translation efficiency.The Direct Kinematics Solution (DKS), a robot arm control algorithm, is presented as a case study to illustrate the methodology. The proposed methodology has a general potential which can be extended to the optimization or implementation of different algorithms.     

REDOM: an OO language to define and on-line manipulate regulations in the resource (re)scheduling problem

In the class of (re)scheduling problems where humans constitute the main resource, the scheduling process is influenced by a great number of complex and frequently changing regulations. The complexity and the dynamic nature of these regulations impose the need for an efficient, flexible and user-friendly way to express and manage them. A solution to this problem, in the form of an object-oriented high-level language with semantics highly-tailored to the user needs, is presented. The language, called REDOM, can be applied to different scheduling application domains with a minimum degree of effort, because it is based on a generic meta-model of the resource scheduling problem. An application programming interface facilitates REDOM integration into existing scheduling systems. REDOM is currently being utilised by the DAYSY resource management system, that is implemented as a constraint satisfaction system based on a partial test-and-generate approach. The combination of REDOM and CHIP (Constraint Handling In Prolog), which was used for the implementation of the solution generation subsystem, resulted in a highly-efficient and flexible (re)scheduling system, well-accepted by users. © 1997 John Wiley & Sons, Ltd.     

基于产生式的多语言程序理解的算法

提出一种程序理解实现方案,通过将程序设计语言的词法规则和语法规则以产生式表示,设计基于产生式多语言程序处理算法,将产生式自动转化为对应的词法和语法规则函数,使得不同的程序设计语言规则可以采用统一的方式描述,从而可用一套程序理解系统实现对多种程序设计语言的程序理解,以后增加某种程序设计语言的程序理解,只要定义对应程序设计语言的词法和语法规则产生式即可实现,有效地解决了程序理解系统的共享性难题。     

An evolutionary approach to incorporating intradepartmental flow into facilities design

Minimizing material transportation is an important design object for many facilities. In traditional facility design, departments and work centers have been located based on interdepartmental flow patterns. We introduce a methodology that extends the planning process to also consider intradepartmental flow patterns. A math programming approach is developed that uses an objective function and constraints that specifically addresses both the intradepartmental and the interdepartmental material flows together. The math programming approach can be used to solve small problems but it is difficult to scale this method to problems with realistic sizes. Therefore, we devise an evolutionary optimization methodology for this same problem. The evolutionary method can readily solve both large and small problems. The effectiveness of the evolutionary approach is demonstrated on a suite of test problems.     

Integrating multiple paradigms within the blackboard framework

The complexity and diversity of real world applications have forced researchers in the AI field to focus more on the integration of diverse knowledge representation and reasoning techniques for solving challenging, real world problems. Our development environment, BEST (Blackboard based Expert Systems Toolkit), is aimed to provide the ability to produce large scale, evolvable, heterogeneous intelligent systems. BEST incorporates the best of multiple programming paradigms in order to avoid restricting users to a single way of expressing either knowledge or data. It combines rule based programming, object oriented programming, logic programming, procedural programming and blackboard modelling in a single architecture for knowledge engineering, so that the user can tailor a style of programming to his application, using any or arbitrary combinations of methods to provide a complete solution. The deep integration of all these techniques yields a toolkit more effective even for a specific single application than any technique in isolation or collections of multiple techniques less fully integrated. Within the basic, knowledge based programming paradigm, BEST offers a multiparadigm language for representing complex knowledge, including incomplete and uncertain knowledge. Its problem solving facilities include truth maintenance, inheritance over arbitrary relations, temporal and hypothetical reasoning, opportunistic control, automatic partitioning and scheduling and both blackboard and distributed problem solving paradigms     

Declarative paradigm of test coverage

Two facts about declarative programming prevent the application of conventional testing methods. First, the classical test coverage measures such as statement, branch or path coverage, cannot be used, since in declarative programs no control flow notion exists. Second, there is no widely accepted language available for formal specification, since predicate logic, which is the most common formalism for declarative programming, is already a very high-level abstract language. This paper presents a new approach exending previous work by the authors on test input generation for declarative programs. For this purpose, the existing program instrumentation notion is extended and a new logic coverage measure is introduced. The approach is mathematically formalized and the goal of achieving 100% program logic coverage controls the automatic test input generation. The method is depicted by means of logic programming; the results are, however, generally applicable. Finally, the concepts introduced have been used practically within a test environment. © 1998 John Wiley & Sons, Ltd.     

Cybersecurity policy verification with declarative programming

Cybersecurity is a growing concern in today’s society. Security policies have been developed to ensure that data and assets remain protected for legitimate users, but there must be a mechanism to verify that these policies can be enforced. This paper addresses the verification problem of security policies in role-based access control of enterprise software. Most existing approaches employ traditional logic or procedural programming that tends to involve complex expressions or search with backtrack. These can be time-consuming, and hard to understand, and update, especially for large-scale security verification problems. Declarative programming paradigms such as “Answer Set” programming have been widely used to alleviate these issues by ways of elegant and flexible modeling for complex search problems. However, solving problems using these paradigms can be challenging due to the nature and limitation of the declarative problem solver. This paper presents an approach to automated security policy verification using Answer Set programming. In particular, we investigate how the separation of duty security policy in role-based access control can be verified. Our contribution is a modeling approach that maps this verification problem into a graph-coloring problem to facilitate the use of generate-and-test in a declarative problem-solving paradigm. The paper describes a representation model and rules that drive the Answer Set Solver and illustrates the proposed approach to securing web application software to assist the hiring process in a company.     

Towards banishing the cut from Prolog

Logic programs can often be inefficient. The usual solution to this problem has been to return some control to the user in the form of impure language features like cut. The authors argue that it is not necessary to resort to such impure features for efficiency. This point is illustrated by considering how most of the common uses of cut can be eliminated from Prolog source programs, relying on static analysis to generate them at compile time. Three common situations where the cut is used are considered. Static analysis techniques are given to detect such situations, and applicable program transformations are described. Two language constructs, firstof and oneof, for situations involving don't-care nondeterminism, are suggested. These constructs have better declarative readings than the cut and extend better to parallel evaluation strategies. Together, these proposals result in a system where users need rely much less on cuts for efficiency, thereby promoting a purer programming style without sacrificing efficiency