软件开发中面向对象的方法

在分析传统的软件工程不足的基础上,介绍了软件开发中面向对象的方法的主要内容.对应于软件的生存周期各个阶段具体分析了软件工程开发中面向对象的方法.     

网络舆情演化的阶段分析

网络舆情演化的阶段分析对于研究网络舆情的演化规律具有重要的意义。由于网络舆情演化比较复杂,因此网络舆情演化过程的阶段划分也有一定难度,为便于研究,本文把网络舆情演化过程简化为三个阶段：初始传播阶段、迅速扩散阶段和消退阶段,在此基础上对网络舆情演化过程进行阶段分析。首先分析网络舆情的构成要素,然后分析网络舆情演化所具有的影响因素,最后分别对这三个阶段的演化因素和特征量的变化进行详细分析,并尽可能采用量化语言来分析每个阶段的特征变化,希望有助于对网络舆情演化规律的定量研究。     

事件驱动编程和面向对象技术的软件开发范式

引言当前,我国正逐步形成市场经济体制,人才的流动相对以前频繁,因此一个软件的开发过程中,开发人员更换的情况并不罕见。为了保证开发工作的连续性,避免换一批人就不得不重头开始,严格的需求规格说明书．数据流图．数据字典．阶段性的计划和报告书等文档,就显得十分重要。软件投入使用后,维护阶段将一直延续至软件废弃不用为止,其间除了不断纠正程序的逻辑错误外,还可能会应用户的要求增加新的功能,这些工作更可能由非原来的软件开发人员承担,所以符合软件工程定义的文档资料是决定软件使用寿命的重要因素。因此,在软件开发过…     

软件开发和管理过程中的演化分析和设计

本文首先介绍了软件过程的概念,提出了软件过程中演化研究的重要性,然后按演化产生的原因对软件演化进行了分类,并分别讨论了软件开发过程中固有的需求演化、分工演化、调试演化、重用演化和工具环境演化以及软件过程管理中的个体视图演化和模板类演化,分析了这些演化之间的关系,简要地介绍了我们设计的文档日志以及如何利用文档日志确定演化范围。     

面向对象软件开发及软件工程方法学实践与探讨

该文在应用软件工程方法学和应用软件系统的开发实践的基础上,分析了面向对象软件工程开发中所发生的问题,提出了面向对象程序开发应遵循的手段和方法,同时也将传统的软件开发和面向对象的软件开发形式互补作了描述。作者认为面向对象软件工程方法学是设计开发的思路,而不是一成不变的定律。     

面向对象的软件开发:思想、特性、方法与风格

本文讨论了面向对象软件开发的基本思想、基本特性、基本步骤和设计的风格     

一种基于面向对象思想和结构化技术的软件开发方法

本文在概述了传统的结构化方法和面向对象软件设计方法的优缺点，提出将两者的优点相结合，根据设计系统的原则给出了一种设计方法，并用实例验证。     

试析软件开发过程中的软件测试

对软件测试进行了介绍,阐述了软件测试的分类、特性及准则步骤,并对软件测试的未来进行了展望,提出了关于软件测试的方法和见解。     

软件开发过程模型的发展

针对软件开发过程模型的发展问题进行研讨。通过分析几个典型的软件开发过程模型：瀑布模型、快速原型化模型、增量模型、螺旋模型、构件组装模型,分析每个模型的产生情况,研究软件开发过程模型整体的发展过程,寻找其中规律性的东西。讨论了促使软件开发过程模型发展的两个主要因素：一是需要新的软件开发过程模型来处理新情况和新问题;二是需要新的软件开发过程模型来提高开发的效率和质量。指出了软件开发过程模型可以按照三个方向去发展：一是通过对现有模型进行改进、扩充、综合去发展;二是遵循新的思维方式去发展;三是借助新技术和新工具去发展。     

国内软件开发过程调查

我们知道,大多数程序员在开发过程中采用了一定的开发方法,包括CMM、XP等。在需求分析时,他们倾向于与客户一起交流。在需求阶段,程序员与客户交流的方式,如何做需求分析;在设计阶段,程序员使用一些设计工具进行设计;在开发过程中,程序员使用测试驱动开发的方式进行开发。通过使用设计模式来提高程序的质量。达到高内聚、低耦合的目标。为了了解用户在软件开发过程中使用的各种开发方法,以及这些开发方法对用户的开发过程产生的影响。我们进行了这样的一个调查,了解程序员的个人经验、项目规模,程序员在开发过程中需求分析的方式,以便知道如何设计一个能够提高效率和质     

JDiff: A differencing technique and tool for object-oriented programs

During software evolution, information about changes between different versions of a program is useful for a number of software engineering tasks. For example, configuration-management systems can use change information to assess possible conflicts among updates from different users. For another example, in regression testing, knowledge about which parts of a program are unchanged can help in identifying test cases that need not be rerun. For many of these tasks, a purely syntactic differencing may not provide enough information for the task to be performed effectively. This problem is especially relevant in the case of object-oriented software, for which a syntactic change can have subtle and unforeseen effects. In this paper, we present a technique for comparing object-oriented programs that identifies both differences and correspondences between two versions of a program. The technique is based on a representation that handles object-oriented features and, thus, can capture the behavior of object-oriented programs. We also present JDiff, a tool that implements the technique for Java programs. Finally, we present the results of four empirical studies, performed on many versions of two medium-sized subjects, that show the efficiency and effectiveness of the technique when used on real programs.

Analyzing the evolutionary history of the logical design of object-oriented software

Today, most object-oriented software systems are developed using an evolutionary process model. Therefore, understanding the phases that the system's logical design has gone through and the style of their evolution can provide valuable insights in support of consistently maintaining and evolving the system, without compromising the integrity and stability of its architecture. In this paper, we present a method for analyzing the evolution of object-oriented software systems from the point of view of their logical design. This method relies on UMLDiff, a UML-structure differencing algorithm, which, given a sequence of UML class models corresponding to the logical design of a sequence of system code releases, produces a sequence of "change records" that describe the design-level changes between subsequent system releases. This change-records sequence is subsequently analyzed from the perspective of each individual system class, to produce the class-evolution profile, i.e., a class-specific change-records' sequence. Three types of longitudinal analyses - phasic, gamma, and optimal matching analysis - are applied to the class-evolution profiles to recover a high-level abstraction of distinct evolutionary phases and their corresponding styles and to identify class clusters with similar evolution trajectories. The recovered knowledge facilitates the overall understanding of system evolution and the planning of future maintenance activities. We report on one real-world case study evaluating our approach.     

The object-oriented structured design notation for software designrepresentation

The development of a notation that supports key software structure concepts and design principles, is discussed. The notation should let designers represent modules, interfaces, hidden information, concurrency, message passing, invocation of operations and overall program structure in a comprehensive way. The authors examine three categories of approach to architectural design: object-oriented design, functional decomposition, and data structure design. They present their design notation, called object-oriented structured design (OOSD) which achieves the above-stated goal. They discuss classes in OOSD, its handling of asynchronous processes, and its design methods and rules. Automated support for OOSD is considered     

Structure of the software for computer-aided logical design of automatic control

Requirements on the software for computer-aided logical design of automatic control were formulated and assumed as a basis of the software concept. According to this concept, the software for the computer-aided logical design of automatic control should have two levels: the environment of the control system designer and the (researcher) environment for development and updating of the first level. Realization of the concept was illustrated by the GAMMA-2RS system.Translated from Avtomatika i Telemekhanika, No. 4, 2005, pp. 176–184.Original Russian Text Copyright © 2005 by Aleksandrov, Isakov, Mikhailova.This paper was recommended for publication by V.V. Kulba, a member of the Editorial Board     

The evolution of an object-oriented compiler framework

Increasing code reuse in software systems is an important way to decrease development and maintenance costs, reduce the time required to respond to new requirements, and significantly advance the feasible complexity limits for new systems. Object-oriented programming languages and environments provide fundamental support for truly reusable code through abstraction, inheritance, and polymorphism. Reusable code is a prerequisite for a significantly more powerful concept: reusable design. Frameworks of resuable design abstractions are difficult to create and typically evolve over a long period of use and refinement. Thus, it is important to understand how systems evolve and how this evolution can be directed to achieve the best results. This article illustrates some of the standard transformations, called refactorings, that occur in object-oriented systems as they evolve by describing the creation and evolution of a framework for building general-purpose string-to-object translators. It reflects our experiences with object-oriented compilers over a five year period while working on the Typed Smalltalk compiler project.     

Structuring the modeling space and supporting evolution in software product line engineering

The scale and complexity of product lines means that it is practically infeasible to develop a single model of the entire system, regardless of the languages or notations used. The dynamic nature of real-world systems means that product line models need to evolve continuously to meet new customer requirements and to reflect changes of product line artifacts. To address these challenges, product line engineers need to apply different strategies for structuring the modeling space to ease the creation and maintenance of models. This paper presents an approach that aims at reducing the maintenance effort by organizing product lines as a set of interrelated model fragments defining the variability of particular parts of the system. We provide support to semi-automatically merge fragments into complete product line models. We also provide support to automatically detect inconsistencies between product line artifacts and the models representing these artifacts after changes. Furthermore, our approach supports the co-evolution of models and their respective meta-models. We discuss strategies for structuring the modeling space and show the usefulness of our approach using real-world examples from our ongoing industry collaboration.     

Search based software testing of object-oriented containers

Automatic software testing tools are still far from ideal for real world object-oriented (OO) software. The use of nature inspired search algorithms for this problem has been investigated recently. Testing complex data structures (e.g., containers) is very challenging since testing software with simple states is already hard. Because containers are used in almost every type of software, their reliability is of utmost importance. Hence, this paper focuses on the difficulties of testing container classes with nature inspired search algorithms. We will first describe how input data can be automatically generated for testing Java containers. Input space reductions and a novel testability transformation are presented to aid the search algorithms. Different search algorithms are then considered and studied in order to understand when and why a search algorithm is effective for a testing problem. In our experiments, these nature inspired search algorithms seem to give better results than the traditional techniques described in literature. Besides, the problem of minimising the length of the test sequences is also addressed. Finally, some open research questions are given.     

构件化软件演化信息及演化相似性度量技术研究

对软件演化信息的度量能发现软件演化过程中的问题,预测其变化趋势。传统的软件演化信息度量技术主要是以文件、目录或者项目作为度量的基本单位,缺乏在较高抽象层次对软件系统进行度量的能力。在基于构件的软件配置管理模型的基础上,以构件作为软件演化度量的基本单位,提出了一组基于属性变化、适用于构件以及软件系统演化度量的公式（包括较近、较早演化度量,演化相似性度量等）,并开发了原型支撑系统。     

Empirical analysis of CK metrics for object-oriented design complexity: implications for software defects

To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer (1991, 1994) suite (CK metrics), in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.