ViDA: A virtual debugging advisor for supporting learning in computer programming courses

Many students need assistance in debugging to achieve progress when they learn to write computer programs. Face‐to‐face interactions with individual students to give feedback on their programs, although definitely effective in facilitating their learning, are becoming difficult to achieve with ever‐growing class sizes. This paper proposes a novel approach to providing practical automated debugging advice to support students' learning, based on the strong relationship observed between common wrong outputs and the corresponding common bugs in students' programs. To implement the approach, we designed a generic system architecture and process, and developed a tool called Virtual Debugging Advisor (ViDA) that was put into use in classes in a university. To evaluate the effectiveness of ViDA, a controlled experiment and a survey were conducted with first year engineering students in an introductory computer programming course. Results are encouraging, showing that (a) a higher proportion of students could correct their faulty code themselves with ViDA enabled, (b) an overwhelming majority of respondents found ViDA helpful for their learning of programming, and (c) most respondents would like to keep ViDA enabled when they practice writing programs.     

The influences of a two-tier test strategy on student learning: A lag sequential analysis approach

Recently, programming skills have become a core competence. Many teaching strategies were developed to improve programming skills. Among them, online tests were widely applied to enhance students learning. Nonetheless, they may not be able to engage students in deep thinking and reflections. Thus, a two-tier test strategy was proposed to address this issue. However, previous research mainly focused on investigating the effectiveness of the two-tier test strategy but there is a lack of studies that investigate why the two-tier test approach is effective. To this end, we developed an online test, where the two-tier test strategy was implemented. Additionally, an empirical study was conducted to explore the influences of the two-tier test approach on students' learning performance and behavior patterns. Pre-test and post-test scores were applied to assess students' learning performance while a lag sequential analysis was used to analyze behavior patterns. Regarding learning performance, the proposed two-tier test can improve students' programming skills. Regarding behavior patterns, the two-tier test approach facilitates students to develop a learning by reviewing strategy, which is useful to improve their programming skills.     

Coding-error based defects in enterprise resource planning software: Prevention,discovery, elimination and mitigation

Software defects due to coding errors continue to plague the industry with disastrous impact, especially in the enterprise application software category. Identifying how much of these defects are specifically due to coding errors is a challenging problem. In this paper, we investigate the best methods for preventing new coding defects in enterprise resource planning (ERP) software, and discovering and fixing existing coding defects. A large-scale survey-based ex-post-facto study coupled with experiments involving static code analysis tools on both sample code and real-life million lines of code open-source ERP software were conducted for such purpose. The survey-based methodology consisted of respondents who had experience developing ERP software. This research sought to determine if software defects could be merely mitigated or totally eliminated, and what supporting policies, procedures and infrastructure were needed to remedy the problem. In this paper, we introduce a hypothetical framework developed to address our research questions, the hypotheses we have conjectured, the research methodology we have used, and the data analysis methods used to validate the stated hypotheses. Our study revealed that: (a) the best way for ERP developers to discover coding-error based defects in existing programs is to choose an appropriate programming language; perform a combination of manual and automated code auditing, static code analysis, and formal test case design, execution and analysis, (b) the most effective ways to mitigate defects in an ERP system is to track the defect densities in the ERP software, fix the defects found, perform regression testing, and update the resulting defect density statistics, and (c) the impact of epistemological and legal commitments on the defect densities of ERP systems is inconclusive.We feel that our proposed model has the potential to vastly improve the quality of ERP and other similar software by reducing the coding-error defects, and recommend that future research aimed at testing the model in actual production environments.     

An empirical study of the impact of modern code review practices on software quality

Software code review, i.e., the practice of having other team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that formal code inspections tend to improve the quality of delivered software. However, the formal code inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight code reviewing process does not. Although recent work explores the modern code review process, little is known about the relationship between modern code review practices and long-term software quality. Hence, in this paper, we study the relationship between post-release defects (a popular proxy for long-term software quality) and: (1) code review coverage, i.e., the proportion of changes that have been code reviewed, (2) code review participation, i.e., the degree of reviewer involvement in the code review process, and (3) code reviewer expertise, i.e., the level of domain-specific expertise of the code reviewers. Through a case study of the Qt, VTK, and ITK projects, we find that code review coverage, participation, and expertise share a significant link with software quality. Hence, our results empirically confirm the intuition that poorly-reviewed code has a negative impact on software quality in large systems using modern reviewing tools.     

Structured inspections of code

Cleanroom programming and code inspections independently provide evidence that it is more efficient to postpone the testing of code to a later stage than is usually done. This paper argues that an additional gain in quality and efficiency of development can be obtained by structuring inspections by means of an inspection protocol. The written part of such a protocol is prepared by the programmer before the inspection. It is modelled on Floyd's method for the verification of flowcharts. However, the protocol differs from Floyd's method in being applicable in practice. Structured inspections gain this advantage by not attempting to be a proof; they are no more than an articulation of existing forms of inspection. With the usual method of structured programming it may be difficult to prepare the inspection protol. On the other hand, ‘assertion-driven programming’ (of which an example is included in this paper) not only facilitates protocol preparation, but also the coding itself.     

Evaluating and Improving Recursive Descent Parsers

Time formulas are symbolic formulas which express the execution time of a program as a function of its input data and of variables representing the time to execute individual operations (e.g., push, pop, transfer, etc.). It is shown that in many cases the time formulas for recursive descent parsers may be generated automatically by a simple inspection of the parser code. These time formulas are instrumental in estimating the gains attained by various types of optimizations. Several of these optimizations are presented and their efficiency gains are estimated. A parser for a simple programming language is generated, optimized, and evaluated using the proposed techniques.     

ZUC-256算法的快速软件实现

ZUC-256算法在ZUC算法的基础上,其初始化阶段、消息认证码生成阶段均采用了新的设计方法,进一步提升了算法的安全性。为了探讨ZUC-256算法的快速软件实现优化方法,首先介绍了该算法的总体结构和工作流程,参考原算法草案,通过软件编程实现了该算法的基本功能。在此基础上,结合软件编程函数中数组形参的传递执行过程和算法自身的计算特点,分析了影响其软件代码执行效率的因素,并对之前所编写的基本功能实现代码作出了改进。经过实际编程测试,分别验证了两种优化方法的有效性。总体而言,在两种不同的软件运行参考机环境下,结合两种优化方案的优化代码执行效率较基本功能实现代码分别提升了8%~9%、18%~36%,对于ZUC-256密码算法今后的软件工程使用具有实际性意义。     

Continuous speech recognition with sparse coding

Sparse coding is an efficient way of coding information. In a sparse code most of the code elements are zero; very few are active. Sparse codes are intended to correspond to the spike trains with which biological neurons communicate. In this article, we show how sparse codes can be used to do continuous speech recognition. We use the TIDIGITS dataset to illustrate the process. First a waveform is transformed into a spectrogram, and a sparse code for the spectrogram is found by means of a linear generative model. The spike train is classified by making use of a spike train model and dynamic programming. It is computationally expensive to find a sparse code. We use an iterative subset selection algorithm with quadratic programming for this process. This algorithm finds a sparse code in reasonable time if the input is limited to a fairly coarse spectral resolution. At this resolution, our system achieves a word error rate of 19%, whereas a system based on Hidden Markov Models achieves a word error rate of 15% at the same resolution.     

Stack virtualization for source level debugging

The compilation of high‐level languages to general‐purpose execution platforms poses some challenges when it comes to debugging. Typically, abstractions that are not natively supported by the execution platform must be emulated with intermediate data structures and function calls. Unfortunately, the details of the emulation are visible in the execution stack, and this unwanted information greatly reduces the effectiveness of debuggers. This paper presents a general method for constructing a virtual view of the stack, in order to mask intermediate function calls that were generated to emulate high‐level abstractions, or even to recover logical frame information that was lost during the compilation process. In particular, virtual views enable the visualization of two disjoint code representations (e.g. native code and interpreted code) as a single unified stack. We illustrate this method by showing how to handle the compilation of Bigloo, a dialect of the Scheme programming language. Copyright © 2006 John Wiley & Sons, Ltd.     

Real-Time Execution Monitoring

Today's programming methodology emphasizes the study of static aspects of programs. In practice, however, monitoring a program in execution, i.e., monitoring a process, is routinely done by any programmer whose task it is to produce a reliable piece of software. There are two reasons why one might want to examine the dynamic aspects of a program: first, to evaluate the performance of a program, and hence to assess its overall behavior; and second, to demonstrate the presence of programming errors, isolate erroneous program code, and correct it. This latter task is commonly called ``debugging a program' and requires a detailed insight into the innards of a program being executed. Today, many computer systems are being used to measure and control real-world processes. The pace of execution of these systems and their control programs is therefore bound to timing constraints imposed by the real-world process. As a step towards solving the problems associated with execution monitoring of real-time programs, we develop a set of appropriate concepts and define the basic requirements for a real-time monitoring facility. As a test case for the theoretical treatment of the topic, we design hardware and software for an experimental real-time monitoring system and describe its implementation.     

基于持续集成的Android自动化测试

Android测试方面的研究大多集中在测试工具和框架的实现上,有些工具和框架可以实现测试用例的自动生成和测试脚本的自动执行。然而在项目开发过程中,测试这个活动是需要人工启动的,不能及时有效地保证新增或者修改代码的质量。在 Robotium 测试框架的基础上,通过研究持续集成方案,包括被测代码和测试代码的托管、版本控制,应用的自动构建,测试的自动执行,实现了Android的自动化测试平台。使用该测试平台,可以及时自动地对被测代码的修改进行测试,直观可控地保证了Android应用的质量。     

Using metrics to manage software projects

Five years ago, Bull's Enterprise Servers Operation in Phoenix, Arizona, used a software process that, although understandable, was unpredictable in terms of product quality and delivery schedule. The process generated products with unsatisfactory quality levels and required significant extra effort to avoid major schedule slips. All but the smallest software projects require metrics for effective project management. Hence, as part of a program designed to improve the quality, productivity, and predictability of software development projects, the Phoenix operation launched a series of improvements in 1989. One improvement based software project management on additional software measures. Another introduced an inspection program, since inspection data was essential to project management improvements. Project sizes varied from several thousand lines of code (KLOC) to more than 300 KLOC. The improvement projects enhanced quality and productivity. In essence, Bull now has a process that is repeatable and manageable, and that delivers higher quality products at lower cost. We describe the metrics we selected and implemented, illustrating with examples drawn from several development projects     

Tool support for fine-grained software inspection

Software inspection is a proven technique to improve quality and reduce costs. Detailed source code inspections are an important part of the formal inspection process, but they require a significant time investment. Research advances in static program analysis can reduce the inspection time required. By calculating answers to standard inspection questions, CodeSurfer frees experts to focus their efforts on more challenging inspection issues. CodeSurfer provides access to and answers queries about the system-dependence graph representation of programs, and can be integrated with other tools.     

Discovering colored Petri nets from event logs

Process-aware information systems typically log events (e.g., in transaction logs or audit trails) related to the actual execution of business processes. Analysis of these execution logs may reveal important knowledge that can help organizations to improve the quality of their services. Starting from a process model, which can be discovered by conventional process mining algorithms, we analyze how data attributes influence the choices made in the process based on past process executions using decision mining, also referred to as decision point analysis. In this paper we describe how the resulting model (including the discovered data dependencies) can be represented as a Colored Petri Net (CPN), and how further perspectives, such as the performance and organizational perspective, can be incorporated. We also present a CPN Tools Export plug-in implemented within the ProM framework. Using this plug-in, simulation models in ProM obtained via a combination of various process mining techniques can be exported to CPN Tools. We believe that the combination of automatic discovery of process models using ProM and the simulation capabilities of CPN Tools offers an innovative way to improve business processes. The discovered process model describes reality better than most hand-crafted simulation models. Moreover, the simulation models are constructed in such a way that it is easy to explore various redesigns. A. Rozinat’s research was supported by the IOP program of the Dutch Ministry of Economic Affairs. M. Song’s research was supported by the Technology Foundation STW.     

Cognitive perturbation through dynamic modelling: a pedagogical approach to conceptual change in science

While simulations have widely been used to facilitate conceptual change in learning science, results indicate that significant disparity or gap between students' prior conceptions and scientific conceptions still exists. To bridge the gap, we argue that the applications of computer simulation in science education should be broadened to enable students to model their thoughts and to improve and advance their theories progressively. While computer simulations are often used to offer opportunities for students to explore scientific models, they do not give them the space to explore their own conceptions, and thus cannot effectively address the challenge of changing students' alternative conceptions. Findings from our recent empirical study reveal that, firstly, dynamic modelling using the environment WorldMaker 2000 in conjunction with the use of a cognitive perturbation strategy by the teacher was effective in helping students to migrate from their alternative conceptions towards a more scientifically inclined one; secondly, the pathways of conceptual change across groups were idiosyncratic and diverse. Respecting students' ideas seriously and providing cognitive perturbation at appropriate junctures of the inquiry process are found to be conducive to fostering conceptual change. In this paper, we will report on the details of the pedagogical approach adopted by the teacher and portray how students' conceptions change during the entire process of model building.     

数字图像处理课程的多视图模型

工科教学的一个难题是激发学生兴趣,提高其独立学习和设计能力。以数字图像处理这一课程为实施对象,提出了以理论模型为主线、以编程模型和图像处理效果可视化模型为副线的多视图教学模型,以解决该课程原有教学模式方法单一、过程枯燥等问题。采用该模型取得了较好的教学效果,实现数学理论模型和编程技术的一体化建模:学生不仅能够理解如何采用数字图像处理的基本理论进行工程应用,而且能够掌握图像处理基本编程能力。     

Evaluating the productivity of a reference-based programming approach: A controlled experiment

ContextDomain engineering aims at facilitating software development in an efficient and economical way. One way to measure that is through productivity indicators, which refer to the ability of creating a quality software product in a limited period and with limited resources. Many approaches have been devised to increase productivity; however, these approaches seem to suffer from a tension between expressiveness on the one hand, and applicability (or the lack of it) in providing guidance for developers.ObjectiveThis paper evaluates the applicability and efficiency of adopting a domain engineering approach, called Application-based DOmain Modeling (ADOM), in the context of the programming task with Java, and thus termed ADOM-Java, for improving productivity in terms of code quality and development time.MethodTo achieve that objective we have qualitatively evaluate the approach using questionnaires and following a text analysis procedure. We also set a controlled experiment in which 50 undergraduate students performed a Java-based programming task using either ADOM-Java or Java alone.ResultsThe qualitative evaluation reveal that the approach is easy to uses and provides valuable guidance. Nevertheless, it requires training. The outcomes of the experiment indicate that the approach is applicable and that the students that used ADOM-Java achieved better code quality, as well as better functionality and within less time than the students who used only Java.ConclusionThe results of the experiments imply that by providing a code base equipped with reuse guidelines for programmers can increase programming productivity in terms of quality and development time. These guidelines may also enforce coding standards and architectural design.     

Caution: this product contains security code

Writing functional and error code already is problematic because of context switches that must occur inside the heads of software developers as they progress in their coding task. These distracting context switches lead to coding errors because developers stop thinking about one type of code and start thinking about another. Having to consider a third code type further increases the code development processes' complexity. In this article, we look at today's security coding environment and suggest some research thrusts to advance programmers' capabilities to address modern security programming challenges.