基于可重用性组件的语言调试器实现

基于组件的ActiveX Scripting技术可使软件扩充变得简单,从而提高软件可重用性,利用此技术开发新的应用程序,能明显提高程序开发效率,改善程序质量.分析了基于组件的ActiveX Scripting技术结构以及脚本语言调试器的原理,采用可重用性组件实现了一个Script语言调试器,并给出了程序的具体实现.测试结果表明,该调试器的软件架构清晰,同时运行十分稳定、可靠.     

支持软件重用的程序设计语言

本文提出一种支持软件重用的程序语言并给出了重用描述语言翻译器的工作原理。该语言是在宿主语言Ｃ＋＋中加入“重用描述”成分和“装配语句”而形成的。该文件以软件重用库为依托,重用描述用于表达用户在程序中对部件的要求,重用描述语言翻译器则分析这些需求,自动在库中查找提出部件来适应用户。     

Java异常处理策略研究

异常处理机制是程序设计语言的重要标志之一,在程序设计过程中用来处理程序运行中的异常。传统的程序设计语言里异常处理较为繁杂。Java是一种面向对象的程序设计语言,且引入了异常处理机制。合理完备的异常处理可以增强程序运行的可靠性、提高软件的健壮性,可以较为快速地确定错误的位置。文章分析了Java异常处理的逻辑,阐述了异常类、异常处理机制以及异常处理方法,提出了异常处理的一些策略。综合运用这些策略可以使编程人员编写出更加简洁、高效的程序代码。     

Learning new programming languages: an analysis of the process and problems encountered

Experienced programmers transferring to a new language have a far easier time than the novice learning a first language. However, they still experience considerable difficulties. The objective in this exploratory study was to characterize the kinds of learning and transfer that take place in the early stages of using a new programming language and where difficulties develop. 'Think-aloud' protocols were videotaped as subjects went about trying to write a program in a new programming language. Subjects used One of two unfamiliar languages, one similar to their known language (Pascal) and the other dissimilar. Three types of analyses were done on the recorded protocols: a procedural analysis showing the activities the subjects engaged in as they learned the new language, a programming knowledge analysis showing in which areas of program development difficulties were encountered, and a solutions analysis showing how successful the programmers were at using unique features of the new language. We found that the procedures programmers used to learn a new language were independent of the language being learned. The slight differences that existed in procedures were between levels of expertise. Programmers spent the majority of their time reading a language textbook. The programming knowledge analysis showed that programmers main area of concentration was planning how to implement their approach given the constructs available in the language. We observed many iterations of programmers trying to implement plans, failing and having to revise their plans. Examination of the subjects solutions and implementation approaches in Pascal led us to believe that programmers learning a new language are often biased by their implementation of algorithms in previous languages.     

Learning new programming languages: an analysis of the process and problems encountered

Abstract

Experienced programmers transferring to a new language have a far easier time than the novice learning a first language. However, they still experience considerable difficulties. The objective in this exploratory study was to characterize the kinds of learning and transfer that take place in the early stages of using a new programming language and where difficulties develop. ‘Think-aloud’ protocols were videotaped as subjects went about trying to write a program in a new programming language. Subjects used One of two unfamiliar languages, one similar to their known language (Pascal) and the other dissimilar. Three types of analyses were done on the recorded protocols: a procedural analysis showing the activities the subjects engaged in as they learned the new language, a programming knowledge analysis showing in which areas of program development difficulties were encountered, and a solutions analysis showing how successful the programmers were at using unique features of the new language. We found that the procedures programmers used to learn a new language were independent of the language being learned. The slight differences that existed in procedures were between levels of expertise. Programmers spent the majority of their time reading a language textbook. The programming knowledge analysis showed that programmers main area of concentration was planning how to implement their approach given the constructs available in the language. We observed many iterations of programmers trying to implement plans, failing and having to revise their plans. Examination of the subjects solutions and implementation approaches in Pascal led us to believe that programmers learning a new language are often biased by their implementation of algorithms in previous languages.     

A component framework for reusing a proprietary computer-aided engineering environment

Nowadays, it is becoming more frequent for engineers to deal with problems and situations that require specific software and the commercially available applications may not result adequate. Because of this, the reuse of software components is becoming a normal practice for improving the productivity of the software programmers, and the quality of the products that they develop. The employment of reusable components presents a number of advantages, such as the reduction in time necessary to develop new software, or the simplification of many computational tasks.There are some proprietary software environments in the engineering domain that are practically de facto standards, since they offer a broad functionality, robustness and constant updating. Therefore, those environments could be ideal candidates to be reusable components when developing new software. An example of this is Matlab, which can be encapsulated, in order to use it as a true reusable component. This will provide the user with efficient tools for designing his/her own applications.Moreover, there is an increasing importance for any software to offer distributed services. To perform this task, it is fundamental to have at one’s disposal reusable components that support Internet-based distributed applications and services development.In the present work, a software component framework that effectively encapsulates Matlab is described. This software allows developers the reuse of Matlab, for both local and distributed applications. To address those issues the .NET technology was employed. The component framework developed can be integrated in the toolbars of software development environments supporting the .NET framework. This facilitates the construction of applications that can reuse the components, since the software developers can use and test them and change their properties in design-time.     

Yada: Straightforward parallel programming

Now that multicore chips are common, providing an approach to parallel programming that is usable by regular programmers has become even more important. This cloud has one silver lining: providing useful speedup on a program is useful in and of itself, even if the resulting performance is lower than the best possible parallel performance on the same program. To help achieve this goal, Yada is an explicitly parallel programming language with sequential semantics. Explicitly parallel, because we believe that programmers need to identify how and where to exploit potential parallelism, but sequential semantics so that programmers can understand and debug their parallel programs in the way that they already know, i.e. as if they were sequential.The key new idea in Yada is the provision of a set of types that support parallel operations while still preserving sequential semantics. Beyond the natural read-sharing found in most previous sequential-like languages, Yada supports three other kinds of sharing. Writeonce locations support a single write and multiple reads, and two kinds of sharing for locations updated with an associative operator generalise the reduction and parallel-prefix operations found in many data-parallel languages. We expect to support other kinds of sharing in the future.We have evaluated our Yada prototype on eight algorithms and four applications, and found that programs require only a few changes to get useful speedups ranging from 2.2 to 6.3 on an 8-core machine. Yada performance is mostly comparable to parallel implementations of the same programs using OpenMP or explicit threads.     

Are visual programming languages better? The role of imagery in program comprehension

This paper presents one experiment to explain why and under which circumstances visual programming languages would be easier to understand than textual programming languages. Towards this goal we bring together research from psychology of programming and image processing. According to current theories of imagery processing imagery facilitates a quicker access to semantic information. Thus, visual programming languages should allow for quicker construction of a mental representation based on data flow relationships of a program than procedural languages. To test this hypothesis the mental models of C and spreadsheet programmers were assessed in different program comprehension situations. The results showed that spreadsheet programmers developed data flow based mental representations in all situations, while C programmers seemed to access first a control flow and then data flow based mental representations. These results could help to expand theories of mental models from psychology of programming to account for the effect of imagery.     

Formal methods integration in software engineering

This paper presents an extract from our works on a software engineering method for avionic real-time systems [3], the C-Method, which covers the whole software lifecycle thanks to a seamless process, and integrates formal methods in its process. Because distributed, real-time and embedded (DRE) systems have safety critical concerns, they require the use of formal languages (that allow non-ambiguous and rigorous specifications) in order to be able to prove their non-functional properties. Therefore, the “C-Method” relies on the use of formal languages in the earliest steps of the system specification and on the use of semi-formal languages in the analysis, design and programming steps. The fundamental question is how to integrate several languages with different levels of formalization and abstraction. The previous software engineering methods were based on a single language or notation, so they did not address this issue. In order to make the transitions more continuous between semi-formal and formal specifications, we have introduced in the development process what we call “intermediate” languages (+CAL and Why), that are easy to manipulate but directly linked to a formal language (TLA+ for +CAL, Why for PVS).     

Coping with Java threads

A thread is a basic unit of program execution that can share a single address space with other threads - that is, they can read and write the same variables and data structures. Originally, only assembly programmers used threads. A few older programming languages such as PL/I supported thread concurrency, but newer languages such as C and C++ use libraries instead. Only recently have programming languages again begun to build in direct support for threads. Java and Ada are examples of industry-strength languages for multithreading. The Java thread model has its roots in traditional concurrent programming. As the "real-time specification for Java" sidebar describes, RTSJ attempts to remove some of the limitations relative to real-time applications - primarily by circumventing garbage collection. But RTSJ does not make the language safer. It retains standard Java's threading pitfalls and is a risky candidate for critical concurrent applications.     

Yet another optimisation article

The author addresses the question: how do we achieve a fast program? For many programmers, performance is something you pay continuous attention to as you program. Every time you write a fragment of code, you consider the performance implications and code the program to maximize performance. Some performance work comes from architectural decisions, some from more tactical optimization activity. The author considers a specific set of steps for program optimization