lnu.sePublications
Change search
Refine search result
1 - 16 of 16
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Ericsson, Morgan
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Löwe, Welf
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Toll, Daniel
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    A Study of the Effect of Data Normalization on Software and Information Quality Assessment2013In: Software Engineering Conference (APSEC, 2013 20th Asia-Pacific), IEEE Press, 2013, p. 55-60Conference paper (Refereed)
    Abstract [en]

    Indirect metrics in quality models define weighted integrations of direct metrics to provide higher-level quality indicators. This paper presents a case study that investigates to what degree quality models depend on statistical assumptions about the distribution of direct metrics values when these are integrated and aggregated. We vary the normalization used by the quality assessment efforts of three companies, while keeping quality models, metrics, metrics implementation and, hence, metrics values constant. We find that normalization has a considerable impact on the ranking of an artifact (such as a class). We also investigate how normalization affects the quality trend and find that normalizations have a considerable effect on quality trends. Based on these findings, we find it questionable to continue to aggregate different metrics in a quality model as we do today.

  • 2.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Towards Pattern Based Architectural Conformance Checking2016Licentiate thesis, monograph (Other academic)
    Abstract [en]

    Patterns are a source of knowledge when architecting software systems. They provide abstract and time-tested solutions that show how a system should be structured to achieve needed qualities. However, when developing software there is a chance that small mistakes are introduced in the source code. Over time, these mistakes can accumulate and break the structure of the pattern and its qualities are lost. There are methods that can help find such errors, but none of these provide a pattern abstraction. In this work, we describe a method that raises the level of abstraction from checking individual dependencies to checking key dependencies in the pattern. We implement our method, apply it to check the Model-View-Controller pattern. We show that the method can find architectural problems in real source code and examine how removal of detected erosions affects the source code. We conducted an experiment in a software project setting to determine if using the method affects the number of architectural problems. Some project teams were randomly assigned to use a software service that automated our method. It checked how well their implementation conformed to Model-View-Controller every time they updated the source code. The experiment showed that developers that used the tool had significantly fewer detected architectural problems during the course of the project. Our method makes conformance checking easier to use. This might help increase the adoption of conformance checking in industry.

  • 3.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    An exploration and experiment tool suite for code to architecture mapping techniques2019In: ECSA '19 Proceedings of the 13th European Conference on Software Architecture / [ed] Laurence Duchien, New York, NY, USA: ACM Publications, 2019, Vol. 2, p. 26-29Conference paper (Refereed)
    Abstract [en]

    Reflexion modeling can be used to validate that source code conforms to an intended architecture. However, it requires a mapping of source code modules (e.g., classes) to (software) architecture elements. We have developed a tool suite that allows for evaluation and exploration of automatic techniques to map source code modules to architecture elements. The suite includes a reusable core component and tools to define the architecture, define and run experiments with mapping strategies, and explore the results of these experiments. The experiments can be executed locally or in a remote high-performance computing environment.

  • 4.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Motivation and Impact of Modeling Erosion using Static Architecture Conformance Checking2017In: Proceedings - 2017 IEEE International Conference on Software Architecture Workshops, ICSAW 2017: Side Track Proceedings, IEEE, 2017, p. 204-209Conference paper (Refereed)
    Abstract [en]

    We motivate and describe why erosion modelingfrom a static architecture conformance checking point of view isimportant as well as the impact we think it can have on industry.Our research goal is to get a better understanding of erosionand develop smarter and simpler methods to assess erosion. Wedescribe preliminary results from a retrospective, longitudinalcase study of an open source software. The software system westudy, JabRef, was created in 2003, and refactored to a layeredstructure to “transition from a spaghetti to a more structuredarchitecture” in 2015. We construct a model from this new,layered architecture, and assess 30 versions of JabRef to findarchitectural conformance violations. Our preliminary resultsshow a significant difference in productivity after refactoring andsuggest that there is a connection between our model of erosionand productivity where more erosion gives lower productivity.

  • 5.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Semi-Automatic Mapping of Source Code Using Naive Bayes2019In: ECSA '19 Proceedings of the 13th European Conference on Software Architecture - / [ed] Laurence Duchien, New York, NY, USA: ACM Publications, 2019, Vol. 2, p. 209-216Conference paper (Refereed)
    Abstract [en]

    The software industry has not adopted continuous use of static architecture conformance checking. One hindrance is the needed mapping from source code elements to elements of the architecture. We present a novel approach of generating and combining dependency and semantic information extracted from an initial set of mapped source code files. We use this to train a Naive Bayes classifier that is then used to map the remainder of the source code files. We compare this approach with the HuGMe technique on six open source projects with known mappings. We find that our approach provides an average performance improvement of 0.22 and an average precision and recall F1-score improvement of 0.26 in comparison to HuGMe.

  • 6.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    The relationship of code churn and architectural violations in the open source software JabRef2017In: ECSA '17 Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings, New York, NY, USA: ACM Publications, 2017, p. 152-158Conference paper (Refereed)
    Abstract [en]

    The open source application JabRef has existed since 2003. In 2015, the developers decided to make an architectural refactoring as continued development was deemed too demanding. The developers also introduced Static Architecture Conformance Checking (SACC) to prevent violations to the intended architecture. Measurements mined from source code repositories such as code churn and code ownership has been linked to several problems, for example fault proneness, security vulnerabilities, code smells, and degraded maintainability. The root cause of such problems can be architectural. To determine the impact of the refactoring of JabRef, we measure the code churn and code ownership before and after the refactoring and find that large files with violations had a significantly higher code churn than large files without violations before the refactoring. After the refactoring, the files that had violations show a more normal code churn. We find no such effect on code ownership. We conclude that files that contain violations detectable by SACC methods are connected to higher than normal code churn.

  • 7.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Towards Improved Initial Mapping in Semi Automatic Clustering2018In: ECSA 2018: PROCEEDINGS OF THE 12TH EUROPEAN CONFERENCE ON SOFTWARE ARCHITECTURE: COMPANION PROCEEDINGS, Association for Computing Machinery (ACM), 2018Conference paper (Refereed)
    Abstract [en]

    An important step in Static Architecture Conformance Checking (SACC) is the mapping of source code entities to entities in the intended architecture. This step is currently relying on manual work, which is one hindrance for more widespread adoption of SACC in industry. Semi-automatic clustering is a promising approach to improve this, and the HuGMe clustering algorithm is an example of such a technique for use in SACC. But HuGMe relies on an initial set of clustered source code elements and algorithm parameters. We investigate the automatic mapping performance of HuGMe in two experiments to gain insight into what influence the starting set has in a medium-sized open source system, JabRef, which contain a relatively large number of architectural violations. Our results show that the highest automatic mapping performance can be achieved with a low number of elements within the initial set. However, the variability of the performance is high. We find a benefit in favoring source code elements with a high fan-out in the initial set.

  • 8.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Using Repository Data for Driving Software Architecture2018In: Proceeding of the 40th International Conference on Software Engineering: Companion Proceeedings (ICSE), 2018, ACM Publications, 2018, p. 197-198Conference paper (Refereed)
    Abstract [en]

    We are in the pursuit of establishing a method for continuous data driven software architecture. We describe the problem with current methods for measuring the impact of refactoring long lived systems at the architectural level and architecture compliance checking. We summarize our studies of code churn, productivity and an automatic tool for compliance checking. We conclude that architecture violations seem to play an important role, but current methods are infeasible for industry practice. Finally we propose to use repository data mining to improve current methods for architecture compliance checking.

  • 9.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Toll, Daniel
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Evaluation of an architectural conformance checking software service2016In: ACM Proccedings of the 10th European Conference on Software Architecture Workshops (ECSA-W), ACM Press, 2016, article id 15Conference paper (Refereed)
    Abstract [en]

    Static architectural conformance checking can be used to find architectural violations, cases where the implementation does not adhere to the architecture, and prevent architectural erosion. We implement a software service for automated conformance checking and investigate the effect this has on the number of architectural violations in software projects. The service is implemented using our heuristic-based approach to static architecture conformance checking of the Model-View-Controller pattern. The service is integrated in the source code management system of each project, so a report is generated every time the source code is modified. The service was evaluated in a field experiment that consisted of eight student projects. We found that the four projects that used the service produced significantly fewer violations compared to those that did not.

  • 10.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Toll, Daniel
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Chalmers University of Technology, Sweden;University of Gothenburg, Sweden.
    Evaluation of a static architectural conformance checking method in a line of computer games2014In: QoSA '14 Proceedings of the 10th international ACM Sigsoft conference on Quality of software architectures, New York, NY, USA: Association for Computing Machinery (ACM), 2014, p. 113-118Conference paper (Refereed)
    Abstract [en]

    We present an evaluation of a simple method to find architectural problems in a product line of computer games. The method uses dependencies (direct, indirect, or no) to automatically classify types in the implementation to high-level components in the product line architecture. We use a commercially available tool to analyse dependencies in the source code. The automatic classification of types is compared to a manual classification by the developer, and all mismatches are reported. To evaluate the method, we inspect the source code and look for a pre-defined set of architectural problems in all types. We compare the set of types that contained problems to the set of types where the manual and automatic classification disagreed to determine precision and recall. We also investigate what changes are needed to correct the found mismatches by either designing and implementing changes in the source code or refining the automatic classification. Our evaluation shows that the simple method is effective at detecting architectural problems in a product line of four games. The method is lightweight, customisable and easy to implement early in the development cycle.

  • 11.
    Olsson, Tobias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Toll, Daniel
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Chalmers University of Technology, Sweden.
    Evolution and Evaluation of the Model-View-Controller Architecture in Games2015In: Proceedings of the Fourth International Workshop on Games and Software Engineering, USA: IEEE Press, 2015, p. 8-14Conference paper (Refereed)
    Abstract [en]

    In game software it is important to separate game play code from rendering code to ease transitions to new technologies or different platforms. The architectural pattern Model-View-Controller (MVC) is commonly used to achieve such separation. We investigate how the MVC architectural pattern is implemented in five game projects from a small development studio. We define a metrics-based quality model to assess software quality goals such as portability and rendering engine independence and perform an architectural analysis. The analysis reveals three different evolutions of the pattern. We also assess the quality and find that 1. The evolutions of the architecture differ in quality and 2. An architectural refactoring to a newer version of the architecture increases the software quality.

  • 12.
    Toll, Daniel
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Olsson, Tobias
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Why is unit-testing in computer games difficult?2011In: Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR / [ed] Tom Mens, Anthony Cleve, Rudolf Ferenc, IEEE, 2011, p. 373-378Conference paper (Refereed)
    Abstract [en]

    In this paper, we investigate how unit testing can be used to verify computer game simulations with implicit and poorly defined mathematical models. The difficulty of calculation of expected values for such cases tends to lead to Fragile and Obscure tests. The effects of these test smells can be reduced if we improve the strategy we use to calculate expected values. We investigate four strategies and while each of these is insufficient, we outline how they can be combined into a single, sufficient strategy.

  • 13.
    Toll, Daniel
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Detailed recordings of student programming sessions2015In: ITiCSE '15: Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education, ACM Press, 2015, p. 328-328Conference paper (Refereed)
    Abstract [en]

    Observation is important when we teach programming. It can help identify students that struggle, concepts that are not clearly presented during lectures, poor assignments, etc. However, as development tools become more widely available or courses move off-campus and online, we lose our ability to naturally observe students. Online programming environments provide an opportunity to record how students solve assignments and the data recorded allows for in-depth analysis. For example, file activities, mouse movements, text-selections, and text caret movements provide a lot of information on when a programmer collects information and what task is currently worked on. We developed CSQUIZ to allow us to observe students on our online courses through data analysis. Based on our experience with the tool in a course, we find recorded sessions a sufficient replacement for natural observations.

  • 14.
    Toll, Daniel
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Fine-Grained Recording of Student Programming Sessions to Improve Teaching and Time Estimations2015In: IFIP TC3 Working Conference “A New Culture of Learning: Computing and next Generations” / [ed] Andrej Brodnik, Cathy Lewin, 2015, p. 264-274Conference paper (Refereed)
    Abstract [en]

    To have direct observation of students during an online programming course is impossible. This makes it harder for teachers to help struggling students. By using an online programming environment we have the opportunity to record what the students actually do to solve an assignment. We can analyse the recordings and provide teachers with valuable information. We developed and used an online programming toolwith fine-grained event logging to observe how our students solve problems. Our tool provides descriptive statistics and accurate replays of a student’s programming sessions, including mouse movements. We used the tool in a course and collected 1028 detailed recordings. We compare fine-grained logging with existing coarsegrained logging solutions to estimate assignment-solving time. We find that time aggregations are improved by including time for active reading and navigation enabled by the increased granularity. We also divide the time users spent into editing (on average 14.8%), active use (on average 37.8%), passive use (on average 29.0%), and also estimate time used for breaks (on average 18.2%).Finally wesee a correlation between early student submission results and students that hand in later, but also see an example where the results differ significantly.

  • 15.
    Toll, Daniel
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Fine-Grained Recording of Student Programming Sessions to Improve Teaching and Time Estimations2016In: International journal of engineering education, ISSN 0949-149X, Vol. 32, no 3, p. 1069-1077Article in journal (Refereed)
    Abstract [en]

    It is not possible to directly observe how students work in an online programming course. This makes it harder for teachers to help struggling students. By using an online programming environment, we have the opportunity to record what the students actually do to solve an assignment. These recordings can be analyzed to provide teachers with valuable information. We developed such an online programming tool with fine-grained event logging and used it to observe how our students solve problems. Our tool provides descriptive statistics and accurate replays of a student's programming sessions, including mouse movements. We used the tool in a course and collected 1028 detailed recordings. In this article, we compare fine-grained logging to existing coarse-grained logging solutions to estimate assignment-solving time. We find that time aggregations are improved by including time for active reading and navigation, both enabled by the increased granularity. We also divide the time users spent into editing (on average 14.8%), active use (on average 37.8%), passive use (on average 29.0%), and estimate time used for breaks (on average 18.2%). There is a correlation between assignment solving time for students who pass assignments early and students that pass later but also a case where the times differ significantly. Our tool can help improve computer engineering education by providing insights into how students solve programming assignments and thus enable teachers to target their teaching and/or improve instructions and assignments.

  • 16.
    Toll, Daniel
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Olsson, Tobias
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Ericsson, Morgan
    University of Gothenburg.
    The challenge of teaching students the value of programming best practices2014In: Innovation and Technology in Computer Science Education Conference 2014 / [ed] Åsa Cajander and Mats Daniels and Tony Clear and Arnold Pears, ACM Publications, 2014, p. 347-347Conference paper (Refereed)
    Abstract [en]

    We investigate the benefits of our programming assignments in correlation to what the students learn and show in their programming solutions. The assignments are supposed to teach the students to use best practices related to program comprehension, but do the programming assignments clearly show the benefits of best practices? We performed an ex- periment that showed no significant result which suggests that the assignments did not emphasise the value of best practices. As lecturers, we understand that constructing as- signments that match the sought after outcome in students learning is a complex task. The experiment provided valu- able insights that we will use to improve the assignments to better mirror best practices. 

1 - 16 of 16
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf