Change search
Refine search result
1 - 13 of 13
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.
    Tanveer, Binish
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Zabardast, Ehsan
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    An approach to align socio-technical dependencies in large-scale software development2023In: Proceedings - IEEE 20th International Conference on Software Architecture Companion, ICSA-C 2023, Institute of Electrical and Electronics Engineers (IEEE), 2023, p. 341-347Conference paper (Refereed)
    Abstract [en]

    Seeking the advantages delivered by agile methods in small-scale software development, large organisations are also adopting agile methods. However, scaling results in a huge growth of socio-technical dependencies that can lead to waiting time, delays, and defects and hinder the teams' ability to recognize their own responsibilities. This research proposes an approach to enable teams' autonomy and clarifies teams' responsibility assignments by aligning socio-technical dependencies. By utilising compile-time, run-time, and task dependencies, our approach identifies the wasteful dependencies between the social structures (teams) and the corresponding technical structures (architecture) and also suggests improvements. The initial results suggest that the approach correctly identifies the wasteful dependencies that are hindering teams' responsibility assignments. The suggested solution proposals are also considered useful. Awareness of such wasteful dependencies is the first step toward being able to handle them successfully. © 2023 IEEE.

    Download full text (pdf)
    fulltext
  • 2.
    Zabardast, Ehsan
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Towards Understanding Assets in Software Engineering2021Licentiate thesis, comprehensive summary (Other academic)
    Abstract [en]

    The development of software products is a massive undertaking, and organisations have to manage all artefacts involved in the process. Managing such artefacts that, in many cases, become crucial assets is important for success. Recognising assets and letting them (unintentionally) degrade can result in maintainability problems. Thus, there is a need to create a structured and organised body of knowledge that can guide practitioners and researchers to deal with the assets during the product/service life-cycle. This includes, but is not limited to, what steps are needed to understand the assets’ degradation, investigating and examining the existing methods and metrics on how to estimate degradation and understanding the implication of assets’ value and degradation.

    This licentiate’s main objective is contributing to the software engineering field by providing a different perspective on assets focusing on assets’ value for the organisation. We have used literature reviews, focus groups, case study, and sample study to address this objective. The collected data is from peer-reviewed work, collaboration with five company partners, and 31 OSS from Apache Foundation.

    First, we have defined the concept and terminology in a position paper. We havecreated an asset management taxonomy based on a literature review and focus groups– fours focus groups conducted in 2019 with 29 participants. The extracted assets represent not only the stages of software development, from requirements to verificationand validation, but also operational and organisational perspectives. The taxonomy wascreated to be extendable as the field evolves and matures.

    Then, we have performed a more in-depth investigation of selected asset types. As a part of studying assets, in a case study, we present the impact of bug-fixing,refactorings, and new development to investigate how source code degrades. In anothersample study, we examine the longevity of specific source-code related issues in 31OSS from Apache Foundation using statistical analysis.

    The work done in this licentiate includes: defining the asset concept and relatedterminology, identifying assets and creating a taxonomy of assets, presenting the preliminary investigation of tools and methods to understand source-code and architecturerelated asset degradation.

    We conclude that a good understanding of the relevant assets for the inception,planning, development, evolution, and maintenance of software-intensive products andservices is necessary to study their value degradation. Our work builds on currentmethods and details the underlying concepts attempting to homogenise definitions andbring the areas of assets and degradation together. A natural progression of our workis to investigate the measurements to evaluate the degradation of assets. This licentiate thesis starts investigating the value degradation of source-code related assets. We planto continue investigating the degradation of architecture in our future work.

    Download full text (pdf)
    fulltext
  • 3.
    Zabardast, Ehsan
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Understanding Asset Degradation in Software Engineering2023Doctoral thesis, comprehensive summary (Other academic)
    Abstract [en]

    Background: As software is everywhere, and almost every company has nowadays a dependency on software, designing and developing software-intensive products or services has become significantly challenging and time-consuming. The challenges are due to the continuous growth of the size and complexity of software and the fast pace of change. It is important that software-developing organisations’ engineering practices adapt to the rising challenges by adopting well-engineered development activities. Organisations deal with many software artefacts, some of which are more relevant for the organisation. We define Software Assets as artefacts intended to be used more than once. Given softwared evelopment’s continuous and evolutionary aspect, the assets involved degrade over time. Organisations need to understand what assets are relevant and how they degrade to exercise quality control over software assets. Asset degradation is inevitable, and it may manifest in different ways. 

    Objective: The main objective of this thesis is: (i) to contribute to the software engineering body of knowledge by providing an understanding of what assets are and how they degrade; and (ii) to gather empirical evidence regarding asset degradation and different factors that might impact it on industrial settings. 

    Method: To achieve the thesis goals, several studies have been conducted. The collected data is from peer-reviewed literature and collaboration with five companies that included extracting archival data from over 20 million LOC and archival data from open-source repositories. 

    Results: The first contribution of this thesis is defining the concept of assets and asset degradation in a position paper. We aim to provide an understanding of software assets and asset degradation and its impact on software development.  Additionally, a taxonomy of assets is created using academic and industrial input. The taxonomy includes 57 assets and their categories. To further investigate the concept of asset degradation, we have conducted in-depth analyses of multiple industrial case studies on selected assets. This thesis presents results to provide evidence on the impact of different factors on asset degradation, including: (I) how the accumulation of technical debt is affected by different development activities; (ii) how degradation ‘survives’; and (iii) how working from home or the misalignment between ownership and contribution impacts the faster accumulation of asset degradation. Additionally, we created a model to calculate the degree of the alignment between ownership and contribution to code. 

    Conclusion: The results can help organisations identify and understand the relevant software assets and characterize their quality degradation. Understanding how assets degrade and which factors might impact their faster accumulation is the first step to conducting sufficient and practical asset management activities. For example, by engaging (i) proactively in preventing uncontrolled growth of degradation (e.g., aligning ownership and contribution); and (ii) reactively in prioritizing mitigation strategies and activities (focusing on recently introducing TD items).

    Download full text (pdf)
    fulltext
  • 4.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Bennin, Kwabena Ebo
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering. Wageningen Univ & Res, NLD.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Further Investigation of the Survivability of Code Technical Debt Items2022In: JOURNAL OF SOFTWARE-EVOLUTION AND PROCESS, ISSN 2047-7473, Vol. 34, no 2, article id e2425Article in journal (Refereed)
    Abstract [en]

    Context: Technical Debt (TD) discusses the negative impact of sub-optimal decisions to cope with the need-for-speed in software development. Code Technical Debt Items (TDI) are atomic elements of TD that can be observed in code artifacts. Empirical results on open-source systems demonstrated how code-smells, which are just one type of TDIs, are introduced and "survive" during release cycles. However, little is known about whether the results on the survivability of code-smells hold for other types of code TDIs (i.e., bugs and vulnerabilities) and in industrial settings.Goal: Understanding the survivability of code TDIs by conducting an empirical study analyzing two industrial cases and 31 open-source systems from Apache Foundation. Method: We analyzed 144,476 code TDIs (35,372 from the industrial systems) detected by Sonarqube (in 193,196 commits) to assess their survivability using survivability models.Results: In general, code TDIs tend to remain and linger for long periods in open-source systems, whereas they are removed faster in industrial systems. Code TDIs that survive over a certain threshold tend to remain much longer, which confirms previous results. Our results also suggest that bugs tend to be removed faster, while code smells and vulnerabilities tend to survive longer.

    Download full text (pdf)
    fulltext
  • 5.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Frattini, Julian
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Mendez, Daniel
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gorschek, Tony
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Asset Management in Software Engineering: What is it after all?2021Manuscript (preprint) (Other academic)
    Abstract [en]

    When developing and maintaining software-intensive products or services, we often depend on various "assets", denoting the inherent value to selected artefacts when carrying out development and maintenance activities. When exploring various areas in Software Engineering, such as Technical Debt and our work with industry partners, we soon realised that many terms and concepts are frequently intermixed and used inconsistently. Despite the central role of assets to software engineering, management, and evolution, little thoughts are yet invested into what assets eventually are. A clear terminology of "assets" and related concepts, such as "value" or "value degradation", just to name two, are crucial for setting up effective software engineering practices.

    As a starting point for our own work, we had to define the terminology and concepts, and extend the reasoning around the concepts. In this position paper, we critically reflect upon the resulting notion of Assets in Software Engineering. We explore various types of assets, their main characteristics, such as providing inherent value. We discuss various types of value degradation and the possible implications of this on the planning, realisation, and evolution of software-intensive products and services over time. 

    Download full text (pdf)
    fulltext
  • 6.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Frattini, Julian
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Mendez, Daniel
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gorschek, Tony
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Wnuk, Krzysztof
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Assets in Software Engineering: What are they after all?2022In: Journal of Systems and Software, ISSN 0164-1212, E-ISSN 1873-1228, Vol. 193, article id 111485Article, review/survey (Refereed)
    Abstract [en]

    During the development and maintenance of software-intensive products or services, we depend on various artefacts. Some of those artefacts, we deem central to the feasibility of a project and the product's final quality. Typically, these central artefacts are referred to as assets. However, despite their central role in the software development process, little thought is yet invested into what eventually characterises as an asset, often resulting in many terms and underlying concepts being mixed and used inconsistently. A precise terminology of assets and related concepts, such as asset degradation, are crucial for setting up a new generation of cost-effective software engineering practices. In this position paper, we critically reflect upon the notion of assets in software engineering. As a starting point, we define the terminology and concepts of assets and extend the reasoning behind them. We explore assets’ characteristics and discuss what asset degradation is as well as its various types and the implications that asset degradation might bring for the planning, realisation, and evolution of software-intensive products and services over time. We aspire to contribute to a more standardised definition of assets in software engineering and foster research endeavours and their practical dissemination in a common, more unified direction. © 2022 The Authors

    Download full text (pdf)
    fulltext
  • 7.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gorschek, Tony
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Šmite, Darja
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Alégroth, Emil
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Fagerholm, Fabian
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    A taxonomy of assets for the development of software-intensive products and services2023In: Journal of Systems and Software, ISSN 0164-1212, E-ISSN 1873-1228, Vol. 202, article id 111701Article in journal (Refereed)
    Abstract [en]

    Context:Developing software-intensive products or services usually involves a plethora of software artefacts. Assets are artefacts intended to be used more than once and have value for organisations; examples include test cases, code, requirements, and documentation. During the development process, assets might degrade, affecting the effectiveness and efficiency of the development process. Therefore, assets are an investment that requires continuous management.

    Identifying assets is the first step for their effective management. However, there is a lack of awareness of what assets and types of assets are common in software-developing organisations. Most types of assets are understudied, and their state of quality and how they degrade over time have not been well-understood.

    Methods:We performed an analysis of secondary literature and a field study at five companies to investigate and identify assets to fill the gap in research. The results were analysed qualitatively and summarised in a taxonomy.

    Results:We present the first comprehensive, structured, yet extendable taxonomy of assets, containing 57 types of assets.

    Conclusions:The taxonomy serves as a foundation for identifying assets that are relevant for an organisation and enables the study of asset management and asset degradation concepts.

    Download full text (pdf)
    fulltext
  • 8.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gorschek, Tony
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Šmite, Darja
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Alégroth, Emil
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Fagerholm, Fabian
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Asset Management Taxonomy: A Roadmap2021Manuscript (preprint) (Other academic)
    Abstract [en]

    Developing a software-intensive product or service can be a significant undertaking, associated with unique challenges in each project stage, from inception to development, delivery, maintenance, and evolution. Each step results in artefacts that are crucial for the project outcome, such as source-code and supporting deliverables, e.g., documentation.

    Artefacts which have inherent value for the organisation are assets, and as assets, they are subject to degradation. This degradation occurs over time, as artefacts age, and can be more immediate or slowly over a period of time, similar to the concept of technical debt. One challenge with the concept of assets is that it seems not to be well-understood and generally delimited to a few types of assets (often code-based), overlooking other equally important assets. 

    To bridge this gap, we have performed a study to formulate a structured taxonomy of assets. We use empirical data collected through industrial workshops and a literature review to ground the taxonomy. The taxonomy serves as foundations for concepts like asset degradation and asset management. The taxonomy can help contextualise, homogenise, extend the concept of technical debt, and serves as a conceptual framework for better identification, discussion, and utilisation of assets.

    Download full text (pdf)
    fulltext
  • 9.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Palma, Francis
    Linnaeus University.
    The Impact of Forced Working-From-Home on Code Technical Debt: An Industrial Case Study2022In: Proceedings - 48th Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2022 / [ed] Callico G.M., Hebig R., Wortmann A., Institute of Electrical and Electronics Engineers (IEEE), 2022, p. 298-305Conference paper (Refereed)
    Abstract [en]

    Background: The COVID-19 outbreak interrupted regular activities for over a year in many countries and resulted in a radical change in ways of working for software development companies, i.e., most software development companies switched to a forced Working-From-Home (WFH) mode. Aim: Although several studies have analysed different aspects of forced WFH mode, it is unknown whether and to what extent WFH impacted the accumulation of technical debt (TD) when developers have different ways to coordinate and communicate with peers. Method: Using the year 2019 as a baseline, we carried out an industrial case study to analyse the evolution of TD in five components that are part of a large project while WFH. As part of the data collection, we carried out a focus group with developers to explain the different patterns observed from the quantitative data analysis. Results: TD accumulated at a slower pace during WFH as compared with the working-from-office period in four components out of five. These differences were found to be statistically significant. Through a focus group, we have identified different factors that might explain the changes in TD accumulation. One of these factors is responsibility diffusion which seems to explain why TD grows faster during the WFH period in one of the components. Conclusion: The results suggest that when the ways of working change, the change between working from office and working from home does not result in an increased accumulation of TD. © 2022 IEEE.

    Download full text (pdf)
    fulltext
  • 10.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Palma, Francis
    Chatzipetrou, Panagiota
    The Impact of Ownership and Contribution Alignment on Code Technical Debt AccumulationManuscript (preprint) (Other academic)
  • 11.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Tanveer, Binish
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Ownership vs Contribution: Investigating the Alignment between Ownership and Contribution2022In: IEEE 19th International Conference on Software Architecture Companion, ICSA-C 2022, Institute of Electrical and Electronics Engineers (IEEE), 2022, p. 30-34Conference paper (Refereed)
    Abstract [en]

    Software development is a collaborative endeavour. Organisations that develop software assign modules to different teams, i.e., teams own their modules and are responsible for them. These modules are rarely isolated, meaning that there exist dependencies among them. Therefore, other teams might often contribute to developing modules they do not own. The contribution can be, among other types, in the form of code authorship, code review, and issue detection. This research presents a model to investigate the alignment between module ownership and contribution and the preliminary results of an industrial case study to evaluate the model in practice. Our model uses seven metrics to assess teams' contributions. Initial results suggest that the model correctly identifies misalignment between ownership and contribution. The detection of misalignment between ownership and contribution is the first step towards investigating the impact it might have on the faster accumulation of Technical Debt. © 2022 IEEE.

    Download full text (pdf)
    fulltext
  • 12.
    Zabardast, Ehsan
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Šmite, Darja
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Refactoring, Bug Fixing, and New Development Effect on Technical Debt: An Industrial Case Study2020In: Proceedings - 46th Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2020 / [ed] Martini A.,Wimmer M.,Skavhaug A., Institute of Electrical and Electronics Engineers Inc. , 2020, p. 376-384, article id 9226289Conference paper (Refereed)
    Abstract [en]

    Code evolution, whether related to the development of new features, bug fixing, or refactoring, inevitably changes the quality of the code. One particular type of such change is the accumulation of Technical Debt (TD) resulting from sub-optimal design decisions. Traditionally, refactoring is one of the means that has been acknowledged to help to keep TD under control. Developers refactor their code to improve its maintainability and to repay TD (e.g., by removing existing code smells and anti-patterns in the source code). While the accumulation of the TD and the effect of refactoring on TD have been studied before, there is a lack of empirical evidence from industrial projects on how the different types of code changes affect the TD and whether specific refactoring operations are more effective for repaying TD. To fill this gap, we conducted an empirical study on an industrial project and investigated how Refactoring, Bug Fixing, and New Development affect the TD. We have analyzed 2, 286 commits in total to identify which activities reduced, kept the same, or even increased the TD, further delving into specific refactoring operations to assess their impact. Our results suggest that TD in the studied project is mainly introduced in the development of new features (estimated in 72.8 hours). Counterintuitively, from the commits tagged as refactoring, only 22.90% repay TD (estimated to repay 8.30 hours of the TD). Moreover, while some types of refactoring operations (e.g., Extract Method), help repaying TD, other refactoring operations (e.g., Move Class) are highly prone to introduce more TD. © 2020 IEEE.

    Download full text (pdf)
    fulltext
  • 13.
    Šāblis, Aivars
    et al.
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Gonzalez-Huerta, Javier
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Zabardast, Ehsan
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Šmite, Darja
    Blekinge Institute of Technology, Faculty of Computing, Department of Software Engineering.
    Building lego towers: An exercise for teaching the challenges of global work2019In: ACM Transactions on Computing Education, E-ISSN 1946-6226, Vol. 19, no 2, article id a15Article in journal (Refereed)
    Abstract [en]

    Global software engineering has changed the way software is developed today. To address the new challenges, many universities have launched specially tailored courses to train young professionals to work in globally distributed projects. However, a mere acknowledgment of the geographic, temporal, and cultural differences does not necessarily lead to a deep understanding of the underlying practical implications. Therefore, many universities developed alternative teaching and learning activities, such as multi-university collaborative projects and small-scale simulations or games. In this article, we present a small-scale exercise that uses LEGO bricks to teach skills necessary for global work. We describe the many different interventions that could be implemented in the execution of the exercise. We had seven runs of the exercises and report our findings from executing seven runs of the exercise with the total of 104 students from five different courses in two different universities. Our results suggest that the exercise can be a valuable tool to help students dealing with troublesome knowledge associated with global software engineering and a useful complement to the courses dedicated to this subject. © 2019 Copyright is held by the owner/author(s)

1 - 13 of 13
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