Programming Language Design Research Articles

Different Teaching Methods for Program Design and Algorithmic Language

Different Teaching Methods for Program Design and Algorithmic Language

Research of Fault Diagnosis System for NC Machine Tool

As the theoretical research and practical application of the key technology and bottlenecks, Fault diagnosis technology get the focus of manufacturing field at home and abroad and have achieved some innovative research achievements[1]. This paper analyzed the failure causes of numerical control machine, linked the fault tree and fault diagnosis expert system knowledge base, develops numerical control machine fault diagnosis expert system which has a friendly man-machine interface, reasonable reasoning method and explanation function by using C programming language and object-oriented program design method.

Tales from the jungle

We rely on a computational infrastructure that is a densely interwined mass of software and hardware: programming languages, network protocols, operating systems, and processors. It has accumulated great complexity, from a combination of engineering design decisions, contingent historical choices, and sheer scale, yet it is defined at best by prose specifications, or, all too often, just by the common implementations. Can we do better? More specifically, can we apply rigorous methods to this mainstream infrastructure, taking the accumulated complexity seriously, and if we do, does it help? My colleagues and I have looked at these questions in several contexts: the TCP/IP network protocols with their Sockets API; programming language design, including the Java module system and the C11/C++11 concurrency model; the hardware concurrency behaviour of x86, IBM POWER, and ARM multiprocessors; and compilation of concurrent code. In this talk I will draw some lessons from what did and did not succeed, looking especially at the empirical nature of some of the work, at the social process of engagement with the various different communities, and at the mathematical and software tools we used. Domain-specific modelling languages (based on functional programming ideas) and proof assistants were invaluable for working with the large and loose specifications involved: idioms within HOL4 for TCP, our Ott tool for programming language specification, and Owens's Lem tool for portable semantic definitions, with HOL4, Isabelle, and Coq, for the relaxed-memory concurrency semantics work. Our experience with these suggests something of what is needed to make full-scale rigorous semantics a commonplace reality.

2.2.2 A Decision Support Framework for the Software Systems Engineer

AbstractDecision Support Systems have been developed to aid the decision maker by providing ranked alternatives to consider. The ranking criteria may be resource‐based, schedule‐based or performance‐based. When considering decisions that affect the overall architecture of a software system and the integration of its subsystems/components, the software systems engineer may have some unique challenges when legacy software is part of the system. For the software systems engineer, reengineering legacy systems or integrating legacy systems with new development and/or off‐the‐shelf software are areas where effective software system analysis is critical. When analyzing a software system, a range of system artifacts may be used. These artifacts include a description of the system in natural language, program design language descriptions, flow charts, object diagrams, as well as the system code. All of these artifact types can contain equivalent information at their specific level of abstraction. However, deriving information that is needed from each of these types of artifacts for reengineering or integrating a legacy system may present varying levels of difficulty. For example, analyzing a poorly structured system with little or no design documentation is a particularly challenging problem. Software modelling using an abstract architecture representation as a common description vehicle can “level the playing field” by creating representations of disparate systems at the same level of abstraction. This is of importance to reengineering efforts; it shows promise for supporting and facilitating integration efforts between legacy and other systems. It also allows the definition and development of a framework for a decision support system to aid the software system engineer. This paper is a follow on to previous work by the authors and presents a proposed decision support system framework that makes the use of the technical analyses and techniques presented.

Quantum programming: From theories to implementations

This paper surveys the new field of programming methodology and techniques for future quantum computers, including design of sequential and concurrent quantum programming languages, their semantics and implementations. Several verification methods for quantum programs and communication protocols are also reviewed. The potential applications of programming techniques and related formal methods in quantum engineering are pointed out.

Heedless programming: ignoring detectable error is a widespread hazard

SUMMARYSoftware should be correct and robust. This paper suggests that we need forthright words for the failure of not being robust—heedless and heedlessness—and of recursively creating software (such as a compiler or virtual machine) that itself does not support dependable software development. Heedless programming is common, particularly affecting ‘trivial’ operations such as on numbers, and extends deep into programming language design and into the use of computers more widely, thus making robust, dependable applications of all sorts unnecessarily problematic. The paper defines the problem and presents a call to action to start addressing the problems identified. Copyright © 2012 John Wiley & Sons, Ltd.

Randomisation in designing software tests for systems of systems

This paper applies randomisation theory to the problem of selecting software test cases for software systems and applications in order to overcome the high costs incurred in testing componentised systems of systems (SoS). We have used a corner point semantics, which can approximate a proof of correctness – termed a pseudo-proof of correctness. Test cases for each component are designed to be mutually orthogonal, or randomised. Integration testing is performed through a composition of the test cases for components with some value-added test cases to cover integration aspects of the system. Integration testing is also designed in such a way that the testing algorithm is written in randomised form. In this paper, we present a theoretical framework for randomising test design for component and integration testing. We also show a meta heuristic algorithm based on the framework to be used with test design methodologies that are randomisation-friendly. The advantages offered by such randomisation are ever present in the algorithm, programming language, integration, and workflow design.

SGL: towards a bridging model for heterogeneous hierarchical platforms

This paper introduces the Scatter-Gather parallel-programming and parallel execution model in the form of a simple imperative Scatter-Gather Language (SGL). Its design is based on past experience with bulk-synchronous parallel (BSP) programming and BSP language design. SGL’s novel features are motivated by the last decade’s move towards multi-level and heterogeneous parallel architectures involving multi-core processors, graphics accelerators and hierarchical routing networks in the largest multiprocessing systems. The design of SGL is coherent with L. Valiant’s multi-BSP while offering a programming interface that is even simpler than the primitives of bulk-synchronous parallel ML (BSML). SGL appears to cover a large subset of all BSP algorithms while avoiding complex message-passing programming. Like all BSP-inspired systems, it supports predictable, portable and scalable performance. Moreover, SGL’s explicit data distribution will allow automatic or programmable load-balancing.

A Multi-thread Data Flow Solution Applying to Java Extension

Abstract The multi-core processors environment is increasingly popular, the parallel studies of application program for this architecture has become the focus. In object-oriented program design language, often use the thread to implement an application program parallelism, however, synchronization and communication between threads are often very complicated to implement and can not take full advantage of multi-core advantage. Proposed a multi-thread basing on data flow and Java extensions to achieve solutions, presents a new multi-thread programming method. The results show that this method is not only easy to implement and can better take advantage of multi-core advantage.

Lessons learned from college freshmen’s participation in a new college English program.

This case study examines two college freshmen’s learning experience in a newly implemented college English program whose primary goal was to enhance learners’ English oral-proficiency. As an effort to meet the needs stated by the learners and instructors, in a Korean university, a task-based, blended college English program was developed and implemented (Kim & Kim, 2010). In order to explore how the program is actually implemented and perceived in classroom contexts, the researchers observed two freshmen learners’ participation in the program and documented data from different sources (i.e., classroom observation, interview, etc.) over one academic year. The collected data were analyzed following the principles of qualitative content analysis (Dornyei, 2007). The findings reveal that the two learners’ perceptions of the program and their classroom participations are in reciprocal relationship, constructing each other. That is, changes and no changes in each learner’s class participations and perceptions triggered transformation in their actions and perceptions. The findings also tell that these changes in learners’ experience are closely related with personal, institutional and social factors. The implications for a similar language program design and its implementation are lastly discussed with the suggestions for future research.

Language design and analyzability: a retrospective

SUMMARYThere is tension between programming language design for modularity and flexibility of programming and the amenability of the resulting programs to static analysis. At the start of Software Practice and Experience in 1971, most languages in commercial use were procedural (e.g., FORTRAN, ALGOL, PL/I) and on the whole were easier to analyze than languages of today such as JavaScript and Python. Modern languages include dynamic features, which enhance prototyping of approaches, often resulting in programs that are difficult for software tools or humans to understand. Starting with this perspective, we explore the relationship between language features and the ability of static analysis to precisely determine control flow and data flow in programs, thus enabling program optimization, transformation and understanding. Copyright © 2011 John Wiley & Sons, Ltd.

EDITORIAL

The journal Software: Practice and Experience has now been published for 40 years. Not many authors of papers that appeared in the early days of the journal are still active in publishing research articles today. However, Dr. Barbara G. Ryder is an outstanding exception. In the October–December issue of 1974, Barbara published a groundbreaking paper with the title ‘The PFORT Verifier’ while she was working at AT&T Bell Laboratories in New Jersey. The paper described a software tool that analyzes a Fortran program and verifies that it conforms to a portable subset of the language. Although the programming language has changed and the goals have become much more ambitious, Dr. Ryder and her research group at Virginia Tech still actively work in the field of program analysis. She is also a member of the Editorial Board of this journal. In her role as one of the journal's earliest authors, I invited Dr. Ryder to write a retrospective article describing how her original work on the PFORT verifier and its software context of the 1970s are related to programming languages and software of today. The result is the paper that appears in this issue of the journal. It is co-authored by Dr. Ben Wiedermann who, until recently, was working with Barbara's research group as a visiting postdoctoral student. He is currently a visiting assistant professor at Harvey Mudd College. In their paper, Drs. Ryder and Wiedermann follow a historical thread that describes the different kinds of analyses performed on software and the reasons for performing the analyses. A recurring theme through the paper is that modern programming languages have introduced new constructs that make analysis much more challenging and that may reduce the precision of the results. The authors ask programming language designers considering new features to think carefully about their potential effects on analyzability of programs including those features.

Guest Editors' Introduction: Special Section on Science of Design for Safety Critical Systems

Guest Editors' Introduction: Special Section on Science of Design for Safety Critical Systems

A qualitative human-centric evaluation of flexibility in middleware implementations

Today middleware is much more powerful, more reliable and faster than it used to be. Nevertheless, for the application developer, the complexity of using middleware platforms has increased accordingly. The volume and variety of application contexts that current middleware technologies have to support require that developers be able to anticipate the widest possible range of execution environments, desired and undesired effects of different programming strategies, handling procedures for runtime errors, and so on. This paper shows how a generic framework designed to evaluate the usability of notations (the Cognitive Dimensions of Notations Framework, or CDN) has been instantiated and used to analyze the cognitive challenges involved in adapting middleware platforms. This human-centric perspective allowed us to achieve novel results compared to existing middleware evaluation research, typically centered around system performance metrics. The focus of our study is on the process of adapting middleware implementations, rather than in the end product of this activity. Our main contributions are twofold. First, we describe a qualitative CDN-based method to analyze the cognitive effort made by programmers while adapting middleware implementations. And second, we show how two platforms designed for flexibility have been compared, suggesting that certain programming language design features might be particularly helpful for developers.

Languages as libraries

Programming language design benefits from constructs for extending the syntax and semantics of a host language. While C's string-based macros empower programmers to introduce notational shorthands, the parser-level macros of Lisp encourage experimentation with domain-specific languages. The Scheme programming language improves on Lisp with macros that respect lexical scope. The design of Racket---a descendant of Scheme---goes even further with the introduction of a full-fledged interface to the static semantics of the language. A Racket extension programmer can thus add constructs that are indistinguishable from "native" notation, large and complex embedded domain-specific languages, and even optimizing transformations for the compiler backend. This power to experiment with language design has been used to create a series of sub-languages for programming with first-class classes and modules, numerous languages for implementing the Racket system, and the creation of a complete and fully integrated typed sister language to Racket's untyped base language. This paper explains Racket's language extension API via an implementation of a small typed sister language. The new language provides a rich type system that accommodates the idioms of untyped Racket. Furthermore, modules in this typed language can safely exchange values with untyped modules. Last but not least, the implementation includes a type-based optimizer that achieves promising speedups. Although these extensions are complex, their Racket implementation is just a library, like any other library, requiring no changes to the Racket implementation.

10.1.2 Legacy Software System Integration

AbstractLegacy software systems are often the subject of analyses in attempts to affect modifications to extend their useful lifetimes. For the systems engineer, reengineering legacy systems or integrating legacy systems with new development and/or off‐the‐shelf software are areas which may provide particular challenges and where effective software system analysis is critical. When analyzing a software system, a range of system artifacts may be used. These artifacts include a description of the system in natural language, program design language descriptions, flow charts, object diagrams, as well as the system code. All of these artifact types can contain equivalent information at their specific level of abstraction. However, deriving information that is needed for reengineering or integrating a legacy system from each of these artifacts cannot be performed equivalently. For example, analyzing a poorly structured system with little or no design documentation is a particularly challenging problem. Software modeling using an abstract architecture representation as a common description vehicle, such as the Unified Modeling Language or some other, can “level the playing field” by creating representations of disparate systems at the same level of abstraction. This is of importance to reengineering efforts; it shows promise for supporting and facilitating integration efforts between legacy and other systems. This paper presents a methodology to express and manipulate (i.e. restructure) system architecture‐level models, an evaluation of the integratability of those models, and proposes a decision support system framework that makes the use of the methods.

Interview with Peter King

Dr. Peter King has been active in digital documents and hypertext for almost thirty years. He was one of the founders of the Electronic Publishing conference series and of the ACM Symposium on Document Engineering, whose Steering Committee he now chairs. He holds the position of Professor Emeritus of Computer Science at the University of Manitoba in Winnipeg, Canada. He has recently held research positions at the University of Kent, UK and at LIRMM, Montpellier, France, and has worked at several other European and Canadian research institutes. Peter's work in document engineering covers several areas. He has performed individual and collaborative work on formalisms for multimedia document specification and on document description languages and systems, leading to the creation of several working systems. He has collaborated on work on hypertext, including the OPALES system and its successors, and on hypertext architectures supporting collaborative document usage and user communities. His joint work with Marc and Jocelyne Nanard won the ACM Engelbart award for best paper at the Hypertext 2003 Conference. Prior to developing his interest in document engineering and hypertext, he worked extensively in the area of programming language design and implementation. Peter King is a leader in computing education and educational standards. He is Director of Accreditation for CIPS, the Canadian Information Processing Society, which establishes and assesses industry recognized standards for postsecondary computing education in university and college institutions across Canada and internationally.

The design of kodu

Kodu is a relatively new programming language designed specifically for young children to learn through independent exploration. Kodu seeks to lower the barrier to entry for new programmers by presenting a radically simplified programming model which nevertheless has significant expressive power. Kodu is integrated in a real-time 3D gaming environment and is designed to compete with modern console games in terms of intuitive user interface and graphical production values. In this paper we will review key tradeoffs made in the design of the programming language and illustrate how it is one of very few languages designed using user interface design principles and methodologies, to the extent that the blend of subjective and objective factors considered in the language design have succeeded in presenting a model of programming which is uniquely approachable and creatively empowering for non-technical users.

A fresh look at programming with names and binders

A wide range of computer programs, including compilers and theorem provers, manipulate data structures that involve names and binding. However, the design of programming idioms which allow performing these manipulations in a safe and natural style has, to a large extent, remained elusive. In this paper, we present a novel approach to the problem. Our proposal can be viewed either as a programming language design or as a library: in fact, it is currently implemented within Agda. It provides a safe and expressive means of programming with names and binders. It is abstract enough to support multiple concrete implementations: we present one in nominal style and one in de Bruijn style. We use logical relations to prove that "well-typed programs do not mix names with different scope". We exhibit an adequate encoding of Pitts-style nominal terms into our system.

예외 처리를 위한 형식 의미론

프로그래밍언어에 대한 형식 의미를 적절하게 표현하면 설계와 표준화, 최적화 및 번역 과정에 중요한 역할을 수행한다. 기존의 자바에 대한 형식 의미 연구는 번역을 위해 정확하고 실제적인 의미 구조를 표현하는데 미흡한 점이 있다. 자바 번역 과정의 효율성을 향상시키기 위해 정적이고 동적인 의미 구조를 정확하게 표현하는 의미 표현법에 관한 연구가 필요하다. 본 논문에서는 기존의 작용식(Action Equations)을 사용해 명세한 연구를 확장하여 자바 언어에 대한 형식 의미를 명세하는 개선된 작용식(Action Equations)을 제시한다. 객체를 다루는 기능은 물론 예외를 처리하는 형식 의미론을 보다 실제적이고 정확하게 명세하게 된다. 판독성(Readability), 모듈성(Modularity), 확장성(Extensibility), 융통성(Flexibility)의 네 영역에서 명세된 작용식을 기존의 의미 표현법과 비교하여 본 작용식의 우수성을 확인하고자 한다. To specify a formal semantics is to do a significant part for design, standardization and translation of programming languages. The existing studies of a formal semantics for Java have a weak point to describe a clear and practical semantics for an efficient translation. It is necessary to do research for a formal semantics to specify a static and dynamic semantics clearly in order to do an efficient translation. This paper presents the improved Action Equation that specifies a formal semantics for Java to extend the research using Action Equation. The Action Equation is a practical and accurate specification that describes object-oriented programming features and handles exceptions. The specified Action Equation is compared to other descriptions, in terms of readability, modularity, extensibility, and flexibility and then we verified that Action Equation is superior to other formal semantics.