集成开发环境简史

如果说1964年的Dartmouth BASIC IDE算是第一个真正意义上的IDE,那么IDE已经陪伴我们走过了44年的风风雨雨。有人说IDE让程序员变懒了:有人说IDE让程序员疏远了编译和连接等操作。但是这并不能否定IDE为提升开发效率所作出的贡献。本期月度关注将带您走进Java IDE的世界,继续体验技术进步所为我们带来的便捷。     

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.     

VS2008的IDE环境中对应用程序进行调试的方法

VS2008是当前软件开发常用的开发环境,其中在VS2008IDE下进行程序的开发,程序开发人员可以很好地利用该开发环境所继承的应用程序调试工具进行程序的调试工作。从对VS2008的开发环境的介绍谈起,就VS2008的IDE环境中对应用程序进行调试的方法进行了说明,最后对VS2008的IDE环境中应用程序进行调试的步骤进行了分析。     

Does syntax highlighting help programming novices?

Program comprehension is an important skill for programmers – extending and debugging existing source code is part of the daily routine. Syntax highlighting is one of the most common tools used to support developers in understanding algorithms. However, most research in this area originates from a time when programmers used a completely different tool chain. We examined the influence of syntax highlighting on novices’ ability to comprehend source code. Additional analyses cover the influence of task type and programming experience on the code comprehension ability itself and its relation to syntax highlighting. We conducted a controlled experiment with 390 undergraduate students in an introductory Java programming course. We measured the correctness with which they solved small coding tasks. Each test subject received some tasks with syntax highlighting and some without. The data provided no evidence that syntax highlighting improves novices’ ability to comprehend source code. There are very few similar experiments and it is unclear as of yet which factors impact the effectiveness of syntax highlighting. One major limitation may be the types of tasks chosen for this experiment. The results suggest that syntax highlighting squanders a feedback channel from the IDE to the programmer that can be used more effectively.     

Language Parametric Module Management for IDEs

An integrated development environment (IDE) monitors all the changes that a user makes to source code modules and responds accordingly by flagging errors, by reparsing, by rechecking, or by recompiling modules and by adjusting visualizations or other information derived from a module. A module manager is the central component of the IDE that is responsible for this behavior. Although the overall functionality of a module manager in a given IDE is fixed, its actual behavior strongly depends on the programming languages it has to support. What is a module? How do modules depend on each other? What is the effect of a change to a module?We propose a concise design for a language parametric module manager: a module manager that is parameterized with the module behavior of a specific language. We describe the design of our module manager and discuss some of its properties. We also report on the application of the module manager in the construction of IDEs for the specification language Asf+Sdf as well as for Java.Our overall goal is the rapid development (generation) of IDEs for programming languages and domain specific languages. The module manager presented here represents a next step in the creation of such generic language workbenches.     

基于.NET平台的WebService构建与调用技术

使用Visual Studio 2008 IDE可以构建.NET平台中的Web Service。通过Method标识创建服务接口。同时,IDE还提供了方便的网络服务调试模式。通过添加网络服务的引用,使用代理类可完成网络服务的本地化映射。     

Do moods affect programmers’ debug performance?

There is much research that shows people’s mood can affect their activities. This paper argues that this also applies to programmers, especially their debugging. Literature-based framework is presented linking programming with various cognitive activities as well as linking cognitive activities with moods. Further, the effect of mood on debugging was tested in two experiments. In the first experiment, programmers (n = 72) saw short movie clips selected for their ability to provoke specific moods. Afterward, they completed a debugging test. Results showed the video clips had a significant effect on programmers’ debugging performance; especially, there was a significant difference after watching low- and high-arousal-evoking video clips. In the second experiment, programmers’ mood was manipulated by asking participants (n = 19) to dry run algorithms for at least 16 min. They performed some physical exercises before continuing dry running algorithms again. The results showed a significant increase in arousal and valence that coincided with an improvement in programmers’ task performance after the physical exercises. Together, this suggests that programmers’ moods influence some programming tasks such as debugging.     

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.     

Vmalloc: A General and Efficient Memory Allocator

Despite its popularity, malloc's shortcomings frequently cause programmers to code around it. The new library Vmalloc generalizes malloc to give programmers more control over memory allocation. Vmalloc introduces the idea of organizing memory into separate regions, each with a discipline to get raw memory and a method to manage allocation. Applications can write their own disciplines to manipulate arbitrary type of memory or just to better organize memory in a region by creating new regions out of its memory. The provided set of allocation methods include general purpose allocation, fast special cases and aids for memory debugging or profiling. A compatible malloc interface enables current applications to select allocation methods using environment variables so they can tune for performance or perform other tasks such as profiling memory usage, generating traces of allocation calls or debugging memory errors. A performance study comparing Vmalloc and currently popular malloc implementations shows that Vmalloc is competitive to the best of these allocators. Applications can gain further performance improvement by using the right mixture of regions with different Vmalloc methods.     

Software Engineering with Transactional Memory Versus Locks in Practice

Transactional Memory (TM) promises to simplify parallel programming by replacing locks with atomic transactions. Despite much recent progress in TM research, there is very little experience using TM to develop realistic parallel programs from scratch. In this article, we present the results of a detailed case study comparing teams of programmers developing a parallel program from scratch using transactional memory and locks. We analyze and quantify in a realistic environment the development time, programming progress, code metrics, programming patterns, and ease of code understanding for six teams who each wrote a parallel desktop search engine over a fifteen week period. Three randomly chosen teams used Intel’s Software Transactional Memory compiler and Pthreads, while the other teams used just Pthreads. Our analysis is exploratory: Given the same requirements, how far did each team get? The TM teams were among the first to have a prototype parallel search engine. Compared to the locks teams, the TM teams spent less than half the time debugging segmentation faults, but had more problems tuning performance and implementing queries. Code inspections with industry experts revealed that TM code was easier to understand than locks code, because the locks teams used many locks (up to thousands) to improve performance. Learning from each team’s individual success and failure story, this article provides valuable lessons for improving TM.     

Debug It: A debugging practicing system

This study reported the research findings on improving programming skills of novice programmers by way of debugging practices. There were two objectives of the debugging training: (1) to uncover and to correct any misconceptions of the programmers; and (2) to improve the debugging abilities of the programmers. To meet these objectives, a model of debugging practices, DebugIt, was presented. The proposed model called for supervised debugging practices on short programs involving frequently committed programming errors. A system, DebugIt:Loop, was developed specifically for debugging practices on programs with loop related errors. Two sets of experiments were conducted with 26 college students and 46 senior high school students enrolled in introductory Pascal courses. For each experiment, students were randomly assigned into the experimental group (using DebugIt:loop for debugging practice) and the control group (using traditional programming practices). A posttest was administered to compare the debugging and errorless programming abilities among the students in the two groups. The statistical procedure of an ANCOVA was used to analyze the gathered data. The results showed that this model of supervised debugging practices was effective in improving novice programmers' programming skills.     

Debugging strategies and tactics in a multi-representation software environment

This paper investigates the interplay between high level debugging strategies and low level tactics in the context of a multi-representation software development environment (SDE). It investigates three questions. 1. How do programmers integrate debugging strategies and tactics when working with SDEs? 2. What is the relationship between verbal ability, level of graphical literacy and debugging (task) performance. 3. How do modality and perspective influence debugging strategy and deployment of tactics? The paper extends the work of Katz and Anderson [1988. Debugging: an analysis of bug location strategies. Human-Computer Interaction 3, 359–399] and others in terms of identifying high level debugging strategies, in this case when working with SDEs. It also describes how programmers of different backgrounds and degrees of experience make differential use of the multiple sources of information typically available in a software debugging environment. Individual difference measures considered among the participants were their programming experience and their knowledge of external representation formalisms. The debugging environment enabled the participants, computer science students, to view the execution of a program in steps and provided them with concurrently displayed, adjacent, multiple and linked programming representations. These representations comprised the program code, two visualisations of the program and its output. The two visualisations of the program were available, in either a largely textual format or a largely graphical format so as to track interactions between experience and low level mode-specific tactics, for example.The results suggest that (i) additionally to deploying debugging strategies similar to those reported in the literature, participants also employed a strategy specific to SDEs, following execution, (ii) verbal ability was not correlated with debugging performance, (iii) knowledge of external representation formalisms was as important as programming experience to succeed in the debugging task, and (iv) participants with greater experience of both programming and external representation formalisms, unlike the less experienced, were able to modify their debugging strategies and tactics effectively when working under different format conditions (i.e. when working with either largely graphical or largely textual visualisations) in order to maintain their high debugging accuracy level.     

Evaluation of integrated software development environments: Challenges and results from three empirical studies

Evidence shows that integrated development environments (IDEs) are too often functionality-oriented and difficult to use, learn, and master. This article describes challenges in the design of usable IDEs and in the evaluation of the usability of such tools. It also presents the results of three different empirical studies of IDE usability. Different methods are sequentially applied across the empirical studies in order to identify increasingly specific kinds of usability problems that developers face in their use of IDEs. The results of these studies suggest several problems in IDE user interfaces with the representation of functionalities and artifacts, such as reusable program components. We conclude by making recommendations for the design of IDE user interfaces with better affordances, which may ameliorate some of most serious usability problems and help to create more human-centric software development environments.     

Empirical studies on programming language stimuli

Comprehending and debugging computer programs are inherently difficult tasks. The current approach to building program execution and debugging environments is to use exclusively visual stimuli on programming languages whose syntax and semantics has often been designed without empirical guidance. We present an alternative: Sodbeans, an open-source integrated development environment designed to output carefully chosen spoken auditory cues to supplement empirically evaluated visual stimuli. Originally designed for the blind, earlier work suggested that Sodbeans may benefit sighted programmers as well. We evaluate Sodbeans in two experiments. First, we report on a formal debugging experiment comparing (1) a visual debugger, (2) an auditory debugger, and (3) a multimedia debugger, which includes both visual and auditory stimuli. The results from this study indicate that while auditory debuggers on their own are significantly less effective for sighted users when compared with visual and multimedia debuggers, multimedia debuggers might benefit sighted programmers under certain circumstances. Specifically, we found that while multimedia debuggers do not provide instant usability, once programmers have some practice, their performance in answering comprehension questions improves. Second, we created and evaluated a pilot survey analyzing individual elements in a custom programming language (called HOP) to garner empirical metrics on their comprehensibility. Results showed that some of the most widely used syntax and semantics choices in commercial programming languages are extraordinarily unintuitive for novices. For example, at an aggregate level, the word for , as in a for loop, was rated reliably worse than repeat by more than 673% by novices. After completing our studies, we implemented the HOP programming language and integrated it into Sodbeans.     

What experts want from programming languages

Abstract

This paper contrasts the aspirations of general-purpose programming language designers with some evidence about expert problem-solving and programming behaviour. The contrast is summarized in a rough wish-list of what experts want from general-purpose programming languages. The programmers' wish-list differs from the aspirations of language designers less in detail than in emphasis: whereas the designers emphasize well-foundedness and correctness, the expert programmers emphasize utility, control, and efficiency. It is argued that a programming language is a tool, not a panacea; tools make easy the tasks for which they are designed, but the outcome depends on the intention and expertise of the wielder.     

Circular attribute grammars with remote attribute references and their evaluators

Attribute grammars (AGs) are a suitable formalism for the development of language processing systems. However, for languages including unrestricted labeled jumps, such as “goto” in C, the optimizers in compilers are difficult to write in AGs. This is due to two problems that few previous researchers could deal with simultaneously, i.e., references of attribute values on distant nodes and circularity in attribute dependency. This paper proposescircular remote attribute grammars (CRAGs), an extension of AGs that allows (1) direct relations between two distant attribute instances through pointers referring to other nodes in the derivation tree, and (2) circular dependencies, under certain conditions including those that arise from remote references. This extension gives AG programmers a natural means of describing language processors and programming environments for languages that include any type of jump structure. We also show a method of constructing an efficient evaluator for CRAGs called amostly static evaluator. The performance of the proposed evaluator has been measured and compared with dynamic and static evaluators. Akira Sasaki: He is a research fellow of the Advanced Clinical Research Center in the Institute of Medical Science at the University of Tokyo. He received his BSc and MSc from Tokyo Institute of Technology, Japan, in 1994 and 1996, respectively. His research interests include programming languages, programming language processors and programming environments, especially compiler compilers, attribute grammars and systematic debugging. He is a member of the Japan Society for Software Science and Technology. Masataka Sassa, D.Sc.: He is Professor of Computer Science at Tokyo Institute of Technology. He received his BSc, MSc and DSc from the University of Tokyo, Japan, in 1970, 1972 and 1978, respectively. His research interests include programming languages, programming language processors and programming environments, currently he is focusing on compiler optimization, compiler infrastructure, attribute grammars and systematic debugging. He is a member of the ACM, IEEE Computer Society, Japan Society for Software Science and Technology, and Information Processing Society of Japan.     

X86汇编程序可视调试虚拟机的设计与实现

应用虚拟机构建技术与可视化技术相结合,设计一个汇编程序可视化集成开发环境X86VVM2.实现了一个可执行X86汇编程序的虚拟机内核,在此内核的基础上,进行对程序运行时数据及其执行过程的可视化研究,实现CPU寄存器值及寄存器之间的数据交换可视化、堆栈信息可视化、代码跟踪和调试可视化.同时也实现了一个可视化代码编辑器.经过实验与分析,具备可视调试特征的X86汇编程序集成开发环境可令程序设计者更为直观地理解汇编程序的执行过程,提高调试效率.     

Learning second and subsequent programming languages: A problem of transfer

Learning second and subsequent programming languages is easier than learning a first programming language because many concepts and constructs are shared. However, it is still a hard task. In this protocol analysis of moderately experienced programmers transferring to a new programming language, we classified episodes by whether they involved the syntactic, semantic, or planning level of programming knowledge. We discovered that most episodes involve planning and that in solving a given subproblem there are typically many cycles of language‐independent tactical planning followed by language‐dependent implementation planning. On the other hand, programmers have relatively minor problems with the syntax and semantics of a new language. Our subjects’ protocols and their final programs revealed that the plans they develop are strongly influenced by their knowledge of what would be convenient and appropriate in other languages they know. This prevents them from taking full advantage of the capabilities of the new language.     

Journeys up the mountain: Different paths to learning object-oriented programming

Among the challenges facing companies transitioning from structured to object-oriented (OO) programming is how (and whether) to retrain existing procedural programmers. Common wisdom has it that old-time programmers can be retrained in object technology only with great difficulty, but new programmers lack experience building large systems and the knowledge of the business. This paper describes a study of students learning OO programming where the participants ranged in experience from a single semester of programming to over 10 years of professional programming. The purpose of this study was to explore how students learn OO programming by observing them between their first exposure to OO programming and the time they finally “get it.” We identified five categories of learners who each took a different path to learning OO programming, encountered different obstacles, and adopted different learning strategies. We describe some factors that may play a part in helping and/or hindering a student's progress and that may be used to predict a student's learning category. We conclude with suggestions for alternative training program strategies that may be appropriate for each category and with directions for future research.     

Timelines: simplifying the programming of lag compensation for the next generation of networked games

Lag compensation algorithms used in networked games require programmers to manage the complexities of dealing with both time and shared state. This can make implementing lag compensation techniques challenging. The difficulties in expressing these algorithms limit experimentation with different algorithms and inhibit programmers from exploring the space of the algorithms and testing their effects. The solution is to have a programming model that is better able to deal with time. In this paper, we present such a programming model, timelines. Timelines dramatically reduce the time and effort required to implement lag compensation techniques by allowing for the explicit treatment of time. The timelines model has been implemented as part of the Janus toolkit.