· · · Institutional Repository

A lot of (legacy) datasets can be combined with other datasets in order to increase their value. New technologies and ideas around the Semantic Web are evolving to make these enrichments possible. In recent years, the Linked Data principles have become the established standard for publishing data on the Semantic Web. With these techniques and principles it becomes possible to enrich a dataset using an interlinking between different datasets in the Linked Data cloud. However, transforming a dataset into a Linked Data dataset is a difficult process. This thesis proposes a way to perform this transformation and explains several required steps needed to be taken in order to succeed. It will discuss difficulties and experiences with entity resolution and evaluates an automatic interlinking approach with the purpose of connecting datasets and creating new opportunities with a (legacy) dataset. As an end result, this thesis will deliver a Linked Data application for the Software Technology publications dataset.

Web applications are rapidly becoming more advanced since the introduction of AJAX technologies. Famous examples include Google’s GMail, Maps and Docs, as well as Twitter and Facebook. These technological advancements bring along a number of challenges, mostly concerning web application testing. In this thesis, we propose a number of techniques to automatically test web applications using invariants on the application’s Document Object Model (DOM) and invariants on the application’s JavaScript code. Using a proxy, we add JavaScript source code that can generate an execution trace. This trace contains all information about the JavaScript variables that is needed to derive invariants on them. Next, we crawl the web application. This can be done manually or in an automated fashion. Crawling the application will generate the actual execution trace. The invariants can be derived using special tools that analyze the trace. Furthermore, during crawling, the DOMs of the web application are fed to an algorithm that can derive invariants on the DOM. We implemented all this as plugins to Crawljax, however these techniques are not only appliable to Crawljax. To evaluate the quality of the invariants, we conducted several case studies. The results are encouraging, meaning our work can be used to automatically generate invariants which can be used for regression testing of dynamic web applications.

While test generators have the potential to significantly reduce the costs of software testing and have the ability to increase the quality of the software tests (and thus, the software itself), they unfortunately have only limited support for testing object-oriented software and their underlying test generation techniques fail to scale up to software of industrial size and complexity. In this context, we developed JTestCraft, a state-of-the-art test generator for the Java programming that deals effectively with all object-oriented programming concepts, such as object array types, inheritance and polymorfism. Furthermore, JTestCraft can locate all relevant test cases due to the use of the novel Candidate Sequence Search algorithm. Other novel concepts introduced in this thesis include the Constraint Tree data-structure to improve scalability and the Heap Simulation Representation to simplify the implementation of the test generator. We evaluated JTestCraft by looking at its ability to generate tests that obtain high code coverage and compare the results to human crafted tests. In addition, the performance of JTestCraft is compared against similar tools. Finally, we give pointers for further research to improve the performance and usability of future test generators.

Ajax is an umbrella term for a set of technologies that allows web developers to create highly interactive web applications. Ajax applications are complex; they consist of multiple heterogeneous artifacts which are combined in a highly dynamic fashion. This complexity makes Ajax applications hard to understand, and thus to maintain. For this reason, we have created FireDetective, a tool that uses dynamic analysis at both the client (browser) and server side to facilitate the understanding of Ajax applications. Using an exploratory pre-experimental user study, we see that web developers encounter problems when understanding Ajax applications. We also find preliminary evidence that the FireDetective tool allows web developers to understand Ajax applications more effectively, more efficiently and with more confidence. We investigate which techniques and features contributed to this result, and use observations made during the user study to identify opportunities for future work.

Unit testing is generally accepted as an aid to produce high quality code, and can provide quick feedback to developers on the quality of the software. To have a high quality and well maintained test suite requires the production and test code to synchronously co-evolve, as added or changed production code should be tested as soon as possible. Traditionally the quality of a test suite is measured using code coverage, but this measurement does not provide insight in how tests are used by developers. In this thesis we explore a new approach to analyse how tests in a system are used based on association rules mined from the system’s change history. The approach is based on the reasoning that an association rule between two entities, possibly of a different type, is a measure for the co-use of the entities. Case studies show that analysing all the resulting rules allows us to uncover the distribution of programmer effort over pure coding, pure testing, or a more test-driven practice. Another application of our approach is that we can express the number of tests that are truly co-evolving with their associated production class.

In 2009 TomTom developed a model, called the MFM-model, which should reflect the maturity, feasibility and progression of a Personal Navigation Device software integration project. However, this model did not reflect all required aspects of the integration project and therefore was unable to correctly reflect the maturity, feasibility or progression. Furthermore, creating and maintaining this model proved to be too time-consuming. In this thesis we identify the problems of this model, propose a number of improvements to eliminate this problems and explain how these improvements have been implemented. In addition, we discuss how the model can be automatically generated from Jira and Perforce in order to reduce the required effort for creating and maintaining it. As an end result, this thesis will deliver a MFM 2.0 prototype which is an automated and improved version of the initial model. We will review this prototype by comparing survey-results taken at the initial situation and the improved situation. To further inspect this prototype, a small case-study is performed to analyze the accuracy, usage and importance of it.

Binnen Tam Tam is kennis van de medewerkers verspreid opgeslagen in verschillende informatiesystemen. Het doel van het bedrijf is dat al deze kennis vanuit een centraal punt effectief kan worden doorzocht. Dit centrale punt is het SharePoint-platform, een product van Microsoft. Voor dit project is SharePoint uitgebreid zodat het mogelijk wordt om alle informatie te voorzien van tags en ratings. Gebruikers kunnen deze extra metadata gebruiken bij het zoeken in het systeem. Aan het begin van dit project is er een analyse gemaakt van de huidige systemen die binnen Tam Tam worden gebruikt om informatie te delen. Aan de hand van de resultaten van deze analyse is er een ontwerp gemaakt voor de uitbreiding op SharePoint. Dit ontwerp is geïmplementeerd en getest in de SharePoint-omgeving. Uiteindelijk is er binnen 12 weken een werkend prototype opgeleverd, dat door eindgebruikers is getest. Wij hadden voor de start van dit project geen ervaring met het SharePoint-platform. Aan het begin van het project is er daarom veel onderzoek gedaan door het schrijven van kleine tests. Dit onderzoek werd bemoeilijkt doordat bepaalde delen van het SharePoint-platform niet of onvolledig zijn gedocumenteerd. Delen van de geschreven tests zijn gebruikt in de uiteindelijke versie van ons prototype. Het ontwerp van sommige onderdelen van het systeem is hierdoor pas achteraf ontstaan.

Serious Gaming is becoming a popular method for training and problem solving in companies. One of the companies who has taken an interest in this is ProRail. Together with the faculty of Technology, Policy and Management of the Delft University of Technology they started a project to develop a gaming simulation suite for training and decision making purposes, called the Railway Gaming Suite. In order to connect the games and simulators of the suite a solid architecture is needed. Three architectures were picked out to see if they are suitable for this, namely: Service Oriented Architectures, High Level Architecture and FAMAS Simulation Backbone. Using the Railway Gaming Suite as a case study, we have extracted requirements (like performance and flexibility) for an architecture for gaming simulation suites using the Architectural Trade-off Analysis Method. These requirements are used to determine the suitability of the three architectures. In this thesis the research on the suitability of Service Oriented Architectures (SOA) is presented. A prototype SOA was created, called Service Oriented Gaming and Simulation (SOGS). This prototype was used to test the performance requirement for the evaluation. The suitability was investigated by evaluating SOA to see if it is able to support the requirements we found. We subsequently also compared the suitability of the other architectures. Intermediate results of this thesis project were used to help with the decision for selecting an architecture for the Railway Gaming Suite.

Regression testing is an expensive process because, most of times, all the available test cases are executed. Many techniques of test selection/filtering have been researched and implemented, each having its own strong and weak points. This paper introduces a tool that helps developers and testers to identify the tests that need to be executed after a code change, in order to check for regressions. The implementation is based on dynamic code analysis and the purpose of the tool is to eliminate the time spent on testing using inappropriate test cases (tests that bring no value in checking for regressions). The adequacy, usability and completeness of this tool have been evaluated through the meanings of a user study. During the study, a number of developers used the tool and expressed their opinion about it through questionnaires.

An anti-pattern is a commonly occurring solution that will always have negative consequences, when applied to a recurring problem. Code smells are considered to be symptoms of anti-patterns and occur at source code level. The lifespan of code smells in a software system can be determined by mining the software repository on which the system is stored. This provides insight into the behaviour of software developers with regard to resolving code smells and anti-patterns. This thesis presents a custom built application that computes the lifespans of certain types of code smells in a software repository. As a case study, this tool is applied on seven open source systems in order to answer research questions concerning the lifespan of code smells and the refactoring behaviour of developers. The results of this study reveal that engineers are aware of code smells, but not very concerned with their impact, given the low refactoring activity. Finally, several suggestions are given to further develop the application and to extend the work done in this thesis.

Nowadays a lot of small companies maintain multiple websites that require the user to sign up for ordering products or extended interaction. The users have to create an account for each website the company owns, creating duplicate information for the company and forcing the customer to remember multiple accounts. Where big companies can solve the problem with commercial solutions, small companies do not have the funding. MediaMij, a small publisher, has to deal with exactly this situation. In this project we investigate options to find a solution for MediaMij. We research ways of re-engineering the current web applications to enable a single central customer database with Single Sign On capabilities. The research renders an approach for the situation which will be verified by conducting 2 case studies on 2 of the current websites of MediaMij. With the verified approach we were able to form a set of guidelines describing how to approach projects that are alike.

Services are used a lot nowadays in order to deploy large scale systems that should never be shut down such as internet shops, online banking applications, and surveillance systems. Because services can be updated at any given time, testing is required during runtime by its clients to validate that the updated service still performs as required. However, testing during runtime may interfere with the nominal operations of the service and its environment. Furthermore, only the methods exposed by the service through its interface are available to the clients, which reduces the ability to control and observe the service for testing purposes, i.e. its testability. Built-in testing can be used to increase the testability, and to ensure that other clients are not hindered while the service is being tested. However, in order to increase the testability of the service, methods will have to be added to the service, which decreases the modularity and evolvability of the service. In order to maintain the modularity of the service, aspects can be used to separate the test facilities and test cases from the service. An approach has been devised to achieve built-in testing for services through the use of aspects. Our feasibility study and evaluation demonstrate that and how aspects can be used to achieve built-in testing for services. Further evaluation is, however, required to assess how our approach holds up when applied to a large real world service-oriented system.

We have identified three fundamental monitoring dimensions for the maintenance and evolution of Maritime Safety and Security Systems, which are representing a class of systems that are required to be continuously online. The monitoring dimensions consist of: 'services', 'users' and 'time'. As traces crosscut these dimensions, we are interested in learning how to extract traces of dynamic and distributed systems. Through a literature study we identified three fundamental online tracing techniques, from which all tracing approaches can be derived: Tagged Tracing, Recognized Tracing and Timestamped Tracing. We devised an evaluation setup on which we evaluated tracing techniques for dynamic and distributed systems. With 28 percent overhead Timestamped Tracing has the lowest overhead, but it only functions on systems using synchronous communication. Tagged Tracing on the other hand, operated correctly on systems employing both asynchronous and synchronous communication with an overhead of 43 percent. We did not evaluate the accuracy of Recognized Tracing as the accuracy is dependent on the implementation of the dynamic system. Recognized Tracing presented an overhead of 36 percent. We developed a dashboard which allows storing and loading of requests and traces, such that the reconstructed traces could be evaluated for correctness. In addition, the dashboard aids maintainers and developers by revealing the usage of the services cluster and the dependencies of services.

developing a mobile application that enables users to browse through a list of voicemail messages and personal greetings; select and play them, and in the case of greetings record them, in a user friendly GUI environment. The product is called “myGreetinq Mobile”.

Static analysis techniques provide a means to detect software errors early in the development process, without actually having to run the software that is being analyzed. These techniques are common for statically typed languages and have found their way into IDEs such as Eclipse and Visual Studio. However, applying the same techniques to dynamically typed languages is much less common. Tool support is less mature and the amount of published research is relatively small. For this project, we design and build a static analyis tool for JavaScript code. We start by giving background information on relevant parts of the JavaScript language, followed by a survey of existing tools and research. In the design of our analysis tool, we achieved a clear separation of responsibilities between the different modules for parsing, analysis, rule definition and reporting. The level of detail in the default reporter makes our tool an ideal candidate for integration in a JavaScript IDE. On the other hand, our tool is also suited for batch analysis of large code collections. To validate our tool, we set up an experiment in which we ran our analysis tool on two large collections of JavaScript code: one from a repository of open source JavaScript packages, mostly for server-side use; another one gathered from client-side code on a large number of popular websites. We present high-level global results as well as more detailed results for selected projects and websites.

The fragmentation of mobile devices nowadays makes it hard for (third party) mobile application developers to develop applications that are suitable for all mobile platforms on the market. A current startup, named Obymobi (Order By Mobile), introduces a new platform for ordering drinks and/or food in the hospitality business using a mobile application. The Obymobi mobile application is targeted at all mobile platforms, so that every mobile user is able to use the application. However, developing a mobile application which can be executed at all current mobile platforms implies several portability issues. This thesis is the result of research which focuses on how to deal with the heterogeneity in mobile devices while developing mobile applications. As current crossplatform mobile application development solutions from industry do not offer flexibility as they tend to have a static character in terms of supported platforms and features, a new cross-platform development framework prototype is presented in this thesis. Using this framework named Voind, mobile applications can be defined in an abstracted model in order to use this model for the generation of multiple versions for different mobile platforms.

In software engineering education manual assessment of students’ programs is a time consuming endeavour that does not scale to high numbers of pupils or to large amounts of practice material. Numerous automatic grading programs, aim- ing to alleviate this problem, have been developed since 1960. These, however, only support fixed programming languages and fixed assessment methods, thus prohibiting their reuse throughout different programming curricula. Educators investigating new grading methods either have to accept the engineering burden of creating a complete grading system or revert to manual grading. This thesis presents LabBack - a reusable automatic grading platform that is extendible with language- and assessment-specific functionality by means of plugins. LabBack provides the necessary infrastructure for building and hosting automatic grading functionality, eliminating the need to consider the issues of scalability and security against malicious programs. LabBack can be hosted in the cloud and provides immediate student feedback. Plugins providing automatic assessment for Scala, JavaScript and C have been implemented and LabBack has been validated in a university-level course with over 100 students.

Software architecture plays an important part in program comprehension, which is one of the most time consuming tasks in software development. If software developers don’t properly share their architectural knowledge with team members, the team will act based on an incomplete or even possibly incorrect view on the code base, and this can lead to architectural degradation. Recently there has been a surge of collaboration, communication and sharing with the advent of Web 2.0 applications. In this thesis we have investigated how Web 2.0 can be used to support software architecture management. In particular in the area of architecture documentation, architecture retrieval, and collaboration. We created an approach which applies Web 2.0 concepts such as traceability, integration, usability, navigability, and user experience, to software architecture management. This approach is supported by a prototype tool called ArchWiki, which has features such as traceability between different artifacts (e.g. source code, architectural diagrams, architectural documentation), context-sensitive views, hyperlinks, notifications, tags, and bookmarks. We performed an initial evaluation study to assess ArchWiki. In this study we found that Web 2.0 has the potential to support software architecture knowledge management.

RDBMS databases typically increase read operation throughput and decrease write operations throughput when more machines are involved. NoSQL databases increase at both throughput rates when more machines are involved. However, NoSQL databases are typically build to run with tens, hundreds or even thousands of machines while little is known about their performance on a smaller scale. This thesis describes the measured maximum throughput rates of read and write operations at RDBMS and NoSQL databases with one to four machines. These measurements show a potential for future databases.

In software engineering, resources such as time, money and developers, are limited. Often when bugs are found in the software developed, bug triaging is used to prioritise bug reports and allocate resources to it. When the number of bugs is considerable, this will require a vast amount of time and effort. The goal of this research is to investigate the usefulness of stack traces in bug reports for the assessment of bug report properties, using existing metrics of bug reports and files, being severity, priority and time-to-fix. In order to investigate the usefulness of stack traces, a research framework and methodology are developed. Overall, we can conclude that stack traces can be used to link software artifacts. Also, stack traces can be a valuable input for prediction models, for example using metrics of related bugs and source files.