The topic of this research is direct user participation in the task based development of interactive software systems. Building usable software demands understanding and supporting users and their tasks. Users are a primary source of usability requirements and knowledge, since users can be expected to have intimate and extensive knowledge of themselves, their tasks and their working environment. Task analysis approaches to software development encourage a focus on supporting users and their tasks while participatory design approaches encourage users' direct, active contributions to software development work. However, participatory design approaches often concentrate their efforts on design activities rather than on wider system development activities, while task analysis approaches generally lack active user participation beyond initial data gathering. This research attempts an integration of the strengths of task analysis and user participation within an overall software development process. This thesis also presents detailed empirical and theoretical analyses of what it is for users and developers to cooperate, of the nature of user-developer interaction in participatory settings. Furthennore, it operationalises and assesses the effectiveness of user participation in development and the impact of user-developer cooperation on the resulting software product. The research addressed these issues through the development and application of an approach to task based participatory development in two real world development projects. In this integrated approach, the respective strengths of task analysis and participatory design methods complemented each other's weaker aspects. The participatory design features encouraged active user participation in the development work while the task analysis features extended this participation upstream from software design activities to include analysis of the users' current work situation and design of an envisioned work situation. An inductive analysis of user-developer interaction in the software development projects was combined with a theoretical analysis drawing upon work on common ground in communication. This research generated an account of user-developer interaction in terms of the joint construction of two distinct fonns of common ground between user and developer: common ground about their present joint development activities and common ground about the objects of those joint activities, work situations and software systems. The thesis further extended the concept of common ground, assessing user participation in terms of contributions to common ground developed through the user-developer discourse. The thesis then went on to operationalise and to assess the effectiveness of user participation in tenns of the assimilation of users' contributions into the artefacts of the development work. Finally, the thesis assessed the value of user participation in tenns of the impact of user contributions to the development activities on the usability of the software produced.

Typescript (photocopy). / Digitized by Kansas Correctional Industries / Department: Computer Science.

Typescript (photocopy). / Digitized by Kansas Correctional Industries / Department: Computer Science.

Typescript (photocopy). / Digitized by Kansas Correctional Industries / Department: Electrical and Computer Engineering.

Submitted by Filipe dos Santos (fsantos@pucsp.br) on 2017-09-04T18:05:32Z No. of bitstreams: 1 Marcela Cristina Pereira.pdf: 1085475 bytes, checksum: 427d918ecf2e85cca7f74cca6a5f5ec6 (MD5) / Made available in DSpace on 2017-09-04T18:05:32Z (GMT). No. of bitstreams: 1 Marcela Cristina Pereira.pdf: 1085475 bytes, checksum: 427d918ecf2e85cca7f74cca6a5f5ec6 (MD5) Previous issue date: 2017-09-24 / Many softwares, which are using by the companies, have the objective to support their business activities. This kind of support happens by means of processes controls and/or accomplishment of business processes. The software used in the companies executes humans being activities and it stays in the same environment of the business process. However, the environment is not static, the software application needs change according the company needs. The software changings are necessary by his useful life and for by his degradation too, because the business process representation inside the software becomes more complex. The complexity is one of the limitation to change the software without high cost and risks for organization until the impossibility of the his maintenance. There are many approaches to extend the use time of software until his replacing in the company. This research uses concepts like evolution, modernization and degradation of software with the objective to discuss and offer indicators metrics based in needs of business processes. The objective is identify which moment the company should makes plan to do the modernization approaches for extend the time of software useful / Muitos sistemas de software utilizados pelas empresas tem como objetivo apoiar suas atividades. Este apoio pode acontecer através de controles e/ou realização dos processos de negócio da empresa. Este tipo de software mecaniza atividades humanas e está inserido no meio ao qual modela. Como o ambiente organizacional é mutável, a aplicação precisa ser alterada de acordo com as novas necessidades da empresa. Porém, estas alterações são responsáveis pela degradação do software porque o torna cada vez mais complexo. A complexidade é limitadora para que novas modificações sejam realizadas sem existirem custos e riscos elevados para a organização até que seja inviável manter o sistema de software. Existem abordagens, chamadas de modernização, que podem prolongar o tempo de uso do software até sua substituição. A pesquisa utiliza os conceitos de evolução, degradação e modernização de software para propor indicadores baseados nas necessidades do processo de negócio atendido pelo software para identificar o momento que a organização precisa realizar ações para prolongar o tempo de uso da aplicação

Traditionell systemutveckling präglas ofta av långa utvecklingsprocesser och en oförmåga attmöta förändrade behov från kunden. Problematik med buggar i mjukvaran och förskjutnadeadlines uppstår kontinuerligt och leder till högre kostnader för företag.För att komma till rätta med dessa problem behövs en systemutvecklingsprocess som belyserproblem direkt när de uppstår och därmed tvingar de inblandade till reflektion över processensom skapar problemen vilket belyser de verkliga bakomliggande orsakerna. Låg kvalitet påmjukvara är ofta ett symptom på djupare organisatoriska problemEtt synsätt som syftar till att möta dessa problem är lean software development. Synsättet harinspirerats av lean production som är en beskrivning av The Toyota Production system vilketi sin tur är det arbetssätt som har tillämpats av Toyota under flera decennier i den traditionellatillverkningen.Mary och Tom Poppendieck har beskrivit sju principer och 22 tankeverktyg som kananvändas för att skapa en metod för lean software development. Studien visar vilka styrkoroch problem som lean software development och lean production beskriver generellt samtvilka styrkor och problem som finns avseende beskrivning av Poppendieck's principer ochtankeverktyg i synnerhet. Detta visar den förbättring som behöver göras av principerna ochtankeverktygen för att de ska kunna användas som underlag för en metod för lean softwaredevelopment samt hur denna metod ser ut konkret.Studiens resultat är en metod för lean software development baserad på Poppendieck &Poppendieck’s principer och tankeverktyg vid namn LUT – Lean systemUTveckling. / Program: Kandidatutbildning i informatik

As software grows in size and complexity, it also becomes more interdependent. Multiple internal components often share state and data. Whether these dependencies are intentional or not, we have found that their mismanagement often poses several challenges to testing. This thesis seeks to make it easier to create reliable software by making testing more efficient and more effective through explicit knowledge of these hidden dependencies. The first problem that this thesis addresses, reducing testing time, directly impacts the day-to-day work of every software developer. The frequency with which code can be built (compiled, tested, and package) directly impacts the productivity of developers: longer build times mean a longer wait before determining if a change to the application being build was successful. We have discovered that in the case of some languages, such as Java, the vast majority of build time is spent running tests. Therefore, it's incredibly important to focus on approaches to accelerating testing, while simultaneously making sure that we do not inadvertently cause tests to erratically fail (i.e. become flaky). Typical techniques for accelerating tests (like running only a subset of them, or running them in parallel) often can't be applied soundly, since there may be hidden dependencies between tests. While we might think that each test should be independent (i.e. that a test's outcome isn't influenced by the execution of another test), we and others have found many examples in real software projects where tests truly have these dependencies: some tests require others to run first, or else their outcome will change. Previous work has shown that these dependencies are often complicated, unintentional, and hidden from developers. We have built several systems, VMVM and ElectricTest, that detect different sorts of dependencies between tests and use that information to soundly reduce testing time by several orders of magnitude. In our first approach, Unit Test Virtualization, we reduce the overhead of isolating each unit test with a lightweight, virtualization-like container, preventing these dependencies from manifesting. Our realization of Unit Test Virtualization for Java, VMVM eliminates the need to run each test in its own process, reducing test suite execution time by an average of 62% in our evaluation (compared to execution time when running each test in its own process). However, not all test suites isolate their tests: in some, dependencies are allowed to occur between tests. In these cases, common test acceleration techniques such as test selection or test parallelization are unsound in the absence of dependency information. When dependencies go unnoticed, tests can unexpectedly fail when executed out of order, causing unreliable builds. Our second approach, ElectricTest, soundly identifies data dependencies between test cases, allowing for sound test acceleration. To enable more broad use of general dependency information for testing and other analyses, we created Phosphor, the first and only portable and performant dynamic taint tracking system for the JVM. Dynamic taint tracking is a form of data flow analysis that applies labels to variables, and tracks all other variables derived from those tagged variables, propagating those tags. Taint tracking has many applications to software engineering and software testing, and in addition to our own work, researchers across the world are using Phosphor to build their own systems. Towards making testing more effective, we also created Pebbles, which makes it easy for developers to specify data-related test oracles on mobile devices by thinking in terms of high level objects such as emails, notes or pictures.

The booming mobile app market attracts a large number of developers. As a result, the competition is extremely tough. This fierce competition leads to high standards required for mobile apps, which mandates efficient and effective testing. Efficient testing requires little effort to use, while effective testing checks that the app under test behaves as expected. Manual testing is highly effective, but it is costly. Automatic testing should come to the rescue, but current automatic methods are either ineffective or inefficient. Methods using implicit specifications – for instance, “an app should not crash” for catching fail-stop errors – are ineffective because they cannot find semantic problems. Methods using explicit specifications such as test scripts are inefficient because they require huge developer effort to create and maintain specifications. In this thesis, we present our two approaches for solving these challenges. We first built the AppDoctor system which efficiently tests mobile apps. It quickly explores an app then slowly but accurately verifies the potential problems to identify bugs without introducing false positives. It uses dependencies discovered between actions to simplify its reports. Our second approach, implemented in the AppFlow system, leverages the ample opportunity of reusing test cases between apps to gain efficiency without losing effectiveness. It allows common UI elements to be used in test scripts then recognizes these UI elements in real apps using a machine learning approach. The system also allows tests to be specified in reusable pieces, and provides a system to synthesize complete test cases from these reusable pieces. It enables robust tests to be created and reused across apps in the same category. The combination of these two approaches enables a developer to quickly test an app on a great number of combinations of actions for fail-stop problems, and effortlessly and efficiently test the app on most common scenarios for semantic problems. This combination covers most of her test requirements and greatly reduces her burden in testing the app.

Context: Knowledge is the major aspect of an organization which enables the enterprise to be more productive and to deliver the high complexity services. Knowledge management plays a key role in agile software development because it supports cultural infrastructure esteems like collaboration, communication, and knowledge transfer. This research aims to explore how organizations that adopts Agile Software Development (ASD) implement knowledge management utilizing practices that supports the key process areas. Several knowledge management maturity models have been proposed over a decade ago but not all of the models that is specially stated knowledge Management Maturity Model (KMMM) for Agile software development. To fulfil this research gap, we introduce the maturity model which emphasize knowledge management in ASD among the practitioners. This maturity model helps to assess their knowledge management in organization and provides a road map to the organizations for any further improvement required in their processes.  Objectives: In this thesis, we investigate the key process areas of knowledge management maturity models that could support agile software development. Through investigation about the key process areas, we found that the organizations should emphasis on key process areas and its practices in order to improve the software process. The objectives of this research include: Explore the key process areas and practices of knowledge management in the knowledge management maturity models.  Identify the views of practitioners on knowledge management practices and key process areas for Agile software development. To propose the maturity model for Knowledge management in Agile software development among the practitioner’s opinions.  Methods: In this research, we conducted two methods: Systematic mapping and Survey to fulfil our aim and objectives. We conducted Systematic mapping study through the snowballing process to investigate empirical literature about Knowledge management maturity models. To triangulate the systematic mapping results, we conducted a survey. From the survey results, we obtained the responses and were analyzed statistically using descriptive statistics. Results: From Systematic mapping, we identified 18 articles and analyzed 24 practices of Knowledge management maturity models. These practices are indicated in key process areas such as process, people, technology. Through the systematic mapping results, 9 KM practices that were found from KMMM literature were listed in the survey questionnaire and answered by software engineering practitioners. Moreover, 5 other new practices for agile have suggested in the survey that was not found in KMMM literature. To address the systematic mapping and survey results, we propose the maturity model which emphasize knowledge management practices in ASD among the practitioners. Conclusions: This thesis lists the main elements of practices that are utilized by the organization and also show the usage of maturity levels at each practice in detail. Furthermore, this thesis helps the organization's to assess the current levels of maturity that exist to each practice in a real process. Hence, the researchers can utilize the model from this thesis and further they can improve their Km in organizations.

Técnicas que partem de modelos de alto nível de abstração são requeridas para lidar com a complexidade encontrada nas novas gerações de sistemas embarcados, sendo cruciais para o sucesso do projeto. Uma grande redução do esforço pode ser obtida com o uso de modelos quando código em uma linguagem de programação pode ser gerado automaticamente a partir desses. Porém, ferramentas disponíveis para modelagem e geração de código normalmente são dependentes de domínio e o software embarcado normalmente possui comportamento heterogêneo, requerendo suporte a múltiplos modelos de computação. Nesta tese, estratégias para desenvolvimento de software embarcado baseado em modelos de alto nível usando UML e Simulink são analisadas. A partir desta análise, observaram-se as principais limitações das abordagens para geração de código baseadas em UML e Simulink. Esta tese, então, propõe estratégias para melhorar a automação provida por estas ferramentas, como por exemplo, propondo uma abordagem para geração de código multithread a partir de modelos Simulink. A comparação feita entre UML e Simulink mostra que, embora UML seja a linguagem mais usada no domínio de engenharia de software, UML é baseada em eventos e não é adequada para modelar sistemas dataflow. Por outro lado, Simulink é largamente usado por engenheiros de hardware e de controle, além de suportar dataflow e geração de código. Porém, Simulink provê abstrações de mais baixo nível, quando comparado a UML. Conclui-se que tanto UML como Simulink possuem prós e contras, o que motiva a integração de ambas linguagens em um único fluxo de projeto. Neste contexto, esta tese propõe também uma abordagem integradora para desenvolvimento de software embarcado que inicia com uma especificação de alto nível descrita usando diagramas UML, a partir da qual modelos dataflow e control-flow podem ser gerados. Desta maneira, o modelo UML pode ser usado como front-end para diferentes abordagens de geração de código, incluindo UML e a proposta geração de código multithread a partir de modelos Simulink. / The use of techniques starting from higher abstraction levels is required to cope with the complexity that is found in the new generations of embedded systems, being crucial to the design success. A large reduction of design effort when using models in the development can be achieved when there is a possibility to automatically generate code from them. Using these techniques, the designer specifies the system model using some abstraction and code in a programming language is generated from that. However, available tools for modeling and code generation are domain-specific and embedded software usually shows heterogeneous behavior, which pushes the need for supporting software automation under different models of computation. In this thesis, strategies for embedded software development based on high-level models using UML and Simulink were analyzed. We observed that the embedded software generation approaches based on UML and Simulink have limitations, and hence this thesis proposes strategies to improve the automation provided on those approaches, for example, proposing a Simulink-based multithread code generation. UML is a well used language in the software engineering domain, and we consider that it has several advantages. However, UML is event-based and not suitable to model dataflow systems. On the other side, Simulink is widely used by control and hardware engineers and supports dataflow, and time-continuous models. Moreover, tools are available to generate code from a Simulink model. However, Simulink models represent lower abstraction level compared to UML ones. This comparison shows that UML and Simulink have pros and cons, which motivates the integration of both languages in a single design process. As the main contribution, we propose in this thesis an integrated approach to embedded software design, which starts from a high-level specification using UML diagrams. Both dataflow and control-flow models can be generated from that. In this way, an UML model can be used as front-end for different code generation approaches, including UML-based one and the proposed Simulink-based multithread code generation.