To see the other types of publications on this topic, follow the link: Software patterns.
Dissertations / Theses on the topic 'Software patterns'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Software patterns.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Jones, Mary Elizabeth Song Il-Yeol. "Dimensional modeling : identifying patterns, classifying patterns, and evaluating pattern impact on the design process /." Philadelphia, Pa. : Drexel University, 2006. http://dspace.library.drexel.edu/handle/1860/743.
Full text
2
Waqas, Ahmad, and Fawad Kamal. "Modeling Patterns in Software Design." Thesis, Blekinge Tekniska Högskola, Avdelningen för programvarusystem, 2007. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-2350.
Full textAbstract:
Software patterns provide solutions to recurring design problems, provide a way to reason about the quality attributes, and support stakeholders in understanding the system. Naturally, the use of software patterns emerges from the requirements of the software. Use Cases have been a traditional and authentic approach to document these requirements. We propose a way to mine these patterns by sing use cases and advocate their significance in saving resources and time. For this purpose, an open-source system is discussed and four design patterns are mined with the help of use cases elicited from the documentation and literature available for the selected system. Patterns mined in this system are then document in GOF format.Furthermore, the consequences of few patterns on quality attributes are studied and an additional design pattern is proposed to improve the quality of the system.Folkspark Vägan 15:11 ,372 40 Ronneby ,Sweden
3
Geyer-Schulz, Andreas, and Michael Hahsler. "Software engineering with analysis patterns." Institut für Informationsverarbeitung und Informationswirtschaft, WU Vienna University of Economics and Business, 2001. http://epub.wu.ac.at/592/1/document.pdf.
Full textAbstract:
The purpose of this article is twofold, first to promote the use of patterns in the analysis phase of the software life-cycle by proposing an outline template for analysis patterns that strongly supports the whole analysis process from the requirements analysis to the analysis model and further on to its transformation into a flexible design. Second we present, as an example, a family of analysis patterns that deal with a series of pressing problems in cooperative work, collaborative information filtering and sharing, and knowledge management. We present the step-by-step evolution of the analysis pattern virtual library with active agents starting with a simple pinboard. In this paper we propose that using patterns in the analysis phase has the potential to reducing development time by introducing reuse already at the analysis stage and by improving the interface between analysis and design phase. To quantify our proposal we present results from the Virtual University project of the Vienna University of Economics and Business Administration, where the analysis patterns developed in this paper were used to implement several information systems. (author's abstract)Series: Working Papers on Information Systems, Information Business and Operations
4
Ayata, Mesut. "Effect Of Some Software Design Patterns On Real Time Software Performance." Master's thesis, METU, 2010. http://etd.lib.metu.edu.tr/upload/2/12612001/index.pdf.
Full textAbstract:
In this thesis, effects of some software design patterns on real time software performance will be investigated. In real time systems, performance requirements are critical. Real time system developers usually use functional languages to meet
the requirements. Using an object oriented language may be expected to reduce performance. However, if suitable software design patterns are applied carefully, the reduction in performance can be avoided. In this thesis, appropriate real time software performance metrics are selected and used to measure the performance of real time software systems.
5
Jerding, Dean Frederick. "Visualizing interaction patterns in program executions." Diss., Georgia Institute of Technology, 1997. http://hdl.handle.net/1853/9223.
Full text
6
Borstad, Ole Gunnar. "Finding Security Patterns to Countermeasure Software Vulnerabilities." Thesis, Norwegian University of Science and Technology, Department of Computer and Information Science, 2008. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-8850.
Full textAbstract:
Software security is an increasingly important part of software development as the risk from attackers is constantly evolving through increased exposure, threats and economic impact of security breaches. Emerging security literature describes expert knowledge such as secure development best practices. This knowledge is often not applied by software developers because they lack security awareness, security training and secure development methods and tools. Existing methods and tools require too much effort and security is often given less priority in the trade-off between functionality and security. This thesis defines a tool supported approach to secure software analysis and design. Possible vulnerabilities and their causes are identified through analysis of software specifications and designs, resulting in vulnerability cause graphs. The security modelling tool SeaMonster is extended to include security activity graphs; this technique is used with vulnerability cause graphs to model vulnerabilities and security improvement activities. A security activity graph is created to identify activities that keep the vulnerabilities from instantiating in the final software product. The activities in the security activity graph can be the use of security patterns. This way the above approach is used to find a security pattern as a countermeasure to a vulnerability, and can be used with the security pattern design templates implemented in a preliminary project. This is a way of providing coupling between security expertise and software developers to apply security knowledge in software development practice. The approach and tools are tested and demonstrated through a development case study of a medical patient journal system. The main contributions of this thesis are an approach to secure software analysis and design, an extension of the security modelling tool SeaMonster, a case study of the approach and tools that show how security can be incorporated in early stages of software development. The contributions are intended to improve availability of security knowledge, to increase security awareness and bridge the gap between software experts and software developers.
7
Harjumaa, L. (Lasse). "Improving the software inspection process with patterns." Doctoral thesis, University of Oulu, 2005. http://urn.fi/urn:isbn:9514278941.
Full textAbstract:
Abstract
The quality of a software product depends largely on the quality of the process that is used to develop it. In small software companies, the development process may be informal or even ad hoc, which causes uncertainty and variation in the product quality. However, quality issues are as important in small companies as in their larger counterparts. To sustain their dynamics and competitiveness, small organizations need to concentrate on the most effective quality assurance methods.
Software inspection is a proven method for improving product quality and it provides a very cost-effective way for small companies to improve their development processes. This study introduces a framework for adjusting the inspection process for the organization's specific needs and evaluating its capabilities. The main focus of this work, however, is on refining and improving the inspection process. The improvement is guided by concrete instructions that are documented as process patterns. The pattern approach has already been used successfully in several other areas of software engineering. Patterns aim at capturing the best practices of software development and transferring this knowledge between people or organizations.
The framework for inspection process capability originates from the literature relating to different types of peer review methods and experiments with flexible and tool-supported inspections in small companies. Furthermore, generic process improvement models are studied to find a feasible structure for the framework. As a result of the analysis, the i3 capability model is introduced. The feasibility of the model has been investigated in real-life software organizations carrying out inspections.
After the capability evaluation, the inspection process can be upgraded with the aid of improvement patterns, which provide structured and easy-to-follow guidelines for implementing improvements. An initial list of patterns, describing solutions to the most common problems confronted in the establishment of inspections, is extracted from related inspection research and an industrial experiment.
The contributions of this study are, first, the new view of the inspection process, based on the fundamental activities that are performed during an inspection instead of a series of stages, as it is usually presented. An activity-based process description enables tailoring of the process for organization-specific needs and its targeted improvement. Second, the study introduces a practical, lightweight method for implementing the improvement. Patterns are especially suitable in companies where resources are limited and full-scale improvement programmes cannot be initiated. Furthermore, the generic process improvement models do not provide detailed information on how improvements should be carried out, and the pattern approach represents a promising method for that. Third, the inspection process currently does not have a very significant role in generic software process improvement models; this study helps in outlining the importance of inspections. A similar approach could be applied to other software subprocesses to enable their evaluation and improvement.
8
Sampson, Adam T. "Process-Oriented Patterns for Concurrent Software Engineering." Thesis, University of Kent, 2008. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.527586.
Full text
9
Khan, Saad Usman. "Identification of malicious behavior patterns for software." Thesis, Norges teknisk-naturvitenskapelige universitet, Institutt for telematikk, 2014. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-26603.
Full textAbstract:
Over the years malware has increased in number and became increasingly harmful. Traditionally, anti-virus suites are used to protect the computers from various forms of malware. In recent years a new technique called “behavior based malware analysis” has become famous which overcomes some of shortcomings of traditional anti-virus suites. Just like antivirus suites require signatures, behavior analysis systems require patterngroups for malware identification. This thesis presents the design and implementation of a Malware Pattern Generator (MPG). MPG is built to automatically generate behavior based pattern groups from a given malicious dataset. MPG uses hierarchical clustering to find similarities between malware and extracts the similarities to generate pattern groups. Three variants of MPG are developed during the work on this thesis and the results of their evaluation against malicious datasets are presented.
10
Ali, Zoya. "Designing Object Oriented Software Applications within the Context of Software Frameworks." The Ohio State University, 2011. http://rave.ohiolink.edu/etdc/view?acc_num=osu1316183692.
Full text
11
Alzyoud, Mazen Salem. "ONTOLOGY DESIGN PATTERNS WITH APPLICATIONS TO SOFTWARE MEASUREMENT." Kent State University / OhioLINK, 2015. http://rave.ohiolink.edu/etdc/view?acc_num=kent1447338253.
Full text
12
Hoffman, Fredrik. "Architectural software patterns and maintainability: A case study." Thesis, University of Skövde, Department of Computer Science, 2001. http://urn.kb.se/resolve?urn=urn:nbn:se:his:diva-528.
Full textAbstract:
The importance of building maintainable software is being recognized in the community of software development. By developing software that is easy to maintain, the time and resources needed to perform the modifications may be decreased. This will in turn mean economical savings and increased profits.
Architectural software patterns are said to promote the development of maintainable software. The aim of this project was therefore to investigate whether architectural software patterns possess this property or not. A case study was performed where two candidate architectures were compared using a method called Architectural analysis of modifiability. This method uses change scenarios and modification ratios to identify differences between candidate architectures. A system developed at Ericsson Microwave Systems AB was used for the case study.
One of the candidate architectures consisted of two architectural software patterns: the Layers pattern and the Model-View-Controller pattern. The architecture analysis showed that the Layers pattern did promote maintainability whereas the Model-View-Controller pattern did not, from the basis of judgement associated with the method.
13
Ljosland, Ingvar. "BUCS: Patterns and Robustness : Experimentation with Safety Patterns in Safety-Critical Software Systems." Thesis, Norwegian University of Science and Technology, Department of Computer and Information Science, 2006. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-10088.
Full textAbstract:
In modern society, we rely on safely working software systems. This is the final report in a masters degree project to reveal key issues in the science field of computer software architecture and design of safety-critical software systems. A pre-study of a navigation system implied that functionality related problems and safety-critical problems do not stack one to one, but rather is a case of solving these aspects in different layers. This means that changes in software systems functionality do not necessary mean that change in safety-critical modules has to be done as well, and visa versa. To further support the findings in the pre-study, an experiment was created to investigate these matters. A group of twenty-three computer science students from the Norwegian University of Science and Technology (NTNU) participated as subjects in the experiment. They were asked to make two functional additions and two safety-critical additions to a software robot emulator. A dynamic web tool was created to present information to the subjects, and they could here answer surveys and upload their task solutions. The results of the experiment shows that there were not found any evidence that the quality attributes got affected by the design approaches. This means that the findings of this study suggest that there is difficult to create safety-critical versions of software architectural design patterns, because all design patterns have a set of additions and concequences to a system, and all sides of the implications of the design pattern should be discussed by the system architects before used in a safety-critical system.
14
Farah, Hanna Ibrahim. "Applying cognitive patterns to support software tool development." Thesis, University of Ottawa (Canada), 2006. http://hdl.handle.net/10393/27354.
Full textAbstract:
This research was motivated by the development of a set of cognitive patterns [3], and the hypothesis that those patterns could lead to innovative and useful features in software development environments. Cognitive patterns are descriptions of ways people think and act when exploring or explaining software. In this research we focused on the Temporal Details cognitive patterns, which describe the dynamics of the changes in someone's mental model.
The main objective of this research, therefore, is to determine to what extent software engineering tool features could be derived from the cognitive patterns, specifically belonging to the Temporal Details hierarchy.
As the first step in our research, we analysed current tool support for cognitive patterns. The second step was to create and evaluate a list of potential new features based on the cognitive patterns. Thirdly, we developed a prototype for our most promising feature entitled Temporal Model Explorer (TME). This prototype helps people understand and manipulate the history of a software model. Users can use a slider to browse the history of the construction of a UML diagram from its point of creation to its current state. Navigation can be performed at different levels of granularity. Design rationale can be included at any point in the history. The final step was to evaluate the TME prototype with twelve participants from different backgrounds. The participants found the tool useful, and agreed that they would use it if it was available in their work environment.
15
Oluyomi, Ayodele. "Patterns and protocols for agent oriented software development /." Connect to thesis, 2006. http://eprints.unimelb.edu.au/archive/00002780.
Full text
16
Motii, Anas. "Engineering secure software architectures : patterns, models and analysis." Thesis, Toulouse 3, 2017. http://www.theses.fr/2017TOU30274/document.
Full textAbstract:
De nos jours la plupart des organisations pour ne pas dire toutes, dépendent des technologies de l'information et de la communication (TIC) pour supporter plusieurs tâches et processus (quelquefois critiques). Cependant, dans la plupart des cas, les organisations et en particulier les petites entreprises accordent une importance limitée à l'information et à sa sécurité. En outre, sécuriser de tels systèmes est une tâche difficile en raison de la complexité et de la connectivité croissante du matériel et du logiciel dans le développement des TICs. Cet aspect doit alors être pris en compte dès les premières phases de conception. Dans ce travail, nous proposons une approche basée sur les modèles permettant de sécuriser des architectures logicielles en utilisant des patrons. Les contributions de ce travail sont : (1) un cadre de conception intégré pour la spécification et l'analyse d'architectures logicielles sécurisées, (2) une nouvelle méthodologie à base de modèles et de patrons et (3) une suite d'outils. Le fondement de l'approche associe un environnement basé sur des langages de modélisation pour la spécification et l'analyse des modèles d'architectures sécurisées et un dépôt à base de modèles d'artéfacts dédiés à la sécurité (modèle de patrons de sécurité, menaces et propriétés de sécurités) permettant la réutilisation de savoir-faire et de connaissances capitalisées. Pour cela on utilise des langages de modélisation pour la spécification et l'analyse de l'architecture. Le processus associé est constitué des activités suivantes : (a) analyse de risques à base de modèle appliquée à l'architecture du système pour identifier des menaces, (b) sélection et importation de modèles de patrons de sécurité, afin d'arrêter ou de mitiger les menaces identifiées, vers l'environnement de modélisation cible, (c) intégration de modèles de patrons dans le modèle d'architecture, (d) analyse de l'architecture obtenue par rapports aux exigences non-fonctionnelles et aux menaces résiduelles. Dans ce cadre, on s'est focalisé sur la vérification du maintien du respect des contraintes temporelles après application des patrons. La recherche de menaces résiduelles est réalisée à l'aide de techniques de vérification exploitant une représentation formelle des scénarios de menaces issus du modèle STRIDE et basés sur des référentiels de menaces existants (ex., CAPEC). Dans le cadre de l'assistance pour le développement des architectures sécurisées, nous avons implémenté une suite structurée d'outils autour du framework SEMCO et de la plateforme Eclipse Papyrus pour supporter les différentes activités basées sur un ensemble de langages de modélisation conforme à des standards OMG (UML et ses profils). Les solutions proposées ont été évaluées à travers l'utilisation d'un cas d'étude autour des systèmes SCADA (systèmes de contrôle et d'acquisition de données)Nowadays most organizations depend on Information and Communication Technologies (ICT) to perform their daily tasks (sometimes highly critical). However, in most cases, organizations and particularly small ones place limited value on information and its security. In the same time, achieving security in such systems is a difficult task because of the increasing complexity and connectivity in ICT development. In addition, security has impacts on many attributes such as openness, safety and usability. Thus, security becomes a very important aspect that should be considered in early phases of development. In this work, we propose an approach in order to secure ICT software architectures during their development by considering the aforementioned issues. The contributions of this work are threefold: (1) an integrated design framework for the specification and analysis of secure software architectures, (2) a novel model- and pattern-based methodology and (3) a set of supporting tools. The approach associates a modeling environment based on a set of modeling languages for specifying and analyzing architecture models and a reuse model repository of modeling artifacts (security pattern, threat and security property models) which allows reuse of capitalized security related know-how. The approach consists of the following steps: (a) model-based risk assessment performed on the architecture to identify threats, (b) selection and instantiation of security pattern models towards the modeling environment for stopping or mitigating the identified threats, (c) integration of security pattern models into the architecture model, (d) analysis of the produced architecture model with regards to other non-functional requirements and residual threats. In this context, we focus on real-time constraints satisfaction preservation after application of security patterns. Enumerating the residual threats is done by checking techniques over the architecture against formalized threat scenarios from the STRIDE model and based on existing threat references (e.g., CAPEC). As part of the assistance for the development of secure architectures, we have implemented a tool chain based on SEMCO and Eclipse Papyrus to support the different activities based on a set of modeling languages compliant with OMG standards (UML and its profiles). The assessment of our work is presented via a SCADA system (Supervisory Control And Data Acquisition) case study
17
Turk, Tuna. "The Effect Of Software Design Patterns On Object-oriented Software Quality And Maintainability." Master's thesis, METU, 2009. http://etd.lib.metu.edu.tr/upload/12611104/index.pdf.
Full textAbstract:
This study investigates the connection between design patterns, object oriented (OO) quality metrics and software maintainability. The literature on OO metrics, design patterns and software maintainability are reviewed, the relation between OO metrics and software maintainability is investigated, and then, in terms of obtained maintainability indicator metrics, the maintainability change of an application due to usage of design patterns is observed.
18
Shah, Dharmesh S. M. Massachusetts Institute of Technology. "On Startups : patterns and practices of contemporary software entrepreneurs." Thesis, Massachusetts Institute of Technology, 2006. http://hdl.handle.net/1721.1/37253.
Full textAbstract:
Thesis (S.M.M.O.T.)--Massachusetts Institute of Technology, Sloan School of Management, Management of Technology Program, 2006.Includes bibliographical references (leaves 106-109).
"When you write a book, you need to have more than an interesting story. You need to have a desire to tell the story. You need to be personally invested in some way. You need to care about it." Malcolm Gladwell Author, "The Tipping Point". "I have never thought of writing for reputation and honor. What I have in my heart must come out, that is the reason why I compose. " Ludwig van Beethoven. The above quotes answer the basic question that many people have asked me (and I have asked myself): Why are you writing a thesis? The answer is simple: I believe there's a story to be told, and I have a personal passion for the subject. This thesis will analyze the patterns and practices of contemporary software startups. Though much has been written about software companies and much has been written on startups, I'm primarily interested in the intersection: software startups. More specifically, I will explore contemporary software startups that were started after the Internet bubble burst. About The Website: onstartups.com
As part of the thesis writing experience, I started a blog called "OnStartups" (http://onstartups.com) where I have been posting articles on software startups. More information on the onstartups.com site is included at the end of the thesis. My passion for learning more about software startups, the opportunity to work with two exceptional individuals as co-advisors and the overwhelming response to my onstartups.com website are my primary motivations for this thesis. Onward!
by Dharmesh Shah.
S.M.M.O.T.
19
Alhusain, Sultan. "Intelligent data-driven reverse engineering of software design patterns." Thesis, De Montfort University, 2016. http://hdl.handle.net/2086/14341.
Full textAbstract:
Recognising implemented instances of Design Patterns (DPs) in software design discloses and recovers a wealth of information about the intention of the original designers and the rationale of their design decisions. Because it is often the case that the documentation available for software systems, if any, is poor and/or obsolete, recovering such information can be of great help and importance for maintenance tasks. Since DPs are abstractly and vaguely defined, a set of software classes with exactly the same relationships as expected for a DP instance may actually be only accidentally similar. On the other hand, a set of classes with relationships that are to an extent different from the typically expected can still be a true DP instance. The deciding factor is mainly whether or not the set of classes is actually intended to solve the design problem addressed by the DP, which makes the intent a fundamental and defining characteristic of DPs. Discerning the intent of potential instances requires building complex models that cannot be built using the information known about DPs. So, a paradigm shift in DP recognition to fully machine learning based approaches is required. The problem is that there exists no accurate and sufficiently large DP datasets and it is difficult to manually construct one. Also, there is a lack of research on the feature set that should be used in DP recognition. The main aim of this thesis is to enable the paradigm shift by laying down an accurate, comprehensive and information-rich foundation of feature and data sets. To achieve this aim, a large set of features is developed to cover a wide range of design aspects, with a particular focus on the design intent. This set serves as a global feature set from which different subsets can be objectively selected for different DPs. A new and feasible approach for DP dataset construction is designed and used to construct training datasets. The feature and data sets are then used experimentally to build and train DP classifiers. The results demonstrate the accuracy and utility of the sets introduced, and show that fully machine learning based approaches do provide the appropriate and well-equipped solutions to the problem of DP recognition.
20
DESTEFANIS, GIUSEPPE. "Assessing sofware quality by micro patterns detection." Doctoral thesis, Università degli Studi di Cagliari, 2013. http://hdl.handle.net/11584/266243.
Full textAbstract:
One of the goals of Software Engineering is to reduce, or at least to try to control, the defectiveness of software systems during the development phase.
Software engineers need to have empirical evidence that software metrics are related to software quality. Unfortunately, software quality is quite an elusive
concept, software being an immaterial entity that cannot be physically measured in traditional ways. In general, software quality means many things.
In software, the narowest sense of product quality is commonly recognized as absence or low incidence of bugs in the product. It is also the most basic meaning of confermance to requirements, because if the software contains too many functional defects, the basic requirement of providing the desired function is not met.
To increase overall customer satisfaction as well as satisfaction toward various quality attributes, the quality attributes must be taken into account in the planning and design of software. To improve quality during development, we need models of the develompment process, and within the process we need to select and deploy specific methods
and approaches, and employ proper tools and technologies. It is necessary to know measures of the characteristics and quality parameters of the development process and its stages, as well as metrics and models to help ensure that the development process is under control to meet the product’s quality objectives. Software quality metrics tend to measure whether software is well structured,
not too simple and not too complex, with cohesive modules that minimize their coupling. Many quality metrics have been proposed for software, depending
also on the paradigm and languages used there are metrics for structured programming, object-oriented programming, aspect-oriented programming, and so on. The use of traditional metrics as quality indicators is very dicult. The Lines of Code (LOC) metric (very related to faults), is dicult to use, you can not say to a team of developers to develop classes by imposing a predefined number of lines
of code. The use of the micro patterns (introduced by Gil and Maman) metrics, that capture concepts of good or bad programming (like anti patterns) can help developers to focus on those classes that belong to categories of micro patterns prone to fault. The relationship between traditional metrics and micro patterns is useful for enabling these new metrics to evaluate software quality. Micro patterns are similar to design patterns, but their characteristic is that they can be identified automatically, and are at a lower level of abstraction with respect to design patterns. This thesis tackles the problem of measuring software quality in Object Oriented (OO) systems by using such novel approaches based on micro patterns that can be a useful metrics in order to measure the quality of software by showing that certain categories of micro patterns are more fault prone than
others, and that the classes that do not correspond to any category of micro patterns are more likely to be faulty. Many empirical studies were performed to
validate empirically CK suite under these two aspects, showing an acceptable correlation between CK metrics values and software fault-proneness and diculty
of maintenance. In OO, micro patterns can help to identify the portions of code that should be
improved (for example those where encapsulation is not respected), and highlight other portions that make up good design practices. The design patterns, defined in the early nineties were an important breakthrough at analysis and design level, but are dicult to be automatically supported at the coding level. There are tools claiming to help finding the usage of design patterns in code, but in practice they are used in a very limited way. On the contrary, micro patterns are defined at coding level, and it is relatively easy to recognize them automatically, thus being able to implement formal conditions on the structure of the class.
Thesis overview The thesis is organized according to this scheme:
• Chapter 2 provides an overview of the concept of software metrics;
• Chapter 3 presents an overview of the design patterns catalogs;
• Chapter 4 discusses the micro patterns catalog using the definitions made
by Gil and Maman;
• Chapter 5 discusses the interpretation of Micro Patterns given by Arcelli
and Maggioni;
• Chapter 6 present the study of the evolution of five particular micro
patterns (anti patterns) in different releases of the Eclipse and NetBeans
systems, and the correlations between anti patterns and faults. The
analysis confirms previous findings regarding the high coverage of micro
patterns onto the system classes, and show that anti patterns not only
represent bad Object Oriented programming practices, but may also be
associated to the production of worse quality software, since they present
a significantly enhanced fault proneness.
• Chapter 7 present a study that aims to show, through empirical studies of
open source software systems, which categories of micro patterns are
more correlated to faults. Gil and Maman demonstrated, and subsequent
studies confirmed, that 75% of the classes of a software system are
covered by micro patterns. In this chapter is also analyzed the relationship
between faults and the remaining 25% of classes that do not match with
any micro pattern. We found that these classes are more likely to be faultprone
than the others. We also studied the correlation among all the micro
patterns of the catalog, in order to verify the existence of relationships
between them.
• Chapter 8 present a study on micro patterns in different releases of two software systems developed with Object Oriented technologies and Agile process. In this chapter we present some empirical results on two case studies of systems devel- oped with Agile methodologies, and compare them to previous results obtained for non Agile systems. In particular we have verified that the distribution of micro patterns in a software system developed using Agile methodologies does not differ from the distribution
studied in other systems, and that the micro patterns fault-proneness is about the same. We also analyzed how the distribution of micro patterns changes in different releases of the same software system. We demonstrate that there is a relationship between the number of faults and
the classes that do not match with any micro patterns. We found that these classes are more likely to be fault-prone than the others even in software
developed with Agile methodologies
• Chapter 9 present the Java tool used in order to extract from the source
code the informations about micro patterns distributions.
• Chapter 10 discusses the related works in the field.
21
Naish, James Alexander. "Towards systematic requirements reuse." Thesis, University of Manchester, 2014. https://www.research.manchester.ac.uk/portal/en/theses/towards-systematic-requirements-reuse(75db42b9-51be-43f6-af3e-324bf6c753fa).html.
Full textAbstract:
Reuse has often been claimed in the software engineering literature to improve thequality and reduce the cost of software. Motivated by the idea that these gains canbe multiplied if reuse can be achieved earlier in the software life-cycle, a subset ofthe requirements engineering literature has focused, since the inception of the field,on investigating approaches to reuse at the requirements level. A wide array of differentapproaches now exist within this space. However, these approaches offer varyingdegrees of generality and utility. Generality is important because it enables a requirementsengineer to utilise the same reuse library across multiple projects. Utility isimportant because it is a measure of the extent to which effort is reduced by utilising areuse approach. This thesis presents Reuse-Oriented Requirements Engineering (RORE): a systematicframework to support the production of requirements models by reuse. RORE aimsto improve on existing requirements-reuse approaches in respect of the generalityutilitytrade-off. RORE seeks to do this by bringing together the strengths of two existingrequirements-level reuse approaches: The Domain Theory and Problem-OrientedSoftware Engineering (POSE - a refinement of Jackson’s Problem Frames Approach).This thesis evaluates RORE with respect to both generality and utility, and comparesRORE against both frameworks. The major conclusion of the thesis is that while ROREimproves on each framework in respect of some, but not all, evaluation metrics, ROREdoes succeed in offering a level of generality which compares favourably to existinghighly general approaches, and without significantly reducing the utility of the approach.
22
Wu, Weizhong. "An on-line library of design patterns." CSUSB ScholarWorks, 2004. https://scholarworks.lib.csusb.edu/etd-project/2611.
Full textAbstract:
This project is to develop an on-line library to help software engineers who utilize design patterns for developing e-commerce applications it translates generic design patterns to concrete design patterns. The graphical user interface was developed to allow the user to develop their own design patterns by modifying or changing stored design patterns.
23
Moore, Freeman Leroy. "Quantifying Design Principles in Reusable Software Components." Thesis, University of North Texas, 1995. https://digital.library.unt.edu/ark:/67531/metadc278795/.
Full textAbstract:
Software reuse can occur in various places during the software development cycle. Reuse of existing source code is the most commonly practiced form of software reuse. One of the key requirements for software reuse is readability, thus the interest in the use of data abstraction, inheritance, modularity, and aspects of the visible portion of module specifications. This research analyzed the contents of software reuse libraries to answer the basic question of what makes a good reusable software component. The approach taken was to measure and analyze various software metrics as mapped to design characteristics. A related research question investigated the change in the design principles over time. This was measured by comparing sets of Ada reuse libraries categorized into two time periods. It was discovered that recently developed Ada reuse components scored better on readability than earlier developed components. A benefit of this research has been the development of a set of "design for reuse" guidelines. These guidelines address coding practices as well as design principles for an Ada implementation. C++ software reuse libraries were also analyzed to determine if design principles can be applied in a language independent fashion. This research used cyclomatic complexity metrics, software science metrics, and traditional static code metrics to measure design features. This research provides at least three original contributions. First it collects empirical data about existing reuse libraries. Second, it develops a readability measure for software libraries which can aid in comparing libraries. And third, this research developed a set of coding and design guidelines for developers of reusable software. Future research can investigate how design principles for C++ change over time. Another topic for research is the investigation of systems employing reused components to determine which libraries are more successfully used than others.
24
Palomares, Bonache Cristina. "Definition and use of software requirement patterns in requirements engineering." Doctoral thesis, Universitat Politècnica de Catalunya, 2016. http://hdl.handle.net/10803/403992.
Full textAbstract:
The final quality of software products and services depends on the requirements stated in the Software Requirements Specifications (SRSs). However, some problems like ambiguity, incompleteness and inconsistency have been reported in the writing of SRSs, especially when natural language is used. Requirements reuse has been proposed as a key asset for requirements engineers to efficiently elicit, validate and document software requirements and, as a consequence, obtain SRSs of better quality through more effective engineering processes.
Among all the possible techniques to achieve reuse, patterns hold a prominent position. In their most classical form, patterns describe problems that occur over and over again, and then describe the core of the solution to these problems. Software engineering practitioners have adopted the notion of pattern in several contexts, remarkably related to software design (e.g., design patterns and software architectural patterns), but also in other software development phases, both earlier and later. Following this strategy, requirement patterns emerge as a natural way to reuse knowledge during the Requirements Engineering (RE) stage.
Although there have been several techniques proposed to reuse requirements, it has been observed that no concrete proposal has achieved a wide acceptance, neither any covered all the necessary elements to encourage organizations to adopt requirements reuse. As a consequence, this thesis proposes the use of Software Requirement Patterns (SRPs) as a means to capture and reuse requirements knowledge in the context of information technology projects. Following the typical context-problem-solution structure of patterns, an SRP mainly consists of: a template (solution) that may generate one or more requirements when applied in a certain project, and some information (context-problem) to identify its applicability in that project. To facilitate their use, SRPs are encapsulated inside the PABRE (PAttern-Based Requirements Elicitation) framework. The framework covers all the elements that could be critical for the adoption of a requirements reuse technique. Specifically, the framework includes:
- A metamodel that describes the structure and semantics of SRPs and their organization inside a catalogue.
- An SRP catalogue composed by non-functional, non-technical and functional SRPs, the functional ones being specific for the content management system domain.
- A method for guiding the use of an SRP catalogue during requirements elicitation and specification, as well as another one for constructing and updating it.
- An economic model to perform cost-benefit analysis on the adoption of SRPs based on return-on-investment.
- The PABRE system as technological support.
In order to analyse the benefits and drawbacks of the SRPs proposed in this thesis, two empirical studies have been carried out to investigate the perception of participants about requirement patterns in general and SRPs in particular. The first one is an exploratory survey addressed to information technology people with industrial experience in RE, which analyses the current state of the practice of requirement patterns approaches. The second one corresponds to a set of semi-structured interviews, focussed on the SRP approach, conducted to requirements engineers of Swedish organizations. Moreover, as it has been discovered that there are few empirical studies showing the state of the practice of requirements reuse in industry, the first study also explores the current situation of requirements reuse practices in organizations.La qualitat final dels productes i serveis de software depèn del requisits definits en l’especificació de Requisits Software (ERS). Tot i així, alguns problemes com la ambigüitat, incompletesa i inconsistència han sigut detectats en la escriptura dels ERS, especialment quan el llenguatge natural és usat per escriure’ls. La reutilització de requisits ha sigut proposada com un recurs clau pels enginyers de requisits per tal d’obtenir, validar i documentar requisits software i, com a conseqüència, obtenir ERS de millor qualitat usant processos d’enginyeria més efectius. Entre totes les tècniques possibles per aconseguir la reutilització, els patrons tenen una posició destacada. En la seva forma més clàssica, els patrons descriuen problemes que ocorren sovint, i després descriuen la part central de la solució a aquests problemes. Els professionals de la enginyeria del software han adoptat la noció de patró en diferents àmbits, especialment en els relacionats amb el disseny del software (per exemple, els patrons de disseny i els patrons d’arquitectura del software), però també en altres etapes del desenvolupament del software, tant abans com després del seu disseny. Seguint aquesta estratègia, els patrons de requisits emergeixen com una manera natural de reutilitzar coneixement durant l’etapa d’enginyeria de requisits. Tot i que hi ha hagut varies tècniques proposades per reutilitzar requisits, s’ha observat que no hi ha cap proposta concreta que hagi aconseguit una àmplia acceptació, ni cap proposta completa que cobreixi tots els elements necessaris per animar a les organitzacions a adoptar la reutilització de requisits. Com a conseqüència, aquesta tesis proposa l’ús de Patrons de Requisits Software (en anglès Software Requirement Patterns o SRPs) com un medi per capturar i reutilitzar coneixement de requisits en l’àmbit de projectes de tecnologia de la informació. Seguint la estructura típica dels patrons de context-problema-solució, un SRP consisteix en: una plantilla (solució) que pot generar un o més requisits quan és aplicat en un projecte específic, i informació relacionada (context-problema) per identificar la seva aplicabilitat en un projecte. Per facilitar el seu ús, els SRP han sigut encapsulats dintre del framework PABRE (de l’anglès PAttern-Based Requirements Elicitation). El framework cobreix tots els elements que podrien ser crítics per adoptar una tècnica de reutilització de requisits. Més detalladament, el framework inclou: - Un meta model que descriu la estructura i semàntica dels SRPs i la seva organització dintre d’un catàleg.
25
Wang, Xin. "Deriving software performance models from architectural patterns by graph transformations." Thesis, National Library of Canada = Bibliothèque nationale du Canada, 1999. http://www.collectionscanada.ca/obj/s4/f2/dsk1/tape8/PQDD_0019/MQ48496.pdf.
Full text
26
Stal, Michael. "Understanding and analyzing software architecture (of distributed systems) using patterns." [S.l. : [Groningen : s.n.] ; University Library Groningen] [Host], 2007. http://irs.ub.rug.nl/ppn/300343159.
Full text
27
Stepan, Petr. "Interaction patterns as composite connectors in component-based software development." Thesis, University of Manchester, 2014. https://www.research.manchester.ac.uk/portal/en/theses/interaction-patterns-as-composite-connectors-in-componentbased-software-development(d4ba9b5e-3c5f-472b-ace1-4060ea5a88de).html.
Full textAbstract:
In current component models, interaction aspects of system behaviour are mostly specified by components, rather than by composition mechanisms, due to the fact that most composition mechanisms cannot express complex interactions. Consequently current component models do not enjoy the benefits that arise from separating the specification of computation from the specification of interaction in software architecture. This thesis investigates the possibility of representing recurring patterns of interaction as composition mechanisms (and other associated component model entities), as distinct from components that define computation; these composition mechanisms would appear as first-class entities in architectures, and can be stored in and reused from repositories. To this end, we have defined a novel, control-driven and data-driven component model that strictly separates computation from interaction. To represent interaction patterns in this model, we have defined composite connectors that can encapsulate control flow and data flow and can be reused via repositories in different contexts. We have also developed a prototype implementation of the component model, and carried out a case study from the reactive control systems domain in order to evaluate the feasibility of our approach. Comparison with related work shows that our composite connectors improve the state of the art in component-based interaction modelling (i) by specifying control flow and data flow explicitly and separately in software architecture; and (ii) by increasing the reuse potential of interaction patterns compared to patterns that are represented by components only.
28
Wang, Xin Carleton University Dissertation Engineering Systems and Computer. "Deriving software performance models from architectural patterns by graph transformations." Ottawa, 1999.
Find full text
29
Moghim, Mohammad Reza. "Incorporating design patterns into object-oriented development methods." Thesis, University of Salford, 1999. http://usir.salford.ac.uk/26820/.
Full textAbstract:
Object-oriented methods and design patterns provide valuable design guidance for object-oriented system development. However, they are not competitors, and in fact complement each other in many ways. The research reported in this thesis studied how to apply design patterns and object-oriented methods together to guide system development. It addresses issues such as, how methods need to be changed to accommodate the application of design patterns; how design patterns need to be adapted to fit within methods; and how the heuristics of design patterns may be brought to bear on improving methods. The thesis reports the experience of accommodating six design patterns ( Adapter, Composite, Facade, Mediator, Observer and Strategy ) from the book entitled "Design Patterns Elements of Reusable Object-Oriented Software" by E.Gamma, R. Helm, R.Johnson and J.Vlissides into certain object-oriented methods namely (Responsibility-Driven Design, Object-Oriented Software Engineering and Unified Modelling Language). This experience has been used in the work to generate a general approach for accommodating design patterns into methods. It also shows how the properties of the object-oriented methods and design patterns interact.�
30
Albertsen, Thomas. "Application patterns for ontology based applications." Thesis, Jönköping University, JTH, Computer and Electrical Engineering, 2006. http://urn.kb.se/resolve?urn=urn:nbn:se:hj:diva-618.
Full textAbstract:
Software patterns have been proven as a valuable way to storing a repeatable solution to a commonly occurring problem in software design. A pattern is not a finished design that can be directly formed into program code; instead it is a description how to solve a problem that may occur in many situations.
In the ontology community very little research have been made in producing high-level patterns where the solution shows how an architecture of an ontology based software might look like.
In this thesis the results of examining how high-level patterns of this type relates to other types of patterns are given and how these patterns would be described are formulated.
31
Avkarogullari, Okan. "Representing Design Patterns As Super Components In Component Oriented Software Engineering." Master's thesis, METU, 2004. http://etd.lib.metu.edu.tr/upload/1305390/index.pdf.
Full textAbstract:
It is widely believed and empirically shown that component reuse improves both the quality and productivity of software development. This brings the necessity of a graphical editor to model the projects by using components. A graphical editor was implemented for the development of Component Oriented software development. The editor facilitates modeling efforts through application of the graphical modeling language COSEML. Both design patterns and software components have come to play important roles in software development. The correlation between software components and design patterns is apparent. In the design phase of the projects design patterns are used widely both in component and object oriented projects. Design patterns can be used as super components in component-based development . Software reuse, software components, design patterns, use of design patterns in component-based development, and component architectures are studied in details to address the need for the approach. COSE modeling activity starts with the decomposition of the target system into building blocks in a top-down order. Next, interfaces between these blocks are defined. If required design patterns can be added to model as super components.
32
Ciftci, Aysegul. "Use Of Design Patterns In Non-object Oriented Real-time Software." Master's thesis, METU, 2013. http://etd.lib.metu.edu.tr/upload/12615431/index.pdf.
Full textAbstract:
After the book, Design Patterns: Elements of Reusable Object-Oriented Software was published in 1994, usage of design patterns in object-oriented (OO) programming has been investigated by many researchers. However, the effects of design patterns on non-object oriented (non-OO) programming have not been analyzed too much in the literature. This study focuses on various design pattern implementations using non OO programming and investigates the benefits of design patterns upon real-time software. In order to evaluate the results, specific quality metrics were selected and performance of traditionally developed software was compared with that of software developed using design patterns.
33
Faniyi, Funmilade Olugbenga. "Self-aware software architecture style and patterns for cloud-based applications." Thesis, University of Birmingham, 2015. http://etheses.bham.ac.uk//id/eprint/6032/.
Full textAbstract:
Modern cloud-reliant software systems are faced with the problem of cloud service providers violating their Service Level Agreement (SLA) claims. Given the large pool of cloud providers and their instability, cloud applications are expected to cope with these dynamics autonomously. This thesis investigates an approach for designing self-adaptive cloud architectures using a systematic methodology that guides the architect while designing cloud applications. The approach termed \(Self-aware\) \(Architecture\) \(Pattern\) promotes fine-grained representation of architectural concerns to aid design-time analysis of risks and trade-offs. To support the coordination and control of architectural components in decentralised self-aware cloud applications, we propose a \(Reputation-aware\) \(posted\) \(offer\) \(market\) \(coordination\) \(mechanism\). The mechanism builds on the classic posted offer market mechanism and extends it to track behaviour of unreliable cloud services. The self-aware cloud architecture and its reputation-aware coordination mechanism are quantitatively evaluated within the context of an Online Shopping application using synthetic and realistic workload datasets under various configurations (failure, scale, resilience levels etc.). Additionally, we qualitatively evaluated our self-aware approach against two classic self-adaptive architecture styles using independent experts' judgment, to unveil its strengths and weaknesses relative to these styles.
34
Duck, Geraint. "Extraction of database and software usage patterns from the bioinformatics literature." Thesis, University of Manchester, 2015. https://www.research.manchester.ac.uk/portal/en/theses/extraction-of-database-and-software-usage-patterns-from-the-bioinformatics-literature(fac16cb8-5b5b-4732-b7af-77a41cc64487).html.
Full textAbstract:
Method forms the basis of scientific research, enabling criticism, selection and extension of current knowledge. However, methods are usually confined to the literature, where they are often difficult to find, understand, compare, or repeat. Bioinformatics and computational biology provide a rich opportunity for resource creation and discovery, with a rapidly expanding "resourceome". Many of these resources are difficult to find due to the large choice available, and there are only a limited number of sufficiently populated lists that can help inform resource selection. Text mining has enabled large scale data analysis and extraction from within the scientific literature, and as such can provide a way to help explore the vast wealth of resources available, which form the basis of bioinformatics methods. As such, this thesis aims to survey the computational biology literature, using text mining to extract database and software resource name mentions. By evaluating the common pairs and patterns of usage of these resources within such articles, an abstract approximation of the in silico methods employed within the target domain is developed. Specifically, this thesis provides an analysis of the difficulties of resource name extraction from the literature, then using this knowledge to develop bioNerDS - a rule-based system that can detect database and software name mentions within full-text documents (with a final F-score of 67%). bioNerDS is then applied to the full-text document corpus from PubMed Central, the results of which are then explored to identify the differences in resource usage between different domains (bioinformatics, biology and medicine) through time, different journals and different document sections. In particular, the well established resources (e.g., BLAST, GO and GenBank) remain pervasive throughout the domains, although they are seeing a slight decline in usage. Statistical programs see high levels of usage, with R in bioinformatics and SPSS in medicine being frequently mentioned throughout the literature. An overview of the common resource pairs has been generated by pairing database and software names which directly co-occur after one another in text. Combining and aggregating these resource pairs together across the literature enables the generation of a network of common resource patterns within computational biology, which provides an abstract representation of the common in silico methods used. For example, sequence alignment tools remain an important part of several computational biology analysis pipelines, and GO is a strong network sink (primarily used for data annotation). The networks also show the emergence of proteomics and next generation sequencing resources, and provide a specialised overview of a typical phylogenetics method. This work performs an analysis of common resource usage patterns, and thus provides an important first step towards in silico method extraction using text-mining. This should have future implications in community best practice, both for resource and method selection.
35
Beauchel, Virginia Bernstrom. "Patterns of Arizona high schools' acquisition and use of microcomputer software." Diss., The University of Arizona, 1990. http://hdl.handle.net/10150/185045.
Full textAbstract:
The purpose of this study was to examine the patterns of acquisition and use of microcomputer software in Arizona high school library media centers, and to determine the selection procedures used by the library media specialists or other designated personnel responsible for the library media centers. The instrument used in this study was a survey developed and reviewed by a committee of school library media specialists. Subjects selected as the target population were 130 Arizona high school library media specialists. The procedures used for testing the 13 hypotheses were: (1) point biserial correlation coefficients, (2) t-tests, and (3) frequency distributions. Significant findings were indicated for the analysis of data of six hypotheses. The conclusions are summarized as follows: (1) As the size of the student body increases, the availability of microcomputer software for library management purposes also increases. (2) As the size of the library media budget increases the availability of microcomputer software for library management purposes also increases. (3) A negative relationship between the size of the library media center budget and the intention to obtain microcomputer software for school-wide purposes presented an anomaly for the intuitive approach to the analysis. (4) The methods chosen for evaluating and selecting microcomputer software varied significantly for each type of software selected. (5) Cell means indicated that for each type of library management programs obtained by the library media center, three school-wide programs were obtained. (6) Microcomputer software is utilized in the library media center more than in either classroom or in computer labs. Recommendations for additional investigation were discussed.
36
Dimitrov, Dimitar. "Towards cloud application architectural patterns: transfer, evolution, innovation and oblivion." Thesis, Tekniska Högskolan, Högskolan i Jönköping, JTH. Forskningsmiljö Informationsteknik, 2015. http://urn.kb.se/resolve?urn=urn:nbn:se:hj:diva-27643.
Full textAbstract:
Recently, cloud computing has been gaining more and more popularity. Misunderstanding, misusing and underutilizing the cloud offerings, though, both from business and technical perspective still poses a threat to the success of cloud projects. On the technical side, one of the main reasons for success or failure is often the architectural design of the system – if a system is not architected the “cloud way”, using cloud’s special characteristics, the business benefits of such a system are often questionable at best. Software architecture through architectural patterns – reusable generic solutions to classes of problems – has for long been a good way to overcome the challenges of software architecture. This paper focuses on establishing the grounds and highlighting the differences of the knowledge transfer regarding architectural patterns from building pre-cloud (“traditional”) software systems to building cloud-native systems. The following 3 research questions drive this research: RQ1. How does the existing knowledge on architectural patterns relate to the cloud computing environment? RQ2. Which characteristics of architectural patterns make them suitable for the cloud environment? RQ3. How can architectural pattern evolution be documented effectively for usage in the practice? In order to answer these 3 research questions and considering their focus is on utility i.e. creating a model which can be directly used in practice, the research uses design science research methodology (Peffers, et al., 2007-8). The emphasis in this methodology is iteratively building artefact(s) which can be improved and proven through practice that they actually help solving the problem at hand. This research contributes with building 4 inter-connected artefacts: a cloud applicability taxonomy of architectural patterns (CATAP) showing how applicable to a cloud environment an architectural pattern is and why; a pattern-to-characteristics mapping showing how using an architectural pattern affects the resulting system in traditional and cloud environments; a pattern form documenting the architectural patterns and the findings about them in the previous two artefacts; a wiki site, APE Wiki, which makes the results available to the public for reference and discussion and improvement. This research has a few interesting findings. First of all, the current architectural pattern knowledge seems to be very mature as no pattern has been found to have significantly evolved because of cloud – the architectural patterns are really generic and very flexible and only their effect on system characteristics has changed with the environment switch. On the other hand, a few new patterns were discovered and documented, which confirms the need for special attention to the new environment. Apart from that, the pattern-to-characteristics mapping provides interesting insights into which characteristics are most important for cloud and where there is a gap which may need to be filled. This paper presents both the process and the results of the research as equally important as replicating and extending this research could help in maturing the results and the knowledge about architecting systems for cloud thus increasing the chances of success of cloud projects.
37
Edge, Crystal. "Quantitative Assessment of the Modularization of Security Design Patterns with Aspects." NSUWorks, 2010. http://nsuworks.nova.edu/gscis_etd/142.
Full textAbstract:
Following the success of software engineering design patterns, security patterns are a promising approach to aid in the design and development of more secure software systems. At the same time, recent work on aspect-oriented programming (AOP) suggests that the cross-cutting nature of software security concerns makes it a good candidate for AOP techniques. This work uses a set of software metrics to evaluate and compare object-oriented and aspect-oriented implementations of five security patterns--Secure Base Action, Intercepting Validator, Authentication Enforcer, Authorization Enforcer, and Secure Logger.
Results show that complete separation of concerns was achieved with the aspect-oriented implementations and the modularity of the base application was improved, but at a cost of increased complexity in the security pattern code. In most cases the cohesion, coupling, and size metrics were improved for the base application but worsened for the security pattern package. Furthermore, a partial aspect-oriented solution, where the pattern code is decoupled from the base application but not completely encapsulated by the aspect, demonstrated better modularity and reusability than a full aspect solution.
This study makes several contributions to the fields of aspect-oriented programming and security patterns. It presents quantitative evidence of the effect of aspectization on the modularity of security pattern implementations. It augments four existing security pattern descriptions with aspect-oriented solution strategies, complete with new class and sequence diagrams based on proposed aspect-oriented UML extensions. Finally, it provides a set of role-based refactoring instructions for each security pattern, along with a proposal for three new basic generalization refactorings for aspects.
38
Huo, Ming Computer Science & Engineering Faculty of Engineering UNSW. "A systematic framework of recovering process patterns from project enactment data as inputs to software process improvement." Publisher:University of New South Wales. Computer Science & Engineering, 2009. http://handle.unsw.edu.au/1959.4/43683.
Full textAbstract:
The study of the software development process is a relatively new research area but it is growing rapidly. This development process, also called 'the software life cycle' or 'the software process', is the methodology used throughout the industry for the planning, design, implementation, testing and maintenance that takes place during the creation of a software product. Over the years a variety of different process models have been developed. From the numerous process models now available, project managers need validation of the choice he/she has made for a software development model that he/she believes will provide the best results. Yet the quality software so sought after by software project managers can be enhanced by improving the development process through which it is delivered. Well tested, reliable evidence is needed to assist these project managers in choosing and planning a superior software process as well as for improving the adopted software process. While some guidelines for software process validation and improvement have been provided, such as CMMI, quantitative evidence is, in fact, scarce. The quantitative evidence sometimes may not be able to be obtained from high level processes that refer to a planned process model, such as a waterfall model. Furthermore, there has been little analysis of low level processes. These low level processes refer to the actions of how a development team follow a high level software process model to develop a software product. We describe these low level processes as project enactment. Normally there is a gap between the high level software process and the project enactment. In order to improve this software development process, this gap needs to be identified, measured and analyzed. In this dissertation, we propose an approach that examines the deviation between a planned process model and the project enactment of that plan. We measure the discrepancy from two aspects: consistency and inconsistency. The analytical results of the proposed approach, which include both qualitative and quantitative data, provide powerful and precise evidence for tailoring, planning and selecting any software process model. The entire approach is composed of four major phases: 1) re-presentation of the planned process model, 2) pre-processing the low level process data, 3) process mining, and 4) analysis and comparison of the recovered process model and planned process model. We evaluate the proposed approach in three case studies: a small, a medium, and a large-sized project obtained from an industrial software development organization. The appropriate data on low level processes is collected and our approach is then applied to these projects individually. From each case study we then performed a detailed analysis of the inconsistencies that had surfaced as well as the consistencies between the plan and the enactment models. An analysis of the inconsistencies revealed that several 'agile' practices were introduced during the project's development even though the planned process model was initially based on 'ISO-12207' instead of the 'agile' method. In addition, our analysis identifies the patterns in the process that are frequently repeated. The outcome of the case studies shows that our approach is applicable to a range of software projects. The conclusions derived from these case studies confirmed that our approach could be used to enhance the entire software development process, including tailoring and assessment.
39
Azman, Norhidayah. "Dark retweets : an investigation of non-conventional retweeting patterns." Thesis, University of Southampton, 2014. https://eprints.soton.ac.uk/368784/.
Full textAbstract:
Retweets are an important mechanism for the propagation of information on the Twitter social media platform. However, many retweets do not use the offcial retweet mechanism, or even community established conventions, and these "dark retweets" are not accounted for in many existing analyses. In this thesis, a typology of 19 different tweet propagation types is presented, based on seven characteristics: whether it is proprietary, the mechanism used, whether it is created by followers or non-followers, whether it mentions other users, if it is explicitly propagating another tweet, if it links to an original tweet, and the audience that it is pushed to. Based on this typology and two retweetability confidence factors, the degrees of a retweet's "darkness" can be determined. This typology was evaluated over two datasets: a random sample of 27,146 tweets, and a URL drill-down dataset of 262,517 tweets. It was found that dark retweets amounted to 20.8% of the random sample, however the behaviour of dark retweets is not uniform. The existence of supervisible and superdark URLs skew the average proportion of dark retweets in a dataset. Dark retweet behaviour was explored further by examining the average reach of retweet actions and identifying content domains in which dark retweets seem more prevalent. It was found that 1) the average reach of a dark retweet action (3,614 users per retweet) was found to be just over double the average reach of a visible retweet action (1,675 users per retweet), and 2) dark retweets were more frequently used in spreading social media (41% of retweets) and spam (40.6%) URLs, whilst they were least prevalent in basic information domains such as music (8.5%), photos (5%) and videos (3.9%). It was also found that once the supervisible and superdark URLs were discarded from the analysis, the proportion of dark retweets decreased from 20.8% to 12%, whilst visible retweets increased from 79.2% to 88%. This research contributes a 19-type tweet propagation typology and the findings that dark retweets exist, but their behaviour varies depending on the retweeter and URL content domain.
40
Elizalde, Edith. "The role of help resources in users' solution patterns comparison of methods /." To access this resource online via ProQuest Dissertations and Theses @ UTEP, 2008. http://0-proquest.umi.com.lib.utep.edu/login?COPT=REJTPTU0YmImSU5UPTAmVkVSPTI=&clientId=2515.
Full text
41
Pizarro, Venegas Cristóbal Gaspar Ignacio. "Implementación de una librería de control de un radar con interfaz a la plataforma Ros." Tesis, Universidad de Chile, 2014. http://repositorio.uchile.cl/handle/2250/131356.
Full textAbstract:
Ingeniero Civil EléctricoIngeniero Civil en Computación
Este trabajo de título se enmarca en la investigación realizada en el Centro de Tecnología Minera Avanzada (Advanced Mining Technology Center, AMTC) con tecnologías de percepción. Los desarrollos hechos en robótica en este centro constan de desarrollos de hardware y de software, siendo el software para robots un problema en si mismo. Actualmente, en el campo de la robótica, existe una plataforma de desarrollo que está tomando fuerza como una solución al problema del desarrollo de software para robots, la plataforma Robot Operating System (ROS), la cual permite el desarrollo de módulos de control para un robot como un sistema distribuido. El objetivo de este trabajo de título es la implementación de una librería de control para un radar de ondas milimétricas que se usa en el AMTC, que permita su uso con la plataforma ROS. De esta forma, el radar podrá ser usado como un sensor en conjunto con las otras piezas de hardware (sensores y actuadores) de que dispone el laboratorio. Esta librería consiste en un conjunto de piezas de software ejecutables que permiten la comunicación con el radar, generando datos en el formato apropiado para la plataforma, una interfaz gráfica que facilita el control del sistema, un módulo que permite la visualización de datos y un módulo que implementa un algoritmo de detección de objetos basado en los datos generados por los otros módulos. La librería implementada fue probada en el laboratorio, en un entorno controlado, para la validación directa de ésta contra el software oficial que se vende con el radar, y para analizar el uso de la red por parte de la librería. Además, se probó en la elipse del parque O'Higgins, para un caso de prueba en terreno, en la que se evaluó el desempeño de la integración del radar con ROS, usando sus funcionalidades de visualización de datos. Con este trabajo se logró la utilización de todas las características del radar y su total integración con la plataforma ROS, lo que permitirá el uso del radar con los otros sensores del laboratorio y su uso para nuevos experimentos.
42
Ji, Katrina Yun. "ADAP: A component-based model using design patterns with applications in E-Commerce." CSUSB ScholarWorks, 2000. https://scholarworks.lib.csusb.edu/etd-project/1694.
Full text
43
Light, Adam. "Design patterns for cartography and data graphics /." view abstract or download file of text, 2004. http://wwwlib.umi.com/cr/uoregon/fullcit?p3153792.
Full textAbstract:
Thesis (Ph. D.)--University of Oregon, 2004.Typescript. Includes vita and abstract. Includes bibliographical references (leaves 93-97). Also available for download via the World Wide Web; free to University of Oregon users.
44
Bohdanowicz, Daniel. "Toward Tool Support for Usage of Object-Oriented Design Patterns Expressed in Unified Modeling Language." Thesis, Blekinge Tekniska Högskola, Avdelningen för programvarusystem, 2005. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-5895.
Full textAbstract:
Design patterns describe solutions that can be used in a particular context for commonly recurring problems at the detailed design level of a software system. Patterns have become an important concept in object-oriented development and their usage is a widely accepted practice. This thesis investigates issue of tool support for design patterns usage that can be offered by UML modelling tools, and proposes UML based method and notation for specification of the patterns, and documentation of their instances in a design model, facilitating such support. Different ways of such support are presented and classified, and comparison of tools offering assistance for patterns usage is depicted. UML profile supporting specification of structural aspects of solutions proposed by design patterns, and documentation of their instances is specified in the thesis.
45
Malik, Obaid Ur Rehman. "Mining object-oriented software execution traces to discover patterns for automated testing." Thesis, University West, Department of Technology, Mathematics and Computer Science, 2006. http://urn.kb.se/resolve?urn=urn:nbn:se:hv:diva-570.
Full textAbstract:
With the evolution of new software technologies, the requirements for automated testing are becoming more and more stringent. With increasing size of software projects, manual testing is becoming less efficient. For automated testing one of the most important question is, what to focus upon while testing? For a large number of functions along with large number of possible call sequences, it is very hard to generate test cases that cover all possible paths of control flow. By finding patterns in the calling sequences we will be able to identify more defects by focusing our testing efforts on those patterns. In this paper, we have described our work on tracing call sequences using Aspect Oriented Programming methodology and discovering those patterns in call sequences using data mining techniques.
46
Liang, Chengzhi. "COPIA: A New Software for Finding Consensus Patterns in Unaligned Protein Sequences." Thesis, University of Waterloo, 2001. http://hdl.handle.net/10012/1050.
Full textAbstract:
Consensus pattern problem (CPP) aims at finding conserved regions, or motifs, in unaligned sequences. This problem is NP-hard under various scoring schemes. To solve this problem for protein sequences more efficiently,a new scoring scheme and a randomized algorithm based on substitution matrix are proposed here. Any practical solutions to a bioinformatics problem must observe twoprinciples: (1) the problem that it solves accurately describes the real problem; in CPP, this requires the scoring scheme be able to distinguisha real motif from background; (2) it provides an efficient algorithmto solve the mathematical problem. A key question in protein motif-finding is how to determine the motif length. One problem in EM algorithms to solve CPP is how to find good startingpoints to reach the global optimum. These two questions were both well addressed under this scoring scheme,which made the randomized algorithm both fast and accurate in practice. A software, COPIA (COnsensus Pattern Identification and Analysis),has been developed implementing this algorithm. Experiments using sequences from the von Willebrand factor (vWF)familyshowed that it worked well on finding multiple motifs and repeats. COPIA's ability to find repeats makes it also useful in illustrating the internal structures of multidomain proteins. Comparative studies using several groups of protein sequences demonstrated that COPIA performed better than the commonly used motif-finding programs.
47
Oduor, M. (Michael). "Persuasive software design patterns and user perceptions of behaviour change support systems." Doctoral thesis, Oulun yliopisto, 2018. http://urn.fi/urn:isbn:9789526218854.
Full textAbstract:
Abstract Modern life has increasingly become intertwined with technology, and recent years have witnessed a growth in technologies that support people in, for instance, leading healthier and more sustainable lifestyles. At the centre of this growth has been persuasive systems design, which has been shown to have a positive effect on individuals’ behaviour and their use of systems. This dissertation consists of five studies, encompassing a literature review, two quantitative studies with a total of 227 respondents, and two constructive studies that address the central research question of the dissertation: How can integrating judgment and decision-making processes and persuasive software design patterns enhance the development of behaviour change support systems? The primary theoretical framework for the research is the Persuasive Systems Design model. This is a model that outlines the key requirements for developing persuasive systems, consisting of the theoretical underpinnings, persuasion context analysis, and four feature categories. In recent years, improving the design of persuasive systems to better achieve their intended objectives has been an important topic. This dissertation, in addition to examining the role of persuasive software features in influencing behaviour, also integrates behavioural economics and software design patterns into the design of persuasive systems. Additionally, the interplay between the categories and other constructs such as perceived competence is investigated through statistical analyses. Overall, results reveal that persuasive system features have an impact on the efficacy of behaviour change support systems. Additionally, integrating behavioural economics concepts that explain the reasons why individuals deviate from expected behaviour and software design patterns can help improve the development of persuasive systems and further enhance their efficacyTiivistelmä Teknologia on yhä tiukemmin osa nykyelämää. Viime vuosina on tapahtunut kasvua ja kehitystä teknologioissa, jotka tukevat ihmisiä esimerkiksi elämään terveellisemmin ja ympäristöä säästäen. Tämän kasvun keskiössä on ollut vakuuttavien järjestelmien suunnittelu, jonka on osoitettu vaikuttavan positiivisesti sekä ihmisten käyttäytymiseen että järjestelmien käyttöön. Tämä väitöskirja käsittää viisi tutkimusta, sisältäen kirjallisuuskatsauksen, kaksi kvantitatiivista tutkimusta yhteensä 227 vastaajalla, ja kaksi konstruktiivista tutkimusta, jotka yhdessä vastaavat väitöskirjan päätutkimuskysymykseen: Kuinka arviointi- ja päätöksentekoprosessit sekä vakuuttavien järjestelmien suunnittelumallit yhdistämällä voidaan edistää käyttäytymisen muutosta tukevien järjestelmien kehitystä? Ensisijainen teoreettinen viitekehys tutkimukselle on vakuuttavien järjestelmien suunnittelumalli (Persuasive Systems Design model). Kyseinen malli määrittää keskeiset vaatimukset vakuuttavien järjestelmien kehittämiselle. Tärkeänä aiheena on ollut vakuuttavien järjestelmien suunnittelemisen edistäminen, jotta niillä voitaisiin paremmin saavuttaa aiotut päämäärät. Vakuuttavien järjestelmien ohjelmisto-ominaisuuksien vaikutuksesta käyttäytymiseen tutkimisen lisäksi väitöskirja yhdistää myös behavioristisen taloustieteen ja ohjelmistosuunnittelumallit vakuuttavien järjestelmien suunnitteluun. Lisäksi kategorioiden ja muiden käsitteiden, kuten koetun pätevyyden, vuorovaikutusta on tutkittu tilastollisen analyysin keinoin. Kaiken kaikkiaan tulokset paljastavat vakuuttavien järjestelmien ominaisuuksilla olevan vaikutusta käyttäytymisen muutosta tukevien järjestelmien vaikuttavuuteen. Lisäksi integroimalla behavioristisen taloustieteen konsepteja, jotka selittävät syitä, joiden vuoksi yksilöt käyttäytyvät odotetusta poikkeavasti, ohjelmistosuunnittelumalleihin, voidaan auttaa edistämään vakuuttavien järjestelmien kehittämistä ja parantaa niiden vaikuttavuutta
48
Brandt, Christina E. "Software Patents and Litigation Patterns: Does patent hoarding deter or incentivize litigation?" Scholarship @ Claremont, 2013. http://scholarship.claremont.edu/cmc_theses/793.
Full textAbstract:
This paper looks at the relationship between software patent hoarding and firm litigation involvement. Software patents are relatively new, as the first software patent was granted in 1995. Since that first patent was granted, firms throughout the industry have engaged in a patent ‘arms race’ of sorts. Using data from Lex Machina IP litigation database and the USPTO, this study examines whether patent stock size impacts the incentives for firms to litigate by assessing the total number of law suits software firms are involved in and their litigation involvement broken down by party role. The results indicate that a larger patent portfolio will marginally increase the number of suits a firm files as a plaintiff. The results are inconclusive on the potential deterrence effect a firm can create by hoarding patents to discourage competitor firms from suing them.
49
Zhang, Tong. "Designing Practical Software Bug Detectors Using Commodity Hardware and Common Programming Patterns." Diss., Virginia Tech, 2020. http://hdl.handle.net/10919/96422.
Full textAbstract:
Software bugs can cost millions and affect people's daily lives. However, many bug detection
tools are not always practical in reality, which hinders their wide adoption. There are three main concerns regarding existing bug detectors: 1) run-time overhead in dynamic bug detectors, 2) space overhead in dynamic bug detectors, and 3) scalability and precision issues in static bug detectors. With those in mind, we propose to: 1) leverage commodity hardware to reduce run-time overhead, 2) reuse metadata maintained by one bug detector to detect other types of bugs, reducing space overhead, and 3) apply programming idioms to static analyses, improving scalability and precision. We demonstrate the effectiveness of three approaches using data race bugs, memory safety bugs, and permission check bugs, respectively. First, we leverage the commodity hardware transactional memory (HTM) selectively to use the dynamic data race detector only if necessary, thereby reducing the overhead from 11.68x to 4.65x. We then present a production-ready data race detector, which only incurs a 2.6% run-time overhead, by using performance monitoring units (PMUs) for online memory access sampling and offline unsampled memory access reconstruction. Second, for memory safety bugs, which are more common than data races, we provide practical temporal memory safety on top of the spatial memory safety of the Intel MPX in a memory-efficient manner without additional hardware support. We achieve this by reusing the existing metadata and checks already available in the Intel MPX-instrumented applications, thereby offering full memory safety at only 36% memory overhead. Finally, we design a scalable and precise function pointer analysis tool leveraging indirect call usage patterns in the Linux kernel. We applied the tool to the detection of permission check bugs; the detector found 14 previously unknown bugs within a limited time budget.Doctor of Philosophy
Software bugs have caused many real-world problems, e.g., the 2003 Northeast blackout and the Facebook stock price mismatch. Finding bugs is critical to solving those problems. Unfortunately, many existing bug detectors suffer from high run-time and space overheads as well as scalability and precision issues. In this dissertation, we address the limitations of bug detectors by leveraging commodity hardware and common programming patterns. Particularly, we focus on improving the run-time overhead of dynamic data race detectors, the space overhead of a memory safety bug detector, and the scalability and precision of the Linux kernel permission check bug detector. We first present a data race detector built upon commodity hardware transactional memory that can achieve 7x overhead reduction compared to the state-of-the-art solution (Google's TSAN). We then present a very lightweight sampling-based data race detector which re-purposes performance monitoring hardware features for lightweight sampling and uses a novel offline analysis for better race detection capability. Our result highlights very low overhead (2.6%) with 27.5% detection probability with a sampling period of 10,000. Next, we present a space-efficient temporal memory safety bug detector for a hardware spatial memory safety bug detector, without additional hardware support. According to experimental results, our full memory safety solution incurs only a 36% memory overhead with a 60% run-time overhead. Finally, we present a permission check bug detector for the Linux kernel. This bug detector leverages indirect call usage patterns in the Linux kernel for scalable and precise analysis. As a result, within a limited time budget (scalable), the detector discovered 14 previously unknown bugs (precise).
50
Taylor, Quinn Carlson. "Analysis and Characterization of Author Contribution Patterns in Open Source Software Development." BYU ScholarsArchive, 2012. https://scholarsarchive.byu.edu/etd/2971.
Full textAbstract:
Software development is a process fraught with unpredictability, in part because software is created by people. Human interactions add complexity to development processes, and collaborative development can become a liability if not properly understood and managed. Recent years have seen an increase in the use of data mining techniques on publicly-available repository data with the goal of improving software development processes, and by extension, software quality. In this thesis, we introduce the concept of author entropy as a metric for quantifying interaction and collaboration (both within individual files and across projects), present results from two empirical observational studies of open-source projects, identify and analyze authorship and collaboration patterns within source code, demonstrate techniques for visualizing authorship patterns, and propose avenues for further research.