Examensarbeten för masterexamen

Länka till denna samling:

https://odr.chalmers.se/handle/20.500.12380/29

Browse

Senast publicerade

Visar 1 - 5 av 1569
  • Bild (thumbnail)
    Post
    A Syntax for Composable Data Types in Haskell, A User-friendly Syntax for Solving the Expression Problem
    (2023) Romeborn, Anna; Albers, Fredrik; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Broberg, Niklas
    The expression problem is the problem of designing a programming language such that it has both extensible data types and extensible sets of functions over those data types. This means that it should be possible to add new functions, new variants to a data type, and function cases for these new variants, without modification or recompilation of existing code. There exist a number of different approaches to solving the expression problem, which have different qualities in expressiveness or simplicity. In this thesis, we have designed a syntax, with an accompanying transformation into compilable code, that acts as a solution to the expression problem in Haskell. By designing this syntax, we can make simplifications that would not be possible for solutions written directly in Haskell. In particular, we can, behind our syntax, abstract away some syntactic overhead that can be generated by the transformation. To demonstrate that our designed syntax is feasible and works as an extension to Haskell, we have implemented the transformation, which transforms code written using our syntax into code that uses the Haskell library compdata. That library is an existing solution to the expression problem, and is based on another solution:Data Types à la Carte. Both of these solutions share many similarities in semantics with our syntax. Similarly to compdata and Data Types à la Carte, data types in our syntax are composable; that is, variants of a data type are manually combined to form a type with a fixed set of possible variants. We introduce a new concept, called categories, with the purpose of grouping variants and compositions of data types and simplifying the syntax into one closer to that of regular data types. This means that compositions of variants can only be formed of variants belonging to the same category, as opposed to freely being able to combine any variants. Again, similar to compdata and Data Types à la Carte, functions over composable data types are extended automatically in our syntax. This means that a function can be used for a variant of the data type as long as the function has a case defined for the variant. Through the introduction of categories and the abstractions possible through the transformation, we are able to conclude that our syntax provides several improvements compared to existing solutions to the expression problem in Haskell.
  • Bild (thumbnail)
    Post
    High-speed Serial SpaceFibre link Software Evaluation
    (2023) Mass, Jesper; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Jonsson, Jan; Waqar Azhar, Muhammad
    SpaceFibre is an emerging standard for onboard spacecraft communication. Cobham Gaisler has recently developed an IP core to communicate through a SpaceFibrelink. However, no software driver API to use the IP is currently available. By using SpaceFibre the speed of communication can be increased by up to 15 times compared to the previously used SpaceWire. This increased speed could enable more data to be sent from sensors quicker for processing at the onboard computer.Currently, few other drivers for SpaceFibre exist and there is little benchmarking for how well it actually performs. The aim of this thesis was to design a software driver to benchmark the actual performance and validate the SpaceFibre IP developed atCobham Gaisler. To accomplish this an external tool, developed by the creators ofthe SpaceFibre standard, was used: the STAR Fire Mk3. With this tool, a test using the driver designed in this thesis was performed where the STAR Fire Mk3 was used to measure the statistics and act as both a recipient and transmitter of messages. As a result, it was found that the IP core does reach speeds up to 1.91 Gbps for reception and 1.5 Gbps for transmission with a link running at effectively 2 Gbps. Using this the user can reach speeds of at least ten times the speed of SpaceWire, and including all the standardised quality of service the protocol provides.
  • Bild (thumbnail)
    Post
    Bayesian modeling approach to Test Case Prioritization
    (2023) Eliasson, Adrian; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Horkoff, Jennifer; Feldt, Robert
    Regression testing taking up valuable time and computational resources is a prevalent issue in software engineering. Lowering the time consumed by the execution of a regression suite enables timely feedback to developers and faster software verification. One technique to reduce the cost of regression testing is called test case prioritization. This project utilized an action research methodology to investigate a case company’s requirements specific to test case prioritization and evaluated a novel Bayesian modeling approach against a Heuristic approach. In addition, the results were discussed in relation to Machine Learning-based approaches. The different approaches were evaluated based on several elicited requirements on one open-source dataset and the case company dataset. The results showed that Bayesian modeling performed similarly to heuristic models and machine learning models in terms of early fault detection, even with limited amounts of training data. Furthermore, Bayesian models showed a higher average percentage fault detection than heuristic models on the open-source dataset. From the perspective of small to medium-sized companies (SMEs), common test case prioritization techniques may improve early fault detection, however, additional work may be needed to meet the requirements and demands of the companies’ testing and verification practices. A pragmatic approach to test case prioritization for SMEs could use a combination of Bayesian modeling and rule-based or heuristic prioritization.
  • Bild (thumbnail)
    Post
    Data Analysis for Defect Monitoring in Additive Manufacturing – Applying Machine Learning to Predict Porosity in L-PBF
    (2023) Sievers, Erik; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Gulisano, Vincenzo; Papatriantafilou, Marina
    Laser powder bed fusion (L-PBF) is an additive manufacturing technique that sees more and more use in industrial settings, but is held back by a lack of cost-effective quality validation of created products. One core attribute of high-quality additive manufactured products is a low porosity, i.e. a high ratio of solid to empty volume inside the object. This thesis provides an overview of the state of the art for in-situ monitoring of L-PBF manufacturing and investigates the use of outlier detection methods as a way of encoding optical tomography data from an L-PBF process. This is done using a commercial L-PBF machine with its accompanying in-situ monitoring camera. The results show that outlier detection methods can be used to detect porosity in created objects (0.94 - 0.99 ROC-AUC, receiver operating characteristics’ area under curve) and that it can generalize between similar object geometries. The thesis also provides a discussion of the limitations of the current research and suggests future work both building upon the methods introduced in the thesis and in the field of in-situ monitoring of L-PBF.
  • Bild (thumbnail)
    Post
    Manually Mapping Model Elements onto the Modeled Code by Analyzing GitHub Data
    (2023) Zhang, Wenli; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Berger, Christian; Hebig, Regina
    Context: Class diagrams are one of the most popular UML models and are frequently used in the early stages of software development. The advantage of using class diagrams is that they can reflect design decisions and the system’s implementation structure. Maintainers can use class diagrams to understand the system’s implementation structure. Yet, as the code evolves, the absence of updating class diagrams will cause the code implementation to deviate from the class diagram design. One concern is that such a divergent class diagram does not help maintainers much in the same way during the maintenance stage. As a solution, reverse engineering methods/tools can reverse code into class diagrams. Yet, another concern comes up, in most cases, the reverse-engineered class diagrams are not abstract, and they contain extensive information that will burden the understanding of the system’s implementation structure. This is because the existing reverse engineering methods/tools are imperfect as they do not manage to imitate the human ability to abstract relevant information from the source code. Surprisingly, existing studies on the characteristics of manual abstraction are based on the opinions and experiences of participants but do not study actual cases of models and source code. Also, the methods/technologies used for checking the similarities and differences between the models and source code are purely structural but do not analyze or take the semantics of the model elements into account when mapping classes from models and code. The semantics is closely related to abstraction creation. Thereby, a systematic manual study on the characteristics of manual abstraction is required. Aim: To fill this gap, this thesis aimed at studying the characteristics of the differences between the class diagram design and the code implementation by manually creating the mappings between the class diagram elements/constituents and the code constructs. Our manual studies can precisely capture the differences between the class diagram design and source code implementation and investigate the causes of these differences. Method: We employed the methodology of five case studies. The five subjects studied are five Java open-source projects collected from GitHub. They are semirandomly selected from the Linholmen dataset [1]. Results: For the differences between the class diagram design and code implementation, three causes are summarized: various levels of manual abstraction created in class diagrams, deviations of code implementation from class diagram design, and common changes between the class diagram elements/constituents and code constructs. We contribute to a sorted list of cases corresponding to these three causes.