Control software and platforms for single or cooperative robots are highly complicated because they coordinate and administer the interaction of a variety of distributed and heterogeneous hardware and software compone...
详细信息
ISBN:
(纸本)9781509007943
Control software and platforms for single or cooperative robots are highly complicated because they coordinate and administer the interaction of a variety of distributed and heterogeneous hardware and software components in a dynamic world. While most of such systems built on some uniform middleware or control system for all distributed nodes which come with restrictions in flexibility on several levels, we aim at a more flexible and open architecture of autonomous components in the style of IoT. In this paper, we introduce a platform independent robotics framework based on an IoT technology and protocols. We compare our architecture with other recent approaches and according to fundamental criteria, we discuss advantages and drawbacks.
As software evolves, data types have to be extended, possibly with new data variants or new operations. object-oriented design is well-known to support data extensions well. In fact, most popular books showcase data e...
详细信息
As software evolves, data types have to be extended, possibly with new data variants or new operations. object-oriented design is well-known to support data extensions well. In fact, most popular books showcase data extensions to illustrate how objects adequately support software evolution. Conversely, operation extensions are typically better supported by a functional design. A large body of programming language research has been devoted to the challenge of properly supporting both kinds of extensions. While this challenge is well-known from a language design standpoint, it has not been studied empirically. We perform such a study on a large sample of Smalltalk projects (over half a billion lines of code) and their evolution over more than 130,000 committed changes. Our study of extensions during software evolution finds that extensions are indeed prevalent evolution tasks, and that both kinds of extensions are equally common in object-oriented software. We also discuss findings about: the evolution of the kinds of extensions over time;the viability of the Visitor pattern as an object-oriented solution to operation extensions;the change-proneness of extensions;and the prevalence of extensions by third parties. This study suggests that object-oriented design alone is not sufficient, and that practical support for both kinds of program decomposition approaches are in fact needed, either by the programming language or by the development environment.
The objective of the present manuscript is to describe a new architecture of the nonlinear multiphysics Finite element code in objectoriented Fortran environment hereafter referred to as FOOF. The salient features of...
详细信息
The objective of the present manuscript is to describe a new architecture of the nonlinear multiphysics Finite element code in objectoriented Fortran environment hereafter referred to as FOOF. The salient features of FOOF are reusability, extensibility, and performance. Computational efficiency stems from the intrinsic optimization of numerical computing intrinsic to Fortran, while reusability and extensibility is inherited from the support of object-oriented programming style in Fortran 2003 and its later versions. The shortcomings of the objectoriented style in Fortran 2003 (in comparison to C+ +) are alleviated by introducing the class hierarchy and by utilizing a multilevel programming style. (C) 2015 Elsevier B.V. All rights reserved.
Mutation testing is a fault injection testing technique around which a great variety of studies and tools for different programming languages have been developed. Nevertheless, the mutation testing research with respe...
详细信息
Mutation testing is a fault injection testing technique around which a great variety of studies and tools for different programming languages have been developed. Nevertheless, the mutation testing research with respect to C++ is pending. This paper proposes a set of class mutation operators related to this language and its particular object-oriented (OO) features. In addition, an implementation technique to apply mutation testing based on the traversal of the abstract syntax tree (AST) is presented. Finally, an experiment is conducted to study the operator behaviour with different C++ programs, suggesting their usefulness in the creation of complete test suites. The analysis includes a Web service (WS) library, one of the domains where this technique can prove useful, considering its challenging testing phase and that C++ is still a reference language for critical distributed systems WS.
To effectively investigate the mechanical performance of microstructure-based layered composites, an object-oriented software with interactive graphical user interface has been developed. This software, named PCLab, i...
详细信息
To effectively investigate the mechanical performance of microstructure-based layered composites, an object-oriented software with interactive graphical user interface has been developed. This software, named PCLab, is able to analyze the microstructure evolution and mechanical performance by both Monte Carlo (MC) simulation and the Finite Element method (FEM). The software has integrated preprocessors, solvers and postprocessors. Some examples are tested and explored the functionality of the software package. It shows that the PCLab software with a user-friendly graphical interface provides an efficient tool for faster material analysis, design and application. It also provides a flexible, robust platform for the future extensity in the material multi-physics research. (C) 2015 Elsevier Ltd. All rights reserved.
Stability refers to a software system's resistance to the "ripple effect", i.e., propagation of changes. In this paper, we investigate the stability of classes that participate in instances/occurrences o...
详细信息
Stability refers to a software system's resistance to the "ripple effect", i.e., propagation of changes. In this paper, we investigate the stability of classes that participate in instances/occurrences of GoF design patterns. We examine whether the stability of such classes is affected by (a) the pattern type, (b) the role that the class plays in the pattern, (c) the number of pattern occurrences in which the class participates, and (d) the application domain. To this end, we conducted a case study on about 65.000 Java open-source classes, where we performed change impact analysis on classes that participate in zero, one (single pattern), or more than one (coupled) pattern occurrences. The results suggest that, the application of design patterns can provide the expected "shielding" of certain pattern-participating classes against changes, depending on their role in the pattern. Moreover, classes that participate in coupled pattern occurrences appear to be the least stable. The results can be used for assessing the benefits and liabilities of the use of patterns and for testing and refactoring prioritization, because less stable classes are expected to require more effort while testing, and urge for refactoring activities that would make them more resistant to change propagation.
Developers write object-oriented programs using numerous tools that come as part of integrated development environments (IDEs). We focus on the tool based interfaces of a dynamic class-based language named Smalltalk. ...
详细信息
Developers write object-oriented programs using numerous tools that come as part of integrated development environments (IDEs). We focus on the tool based interfaces of a dynamic class-based language named Smalltalk. Smalltalk IDEs have remained the same for almost 30 years now, despite that they have been found to induce problems related to navigation and the loss of context. The tools work on a textual representation of a program: the source code, which makes it more difficult to comprehend and manipulate the system under construction. In reaction to that, researchers have proposed building IDEs around other metaphors. We explore the desktop metaphor applied to object-oriented languages in the form of an object-focused environment, and provide a detailed description of our working prototype, named Gaucho. Our goal is to depart from IDEs with tool based interfaces and fancy text editors, towards an environment that eases the interaction and the crafting of objects by providing more concrete means of manipulation within the interface. (C) 2013 Elsevier B.V. All rights reserved.
Teaching advanced programming can be a challenge, especially when the students are pursuing different majors with diverse analytical and problem-solving capabilities. The purpose of this paper is to explore the effica...
详细信息
Teaching advanced programming can be a challenge, especially when the students are pursuing different majors with diverse analytical and problem-solving capabilities. The purpose of this paper is to explore the efficacy of using a particular problem as a vehicle for imparting a broad set of programming concepts and problem-solving techniques. We present a classic brain teaser that is used to communicate and demonstrate advanced software development concepts and techniques. Our results show that students with varied academic experiences and goals, assuming at least one procedural/structured programming pre-requisite, can benefit from and also be challenged by such an exercise. Although this problem has been used by others in the classroom, we believe that our use of this problem in imparting such a broad range of topics to a diverse student population is unique.
The hierarchical method of organizing information has proven beneficial in learning in part because it maps well onto the human brain's memory. Exploiting this organizational strategy may help engineers cope with ...
详细信息
ISBN:
(纸本)9781467375290
The hierarchical method of organizing information has proven beneficial in learning in part because it maps well onto the human brain's memory. Exploiting this organizational strategy may help engineers cope with large software systems. In fact such an strategy is already present in source code and is manifested in the class hierarchies of objected-oriented programs. However, an engineer faced with fixing a bug or any similar need to locate the implementation of a particular feature in the code is less interested in the syntactic organization of the code and more interested in its conceptual organization. Therefore, a conceptual hierarchy would bring clear benefit. Fortunately, such a view can be extracted automatically the source code. The hierarchy generating tool HierIT performs this task using an information-theoretic approach to identify "content-bearing" words and associate them hierarchically. The resulting hierarchy enables an engineer to better understand the concepts contained in a software system. To study their value, an experiment was conducted to quantitatively and qualitatively investigate the value that hierarchies bring. The quantitative evaluation first considers the Expected Mutual Information Measure (EMIM) between the set of topic words and natural language extracted from the source code. It then considers the Best Case Tree Walk (BCTW), which captures how "expensive" it is to find interesting documents. Finally, the hierarchies are considered qualitatively by investigating their perceived usefulness in a case study involving three engineers.
We present the Flyweight object-oriented (Foo) calculus for the modeling of object-oriented languages. Foo is a simple, minimal class-based calculus, modeling only essential computational aspects and emphasizing large...
详细信息
ISBN:
(纸本)9781450336567
We present the Flyweight object-oriented (Foo) calculus for the modeling of object-oriented languages. Foo is a simple, minimal class-based calculus, modeling only essential computational aspects and emphasizing larger-scale features (e.g., inheritance and generics). Foo is motivated by the observation that recent language design work focuses on elements not well-captured either by traditional object calculi or by language-specific modeling efforts, such as Featherweight Java. Foo integrates seamlessly both nominal and structural subtyping ideas, leveraging the latter to eliminate the need for modeling object fields and constructors. Comparing to recent formalization efforts in the literature, Foo is more compact, yet versatile enough to be usable in multiple settings modeling Java, C#, or Scala extensions.
暂无评论