<p>The product integration is a particularly critical phase of the software product development process as many problems originating from earlier phases become visible in this phase. Problems in product integration result in delays and rework. One of the measures to decrease the late discovery of problems is the use of development standards and guidelines that define practices to ensure correctness of the product integration. However, even if such standards and reference models exist, they are in not used consistently. One of the reasons is a lack of a proof that they indeed improve the integration process, and even more important, that they are sufficient for performing efficient and correct product integration.</p><p>The conclusion of the presented research is that the available descriptions in standards and reference models taken one by one are insufficient and must be consolidated to help development organizations improve the product integration process. The research has resulted in a proposed combination of the activities included in the different reference models. This combination has been based on a number of case studies. Through the case studies performed in seven different product development organizations, a relationship between problems that are observed and the failure to follow the recommendations in reference models is identified. The analysis has indicated which practices are necessary, and how other practices support these. The goal with the research is to provide product development organizations with guidelines for how to perform software product integration.</p><p>One additional finding of the research is the existence of relation between software architecture and the development process. A method for identifying dependencies between evolvement of software architectures and adaptation of integration practices has been demonstrated.</p>

The appropriate separation of concerns is a fundamental engineering principle. A concern, for software developers, is that which must be represented by code in a program; by extension, separation of concerns is the ability to represent a single concern in a single appropriate programming language construct. Advanced separation of concerns is a relatively recent technique in software development for dealing with the complexity of systems that contain crosscutting concerns, namely those individual concerns that cut across programs. Aspect-oriented programming (AOP), which is the area of this dissertation, offers a form of advanced separation of concerns in which primary and crosscutting concerns can be separated during problem solving. An aspect gathers into one place a concern that is or would otherwise be scattered throughout an object-oriented program or system. The primary aim of this dissertation-the AOPy project-is to investigate the usefulness of advanced separation of concerns that aspect-oriented programming offers. In other words, the AOPy Project determines whether the potential usefulness of aspect-oriented programming is currently actualized in practice. In determining its current practical usefulness, this dissertation also determines characteristics of and obstacles to usefulness of aspect-orientation in software development. Perhaps the most important contribution to understanding and addressing the problem of complexity in software systems that this dissertation makes is that the AOPy research project establishes a definition of compatibility of aspect-orientation and provides an analysis of sample instances during problem solving that indicate evidence of compatibility between object-orientation and aspect-orientation. Compatibility, as defined by the AOPy Project, exists when aspect-oriented ideas, terminology, and techniques are appropriately employed in the experimental problem-solving session. The primary scientific contribution of this dissertation, therefore, is a narrative description of the actual use of aspect-oriented programming in a series of controlled, problem-solving scenarios. Theories describing the use of aspect-oriented ideas, terminology, and techniques are generated and refined by means of Grounded Theory, a qualitative data analysis technique. Because this dissertation 1) analytically explores areas of compatibility of aspect-orientation with object-orientation and 2) defines areas of compatibility thwarted in practice, this research project can serve as a foundation for the development of aspect-oriented programming-based design methodologies that encourage compatibility and discourage non-compatibility. Therefore, the AOPy Project establishes a foundation for future research in both its methodology and its results and for future software development in practice. By contributing a definition of aspect-oriented compatibility and a framework within which it can be understood, this dissertation fosters the progression toward a seamless use of aspect-orientation between developer and task. / Graduation date: 2005

End-user programmers are writing an unprecedented number of programs, due in large part to the significant effort put forth to bring programming power to end users. Unfortunately, this effort has not been supplemented by a comparable effort to increase the correctness of these often faulty programs. To address this need, we have been working towards bringing fault localization techniques to end users. In order to understand how end users are affected by and interact with such techniques, we conducted a think-aloud study, examining the interactive, human-centric ties between end-user debugging and a fault localization technique for the spreadsheet paradigm. Our results provide insights into the contributions such techniques can make to an interactive end-user debugging process. / Graduation date: 2004

The Object-oriented Reuse Tool (ORT) supports the reuse of object-oriented software by maintaining a library of reusable classes and recording information about their reusability as well as information associated with their design and verification. In the early design phases of object-oriented development, ORT facilitates reuse by providing a flexible way to navigate the library, thereby aiding in the process of refining a design to maximally reuse existing classes. A collection of extensions to ORT have also been identified. These extensions would compose the remainder of a system useful in increasing reuse in object-oriented software production.

Providing means for the development of correct software still remains a central challenge of computer science. In this thesis we present a novel approach to tool-based inspection focusing on the functional correctness of software artifacts. The approach is based on conventional inspection in the style of Fagan, but extended with elements of formal verification in the style of Hoare. In Hoare’s approach a program is annotated with assertions. Assertions express conditions on program variables and are used to specify the intended behavior of the program. Hoare introduced a logic for formally proving the correctness of a program with respect to the assertions. Our main contribution concerns the predicates used to express assertions. In contrast to Hoare, we allow an incomplete axiomatization of those predicates beyond the point where a formal proof of the correctness of the program may no longer be possible. In our approach predicates may be defined in a completely informal manner (e.g. using natural language). Our hypothesis is, that relaxing the requirements on formal rigor makes it easier for the average developer to express and reason about software artifacts while still allowing the automatic generation of relevant, focused questions that help in finding defects. The questions are addressed in the inspection, thus filling the somewhat loosely defined steps of conventional inspection with a very concrete content. As a side-effect our approach facilitates a novel systematic, asynchronous inspection process based on collecting and assessing the answers to the questions. We have adapted the method to the inspection of code as well as the inspection of early designs. More precisely, we developed prototype tools for the inspection of programs written in a subset of Java and early designs expressed in a subset of UML. We claim that the method can be adapted to other notations and (intermediate) steps of the software process. Technically, our approach is working and has successfully been applied to small but non-trivial code (up to 1000 lines) and designs (up to five objects and ten messages). An in-depth industrial evaluation requires an investment of substantial resources over many years and has not been conducted. Despite this lack of extensive assessment, our experience shows that our approach indeed makes it easier to express and reason about assertions at a high level of abstraction.

The objective of this thesis is to obtain knowledge regarding how effective user centred evaluation methods are and how user centred evaluations are conducted by IT professionals. This will be achieved by exploring user centred evaluation in experimental and practical settings. The knowledge gained in these studies should inspire suggestions for further research and suggestions for improvements on the user centred evaluation activity. Two experimental studies were conducted. One compares the results from using three user centred evaluation methods, and the other examines two factors while conducting heuristic evaluation. The results show that the think-aloud evaluation method was the most effective method in finding realistic usability problems of the three methods. The number of critical problems found during think-aloud evaluation increases, if heuristic evaluation is conducted prior to the think-aloud evaluations. Further, two studies of user centred evaluation in practical settings were performed. The IT professionals participating in those studies were using the software development process Scrum to plan their work. The results show that user centred evaluation is infrequently conducted in Scrum projects, compared to testing activities like acceptance testing. The main type of evaluation is qualitative. Few participants measure user performance or use surveys to gather quantitative results on the usability and the user experience. IT professionals get feedback from users in an informal way and gather informal feedback from peers. Many participants use a mixture of methods for gathering feedback on their work. The outcome of this thesis shows that IT professionals should be encouraged to include users whenever possible when evaluating software, for example by using the think-aloud method. Using heuristic evaluation prior to conducting think-aloud evaluations is also recommended. In addition, IT professionals are encouraged to evaluate their software in an informal way frequently, rather than waiting for the right time to conduct a thorough quantitative evaluation. To advance this field further, researchers who want to improve the evaluation activity for the IT professionals should study how user centred evaluation methods could be combined in an efficient way and how the use of qualitative evaluation methods could be made more effective. / QC 20120522

In this thesis, we have identified the difference between Agile and Lean methodsbased on stakeholder’s perspectives. To achieve the goal we have dealwith only Agile and Lean principles. In addition, in order to identify thestakeholders from Agile and Lean principles we have used the relevant practicesfrom both sides. As the principles of Agile manifesto are directly followedby most of the organizations, we have also used Agile principles directlyin this research. On the other hand lean methods have no pure principles,as a result we have used the most common and popular lean principlesderived from different authors. We have only considered the mostrelevant principles that might be useful in software development. To achievea stronger result of this thesis we have also considered stakeholder theory.Moreover we have identified the stakeholder’s involvement with Agile/Leanprinciples and stakeholder theory.

Agile software development challenges the traditional way of software development and project management. In rapidly changing environments, changing requirements and tight schedule constraints require software developers to take a different approach toward the process of software development. However, beyond a few case studies, surveys and studies focused on specific practices such as pair programming, the effectiveness and applicability of agile methods have not been established adequately. The objective of my research is to improve the understanding of and gain insights into these issues. For this purpose, I develop a system dynamic simulation model that considers the complex interdependencies among the variety of practices used in agile development. The model is developed on the basis of an extensive review of the literature as well as quantitative and qualitative data collected from real projects in seven organizations. The development of the model was guided by dynamic hypotheses on customer involvement, refactoring and quality of design. The model was refined and validated using data from independent projects. The model helps in answering important questions on the impact of customer behavior, cost of making changes and economics of pair programming. Experimentation with the model suggests that the cost of change is not constant; instead, its value changes cyclically and increases towards the later phase of development. Also, the results of simulation show that with no pair programming, fewer tasks are delivered and it costs more to deliver a task when compared to development with pair programming. Further, customer behavior has a major impact on project performance. The quality of customer feedback is found to be very critical to the successful of an agile software development project. The primary contribution of this research is the simulation model of agile software development that can be used a tool to examine the impact of agile practices and management policies on critical project variables including project scope, schedule, and cost. This research provides a mechanism to study agile development as a dynamic system of practices rather than using a static view and in isolation. The results from this study are expected to be of significant interest to practitioners of agile methods by providing them a simulation environment to examine the impact of their practices, procedures and management policies.

The visualization is an important and vital tool of describing complex data for an uninitialized user. SICK has developed an array of advanced machine vision cameras all capable of producing large data sets of information at a high rate. Although capable of fast data handling and the ability of controlling robots and other types of controls, the data used for these calculations can be showed for an easy and fast feedback to the users or in a sales situation. The visualization available today, although fairly fast, is limited to a gradient textured model with few tools. Based on OpenGL the current visualization requires a wrapper to handle correctly within .NET applications which is the preferred platform at SICK. This thesis studies the possibility and development of new visualization tool based on .NET capable of adding textures and interaction with the visualization. Since the data derived from the different cameras can occur in so many different ways a robust application ia needed. With the use of Windows presentation Foundation (WPF) framework the application is divided in three components. The first one is a library capable of reading the correct section of the file and then structuring the data. The second component is a user control; this allows the visualization to be constructed and displayed with ease within all .NET applications. The third component is a application which make use of the two other components to display and interact with the visualization. The developed visualization can display several different textures and has support for full navigation in the form of zoom, panning and rotation. The application is developed in .NET for easy integration with other applications and tools. WPF has a straightforward way of handling 3d content, however it is mostly used for small elements of 3D not for as large models as provided by the cameras. By subsampling the data set, the loading time can be reduced to an acceptable value. Although visualizing the data in a detailed and interactive way, the WPF-framework is on its knees when handling the larger files. There are several limitations in WPF which indicates the unsuitability as the main graphical engine. / Visualisering är ett viktigt och nödvändigt verktyg för att beskriva komplexa data för en oinitierad användare. SICK har utvecklat en rad avancerade kameror som alla kan producera stora datamängder i hög takt. Även om kamerorna klarar av snabb datahantering och kan styra robotar och andra typer av kontroller, kan datan som används för dessa beräkningar även visas för en enkel och snabb återkoppling till användare eller i en säljsituation. Visualisering som finns idag är begränsad till en enkel modell med få verktyg. Denna avhandling studerar möjligheten och utvecklingen av ett nytt visualiseringsverktyg. Eftersom datan kommer från olika kameror behövs ett robust och mångsidigt system. Med hjälp av Windows Presentation Foundation (WPF) som ramverk är programvaran indelad i tre delar. Den första är ett bibliotek som kan läsa rätt del av filen och sedan strukturera data. Den andra komponenten är en kontroll, vilket gör att visualisering kan byggas och visas med lätthet inom alla .NET-applikationer. Den tredje komponenten är en applikation som använder sig av de två andra komponenterna för att visa och interagera med visualiseringen. Den utvecklade visualisering kan visa flera olika texturer och har stöd för full navigering i form av zoom, panorering och rotation. WPF har ett enkelt sätt att hantera 3D-objekt, men det används mestadels för mindre tillämpningar och inte för så stora modeller som tillhandahålls av kamerorna. Genom att sampla ner datamängden, så kan belastningen minskas. Även om kraven uppfylls och programvaran är användbar så finns det flera begränsningar i WPF som indikerar att det är en olämplig plattform för denna uppgift.

Modern organizations within IT-developing needs to be prepared to face challengesthat are not necessarily connected to the mere technological aspects of softwares.These challenges might lie within e. g. communication between stakeholders, userinvolvement, organizational regulations, the need for standards and maintainability ofthe products. This study is investigating the software development at one of thevarious IT-departments at Swedish bank Nordea, in order to point out the mostinteresting areas of improvement. Many different tools, standards, organizationalprocesses and methodologies are available to the developers, whereof some of themmight be inhibitory rather than enhancing the effectiveness. Nordea is also having anoffshoring-oriented strategy, having development resources located in India. Thediscussion is concerned with modern methodologies such as Scrum and other agiledevelopment concepts, and their use in a geographically dispersed context and withina non-agile organization.