lnu.sePublications
Change search
Refine search result
12 1 - 50 of 81
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • 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.
    Ambrosius, Robin
    et al.
    Dezember IT GmbH, Germany.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Löwe, Welf
    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).
    Interviews Aided with Machine Learning2018In: Perspectives in Business Informatics Research. BIR 2018: 17th International Conference, BIR 2018, Stockholm, Sweden, September 24-26, 2018, Proceedings / [ed] Zdravkovic J., Grabis J., Nurcan S., Stirna J., Springer, 2018, Vol. 330, p. 202-216Conference paper (Refereed)
    Abstract [en]

    We have designed and implemented a Computer Aided Personal Interview (CAPI) system that learns from expert interviews and can support less experienced interviewers by for example suggesting questions to ask or skip. We were particularly interested to streamline the due diligence process when estimating the value for software startups. For our design we evaluated some machine learning algorithms and their trade-offs, and in a small case study we evaluates their implementation and performance. We find that while there is room for improvement, the system can learn and recommend questions. The CAPI system can in principle be applied to any domain in which long interview sessions should be shortened without sacrificing the quality of the assessment.

  • 2.
    Andersson, Jesper
    et al.
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Ericsson, Morgan
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Kessler, Chistoph
    Löwe, Welf
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Profile-guided Composition2008In: 7th International Symposium on Software Composition, Springer , 2008, p. 157-164Conference paper (Refereed)
  • 3.
    Andersson, Jesper
    et al.
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Ericsson, Morgan
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Löwe, Welf
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Automatic Rule Derivation for Adaptive Architectures2008In: 8th IEEE/IFIP Working Conference on Software Architecture, IEEE , 2008, p. 323-326Conference paper (Refereed)
    Abstract [en]

    This paper discusses on-going work in adaptive architectures concerning automatic adaptation rule derivation. Adaptation is rule-action based but deriving rules that meet the adaptation goals are tedious and error prone. We present an approach that uses model-driven derivation and training for automatically deriving adaptation rules, and exemplify this in an environment for scientific computing.

  • 4.
    Andersson, Jessica
    et al.
    Gothenburg Univ, Sweden.
    Larsson, Sofia
    Gothenburg Univ, Sweden.
    Ericsson, Morgan
    Gothenburg Univ, Sweden.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science. Linnaeus Univ, Vaxjo, Sweden..
    A Study of Demand-Driven Documentation in Two Open Source Projects2015In: 2015 48th Hawaii International Conference on System Sciences (HICSS), 2015, p. 5271-5279Conference paper (Refereed)
    Abstract [en]

    We investigate how demand-driven documentation is used by open source projects. Our study relies on questions and answers (i.e., demand-driven documentation) posted to Stack Overflow and focuses on two projects: Apache POI and Fennec (Firefox for Android). We find that the demand-driven documentation provided by respective community is of good quality and contributions are made within an acceptable amount of time. We conclude that demand-driven documentation can be suitable as a primary information source if other resources accompany it, e.g., websites. However, the suitability is closely related to size and activity of the project's community. We also investigate whether the type of project (e.g., API, application, product, etc.) matters, and find that given the nature of a forum, projects where the intended users are developers have larger and more active communities and are thus better suited for demand-driven documentation.

  • 5.
    Andersson, Jessica
    et al.
    Chalmers University of Technology.
    Larsson, Sofia
    Chalmers University of Technology.
    Ericsson, Morgan
    University of Gothenburg.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Quality of Demand-Driven Documentation2014In: Proceedings of the 37th Information Systems Research Seminar in Scandinavia / [ed] Ahmad Ghazawneh, Jacob Nørbjerg and Jan Pries-Heje, 2014Conference paper (Refereed)
    Abstract [en]

    In this case study we investigate how demand-driven documentation can be used in open source projects. The study relied on questions and answers (demand-driven documenta- tion) posted on Stack Overflow and studied two open source projects, Apache POI and Firefox for Android, in depth. We found that the demand driven documentation provided by the respec- tive community is in general of good quality and contributed within an acceptable amount of time. We conclude that demand driven documentation can be suitable as a primary information source if other resources accompany it. However, the suitability is closely related to the size and activity of the project’s community. 

  • 6.
    Andersson, Rikard
    et al.
    Chalmers University of Technology.
    Ericsson, Morgan
    University of Gothenburg.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Mining Relations from Git Commit Messages: an Experience Report2014In: Proceedings of the Fifth Swedish Language Technology Conference, 2014Conference paper (Refereed)
  • 7.
    Ericsson, Morgan
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering.
    Composition and Optimization2008Doctoral thesis, monograph (Other academic)
    Abstract [en]

    A recent trend in software engineering is to delay design decisions. One motivation is that requirements or properties of the application and environment are not known until later in the design and development process. This continues to hold for design decisions in a high-performance context where e.g., the number of processors is assigned late to applications and their components.

    In this thesis we present three case studies, ranging from Web Services and Grid computing to library design. In each of these case studies we study how performance requirements, and both properties of the application and the environment determine when design decisions can be made. We found that in many scenarios, design decisions have to be delayed, sometimes even until execution time.

    Based on our findings, we introduce context-aware composition, a composition technique that allows the designer to specify a set of variant implementations, a set of properties and goal criteria. The context-aware composition then composes the variants into a best fit application according to the goal criteria as well as application and environmental properties. The composition will happen automatically at the earliest possible time i.e., when enough information is available, either off-line or on-line. By using context-aware composition, developers can focus on the functional aspects of the application, and let the composition technique decide the delayed optimization decisions.

    We show that each of the cases studies is a special case of the context-aware composition. This makes context-aware composition a plausible solution to the problems solved in the case studies as well as other similar problems.

  • 8.
    Ericsson, Morgan
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Datalogi.
    The Effects of XML Compression on SOAP Performance2007In: World Wide Web: Internet and Web Information Systems, ISSN 1386-145x, Vol. 10, no 3, p. 279-307Article in journal (Other (popular science, discussion, etc.))
    Abstract [en]

    ML is the foundation of the SOAP protocol, and in turn, Web Service communication. This self-descriptive textual format for structured data is renowned to be verbose. This verbosity can cause problems due to communication and processing overhead in resource-constrained environments (e.g., small wireless devices). In this paper, we compare different binary representations of XML documents. To this end, we propose a multifaceted and reusable test suite based on real-world scenarios. Our main result is that only simple XML compression methods are suitable for a wide range of scenarios. While these simple methods do not match the compression ratios of more specialized ones, they are still competitive in most scenarios. We also show that there are scenarios that none of the evaluated methods can deal with efficiently.

  • 9.
    Ericsson, Morgan
    et al.
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Löwe, Welf
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Kessler, Chistoph
    Andersson, Jesper
    Växjö University, Faculty of Mathematics/Science/Technology, School of Mathematics and Systems Engineering. Computer Science.
    Composition and Optimization2008In: Proc. Int. Workshop on Component-Based High Performance Computing, 2008Conference paper (Refereed)
  • 10.
    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.

  • 11.
    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.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Probabilistic Quality Models to Improve Communication and Actionability2015In: 2015 30th IEEE/ACM International Conference on Automated Software Engineering Workshop (ASEW), IEEE: IEEE Press, 2015, p. 1-4Conference paper (Refereed)
    Abstract [en]

    We need to aggregate metric values to make quality assessment actionable. However, due to properties of metric values, i.e., unknown distributions and different measurement scales, they are difficult to aggregate. We present and evaluate a method to aggregate metric values based on observed numerical distributions that are converted into cumulative density functions. We use these to determine the probability of each metric and file, and aggregate these. Our limited study suggests that the method improves correctness, communication, and the ability to take action. However, more evaluation is required.

  • 12.
    Ericsson, Morgan
    et al.
    University of Gothenburg.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Mining job ads to find what skills are sought after from an employers' perspective on IT graduates2014In: Proceedings of the 2014 conference on Innovation & technology in computer science education, ACM Publications, 2014, p. 354-354Conference paper (Refereed)
    Abstract [en]

    We mine job ads to discover what skills are required from an employers' perspective. Some obvious trends appear, such as skills related to web and mobile technology. We aim to uncover more detailed information as the study continues to allow course content to better match the expressed needs.

  • 13.
    Ericsson, Morgan
    et al.
    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).
    TDMentions: A Dataset of Technical Debt Mentions in Online Posts2019In: 2019 IEEE/ACM INTERNATIONAL CONFERENCE ON TECHNICAL DEBT (TECHDEBT 2019), IEEE, 2019, p. 123-124Conference paper (Refereed)
    Abstract [en]

    The term technical debt is easy to understand as a metaphor, but can quickly grow complex in practice. We contribute with a dataset, TDMentions, that enables researchers to study how developers and end users use the term technical debt in online posts and discussions. The dataset consists of posts from news aggregators and Q&A-sites, blog posts, and issues and commits on GitHub.

  • 14.
    Ericsson, Morgan
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Wingkvist, Anna
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Löwe, Welf
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    A Software Infrastructure For Information Quality Assessment2011In: Proceedings of the International Conference on Information Quality, 2011Conference paper (Refereed)
    Abstract [en]

    Information quality assessment of technical documentation is nowadays an integral part of quality management of products and services. These are usually assessed using questionnaires, checklists, and reviews and consequently work that is cumbersome, costly and prone to errors. Acknowledging the fact that only humans can assess certain quality aspects, we suggest complementing these with automatic quality assessment using a software infrastructure that (i) reads information from documentations, (ii) performs analyses on this information, and (iii) visualizes the results to help stakeholders understand quality issues. We introduce the software infrastructure’s architecture and implementation, its adaptation to different formats of documentations and types of analyses, along with a number of real world cases exemplifying feasibility and benefit of our approach. Altogether, our approach contributes to more efficient and automatic information quality assessments. 

  • 15.
    Ericsson, Morgan
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Wingkvist, Anna
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Löwe, Welf
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    The Design and Implementation of a Software Infrastructure for IQ Assessment2012In: International Journal of Information Quality, ISSN 1751-0457, Vol. 3, no 1, p. 49-70Article in journal (Refereed)
    Abstract [en]

    Information quality assessment of technical documentation is an integral part of quality management of products and services. Technical documentation is usually assessed using questionnaires, checklists, and reviews. This is cumbersome, costly and prone to errors. Acknowledging the fact that only people can assess certain quality aspects, we suggest complementing these with software-supported automatic quality assessment. The many different encodings and representations of documentation, e.g., various XML dialects and XML Schemas/DTDs, is one problem. We present a system, a software infrastructure, where abstraction and meta modelling are used to define reusable analyses and visualisations that are independent of specific encodings and representations. We show how this system is implemented and how it: 1) reads information from documentations; 2) performs analyses on this information; 3) visualises the results to help stakeholders understand quality issues. We introduce the system, the architecture and implementation, its adaptation to different formats of documentations and types of analyses, along with a number of real world cases exemplifying the feasibility and benefits of our approach. Altogether, our approach contributes to more efficient information quality assessments.

     

  • 16.
    Ericsson, Morgan
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Wingkvist, Anna
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Löwe, Welf
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Visualization of Text Clones in Technical Documentation2012In: Proceedings of SIGRAD 2012: Interactive Visual Analysis of Data / [ed] Andreas Kerren and Stefan Seipel, 2012, p. 79-82Conference paper (Refereed)
    Abstract [en]

    An initial study of how text clones can be detected and visualized in technical documentation, i.e., semi-structured text that describe a product, software, or service. The goal of the visualizations is to support human experts to assess and prioritize the clones, since certain clones can be either intentional or harmless. We study some existing visualizations designed for source code, and provide initial and limited adaption of these. A major difficulty in this adaptation is to manage the semi-structured technical documentation compared to structured source code. 

  • 17.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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).
    A changeset-based approach to assess source code density and developer efficacy2018In: ICSE '18 Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings, IEEE, 2018, p. 220-221Conference paper (Refereed)
    Abstract [en]

    The productivity of a (team of) developer(s) can be expressed as a ratio between effort and delivered functionality. Several different estimation models have been proposed. These are based on statistical analysis of real development projects; their accuracy depends on the number and the precision of data points. We propose a data-driven method to automate the generation of precise data points. Functionality is proportional to the code size and Lines of Code (LoC) is a fundamental metric of code size. However, code size and LoC are not well defined as they could include or exclude lines that do not affect the delivered functionality. We present a new approach to measure the density of code in software repositories. We demonstrate how the accuracy of development time spent in relation to delivered code can be improved when basing it on net-instead of the gross-size measurements. We validated our tool by studying ca. 1,650 open-source software projects.

  • 18.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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).
    Bayesian Regression on segmented data using Kernel Density Estimation2019In: 5th annual Big Data Conference: Linnaeus University, Växjö, Sweden, 5-6 December 2019, Zenodo , 2019Conference paper (Other academic)
    Abstract [en]

    The challenge of having to deal with dependent variables in classification and regression using techniques based on Bayes' theorem is often avoided by assuming a strong independence between them, hence such techniques are said to be naive. While analytical solutions supporting classification on arbitrary amounts of discrete and continuous random variables exist, practical solutions are scarce. We are evaluating a few Bayesian models empirically and consider their computational complexity. To overcome the often assumed independence, those models attempt to resolve the dependencies using empirical joint conditional probabilities and joint conditional probability densities. These are obtained by posterior probabilities of the dependent variable after segmenting the dataset for each random variable's value. We demonstrate the advantages of these models, such as their nature being deterministic (no randomization or weights required), that no training is required, that each random variable may have any kind of probability distribution, how robustness is upheld without having to impute missing data, and that online learning is effortlessly possible. We compare such Bayesian models against well-established classifiers and regression models, using some well-known datasets. We conclude that our evaluated models can outperform other models in certain settings, using classification. The regression models deliver respectable performance, without leading the field.

  • 19.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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).
    Contextual Operationalization of Metrics as Scores: Is My Metric Value Good?2022In: Proceedings of the 2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS), IEEE, 2022, p. 333-343Conference paper (Refereed)
    Abstract [en]

    Software quality models aggregate metrics to indicate quality. Most metrics reflect counts derived from events or attributes that cannot directly be associated with quality. Worse, what constitutes a desirable value for a metric may vary across contexts. We demonstrate an approach to transforming arbitrary metrics into absolute quality scores by leveraging metrics captured from similar contexts. In contrast to metrics, scores represent freestanding quality properties that are also comparable. We provide a web-based tool for obtaining contextualized scores for metrics as obtained from one’s software. Our results indicate that significant differences among various metrics and contexts exist. The suggested approach works with arbitrary contexts. Given sufficient contextual information, it allows for answering the question of whether a metric value is good/bad or common/extreme.

  • 20.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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).
    Importance and Aptitude of Source code Density for Commit Classification into Maintenance Activities2019In: 2019 IEEE 19th International Conference on Software Quality, Reliability and Security (QRS) / [ed] Dr. David Shepherd, IEEE, 2019, p. 109-120Conference paper (Refereed)
    Abstract [en]

    Commit classification, the automatic classification of the purpose of changes to software, can support the understanding and quality improvement of software and its development process. We introduce code density of a commit, a measure of the net size of a commit, as a novel feature and study how well it is suited to determine the purpose of a change. We also compare the accuracy of code-density-based classifications with existing size-based classifications. By applying standard classification models, we demonstrate the significance of code density for the accuracy of commit classification. We achieve up to 89% accuracy and a Kappa of 0.82 for the cross-project commit classification where the model is trained on one project and applied to other projects. Such highly accurate classification of the purpose of software changes helps to improve the confidence in software (process) quality analyses exploiting this classification information.

  • 21.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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).
    Metrics As Scores: A Tool- and Analysis Suite and Interactive Application for Exploring Context-Dependent Distributions2023In: Journal of Open Source Software, E-ISSN 2475-9066, Vol. 8, no 88, article id 4913Article in journal (Refereed)
    Abstract [en]

    Metrics As Scores can be thought of as an interactive, multiple analysis of variance (abbr. "ANOVA," Chambers et al., 2017). An ANOVA might be used to estimate the goodness-of-fit of a statistical model. Beyond ANOVA, which is used to analyze the differences among hypothesized group means for a single quantity (feature), Metrics As Scores seeks to answer the question of whether a sample of a certain feature is more or less common across groups. This approach to data visualization and -exploration has been used previously (e.g., Jiang etal., 2022). Beyond this, Metrics As Scores can determine what might constitute a good/bad, acceptable/alarming, or common/extreme value, and how distant the sample is from that value, for each group. This is expressed in terms of a percentile (a standardized scale of [0, 1]), which we call score. Considering all available features among the existing groups furthermore allows the user to assess how different the groups are from each other, or whether they are indistinguishable from one another. The name Metrics As Scores was derived from its initial application: examining differences of software metrics across application domains (Hönel et al., 2022). A software metric is an aggregation of one or more raw features according to some well-defined standard, method, or calculation. In software processes, such aggregations are often counts of events or certain properties (Florac & Carleton, 1999). However, without the aggregation that is done in a quality model, raw data (samples) and software metrics are rarely of great value to analysts and decision-makers. This is because quality models are conceived to establish a connection between software metrics and certain quality goals (Kaner & Bond, 2004). It is, therefore, difficult to answer the question "is my metric value good?". With Metrics As Scores we present an approach that, given some ideal value, can transform any sample into a score, given a sample of sufficiently many relevant values. While such ideal values for software metrics were previously attempted to be derived from, e.g., experience or surveys (Benlarbi et al., 2000), benchmarks (Alves et al., 2010), or by setting practical values (Grady, 1992), with Metrics As Scores we suggest deriving ideal values additionally in non-parametric, statistical ways. To do so, data first needs to be captured in a relevant context (group). A feature value might be good in one context, while it is less so in another. Therefore, we suggest generalizing and contextualizing the approach taken by Ulan et al. (2021), in which a score is defined to always have a range of [0, 1] and linear behavior. This means that scores can now also be compared and that a fixed increment in any score is equally valuable among scores. This is not the case for raw features, otherwise. Metrics As Scores consists of a tool- and analysis suite and an interactive application that allows researchers to explore and understand differences in scores across groups. The operationalization of features as scores lies in gathering values that are context-specific (group-typical), determining an ideal value non-parametrically or by user preference, and then transforming the observed values into distances. Metrics As Scores enables this procedure by unifying the way of obtaining probability densities/masses and conducting appropriate statistical tests. More than 120 different parametric distributions (approx. 20 of which are discrete) are fitted through a common interface. Those distributions are part of the scipy package for the Python programming language, which Metrics As Scores makes extensive use of (Virtanen et al., 2020). While fitting continuous distributions is straightforward using maximum likelihood estimation, many discrete distributions have integral parameters. For these, Metrics As Scores solves a mixed-variable global optimization problem using a genetic algorithm in pymoo (Blank& Deb, 2020). Additionally to that, empirical distributions (continuous and discrete) and smooth approximate kernel density estimates are available. Applicable statistical tests for assessing the goodness-of-fit are automatically performed. These tests are used to select some best-fitting random variable in the interactive web application. As an application written in Python, Metrics As Scores is made available as a package that is installable using the PythonPackage Index (PyPI): pip install metrics-as-scores. As such, the application can be used in a stand-alone manner and does not require additional packages, such as a web server or third-party libraries.

    Download full text (pdf)
    fulltext
  • 22.
    Hönel, Sebastian
    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).
    Löwe, Welf
    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 source code density to improve the accuracy of automatic commit classification into maintenance activities2020In: Journal of Systems and Software, ISSN 0164-1212, E-ISSN 1873-1228, Vol. 168, p. 1-19, article id 110673Article in journal (Refereed)
    Abstract [en]

    Source code is changed for a reason, e.g., to adapt, correct, or adapt it. This reason can provide valuable insight into the development process but is rarely explicitly documented when the change is committed to a source code repository. Automatic commit classification uses features extracted from commits to estimate this reason.

    We introduce source code density, a measure of the net size of a commit, and show how it improves the accuracy of automatic commit classification compared to previous size-based classifications. We also investigate how preceding generations of commits affect the class of a commit, and whether taking the code density of previous commits into account can improve the accuracy further.

    We achieve up to 89% accuracy and a Kappa of 0.82 for the cross-project commit classification where the model is trained on one project and applied to other projects. Models trained on single projects yield accuracies of up to 93% with a Kappa approaching 0.90. The accuracy of the automatic commit classification has a direct impact on software (process) quality analyses that exploit the classification, so our improvements to the accuracy will also improve the confidence in such analyses.

  • 23.
    Kopetschny, Chris
    et al.
    Dezember IT GmbH, Germany.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Löwe, Welf
    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).
    Optimization of Software Estimation Models2019In: Proceedings of the 14th International Conference on Software Technologies - Volume 1 / [ed] VanSinderen, M; Maciaszek, L, SciTePress, 2019, p. 141-150Conference paper (Refereed)
    Abstract [en]

    In software engineering, estimations are frequently used to determine expected but yet unknown properties of software development processes or the developed systems, such as costs, time, number of developers, efforts, sizes, and complexities. Plenty of estimation models exist, but it is hard to compare and improve them as software technologies evolve quickly. We suggest an approach to estimation model design and automated optimization allowing for model comparison and improvement based on commonly collected data points. This way, the approach simplifies model optimization and selection. It contributes to a convergence of existing estimation models to meet contemporary software technology practices and provide a possibility for selecting the most appropriate ones.

    Download full text (pdf)
    fulltext
  • 24.
    Kovbasiuk, Igor
    et al.
    Softwerk.
    Löwe, Welf
    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.
    Quick Decide: A Tool to Aid the Analytic Hierarchy Process for Group Decisions2015In: Perspectives in Business Informatics Research: 14th International Conference, BIR 2015, Tartu, Estonia, August 26-28, 2015, Proceedings / [ed] Raimundas Matulevičius, Marlon Dumas, Springer: Springer, 2015, Vol. 229, p. 179-193Conference paper (Refereed)
    Abstract [en]

    To take simple decisions comes naturally and does not re- quire additional considerations but when there are multiple alternatives and criteria to be considered, a decision-making technique is required. The most studied and developed technique is the Analytic Hierarchy Process (AHP). We focus on the practical implementation of AHP and study the set of features that are necessary when the process involves several experts together with a set of non-functional requirements, such as portability and usability. Since no existing tool satisfy all our require- ments, we design and implement a new AHP tool called Quick Decide. We perform a user experiment to evaluate our tool, and find that it fulfils all our requirements. To support our usability requirements, we extend AHP with an external consistency check, which measures the distance between expert opinions to avoid results that are mathematically correct but provide no semantic value (e.g., two opposite extreme opinions). 

  • 25.
    Luckert, Michael
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Schaefer-Kehnert, Mortiz
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Löwe, Welf
    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.
    A Classifier to Determine Whether a Document is Professionally or Machine Translated2016In: PERSPECTIVES IN BUSINESS INFORMATICS RESEARCH, BIR 2016, Springer, 2016, p. 339-353Conference paper (Refereed)
    Abstract [en]

    In an increasingly networked world, the availability of high quality translations is critical for success, especially in the context of international competition. International companies need to provide well translated, high quality technical documentation not only to be successful in the market but also to meet legal regulations. We seek to evaluate translation quality, specifically concerning technical documentation, and formulate a method to evaluate the translation quality of technical documents both when we do have access to the original documents and when we do not. We rely on state-of-the-art machine learning algorithms and translation evaluation metrics in the context of a knowledge discovery process. Our evaluation is performed on a sentence level where each sentence is classified as either professionally translated or machine translated. The results for each sentence is then combined to evaluate the full document. The research is based on a database that contains 22,327 sentences and 32 translation evaluation attributes, which are used to optimize Decision Trees that are used to evaluate translation quality. Our method achieves an accuracy of 70.48% on sentence level for texts in the database and can accurately classify documents with at least 100 sentences.

  • 26.
    Martins, Rafael Messias
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ericsson, MorganLinnaeus University, Faculty of Technology, Department of computer science and media technology (CM).Weyns, DannyLinnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Katholieke Universiteit Leuven, Belgium.Kucher, KostiantynLinnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Linköping University, Sweden.
    Proceedings of the 2021 Swedish Workshop on Data Science (SweDS): Växjö, SwedenDecember 2–3, 20212021Conference proceedings (editor) (Refereed)
    Abstract [en]

    Welcome to the 9th Swedish Workshop on Data Science (SweDS21) held (virtually) in Växjö, Sweden during December 2–3, 2021. SweDS is a national event with a focus of maintaining and developing Swedish data science research and its applications by fostering the exchange of ideas and promoting collaboration within and across disciplines. This annual workshop brings together researchers and practitioners of data science working in a variety of academic, commercial, industrial, or other sectors. The current and past workshops have included presentations from a variety of domains, e.g., computer science, linguistics, eco- nomics, archaeology, environmental science, education, journalism, medicine, healthcare, biology, sociology, psychology, history, physics, chemistry, geography, forestry, design, and music. SweDS is hosted by Linnaeus University (Växjö, Sweden) this year. Due to the yet ongoing COVID-19 pandemic, travel restrictions, and public health concerns, the workshop is conducted online-only, which has allowed authors both within and outside of Sweden to submit and present their work. 

  • 27.
    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).
    A Preliminary Study on the Use of Key-words for Source Code to Architecture Mappings2021In: Companion Proceedings of the 15th European Conference on Software Architecture / [ed] Robert Heinrich, Raffaela Mirandola, Danny Weyns, CEUR-WS.org , 2021, Vol. 2978Conference paper (Refereed)
    Abstract [en]

    We implement an automatic mapper that can find the corresponding architectural module for a source code file. The mapperis based on multinomial naive Bayes, and it is trained using custom keywords for each architectural module. For prediction,the mapper uses the path and file name of source code elements. We find that the needed keywords often match the modulenames, but also that ambiguities and discrepancies exist. We evaluate the mapper using nine open-source systems and findthat the mapper can successfully create a mapping with perfect precision, but in most cases, it cannot cover all source codeelements. Other techniques can, however, use the mapping as a foothold and create further mappings.

    Download full text (pdf)
    fulltext
  • 28.
    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.

  • 29.
    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).
    Hard Cases in Source Code to Architecture Mapping using Naive Bayes2021In: Companion Proceedings of the 15th European Conference on Software Architecture: ECSA 2021 Companion Volume Virtual (originally: Växjö, Sweden), 13-17 September, 2021 / [ed] Robert Heinrich, Raffaela Mirandola, Danny Weyns, CEUR-WS.org , 2021Conference paper (Refereed)
    Abstract [en]

    The automatic mapping of source code entities to architectural modules is a challenging problem that is necessary to solve if we want to increase the use of Static Architecture Conformance Checking in the industry. We apply the state-of-the-art automatic mapping technique to eight open-source systems and find that there are systematic problems in the automatically created mappings. All of these eight systems have small modules that are very hard to map correctly since only a few source code entities are mapped to these. All systems seem to use some naming strategy, mapping source code to modules; however, naming is often ambiguous. We also find differences in ground truth mappings performed by experts, which affect mappings based on these, and that architectural refactoring also affects the mapping performance. 

    Download full text (pdf)
    fulltext
  • 30.
    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).
    Mapping Source Code to Modular Architectures Using Keywords2022In: Software Architecture. ECSA 2021 / [ed] Scandurra, P., Galster, M., Mirandola, R., Weyns, D., Springer, 2022, p. 65-85Conference paper (Refereed)
    Abstract [en]

    We implement an automatic mapper that can find the corresponding architectural module for a source code file. The mapper is based on multinomial naive Bayes, and it is trained using custom keywords for each architectural module. The mapper uses the path and file name of source code elements for prediction. We find that the needed keywords often match the module names; however, ambiguities and discrepancies exist. We evaluate the mapper using ten open-source systems with a mapping to an intended architecture and find that the mapper can successfully create a mapping with perfect precision. Still, it cannot cover all source code elements in most cases. However, other techniques can use the mapping as a foothold and automatically create further mappings. We also apply the approach to two cases where the architecture has been recovered from the implementation and find that the approach currently has limitations of applicability in such architectures. 

  • 31.
    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.

  • 32.
    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).
    Optimized Dependency Weights in Source Code Clustering2021In: Software Architecture, ECSA 2021 / [ed] Biffl, S Navarro, E Lowe, W Sirjani, M Mirandola, R Weyns, D, Springer, 2021, Vol. 12857, p. 223-239Conference paper (Refereed)
    Abstract [en]

    Some methods use the dependencies between source code entities to perform clustering to, e.g., automatically map to an intended modular architecture or reconstruct the implemented software architecture. However, there are many different ways that source code entities can depend on each other in an object-oriented system, and it is not likely that all dependencies are equally useful. We investigate how well an optimized set of weights for 14 different types of dependencies perform when automatically mapping source code to modules using an established mapping technique. The optimized weights were found using genetic optimization. We compare the F1 score of precision and recall to uniform weights and weights computed by module relation ratio in eight open-source systems to evaluate performance. Our experiments show that optimized weights significantly outperform the others, especially in systems that seem not to have been designed using the low coupling, high cohesion principle. We also find that dependencies based on method calls are not useful for automatic mapping in any of the eight systems.

  • 33.
    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).
    Optimized Machine Learning Input for Evolutionary Source Code to Architecture Mapping2023In: Software Architecture. ECSA 2022 Tracks and Workshops. ECSA 2022 / [ed] Batista, T., Bureš, T., Raibulet, C., Muccini, H., Springer, 2023, p. 421-435Conference paper (Refereed)
    Abstract [en]

    Automatically mapping source code to architectural modules is an interesting and difficult problem. Mapping can be considered a classification problem, and machine learning approaches have been used to automatically generate mappings. Feature engineering is an essential element of machine learning. We study which source code features are important for an algorithm to function effectively. Additionally, we examine stemming and data cleaning. We systematically evaluate various combinations of features on five datasets created from JabRef, TeamMates, ProM, and two Hadoop subsystems. The systems are open-source with well-established mappings. We find that no single set of features consistently provides the highest performance, and even the subsystems of Hadoop have varied optimal feature combinations. Stemming provided minimal benefit, and cleaning the data is not worth the effort, as it also provided minimal benefit.

  • 34.
    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).
    s4rdm3x: A Tool Suite to Explore Code to ArchitectureMapping Techniques2021In: Journal of Open Source Software, E-ISSN 2475-9066, Vol. 6, no 58, article id 2791Article in journal (Refereed)
    Abstract [en]

    Architectural drift and erosion, where the implementation starts to deviate from the intended software architecture or the rules set by it, are common problems in long-lived software systems. This can be avoided by using techniques, such as Reflexion modeling, to validate that the implementation conforms to the indented architecture. Unfortunately, such techniques require a mapping from source code modules (e.g., classes) to elements of the architecture, something that is not always available or up to date. This is a known problem when, e.g., companies want to adopt static architecture conformance checking; the effort to manually create or bring this mapping up to date is just too time-consuming and error-prone. The s4rdm3x tool suite is designed for researchers and practitioners to study and evaluate algorithms that perform part of the mapping automatically, such as orphan-adoption clustering or information retrieval techniques. It includes a graphical user interface to define and run experiments with mapping algorithms and their parameters, and visualize and explore the results of these experiments. The experiments can be executed locally or in a remote high-performance computing environment. The tool suite includes reference implementations of state of the art mapping algorithms and a set of Java systems with validated mappings between classes and architecture elements. The tool suite is extensible, so it is easy to add new mapping algorithms and visualizations to explore their performance. 

    Download full text (pdf)
    fulltext
  • 35.
    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.

  • 36.
    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).
    Studying expert initial set and hard to map cases in automated code-to-architecture mappings2021In: Companion Proceedings of the 15th European Conference on Software Architecture: ECSA 2021 Companion VolumeVirtual (originally: Växjö, Sweden), 13-17 September, 2021 / [ed] Heinrich R., Heinrich R. and Weyns D., CEUR-WS , 2021Conference paper (Refereed)
    Abstract [en]

    We study the mapping of software source code to architectural modules. Background: To evaluate techniques for performing automatic mapping of code-to-architecture, a ground truth mapping, often provided by an expert, is needed. From this ground truth, techniques use an initial set of mapped source code as a starting point. The size and composition of this set affect the techniques’ performance, and to make comparisons, random sizes and compositions are used. However, while randomness will give a baseline for comparison, it is not likely that a human expert would compose an initial set on random to map source code. We are interested in letting an expert create an initial set based on their experience with the system and study how this affects how a technique performs. Also, previous research has shown that when comparing an automatic mapping with the ground truth mappings, human experts often accept the automated mappings and, if not, point to the need for refactoring the source code. We want to study this phenomenon further. Audience: Researchers and developers of tools in the area of architecture conformance. The system expert can gain valuable insights into where the source code needs to be refactored. Aim: We hypothesize that an initial set assigned by an expert performs better than a random initial set of similar size and that an expert will agree upon or find opportunities for refactoring in a majority of cases where the automatic mapping and expert mapping disagrees. Method: The initial set will be extracted from an interview with the expert. Then the performance (precision and recall f1 score) will be compared to mappings starting from random initial sets and using an automatic technique. We will also use our tool to find the cases where the automatic and human mapping disagrees and then let the expert review these cases. Results: We expect to find a difference when performance is compared. We expect the expert review to reveal source code that should be remapped, source code that needs refactoring (e.g., possible architectural violations), and points where the automatic technique needs to be improved. Limitations: The study will only focus on only a single system, which limits the external validity significantly. The protocol for the interaction with the human expert can also introduce validity problems; for example, a mapping presented by an algorithm could be perceived as more objective and thus more acceptable for a software engineer. Conclusions: We seek to improve our understanding of how a human creates an initial set for automatic mapping and its effect on how well an automated mapping technique performs. By improving the ground truth mappings, we can improve our techniques, tools, and methods for architecture conformance checking.

    Download full text (pdf)
    fulltext
  • 37.
    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.

    Download full text (pdf)
    fulltext
  • 38.
    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).
    To automatically map source code entities to architectural modules with Naive Bayes2022In: Journal of Systems and Software, ISSN 0164-1212, E-ISSN 1873-1228, Vol. 183, article id 111095Article in journal (Refereed)
    Abstract [en]

    Background: The process of mapping a source code entity onto an architectural module is to a large degree a manual task. Automating this process could increase the use of static architecture conformance checking methods, such as reflexion modeling, in industry. Current techniques rely on user parameterization and a highly cohesive design. A machine learning approach would potentially require fewer parameters and better use of the available information to aid in automatic mapping.

    Aim: We investigate how a classifier can be trained to map from source code to architecture modules automatically. This classifier is trained with semantic and syntactic dependency information extracted from the source code and from architecture descriptions. The classifier is implemented using multinomial naive Bayes and evaluated.

    Method: We perform experiments and compare the classifier with three state-of-the-art mapping functions in eight open-source Java systems with known ground-truth-mappings.

    Results: We find that the classifier outperforms the state-of-the-art in all cases and that it provides a useful baseline for further research in the area of semi-automatic incremental clustering.

    Conclusions: We conclude that machine learning is a useful approach that performs better and with less need for parameterization compared to other approaches. Future work includes investigating problematic mappings and a more diverse set of subject systems.

    Download full text (pdf)
    fulltext
  • 39.
    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.

  • 40.
    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.

  • 41.
    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.

  • 42.
    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.

  • 43.
    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.

  • 44.
    Picha, Petr
    et al.
    University of Western Bohemia, Czech Republic.
    Hönel, Sebastian
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Brada, Premek
    University of Western Bohemia, Czech Republic.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Löwe, Welf
    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).
    Danek, Jakub
    University of Western Bohemia, Czech Republic.
    Process anti-pattern detection: a case study2022In: Proceedings of the 27th European Conference on Pattern Languages of Programs, EuroPLop 2022, Irsee, Germany, July 6-10, 2022, ACM Publications, 2022, p. 1-18, article id 5Conference paper (Refereed)
    Abstract [en]

    Anti-patterns are harmful phenomena repeatedly occurring, e.g., in software development projects. Though widely recognized and well-known, their descriptions are traditionally not fit for automated detection. The detection is usually performed by manual audits, or on business process models. Both options are time-, effort- and expertise-heavy, prone to biases, and/or omissions. Meanwhile, collaborative software projects produce much data as a natural side product, capturing their status and day-to-day history. Long-term, our research aims at deriving models for the automated detection of process and project management anti-patterns, applicable to project data. Here, we present a general approach for studies investigating occurrences of these types of anti-patterns in projects and discuss the entire process of such studies in detail, starting from the anti-pattern descriptions in literature. We demonstrate and verify our approach with the Fire Drill anti-pattern detection as a case study, applying it to data from 15 student projects. The results of our study suggest that reliable detection of at least some process and project management anti-patterns in project data is possible, with 13 projects assessed accurately for Fire Drill presence by our automated detection when compared to the ground truth gathered from independent data. The overall approach can be similarly applied to detecting patterns and other phenomena with manifestations in Application Lifecycle Management data.

  • 45.
    Shpak, Oleksandr
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Löwe, Welf
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Wingkvist, Anna
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    A Method to Test the Information Quality of Technical Documentation on Websites2014In: 14th International Conference on Quality Software (QSIC), IEEE Press, 2014, p. 296-304Conference paper (Refereed)
    Abstract [en]

    In software engineering, testing is one of the corner-stones of quality assurance. The idea of software testing can be applied to information quality as well. Technical documentation has a set of intended uses that correspond to use cases in a software system. Documentation is, in many cases, presented via software systems, e.g., web servers and browsers, and contains software, e.g., Javascript for user interaction, animation, and customization, etc. This makes it difficult to find a clear-cut distinction between a software system and technical documentation. However, we can assume that each use case of a technical documentation involves retrieval of some sort of information that helps a user answer a specific questions. To assess information testing as a method, we implemented QAnalytics, a tool to assess the information quality of documentation that is provided by a website. The tool is web-based and allows test managers and site owners to define test cases and success criteria, disseminate the test cases to testers, and to analyze the test results. This way, information testing is easily manageable even for non-technical stakeholders. We applied our testing method and tool in a case study. According to common perception, the website of Linnaeus University needs to be re-engineered. Our method and tool helped the stakeholders identify what information is presented well and which parts of the website that need to change. The test results allowed the design and development effort to prioritize actual quality issues and potentially save time and resources.

  • 46.
    Steghöfer, Jan-Philipp
    et al.
    Chalmers University of Technology, Sweden;University of Gothenburg, Sweden.
    Knauss, Eric
    Chalmers University of Technology, Sweden;University of Gothenburg, Sweden.
    Alégroth, Emil
    Chalmers University of Technology, Sweden;University of Gothenburg, Sweden.
    Hammouda, Imed
    Chalmers University of Technology, Sweden;University of Gothenburg, Sweden.
    Burden, Håkan
    Viktoria Swedish ICT, Sweden.
    Ericsson, Morgan
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science.
    Teaching Agile: addressing the conflict between project delivery and application of Agile methods2016In: Proceedings of the 38th International Conference on Software Engineering Companion, ACM Publications, 2016, p. 303-312Conference paper (Refereed)
    Abstract [en]

    This paper analyses the changes we have made in teaching agile methodologies, practices, and principles in four courses in order to address a specific dilemma: students need to apply agile methods in order to learn them, but when complementing our courses with applied content, we face the problem that students perceive the learning and application of agile methods as less important than delivering a finished product at the end of the course. This causes students to not apply theoretical process knowledge and therefore to not develop necessary skills associated with working with defined processes in the industry. Concretely, we report on our experience with teaching Scrum with Lego, removing formal grading requirements on the delivered product, emphasising process application in post-mortem reports, and organisational changes to support the process during supervision. These changes are analysed in the context of student satisfaction, teacher observations, and achievements of learning outcomes. We also provide an overview of the lessons learnt to help guide the design of courses on agile methodologies.

  • 47.
    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.
    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.

  • 48.
    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.

  • 49.
    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.

  • 50.
    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. 

12 1 - 50 of 81
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • 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