Capturing client’s needs and expectations for a product or service is an important problem in software development. Software requirements are normally captured in natural language and mostly they are unstructured which makes it difficult to automate the process of going from software requirements to the executable code. A big hurdle in this process is the lack of consistency and standardization in software requirements representation. Thus, the aim of the thesis is to present a method for transforming natural language requirement text into ontology. It is easy to store and retrieve information from ontology as it is a semantic model, and it is also easy to infer new knowledge from it.

As it is clear from the aim of this work, the main component of our research was software requirements, so there was a need to investigate and decide the types of requirements to define the scope of this research. We selected INCOSE guidelines as a benchmark to scrutinize the properties which we desired in the Natural Language Requirements. These natural language requirements were used in the form of user stories as the input of the transformation process. We selected a combination of two methods for our research i.e. Literature Review and Design Science Research. The reason for selecting these methods was to obtain a good grip on existing work going on in this field and then to combine the knowledge to propose new rules for the requirements to ontology transformation. We studied different domains during literature review such as Requirements Engineering, Ontologies, Natural Language Processing, and Information Extraction. The gathered knowledge was then used to propose the rules and the flow of their implementation. This proposed system was named as “Reqtology”. Reqtology defines the process, from taking the requirements in form of user stories, to extracting the useful information based on the rules and then classifying that information so that it can be used to form ontologies. The workflow consists of a 6-step process which starts from input text in form of user stories and at the end provides us entities which can be used for ontologies formation.

Everyone is talking about the software development methods but these methods are categorised into the different parts and the most important are two categories, one is agile software development methods and second is using the traditional software development methods. Agile software methods are relatively considered to be quick and for the small teams. Our main mission is to check which method is better from each other, so for that purpose we go out in the software development market to meet the professional to ask about their satisfaction on these software development methods. Our research is based on to see the suitable method for the professionals; see the challenges on the adoptability of methods and which method is quicker. To perform this study we have gone through a survey questionnaire, and results are analysed by using mixed method approach. Results shows that professionals from both types of methods are satisfied but professionals with traditional methods are more satisfy with their methods with respect to development of quality software, whereas agile professionals are more satisfied with their methods with respect of better communication with their customers. With agility point of view, our study says that both methods have characteristics which support agility but not fully support, so in such case we need to customize features from both types of methodologies.

Exploratory Testing (ET) is a software testing practice characterized by simultaneous activities: test design, test execution and learning from the test results. Recently ET has received much attention from testing practitioners and researchers as well as software testing standardization bodies. Nevertheless, scientific evidence and knowledge about ET’s application in software industry are little. This multi case study conducted in three software companies, provides insights into the real perception of Exploratory Testing and the role of this practice in the whole testing process of them. This study identifies three distinct applications of Exploratory Testing in these software companies: ET as a standard process; ET as a discretionary, formalized process; ET as an informal, ad hoc process. Also, a number of key factors that affect the choice of Exploratory Testing in an organization have been identified: product characteristics and features; the products market; pressure for faster product release.

The consultancy firm Knowit sought a smartphone application for communication between schools and pupils. Together with the students, it was decided to create the app both for Android and for iPhone. The project would produce a prototype app with limited functionality usable as a proof-of-concept in communication with potential customers.The questions that have characterized the work are; what features would be demanded in a school app, how to program user-friendly functionality and how to use object-orientation to design such an app. A question has also mentioned the differences between development for iOS and Android. The work was done in an iterative process in which the students worked together with planning, programming and testing. In addition, a small study was made, in which pupils were asked for their desired functionality in a school app.The project has resulted in a working prototype with a few pages implemented. During the work it was established that the pages and the functionality that pupils ask for includes: schedule, exam schedule, chat and custom push notifications. Factors besides functionality that contribute to a user friendly app are transparency and smoothness. This work has also led to a suggestion of how these features can be joined in a project and a class diagram has been used to illustrate the common solution for Android and iOS. Based on the diagram it can be seen that the apps have a menu as a base for all the pages that are presented and a class is the link between the applications and the data retrieved from the database.The work also explains differences between the platforms. One difference is that iOS programmer normally only need to program for the last two iOS releases while the Android developer must adapt its product for many different screen sizes and versions of the operating system. Another difference is that it is perceived that Objective-C is a more difficult programming language to adapt to than java.

Clustering algorithms have been used to divide genes into groups according to the degree of their expression similarity. Such a grouping may suggest that the respective genes are correlated and/or co-regulated, and subsequently indicates that the genes could possibly share a common biological role. In this paper, four clustering algorithms are investigated: k-means, cut-clustering, spectral and expectation-maximization. The algorithms are benchmarked against each other. The performance of the four clustering algorithms is studied on time series expression data using Dynamic TimeWarping distance in order to measure similarity between gene expression profiles. Four different cluster validation measures are used to evaluate the clustering algorithms: Connectivity and Silhouette Index for estimating the quality of clusters, Jaccard Index for evaluating the stability of a cluster method and Rand Index for assessing the accuracy. The obtained results are analyzed by Friedman's test and the Nemenyi post-hoc test. K-means is demonstrated to be significantly better than the spectral clustering algorithm under the Silhouette and Rand validation indices.

In software development, customer trust hinges on a product performing as expectedand ensuring appropriate steps are taken to prevent incidents due to faulty systems. Oneway of achieving this lies within in requirement validation – the process of validatingthe requirements set on the software. However, the complexity of the requirementvalidation domain can be challenging for companies and organizations seeking toimprove their validation processes. This research investigates this area, pinpointingpotential failure factors that may hinder effective requirement validation. The study wasconducted using a multi-case research design, involving individual interviews with fourdistinct divisions at SAAB: hardware, software, systems, and test equipment.This study built upon Niazi’s & Shastry's previous research where findings of failurefactors in requirement engineering are brought forward. What this research has done istaking the failure factors and applying them to requirement validation, which is asubcategory to requirement engineering. The failure factors taken into consideration inthis research are therefore the following:

• Vague requirements• Undefined requirements process• Lack of stakeholder involvement• Business needs are not considered• Lack of requirement management• The requirements do not reflect the real needs of the customer• The requirements are inconsistent and/or incomplete• It is expensive to make changes to requirements after they have been agreed• Requirements growth• Stakeholders’ communication problems

During the research, focus was placed on noting how often the interviewees mentionedeach failure factor. This helped in understanding which issues were most often seen asproblems in the requirement validation process.Particularly, stakeholder issues and the tendency towards vague requirement definitionsemerged as prevalent problems. The findings of this research do not only concernsafety-critical software companies but can additionally prove beneficial to any industrydealing with stakeholders and product/service requirements. The research providesiiipotential pitfalls in requirement validation, aiding organizations in refining theirapproach for better software product reliability and customer trust.

This paper reports an ethnographic researcher’s shift towards the tech industry while maintaining the purpose of spotting opportunities and problems. It must be emphasized that whether working with remote communities in far-flung corners of the world or sitting in a room full of software developers, the concept remains the same: it is all about the users. Ethnographic researchers may not live with software developers but are getting increasingly closer to them. This paper aims to explain how this is done, i.e., by using participatory methods, such as field diaries. The first author’s initial realization of the full potential of diaries arose in Ethiopia and Mozambique, where efforts by institutions to help people often fail due to the lack of on-the-ground knowledge about the communities in which they operate. To address this, written and photo diaries were implemented so that community members could clearly express what is important in their everyday lives. In the current software company setting, we use the same method to understand what happens when users develop with our platform. The salient difference is that instead of receiving handwritten diaries and photos, we collect digital journals and screenshots from our users’ experience. This enables moving towards a continuous research vision to identify new user needs timely and ensure we are always building the right thing. However, by adopting this and other proactive approaches for generative research, new challenges are emerging regarding the efficient collection and analysis of large amounts of qualitative information.

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.

The purpose of this study is to examine and compare a small set of software stacks which can be used for a progressive web application to see if one stack is more suitable to build a journaling system with strict requirements on accessibility and traceability.

The study is a comparative case study where the development of a system with different software stacks were compared. First a literature study was conducted to find potential technologies to use. Then interviews were conducted with persons who have used journaling systems within their work to get a clear picture of the essential functionality of a journaling system. The purpose of this was to create a specification of a simple journaling system. This specification was used during the development of two software stacks.

The literature study showed that two databases and two javascript-framework of the researched potential technologies were more suitable than the other technologies. These technologies were then used in the two software stacks where code size and development time was measured.

In the end there was not a big difference between the two software stacks in terms of code size and development time. Though one of the stacks had a small advantage of having a marginally faster development time and smaller code size. The conclusion was that a more comprehensive study should be done to get a more conclusive answer but that the results of this study can be used together with other data as a decision guide when a software stack is chosen for a project for a progressive web application with strict requirements on accessibility and traceability.

A limitation had been set at only choosing two software stacks to compare because the lack of time. Also, the number of features in the finished systems has been limited, because of the lack of time only the essential parts of a journaling system will be included. The study also doesn’t present or take into account all the laws and requirements that affects a journaling system

This study presents an investigation into the use of ChatGPT in the software development field. With the rapid growth of artificial intelligence (AI) and its impact on the technology field, tools like ChatGPT have become increasingly relevant in software development. The main aim of the study is to investigate how ChatGPT can work as a tool in the software development process and if it can help facilitate the development process for a developer.Through a combination of questionnaire survey and experiments, the study has shown that ChatGPT has the potential to be a tool of great value in software development. This by offering automatic code completion and other aids that can improve developers' efficiency. The results of this study indicate that the integration of AI tools such as ChatGPT into the software development process can lead to improved workflows and increased productivity. However, further research should be conducted to better understand potential benefits and challenges. To further understand ChatGPT's role in software development, it is recommended to conduct more extensive field studies where the tool is used in real world development projects.

This thesis was made possible by the company Verendus system AB, which is the leading developer of dealership management systems in the caravan and camper market. The goal of the thesis was to create a statistics module for a new producer system envisioned by Verendus. The new system is aimed at manufacturers and importers of caravans and campers, with the goal of enabling its users to create more effective production lines. By providing statistical data to mentioned users they will be able to predict market trends and customize their production lines accordingly. Today such software does not exist which leads Verendus to think that its arrival would lead to a success on the market.

Before the development and design of the producer system began, a new agile method had to be developed, MAM (Minimum Agile Method). The method has strong influences from already established agile methods such as Scrum, Extreme Programming (XP) and Disciplined Agile Delivery (DAD) and was used during the development of the producer system.

The development of the basic statistics module resulted in an administration panel where new users and present users can be added or edited. The administrator can also create new connections and permissions between users and companies, which leads to specific information being displayed for each user. The major part of the development resulted in a page for viewing the statistical data currently present in the database of Verendus. With the provided statistics the user can then make qualified decisions and forecasts that have the potential of directly influencing sales.

The rise of Large Language Models (LLMs) over the past years and their use in software development has raised questions and concerns about the quality of the code they generate. While LLMs such as ChatGPT have the potential to accelerate the development of new software and boost code productivity, their ability to generate high-quality code is debatable. This study presents an investigation into the code quality that is generated by LLMs, specifically focusing on iOS applications generated by ChatGPT.

To investigate the code quality of the generated iOS applications, the study implemented three movie applications in Swift with ChatGPT-3.5 and ChatGPT-4, along with a similar application written by a human developer. To measure the code quality, a set of code quality metrics was chosen to make a fair evaluation of the results.

The findings showed that ChatGPT can generate iOS applications with code quality comparable to a human-written application, and ChatGPT-4 in particular showed this capability. However, the ChatGPT-3.5 model showed inconsistent results, suggesting potential limitations in the current model. The level of human intervention required for development varies depending on the complexity of the task, with simpler tasks requiring less intervention. Overall, the study suggests that human intervention and guidance are essential for developing a working application.

Keywords: Code generation, Code Quality, Generative AI, iOS code quality, iOS development, Large Language Models

This research aims to explore different Large Language Models (LLM) and drawconclusions as to how well they can generate edge cases and respective unit tests in aTest-Driven Development (TDD) workflow. The experiment is concluded with LLMsthat are of the type Generative Pre-trained Transformers (GPT). The different LLMsthat are used for this research are ChatGPT 4 (GPT-4), ChatGPT 3.5 (GPT3.5) andGithub Copilot (Codex/GPT-4). The experiment consists of two phases, one where theprompt goes through prompt engineering with different methods such as few-shot andChain of Thought (COT). The second phase is where the prompt is sent to thedifferent LLMs to generate edge cases and unit tests. The prompt and questions thatare sent and asked to the LLM are taken from Advent of Code (AoC) which is aprogramming event every year. The LLMs performed differently depending on thetype of question from AoC. ChatGPT 3.5 performed better during text heavyquestions, ChatGPT 4 had an average performance throughout all the questions andGithub Copilot performed better towards the end where the questions became morecomplex and more programmatically focused.

Purpose – To construct successful mobile Augmented Reality solutions that make virtual objects coexist with reality, robust tracking systems capable of tracking position and orientation with high precision is required. The study's purpose was therefore to investigate the precision of the tracking systems in ARKit and ARCore to receive material regarding how well virtual objects can be anchored on a physical position. Both ARKit and ARCore utilize a concept called anchors to achieve heightened precision in the tracking of virtual objects. How reliable these anchors are in each framework and whether they improve precision was thus examined.

Method – Experiments were designed and performed in the study, where one app for each framework was created with the purpose of placing a virtual object with or without an anchor in front of the device. Fixed physical positions were used as references to calculate how much the virtual object were drifting when the device was moved around in two different scenes.

Findings – The average drift of the anchors were 15,2 cm and 27 cm with ARKit in each scene. The anchors with ARCore had an average drift of 7,8 cm and 4,7 cm. The study found that the tracking of virtual objects improved in ARCore when anchors were used, while ARKit gave mixed results where clear improvements could be seen only when there was enough texture in the scene.

Implications – The study shows that ARCore handles the tracking of virtual objects better than ARKit. The study also confirms that anchors should be utilized to improve the precision of the tracking in ARCore, while in ARKit it is only improved when there are a sufficient amount of texture in the surroundings.

Limitations – Only one smartphone for each framework were used in the experiments. The scenes were static and the experiments were performed in as bright conditions as possible. The study only tested one anchor and says nothing regarding changes in the reliability and precision when multiple anchors are used.

Being able to efficiently and effectively provide custom products has been identified as a competitive advantage for manufacturing organizations. Product configuration has been shown to be an effective way of achieving this through a modularization, product platform and product family development approach. A core assumption behind product configuration is that the module variants and their constraints can be explicitly defined as product knowledge in terms of geometry and configuration rules. This is not always the case, however. Many companies require extensive engineering to develop each module variant and cannot afford to do so in order to meet potential customer requirements within a predictable future. Instead, they try to implicitly define the module variants in terms of the process for how they can be realized. In this way they can realize module variants on demand efficiently and effectively when the customer requirements are better defined, and the development can be justified by the increased probability of profiting from the outcome.

Design automation, in its broadest definition, deals with computerized engineering support by effectively and efficiently utilizing pre-planned reusable assets to progress the design process. There have been several successful implementations reported in the literature, but a widespread use is yet to be seen. It deals with the explicit definition of engineering process knowledge, which results in a collection of methods and models that can come in the form of computer scripts, parametric CADmodels, template spreadsheets, etc. These methods and models are developed using various computer tools and maintained within the different disciplines involved, such as geometric modeling, simulation, or manufacturing, and are dependent on each other through the product model. To be able to implement, utilize, and manage design automation systems in or across multiple disciplines, it is important to first understand how the disciplinary methods and models are dependent on each other through the product model and then how these relations should be constructed to support the users without negatively affecting other aspects, such as modeling flexibility, minimum documentation, and software tool independence.

To support the successful implementation and management of design automation systems the work presented here has focused on understanding how some digital product model constituents are, can, and, to some extent, should be extended to concretize relations between methods and models from different tools and disciplines. It has been carried out by interviewing Swedish industrial companies, performing technical reviews, performing literature reviews, and developing prototypes, which has resulted in an increased understanding and the consequent development of a conceptual framework that highlights aspects relating to the choice of extension techniques.

Set-based concurrent engineering (SBCE) has been pointed out as a means of enabling customisation and easy adaptation to fluctuating requirements. A feature and script based automation method of Finite Element Analysis has been proposed and developed by [Johansson, 2014] to help support SBCE. This article presents an assessment of the purposed method with respect to its industrial need, scientific novelty, and further work required. Outcomes of which include a new CAD-model tagging technique, positive industrial feedback and further work suggestions.

Design automation can be used to support efficient information handling and knowledge processing in computer-based product modelling, as well as make possible new design exploration and optimisation capabilities. To be able to utilise and manage design automation systems over time, it is important to understand how the disciplinary methods and models are dependent on each other through the product model constituents and then how these relations should be built to support maintenance, leveraging and future reuse. Awareness of the concrete representation of relations could support the system's traceability and transparency, and depending on the chosen technique, comprehension and extendability can be affected. This paper presents a conceptual framework for how a set of product model constituents are, can and to some extent, should be extended to define relations in multidisciplinary design automation systems.

Increasing competition in cost efficiency, lead-times, product quality, quotation accuracy, and abilities to provide customization drives companies toward development and adoption of new methods. To re-use knowledge gained from previous projects in order to avoid producing the same knowledge again and to circumvent previously encountered obstacles is an approach which is more or less used by most companies. Utilization of Design Automation (DA) systems in the engineering design process have proven to increase process efficiency and to enable new ways of working by systematic re-use of engineering knowledge. In order to ensure system longevity, industrial practitioners and researchers have pointed at implementation and long term management as important aspects to consider during development. The systems are often built on top of commercial software and legacy systems integrated by different types of scripts and system descriptions which becomes dependent of each other in different ways. Changes made during maintenance in one of these artifacts propagates through the dependency structure making traceability and transparency key factors for keeping the system valid over time. This paper presents a description of the problem in a real industrial setting together with a suggestion of an approach, based on set-up and management of dependencies between sections inside and across different types of system components, which is aimed to aid implementation and management of DA tools. A prototype system which informs the user, of functional sections related to a functional section to be updated, have been developed. The prototype is applied on a multidisciplinary heterogeneous system environment used for simulation based knowledge build up and concept evaluations of jet engine components.

As the speed and complexity of computers have increased so have software and the expectations of users. Software development follows a straightforward evolution where complicated tasks are made easier by better tools; this repeats itself as those tasks in turn are automated.

Software mechanics that were seen as revolutionary a decade ago are seen as obvious requirements that no multimedia application can be without.

dotNet is the next step in line and makes it easier and faster to build software.

This report focuses on the development of a multimedia platform developed in dotNet. It does this by developing the tools and framework from which a complete game can be built.

A game is selected because it combines the most aspects of multimedia development, such as interaction, graphics, sound & music. The report goes further by describing why the game looks like it does as well as the mechanics of the game and the benefits of the dotNet platform.

Combining several ANNs into ensembles normally results in a very accurate and robust predictive models. Many ANN ensemble techniques are, however, quite complicated and often explicitly optimize some diversity metric. Unfortunately, the lack of solid validation of the explicit algorithms, at least for classification, makes the use of diversity measures as part of an optimization function questionable. The merits of implicit methods, most notably bagging, are on the other hand experimentally established and well-known. This paper evaluates a number of straightforward techniques for introducing implicit diversity in ANN ensembles, including a novel technique producing diversity by using ANNs with different and slightly randomized link structures. The experimental results, comparing altogether 54 setups and two different ensemble sizes on 30 UCI data sets, show that all methods succeeded in producing implicit diversity, but that the effect on ensemble accuracy varied. Still, most setups evaluated did result in more accurate ensembles, compared to the baseline setup, especially for the larger ensemble size. As a matter of fact, several setups even obtained significantly higher ensemble accuracy than bagging. The analysis also identified that diversity was, relatively speaking, more important for the larger ensembles. Looking specifically at the methods used to increase the implicit diversity, setups using the technique that utilizes the randomized link structures generally produced the most accurate ensembles.

This report describes the development of an application in collaboration with Designingenjörerna AB. The company has worked for a long time with a community platform and they required an application where users can create their own unique profile representations, called Avatar Creator. An Avatar Creator is computer based application, which makes it possible to create a virtual character. The problem area behind this is that, large websites require a lot of administrative work when people upload profile pictures on different community pages. They can contain abusive material or pictures of other people rather than those who created the profile.The questions in this report are, how can an Avatar Creator help user to get a unique profile of himself? What are the advantages and disadvantages of an Avatar Creator? How to create a user-friendly application?To understand how an Avatar Creator works and get ideas to create an application, exiting Avatar Creators were reviewed on the Web.Collaborative work with Designingenjörerna AB was done to pin down the requirements for the Avatar creator application. The requirements were implemented to come up with an application with the features that allows users to create their unique Avatar profile, change looks etc. With this kind of application, the content that the users can choose is limited and controlled. On other hand, if users are allowed to change Avatar appearance too much, it can lead to disturbing images.The usability of the application was evaluated through survey which concluded that further work is needed to make the application user friendly. Users pointed out some functions were hard to understand and help-instructions were missing. Apart from these points, the application was considered good and held up to its purpose of creating a unique Avatar profile easily.

The Covid-19 situation has changed the work environment for a lot of companies in Sweden. Due to restrictions from Sweden's health care association, people have been working from home to as large extent as possible. Even though the work environment in the software industry was started to be digitized before Covid-19, it has been a huge readjustment for the employees. The software industry has been selected for this study for its significant importance for the BNP in Sweden. SMEs have been selected to cover as large a portion of the companies as possible. This study goes through how Covid-19 has affected the agile way of working within agile teams in software SMEs. To do this investigation, a grounded theory approach with qualitative interviews from 11 different software companies, and 13 participants has been made. The analysis of the study resulted in six main impacts that Covid-19 has had on agile teams in the software SMEs: Communication, Structure, Motivation, Health, Relationship, and Responsibility.

Software is a key component of most products, services, industrial processes, and back-office functions. Thus, companies may gain an advantage by establishing fast feedback cycles to improve their software.

Continuous software engineering (CI/CD) is being primarily studied as an engineering topic. However, the rest of the organization needs to align and be prepared to utilize the benefits of CI/CD.

In this paper, we explore the overlap between CI/CD and digital transformation (DT). We study literature in both areas to develop a map of conditions, mechanisms, and outcomes. As a result, we present a unified perspective of CI/CD and DT. We found that CI/CD can be seen as an implementation of DT in a software organization. DT perspective can help to guide the adoption of CI/CD from an organizational perspective. © 2022 ACM.

Global software development (GSD), as a mode of information systems development, surfaces various challenges and benefits that are not always present in co-located teams. A psychological contract reflects the written and unwritten expectations, or obligations, of collaborating parties in a transaction. This paper uncovers a set of candidate obligations that make up the psychological contract of parties collaborating in global software development efforts (the GSD psychological contract). Particular focus is applied to certain development roles: business analyst, designer, developer and development-support. A qualitative research approach is employed against various incidents that occurred in development projects performed by a global software product development organization. Finally, opportunities for future research are presented.

This thesis will examine how to create a web site with a game, based on the PHP-framework CodeIgniter. The report explains how this framework works and how you can make secure applications by using the framework. The reader will also get to know more about the HTML-standards possible to use for web sites and about the programming method, the MVC-principle, CodeIgniter is using. In short, the report explains technical web development and the programming behind it.

Today, it is common to include machine learning components in software products. These components offer specific functionalities such as image recognition, time series analysis, and forecasting but may not satisfy the non-functional constraints of the software products. It is difficult to identify suitable learning algorithms for a particular task and software product because the non-functional requirements of the product affect algorithm suitability. A particular suitability evaluation may thus require the assessment of multiple criteria to analyse trade-offs between functional and non-functional requirements. For this purpose, we present a method for APPlication-Oriented Validation and Evaluation (APPrOVE). This method comprises four sequential steps that address the stated evaluation problem. The method provides a common ground for different stakeholders and enables a multi-expert and multi-criteria evaluation of machine learning algorithms prior to inclusion in software products. Essentially, the problem addressed in this article concerns how to choose the appropriate machine learning component for a particular software product.

Learning algorithm evaluation is usually focused on classification performance. However, the characteristics and requirements of real-world applications vary greatly. Thus, for a particular application, some evaluation criteria are more important than others. In fact, multiple criteria need to be considered to capture application-specific trade-offs. Many multi-criteria methods can be used for the actual evaluation but the problems of selecting appropriate criteria and metrics as well as capturing the trade-offs still persist. This paper presents a framework for application-oriented validation and evaluation (APPrOVE). The framework includes four sequential steps that together address the aforementioned problems and its use in practice is demonstrated through a case study.

Software Defect Prediction (SDP) is an integral aspect of the Software Development Life-Cycle (SDLC). As the prevalence of software systems increases and becomes more integrated into our daily lives, so the complexity of these systems increases the risks of widespread defects. With reliance on these systems increasing, the ability to accurately identify a defective model using Machine Learning (ML) has been overlooked and less addressed. Thus, this article contributes an investigation of various ML techniques for SDP. An investigation, comparative analysis and recommendation of appropriate Feature Extraction (FE) techniques, Principal Component Analysis (PCA), Partial Least Squares Regression (PLS), Feature Selection (FS) techniques, Fisher score, Recursive Feature Elimination (RFE), and Elastic Net are presented. Validation of the following techniques, both separately and in combination with ML algorithms, is performed: Support Vector Machine (SVM), Logistic Regression (LR), Naïve Bayes (NB), K-Nearest Neighbour (KNN), Multilayer Perceptron (MLP), Decision Tree (DT), and ensemble learning methods Bootstrap Aggregation (Bagging), Adaptive Boosting (AdaBoost), Extreme Gradient Boosting (XGBoost), Random Forest(RF), and Generalized Stacking (Stacking). Extensive experimental setup was built and the results of the experiments revealed that FE and FS can both positively and negatively affect performance over the base model or Baseline. PLS, both separately and in combination with FS techniques, provides impressive, and the most consistent, improvements, while PCA, in combination with Elastic-Net, shows acceptable improvement.

The Internet of Things (IoT) has become a crucial topic in research and industry over recent years. Enterprises often fail to create business value from IoT technology because they have difficulties defining organizational integration. Model-driven Development (MDD) is considered an effective technique for IoT application development. We argue that methods for MDD should comprise the organizational as well as the system development and integration. This paper aims to provide an overview of the current state of research on MDD of IoT applications. For this purpose, we conducted a structured literature review (SLR). A research gap was identified as no specific research could be found on MDD of IoT applications with a focus on organizational and system aspects. We also derived requirements from an industrial use case. The main contributions of this paper are (a) requirements from medium-sized enterprises (SMEs) to methodical and technical IoT development support derived from a use case, (b) the results of a systematic literature analysis in this field, and (c) an initial structure for the methodical support and initial architecture for the accompanying tool support. 

Serverless functions have emerged as a prominent paradigm in software deployment, providing automated resource scaling, resulting in demand-based operational expenses. One of the most significant challenges associated with serverless functionsis the cold start delay, preventing organisations with latency-critical web applications from adopting a serverless technology.

Existing research on the cold start problem primarily focuses on mitigating the delay by modifying and optimising serverless platform technologies. However, these solutions have predominantly yielded modest reductions in time delay. Consequently, the purpose of this study is to establish conditions and circumstances under which the cold start issue can be addressed through the type of approach presented in this study.

Through a design science research methodology, a software artefact named AdaptiveServerless Invocation Predictor (ASIP) was developed to mitigate the cold start issue through monitoring web application user traffic in real-time. Based on the user traffic, ASIP preemptively pre-initialises serverless functions likely to be invoked, to avoid cold start occurrences. ASIP was tested against a realistic workload generated by test participants.

Evaluation of ASIP was performed through analysing the reduction in time delay achieved and comparing this against existing cold start mitigation strategies. The results indicate that predicting serverless function invocations based on real-time traffic analysis is a viable approach, as a tangible reduction in response time was achieved. Conclusively, the cold start mitigation strategy assessed and presented in this study may not provide a sufficiently significant mitigation effect relative to the required implementation effort and operational expenses. However, the study has generated valuable insights regarding circumstantial factors concerning cold start mitigation. Consequently, this study provides a proof of concept for a more sophisticated version of the mitigation strategy developed in this study, with greater potential to provide a significant delay reduction without requiring substantial computational resources. 

This report describes a final thesis done during the spring of 2008 as part of the bachelor degree in computer engineering degree at the School of Engineering in Jönköping.

The client is working in the consulting business and is involved in, amongst others, work regarding information security. Within this field they perform so called Threat, Risk and Vulnerability assessments. Today these assessments are done by a predefined method, but many details are controlled by the person documenting the project. A wish was made that the implementation was standardized, it should also ease the task of estimating the need for time and money. The solution for this seems to be a software tool. This software should handle the data from the assessments and generate foundations for reports.

The question formulation that has been used is:

• What are the possibilities to, with software, improve the workflow for handling the information from the assessments?

• What are suitable techniques to handle this?

To plan the software focus was put on the assessment and the types of input to them. These inputs were identified through descriptions in literature and informal interviews with analytics. The handling of the information remained unspecified as to not steer the design of the application in a direction that was formed after accustomed patterns, instead an objective solution was sought after.

The resulting software fulfills all requirements that were specified at the beginning of the project, and it shows that the possibilities to improve the workflow are great. It is possible even with very small means to make it easier for the person doing the documentation. The report resulting from the assessments then become more standardized and make it easier to verify its validity.

In the modern world, Scrum is widely adopted by many companies for software development, no matter the size of the company. As Scrum provides rapid development and meets the customer needs in a faster and efficient way, many companies want to move towards Scrum but moving towards Scrum is difficult and challenging due to different barriers for example cost, lack of experience, and so on. This thesis is to address the barriers which are involved during the Scrum adoption for software start-up companies such as communication, team mindset, backlog refining, daily stand up, and retrospective meetings. In this research report, these issues are divided based on the factors such as organization, people, process, and tools. We have figured out these barriers using action research based on the observation done during the Scrum team meetings and through interviews and surveys.  

The gap between software engineering education and the software engineering industry is a prevalent factor for both the students and the companies recruiting them. The gap is specified as the lack of knowledge software engineering students obtain relative to what the industry requires. This gap increases the difficulty for the students whenmoving from education to industry. This thesis aims to provide insight for what role the capstone project played for the graduate students’ transition to industry by looking at it from a CDIO perspective. The subjects for this research were graduate students who now work in the software engineering industry and who realised their studies up to three years earlier. A total of 38 people took part in this research by answering a questionnaire. They provided their opinions on how they experienced their capstone project and how they now experience their work assignments. This research used metadata to categorically separate the respondents into groups to find outliers. The results show that 94% of the respondents got to perform three or more CDIO criteria in their capstone projects. The respondents also recognize that they are able to perform their industry assignments in terms of the CDIO criteria.

Testing of a software system is a resource-consuming activity that requires high-level expert knowledge. In previous work we proposed an ontologybased approach to alleviate this problem. In this paper we discuss the lessons learned from the implementation and application of the approach in a use case from the avionic industry. The lessons are related to the areas of ontology development, ontology evaluation, the OWL language and rule-based reasoning.

Testing of a software system is a resource-consuming activity that requires high-level expert knowledge. Methods based on knowledge representation and reasoning can alleviate this problem. This paper presents an approach to enhance the automation of the testing process using ontologies and inference rules. The approach takes software requirements specifications written in structured text documents as input and produces the output, i.e. test scripts. The approach makes use of ontologies to deal with the knowledge embodied in requirements specifications and to represent the desired structure of test cases, as well as makes use of a set of inference rules to represent strategies for deriving test cases. The implementation of the approach, in the context of an industrial case, proves the validity of the overall approach.

Testing of a software system is resource-consuming activity. One of the promising ways to improve the efficiency of the software testing process is to use ontologies for testing. This paper presents an approach to test case generation based on the use of an ontology and inference rules. The ontology represents requirements from a software requirements specification, and additional knowledge about components of the software system under development. The inference rules describe strategies for deriving test cases from the ontology. The inference rules are constructed based on the examination of the existing test documentation and acquisition of knowledge from experienced software testers. The inference rules are implemented in Prolog and applied to the ontology that is translated from OWL functional-style syntax to Prolog syntax. The first experiments with the implementation showed that it was possible to generate test cases with the same level of detail as the existing, manually produced, test cases.

Assertions are one of the most useful automated techniques for checking program’s behaviour and hence have been used for different verification and validation tasks. We provide an overview of the last two decades of research involving ‘assertions’ in software testing. Based on a term–based search, we filtered the inclusion of relevant papers and synthesised them w.r.t. the problem addressed, the solution designed, and the evaluation conducted. The survey rendered 119 papers on assertions in software testing. After test oracle, the dominant problem focus is test generation, followed by engineering aspects of assertions. Solutions are typically embedded in tool prototypes and evaluated throughout limited number of cases while using large–scale industrial settings is still a noticeable method. We conclude that assertions would be worth more attention in future research, particularly regarding the new and emerging demands (e.g., verification of programs with uncertainty), for effective, applicable, and domain-specific solutions.

The number of available mobile applications (or apps) as well as the usage of these are rapidly increasing. With this increase there naturally also follows an increased competitiveness in the app market, with developers needing to produce apps of high perceived quality in order to get return users and also needing to make their apps available to multiple different platforms and devices. With substantial platform and device fragmentation, this is often a difficult and costly task. While traditionally an app basically had to be build from scratch for each platform it needed to support, in later years alternative development techniques for what is called cross-platform development have emerged and seen a rapid increase in usage. Contrary to native development, cross-platform development aims to enable development of a single codebase that can then run on all platforms. The idea is that this would save development time and thereby cost.

Academic literature was found to often evaluate and compare performance differences between apps developed with cross-platform frameworks and their natively developed counterparts. Typically, these studies reported several reoccurring drawbacks with cross-platform development, compared to native development. However, research within the field was found to be lacking in regard to developers’ experience in general, and specifically whether this focus on comparing performance and listing pros and cons was representative of the concerns of industry developers. This study aimed to begin filling this gap, byinvestigating the extent to which these developers were relating any drawbacks to cross-platform development as well as which these were. Also, the study sought to answer how big a part this awareness of drawbacks played in the decision when developers chose to develop natively instead of cross-platform. With this, the goal of the study was ultimately to discussthe state of cross-platform research and whether it focused on aspects that were relevant to the industry.

Data in this study was gathered in two ways: (1) a literature study, aiming to get an image of the current state of cross-platform research and (2) a web survey, in which app developers were invited through various groups in Facebook and Reddit. Ultimately, the results indicated that industry developers were to a large extent relating the same drawbacks to cross-platform development as were found to be frequently reported by academia. Further, all of the survey participants that related drawbacks to cross-platform development and ever chose to develop natively instead of cross-platform, did so to a very large degree because of those drawbacks.

There were limitations to both the planning and the execution of the methods that were used, primarily in the gathering of data but also the analysis of this. However, it was still deemed possible to conclude that the results of the study indicated that research regarding cross-platform development could reasonably keep its current focus moving forward, as this appeared to be of high relevance to the industry. 

Background: Software Engineering activities are information intensive. Research proposes Information Retrieval (IR) techniques to support engineers in their daily tasks, such as establishing and maintaining traceability links, fault identification, and software maintenance.

Objective: We describe an engineering task, test case selection, and illustrate our problem analysis and solution discovery process. The objective of the study is to gain an understanding of to what extent IR techniques (one potential solution) can be applied to test case selection and provide decision support in a large-scale, industrial setting.

Method: We analyze, in the context of the studied company, how test case selection is performed and design a series of experiments evaluating the performance of different IR techniques. Each experiment provides lessons learned from implementation, execution, and results, feeding to its successor.

Results: The three experiments led to the following observations: 1) there is a lack of research on scalable parameter optimization of IR techniques for software engineering problems; 2) scaling IR techniques to industry data is challenging, in particular for latent semantic analysis; 3) the IR context poses constraints on the empirical evaluation of IR techniques, requiring more research on developing valid statistical approaches.

Conclusions: We believe that our experiences in conducting a series of IR experiments with industry grade data are valuable for peer researchers so that they can avoid the pitfalls that we have encountered. Furthermore, we identified challenges that need to be addressed in order to bridge the gap between laboratory IR experiments and real applications of IR in the industry.

Datakraft i Småland AB is an IT consulting company that specializes in hosting and IT services. The company also offers an enterprise resource planning system, called Pyramid, which has built in tools for users to make customized solutions through programming. Datakraft are now interested in getting an evaluation of the programming tools existing in the system, which is the main objective of this report.

The questions that will be answered in this project are:

• What is possible to do with the programming tools in Pyramid with C# in Visual Studio as a guideline?
• Is Visual Kosmos an easy/efficient programming language to work with compared to C#?

For the evaluation, the work consists of collecting theories and data through education and by creating a solution in Pyramid for Techno Skruv, one of Datakraft’s customers. The methodology that was used for this project is also the procedures used by DataKraft's own staff. This methodology includes the steps feasibility study, design, programming and documentation.

The result is presented as a distinguishable comparison between Pyramid’s development environment with its programming language, Visual Cosmos and Visual Studio with the C# in table forms. With the results, analysis was made with the data combined with the theories to get the answers for the questions of the objective.

The programming tools in Pyramid have features that can be found in the standardized Visual Studio and C#. In the light of this, theoretical, the programming tools in Pyramid have no restrictions in terms of programming. In practice, however, the tools are limited due to the fact that the system was created to serve resource planning systems, which is the conclusion of this study.