Spelling suggestions: "subject:"1design patterns."" "subject:"22design patterns.""
201 |
Analysing artefacts dependencies to evolving software systemsJaafar, Fehmi 08 1900 (has links)
Les logiciels sont en constante évolution, nécessitant une maintenance et un développement continus. Ils subissent des changements tout au long de leur vie, que ce soit pendant l'ajout de nouvelles fonctionnalités ou la correction de bogues.
Lorsque les logiciels évoluent, leurs architectures ont tendance à se dégrader et deviennent moins adaptables aux nouvelles spécifications des utilisateurs. En effet, les architectures de ces logiciels deviennent plus complexes et plus difficiles à maintenir à cause des nombreuses dépendances entre les artefacts.
Par conséquent, les développeurs doivent comprendre les dépendances entre les artefacts des logiciels
pour prendre des mesures proactives qui facilitent les futurs changements et ralentissent la dégradation des architectures des logiciels.
D'une part, le maintien d'un logiciel sans la compréhension des les dépendances entre ses artefacts peut conduire à l'introduction de défauts.
D'autre part, lorsque les développeurs manquent de connaissances sur l'impact de leurs activités de maintenance, ils peuvent introduire des défauts de conception, qui ont un impact négatif sur l'évolution du logiciel. Ainsi, les développeurs ont besoin de mécanismes pour comprendre comment le changement d'un artefact impacte le reste du logiciel.
Dans cette thèse, nous proposons trois contributions principales :
La spécification de deux nouveaux patrons de changement et leurs utilisations pour fournir aux développeurs des informations utiles concernant les dépendances de co-changement.
La spécification de la relation entre les patrons d'évolutions des artefacts et les fautes.
La découverte de la relation entre les dépendances des anti-patrons et la prédisposition des différentes composantes d'un logiciel aux fautes. / Program maintenance accounts for the largest part of the costs of any program.
During maintenance activities, developers implement changes (sometimes simultaneously) on artefacts to fix bugs and to implement new requirements.
Thus, developers need knowledge to identify hidden dependencies among programs artefacts and detect correlated artefacts.
As programs evolved, their designs become more complex over time and harder to
change. In the absence of the necessary knowledge on artefacts dependencies, developers could introduce design defects and faults that causes development and maintenance costs to rise.
Therefore, developers must understand the dependencies among program artefacts
and take proactive steps to facilitate future changes and minimize fault proneness.
On the one hand, maintaining a program without understanding the different
dependencies between their artefacts may lead to the introduction of faults. On the
other hand, when developers lack knowledge about the impact of their maintenance
activities, they may introduce design defects, which have a negative impact on program evolution. Thus, developers need mechanisms to understand how a change to an artefact will impact the rest of the programs artefacts and tools to detect design defects impact.
In this thesis, we propose three principal contributions. The first contribution is two novel change patterns to model new co-change and change propagation scenarios.
We introduce the Asynchrony change pattern, corresponding to macro co-changes, i.e., of files that co-change within a large time interval (change periods), and the Dephase change pattern, corresponding to dephase macro co-changes, i.e., macro co-changes that always happen with the same shifts in time. We present our approach, named Macocha, and we show that such new change patterns provide interesting
information to developers.
The second contribution is proposing a novel approach to analyse the evolution of different classes in object-oriented programs and to link different evolution behaviour
to faults. In particular, we define an evolution model for each class to study the evolution and the co-evolution dependencies among classes and to relate such dependencies with fault-proneness.
The third contribution concerns design defect dependencies impact. We propose
a study to mine the link between design defect dependencies, such as co-change
dependencies and static relationships, and fault proneness.
We found that the negative impact of design defects propagate through their dependencies.
The three contributions are evaluated on open-source programs.
|
202 |
Editor videa / Video EditorHomola, Miloš January 2011 (has links)
In this paper I pay attention to video editation issue. Firstly the basic terminology is explained, then the history of analog editation is described and further more even digital editation as well. At this spot, very interesting history of development of this field isn't forgotten and also the architecture of video editing software is described as we know them today. The most used digital forrmats are summarized as well. In next chapters the design of simple video editing application is explained. The applied technologies are briefly described and the decision of the choice is clarified. The result of whole work is a library of tools for video processing applications development demonstrated in a simple application.
|
203 |
Analyzing and Reducing Compilation Times for C++ ProgramsMivelli, Dennis January 2022 (has links)
Software companies often choose to develop in C++ because of the high performance that the language offers. Facilitated by static compilation and powerful optimization options, runtime performance is paid for with compilation time. Although the trade-off is inevitable to some extent, building very large C++ programs from scratch can take up to several hours if extra care is not taken during development. This thesis analyzes compilation times for C++ programs and shows how they can be reduced with the help of design patterns, implementation hiding, and framework related fixes. The results presented prove that compilation times can be decreased significantly with no drawbacks to the maintainability of a program. An in-depth analysis of compilation times and dependencies has been conducted for two large software modules from a representative company. Both modules take over an hour of CPU time each to compile. The time consumption for different compiler activities, such as parsing, preprocessing, and runtime optimization tasks have been measured for the modules. The compilation times for unit tests and mocks which use the GoogleTest framework have been analyzed. A simple method that may reduce compilation times by up to 50% for programs that use GoogleTest is presented. A dependency metric has been created, based on the number of include statements found recursively throughout a program. The dependency metric was found to be connected to compilation time for the two analyzed modules. Other factors that can influence compilation times are also shown, such as runtime optimization options, and the use of templates. Experiments which show how a typical usage of templates can drastically increase compilation times are presented. In addition, a solution which allows templates to be used while avoiding code bloat across translation units is reviewed. The solution effectively rivals non-template code in terms of compilation time. The Pointer to Implementation (PImpl) and Dependency Injection design patterns have been used to refactor a small program. Both design patterns performed well, reducing the total compilation time and total compiler memory usage by 70%. A program that detects dependency cycles has been created, but no cycles were found in any of two modules from the representative company.
|
Page generated in 0.2876 seconds