现代操作系统中的多进程技术实及其应用

进程作为资源的拥有者和操作系统中被调度的基本单元,是现代操作系统的重要概念;掌握多进程编程并应用于实际,可以加深对操作系统的认识,是每个优秀程序员必备的素质。本文通过基于RPC的Client/Server进程应用程序的编写,讲述了实现进程并发的分布式计算。     

A New Model of Computation for Learning Vision Modules from Examples

This paper addresses an important class of mimicry problems, where the goal is to construct a computer program which is functionally equivalent to an observed behaviour. Computer vision research can be considered such a challenge, where a researcher attempts to impart human visual abilities to a computer. Unfortunately this has proved a difficult task, not least because our vision processes occur mostly at a subconscious level. It is therefore useful to study the general mimicry problem in order to develop tools which may assist computer vision research.This paper formalises a mimicry problem as one in which a computer learning system (L) constructs a solution from a given program structure (i.e. template or outline) by posing questions to an Oracle. The latter is an entity which, when given an input value, produces the corresponding output of the function which is to be mimicked.In order to define a program's structure, particularly one which can be extracted from any computer program automatically, a new model of computation is developed. Based on this a fast algorithm which determines the best questions to pose to the Oracle is then described. Thus L relieves the human programmer of the difficulties faced in choosing the examples from which to learn. This is important because a human programmer might inadvertently choose biased, redundant or otherwise unhelpful examples. Results are shown which demonstrate the utility of a complete learning system (L) based on this work.This paper represents background theory and initial algorithms which further work will extend into powerful automatic learning systems, examples of which are found in [36] and [38].     

The design of an interactive program development system for Pascal

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program-structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.     

Programming methodology,organizational environment,and programming productivity

Programming data involving 278 commercial-type programs were collected from 23 medium- to large-scale organizations in order to explore the relationships among variables measuring program type, the testing interface, programming technique, programmer experience, and productivity. Programming technique and programmer experience after 1 year were found to have no impact on productivity, whereas on-line testing was found to reduce productivity. A number of analyses of the data are presented, and their relationship to other studies is discussed.     

DOC 1988: The modernization of a chinese dialect dictionary on computer

The following paper argues against the abandonment of outdated computer-based research projects in favor of the redevelopment of such projects to take advantage of the recently available computer technology. Specifically, the paper reviews the rebirth of the Dictionary on Computer (DOC) of the Project on Linguistic Analysis at the University of California, Berkeley. A team of students and faculty have redesigned this research system and are implementing it on a personal computer to increase its availability compared with the previous implementation on an obsolete mainframe computer. In addition, changes to the system which take advantage of the features available in today's modern personal computers are reviewed.The author, Jonathan Scott Yaruss, is a recent graduate (1989) of the University of California, who worked at POLA as the primary database programmer in the new DOC project while studying for his Baccalaureate degrees in Linguistics and Psychology. Mr. Yaruss will be continuing his linguistic studies during the coming years in the Department of Communication Disorders at Syracuse University.     

Classes extraction from procedural programs

We analyse the relation between users' functions and global variables of procedural program. We apply rectangular decomposition in order to find the coverage. The paper shows how we extract classes from this coverage by using some defined rules. Thus, the proposed approach is a tool that can be used in re-engineering of old programs because it helps the programmer in transforming the program such as it obeys object oriented principles.     

Program Behavior at the Symbolic Level

No application programmer writes machine-language programs–i.e., strings of ones and zeroes. That primitive pursuit has long been reserved for those few who create the very first modules of a software system for new hardware. Instead, programmers make use of a wide spectrum of symbolic programming languages, ranging from assembly code to high-level languages such as Fortran, Cobol, and the Algol family. Every programming language has semantics which define some abstract machine. For the assembly-language programmer this machine bears a great resemblance to the actual hardware on which the program will be interpreted, but even here the programmer will frequently use system-defined subroutines or macros which represent extensions of the base hardware facilities. The high-level language programmer's abstract machine reflects the control mechanisms and data structures characteristic of the language. The Fortran programmer, for example, can think in terms of multidimensional array structures, DO loops, subprogram facilities, and so on. In principle he need never be concerned with the manner in which his abstract Fortran machine is to be realized by a particular hardware and software system. The user of a modern electronic hand calculator needs no knowledge of the works inside the box, and a modern high-level language system should present to its users an equally consistent environment, completely defined in terms of the syntax and semantics of the source language.     

Awareness of Organizational Expertise

Comprehension of computer programs involves identifying important program parts and inferring relationships between them. The ability to comprehend a computer program is a skill that begins its development in the novice programmer and reaches maturity in the expert programmer. This research examined the beginning of this process, that of comprehension of computer programs by novice programmers. The mental representations of the program text that novices form, which indicate the comprehension strategies being used, were examined. In the first study, 80 novice programmers were tested on their comprehension of short program segments. The results suggested that novices form detailed, concrete mental representations of the program text, supporting work that has previously been done with novice comprehension. Their mental representations were primarily procedural in nature, with little or no modeling using real‐world referents. In a second study, the upper and lower quartile comprehenders from Study 1 were tested on their comprehension of a longer program. Results supported the conclusions from Study 1 in that the novices tended towards detailed representations of the program text with little real‐world reference. However, the comprehension strategies used by high comprehenders differed substantially from those used by low comprehenders. Results indicated that the more advanced novices were using more abstract concepts in their representations, although their abstractions were detailed in nature.     

Linux系统下的程序测量的实现

对于程序的测量是软件开发人员必须要重视的一项内容,如何能够实现自己的程序最优,是每个程序员都追求的目标,该文通过用C语言开发了一个用于程序测量的工具,在Linux环境下测出所开发程序其所占用的CPU时间和内存空间。为程序员开发程序提供了一个用于自检的工具。     

Identifying Failure Causes in Java Programs: An Application of Change Impact Analysis

During program maintenance, a programmer may make changes that enhance program functionality or fix bugs in code. Then, the programmer usually will run unit/regression tests to prevent invalidation of previously tested functionality. If a test fails unexpectedly, the programmer needs to explore the edit to find the failure-inducing changes for that test. Crisp uses results from Chianti, a tool that performs semantic change impact analysis, to allow the programmer to examine those parts of the edit that affect the failing test. Crisp then builds a compilable intermediate version of the program by adding a programmer-selected partial edit to the original code, augmenting the selection as necessary to ensure compilation. The programmer can reexecute the test on the intermediate version in order to locate the exact reasons for the failure by concentrating on the specific changes that were applied. In nine initial case studies on pairs of versions from two real Java programs, Daikon and Eclipse jdt compiler, we were able to use Crisp to identify the failure-inducing changes for all but 1 of 68 failing tests. On average, 33 changes were found to affect each failing test (of the 67), but only 1-4 of these changes were found to be actually failure-inducing     

线性规划求解在客户服务中心排班问题中的应用

线性规划被广泛地应用于工业、交通、国防、经济、管理等领域,已成为现代科学管理的重要手段和管理决策的有效方法,在管理中的有代表性的应用案例有资源分配问题、员工的排班问题、运输问题、投资问题和成本效益平衡问题等。Exce的普及性和易学性也会让读者感到利用计算机求解线性规划十分容易。本文给出运用规划求解,解决客户服务中心每个班次的上班人数,使在满足客户服务的情况下,达到成本最低。     

The object-oriented DFT program library S/PHI/nX

In order to simplify the development and implementation process of quantum mechanical algorithms, we developed a set of object-oriented C++ libraries which can exploit modern computer architectures. The libraries are characterized as follows: (i) State-of-the-art computer science techniques have been applied or developed in this work to provide language elements to express algebraic expressions efficiently on modern computer platforms. (ii) Quantum mechanical algorithms are crucial in the field of materials research. The new libraries support the Dirac notation to implement such algorithms in the native language of physicists. (iii) The libraries are completed by elements to express equations of motions efficiently which is required for implementing structural algorithms such as molecular dynamics. Based on these libraries we introduce the DFT program package S/PHI/nX.     

Program entanglement,feature interaction and the feature language extensions

One of the most difficult tasks in software development is that the programmer must implement a feature going through a laborious and error prone process of modifying the programs of other features. The programs of the different features entangle in the same reusable program units of the programming language, making them also difficult to be verified, maintained and reused. We show that if (C1) the features interact, (C2) they are executed by the same process and (C3) they are implemented in a programming language that requires the programmer to specify execution flows, program entanglement is inevitable and the problem cannot be solved by software design alone. Applications with interacting features are common including those that require exception handling.The feature language extensions (FLX) is a set of programming language constructs designed to enable the programmer to develop interacting features as separate and reusable program modules even though the features interact. The programmer uses FLX to specify non-procedural program units, organize the program units into reusable features and integrate features into executable feature packages. He develops a feature based on a model instead of the code of other features. FLX supports an automatic procedure to detect the interaction condition among features; the programmer then resolve the interaction in a feature package without changing feature code. FLX features and feature packages are reusable; the programmer may package different combinations of them and resolve their interactions differently to meet different user needs. An FLX to Java compiler has been implemented; our experience of using it has been very positive.     

Cloud refactoring: automated transitioning to cloud-based services

Using cloud-based services can improve the performance, reliability, and scalability of a software application. However, transitioning an application to use cloud-based services is difficult, costly, and error-prone. The required re-engineering effort includes migrating to the cloud the functionality to be accessed as remote cloud-based services and re-targeting the client code accordingly. In addition, the client must be able to detect and handle the faults raised in the process of invoking the services. As a means of streamlining this transitioning, we developed a set of refactoring techniques—automated, IDE-assisted program transformations that eliminate the need to change programs by hand. In particular, we show how a programmer can extract services, add fault tolerance functionality, and adapt client code to invoke cloud services via refactorings integrated with a modern IDE. As a validation, we have applied our approach to automatically transform two third-party Java applications to use cloud-based services. We have also applied our approach to re-engineer a suite of services operated by General Electric to use cloud-based resources to better satisfy the GE business requirements.     

Mental models and software maintenance

Understanding how a program is constructed and how it functions are significant components of the task of maintaining or enhancing a computer program. We have analyzed vidoetaped protocols of experienced programmers as they enhanced a personnel data base program. Our analysis suggests that there are two strategies for program understanding, the systematic strategy and the as-needed strategy. The programmer using the systematic strategy traces data flow through the program in order to understand global program behavior. The programmer using the as-needed strategy focuses on local program behavior in order to localize study of the program. Our empirical data show that there is a strong relationship between using a systematic approach to acquire knowledge about the program and modifying the program successfully. Programmers who used the systematic approach to study the program constructed successful modifications; programmers who used the as-needed approach failed to construct successful modifications. Programmers who used the systematic strategy gathered knowledge about the causal interactions of the program's functional components. Programmers who used the as-needed strategy did not gather such causal knowledge and therefore failed to detect interactions among components of the program.     

Development of personal computer software for a visual electrophysiology laboratory

This paper describes the software developed by the authors in order to introduce the flexibility and computing power of a modern personal computer in an existing visual electrophysiology laboratory. The basic problems that a programmer must solve in order to implement the main tasks requested are discussed. Such problems include signal acquisition, signal averaging, artifact rejection, time domain analysis, frequency domain analysis and data management. The software developed following our guidelines makes it possible for a personal computer equipped with a commercial analog-to-digital converter to interface directly with the physiologic amplifiers and visual stimulators commonly used either for classical electroretinography or for pattern and focal electroretinography.     

Program sketching

Sketching is a synthesis methodology that aims to bridge the gap between a programmer’s high-level insights about a problem and the computer’s ability to manage low-level details. In sketching, the programmer uses a partial program, a sketch, to describe the desired implementation strategy, and leaves the low-level details of the implementation to an automated synthesis procedure. In order to generate an implementation from the programmer provided sketch, the synthesizer uses counterexample-guided inductive synthesis (CEGIS). Inductive synthesis refers to the process of generating candidate implementations from concrete examples of correct or incorrect behavior. CEGIS combines a SAT-based inductive synthesizer with an automated validation procedure, a bounded model-checker, that checks whether the candidate implementation produced by inductive synthesis is indeed correct and to produce new counterexamples. The result is a synthesis procedure that is able to handle complex problems from a variety of domains including ciphers, scientific programs, and even concurrent data-structures.     

Program Complexity and Programmer Productivity

This paper proposes a measure of program control complexity from an information theory viewpoint. A set of empirical data showing programmer productivity as a function of program control complexity is also presented. The data reveals a step-function-like contour to programmer productivity with increasing program control complexity.     

Case Studies on Cache Performance and Optimization of Programs with Unit Strides

Cache performance in modern computers is important for program efficiency. A cache is thrashing if a significant amount of time is spent moving data between the memory and the cache. This paper presents two cache thrashing examples, one in scientific computing and one in image processing, both of which involve several one-dimensional arrays that are accessed sequentially, i.e., with unit strides. Accessing arrays in unit strides was considered very efficient on cache-based computer systems. However, the existence of cache thrashing is demonstrated by significant increases in computing speed in the equivalent programs tuned for cache locality. This shows that accessing several arrays sequentially may cause cache thrashing. Thus, to improve cache performance, it is important that the compiler or the programmer takes all arrays inside a loop into consideration. © 1997 by John Wiley & Sons, Ltd.