Reference Type:  Conference Paper
Record Number: 8110
Author: Verlage, Martin
Year: 1996
Title: About views for modeling software processes in a role-specific manner
Conference Name: Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops
Conference Location: San Francisco, California, USA
Publisher: ACM
Pages: 280-284
DOI: 10.1145/243327.243681
Place Published: 243681


Reference Type:  Conference Paper
Record Number: 7983
Author: Wagner, Stefan and Deissenboeck, Florian
Year: 2008
Title: Abstractness, specificity, and complexity in software design
Conference Name: Proceedings of the 2nd international workshop on The role of abstraction in software engineering
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 35-42
DOI: 10.1145/1370164.1370173
Place Published: 1370173
Abstract: Abstraction is one of the fundamental concepts of software design. Consequently, the determination of an appropriate abstraction level for the multitude of artefacts that form a software system is an integral part of software engineering. However, the very nature of abstraction in software design and particularly its interrelation with equally important concepts like complexity, specificity or genericity are not fully understood today. As a step towards a better understanding of the trade-offs involved, this paper proposes a distinction of abstraction into two types that have different effects on the specificity and the complexity of artefacts. We discuss the roles of the two types of abstraction in software design and explain the interrelations between abstractness, specificity, and complexity. Furthermore, we illustrate the benefit of the proposed distinction with multiple examples and describe consequences of our findings for software design activities.


Reference Type:  Journal Article
Record Number: 8704
Author: Christiaans, Henri and Almendra, Rita Assoreira
Year: 2010
Title: Accessing decision-making in software design
Journal: Design Studies
Volume: 31
Issue: 6
Pages: 641-662
Date: 11//
Short Title: Accessing decision-making in software design
ISSN: 0142-694X
DOI: https://doi.org/10.1016/j.destud.2010.09.005
Keywords: decision-making
design process
design behaviour
design cognition
Abstract: This paper presents an analysis of software design protocols as one of the contributions to the 2010 international workshop ‘Studying Professional Software Design’. The aim of the study described here is to analyse the design process of software designers and to compare the results with that of product designers, an area familiar to the authors. Decision-making is the main focus of this study. A descriptive model of decision-making, developed by the authors, has been used to analyse the protocols of the three software design teams. The results give insight in how software designers process their activities, on the influence of individual or team differences, and what the consequences for their outcomes are.
URL: https://www.sciencedirect.com/science/article/pii/S0142694X10000670


Reference Type:  Journal Article
Record Number: 8549
Author: McDonnell, Janet
Year: 2012
Title: Accommodating disagreement: A study of effective design collaboration
Journal: Design Studies
Volume: 33
Issue: 1
Pages: 44-63
Date: 1//
Short Title: Accommodating disagreement: A study of effective design collaboration
ISSN: 0142-694X
DOI: https://doi.org/10.1016/j.destud.2011.05.003
Keywords: collaborative design
conceptual design
design negotiation
design processes
software design
Abstract: This paper reports an investigation into the verbal interaction between two experienced software designers developing initial ideas for a new software application. Paying attention to the conversational strategies that make manifest the ‘web of moves’ (Schön, 1985) that characterises expert design behaviour, the study focuses on how the designers keep the designing moving on productively despite uncertainties and ambiguities over the brief and disagreement over elements of the design itself. The study examines how tentativeness supports constructive collaboration and draws attention to the conversational strategies used to accommodate disagreement, in particular explicit reference to it and the use of technicalising terms to encapsulate, but acknowledge, differences about how design requirements should be realised. The work contributes to understanding the subtle conversational mechanisms that support effective design collaboration and highlights the need to acknowledge phenomena that serve collaboration itself.
URL: https://www.sciencedirect.com/science/article/pii/S0142694X1100038X
'File' Attachments: internal-pdf://0602239054/Accommodating disagreement A study of effectiv.pdf


Reference Type:  Journal Article
Record Number: 8702
Author: Parnas, D. L. and Weiss, D. M.
Year: 1987
Title: Active design reviews: Principles and practices
Journal: Journal of Systems and Software
Volume: 7
Issue: 4
Pages: 259-265
Date: 12//
Short Title: Active design reviews: Principles and practices
ISSN: 0164-1212
DOI: https://doi.org/10.1016/0164-1212(87)90025-2
Abstract: Although many new software design techniques have emerged in the past 15 years, there have been few changes to the procedures for reviewing the designs produced using these techniques. This report describes an improved technique, based on the following ideas, for reviewing designs. 1. 1. The efforts of each reviewer should be focused on those aspects of the design that suit his or her experience and expertise. 2. 2. The characteristics of the reviewers needed should be explicitly specified before reviewers are selected. 3. 3. Reviewers should be asked to make positive assertions about the design rather than simply allowed to point out defects. 4. 4. The designers pose questions to the reviewers, rather than vice versa. These questions are posed on a set of questionnaires that requires careful study of some aspect of the design. 5. 5. Interaction between designers and reviewers occurs in small meetings involving two to four people rather than meetings of large groups. Illustrations of these ideas are drawn from the application of active design reviews to the Naval Research Laboratory's Software Cost Reduction project.
URL: https://www.sciencedirect.com/science/article/pii/0164121287900252


Reference Type:  Conference Paper
Record Number: 7935
Author: Song, Yuanyuan, Rai, Devendra and Sullivan, Kevin
Year: 2008
Title: Adaptation architectures cross levels
Conference Name: Proceedings of the 2nd international workshop on Ultra-large-scale software-intensive systems
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 27-28
DOI: 10.1145/1370700.1370708
Place Published: 1370708
Abstract: To design ULS systems with the adaptive capacity they will need to be viable, requires that we broaden our understanding of software architecture. It is not just the software that must adapt, but the human-technical systems that produce and operate it. The traditional notion of an architecture as an abstract description of software artifacts and processes in an ontology of computational components, connections, and behavioral properties will not suffice. An alternative ontology based on decisions, decision-making tasks, agents, dependences among decisions, and the structure of such dependences appears to be worth exploring.


Reference Type:  Conference Proceedings
Record Number: 9193
Author: Hadar, I. and Sherman, S.
Year of Conference: 2012
Title: Agile vs. plan-driven perceptions of software architecture
Conference Name: 2012 5th International Workshop on Co-operative and Human Aspects of Software Engineering (CHASE)
Pages: 50-55
Date: 2-2 June 2012
Short Title: Agile vs. plan-driven perceptions of software architecture
DOI: 10.1109/CHASE.2012.6223022
Keywords: software architecture
software prototyping
agile methodologies
agile philosophy
agile projects perceive architecture activities
complex system development projects
human-centric software development process
plan-driven perceptions
Computer architecture
Conferences
Documentation
Programming
Software
Testing
agile methodology
development methodologies
qualitative research
Abstract: The use of agile methodologies in industry has increased significantly over the past decade, promoting the value of human-centric software development process. This growing use derives the need to adjust agile methodologies to bigger, more complex system development projects, where architecture plays a significant role. However, many believe that an essential conflict exists between the requirement of minimalism in agile methods and the need for well-defined and documented architecture in complex systems. This paper presents an exploratory study aimed at understanding the software architecture related activities as perceived by architects with and without experience in agile methodologies. The findings indicate that while architects practicing only plan-driven methodologies perceive architecture activities as being related only to the first phases of the development process, architects involved in agile projects perceive architecture activities to be related to most or all phases of the development lifecycle. The latter perceptions are consistent with suggestions expressed in the literature regarding architecture in general and in agile methodologies in particular. Based on these findings we suggest that agile methods not only lead architects to adjust their behavior to the agile philosophy, but also improve architects' perceptions and practice of architecture in general.
'File' Atttachments: internal-pdf://1958886197/Agile vs. plan-driven perceptions of software.pdf


Reference Type:  Journal Article
Record Number: 9371
Author: Abrahamsson, P., Babar, M. A. and Kruchten, P.
Year: 2010
Title: Agility and Architecture: Can They Coexist?
Journal: IEEE Software
Volume: 27
Issue: 2
Pages: 16-22
Short Title: Agility and Architecture: Can They Coexist?
ISSN: 0740-7459
DOI: 10.1109/MS.2010.36
Keywords: software architecture
software development management
agile development
design assumptions
design decisions
industrial software development practices
software intensive systems
Computer architecture
Computer industry
Feedback
Programming
Scalability
agile development methods
software engineering
Abstract: Agile development has significantly impacted industrial software development practices. However, despite its wide popularity, there's an increasing perplexity about software architecture's role and importance in agile approaches. Advocates of architecture's vital role in achieving quality goals for large software-intensive systems doubt the scalability of any development approach that doesn't pay sufficient attention to architecture. This article talks about software architecture being relevant to the basis of aspects such as communication among team members, inputs to subsequent design decisions, documenting design assumptions, and evaluating design alternatives. In a large software organization, implementing agile approaches isn't a straightforward adoption problem. Most likely, it will take several years to shorten the feedback cycles to benefit from the adaptability and earlier value-creation opportunities. Failure is a natural part of process improvement.


Reference Type:  Journal Article
Record Number: 8589
Author: Sørby, Inger Dybdahl and Nytrø, Øystein
Year: 2010
Title: Analysis of communicative behaviour: Profiling roles and activities
Journal: International Journal of Medical Informatics
Volume: 79
Issue: 6
Pages: e144-e151
Date: 6//
Short Title: Analysis of communicative behaviour: Profiling roles and activities
ISSN: 1386-5056
DOI: https://doi.org/10.1016/j.ijmedinf.2009.08.003
Keywords: Structured observation
Communicative acts profiling
Requirements elicitation
Software design
Point of care clinical information systems
Abstract: Objectives In this paper we present a method for processing and presentation of data recorded through structured observation of clinicians’ information and communication activities. The activities are encoded as sequences of distinctive speech acts, and resulting profiles of communicative behaviour are visualized in radar graphs. Example profiles resulting from the analysis of three clinicians’ communicative behaviour during pre-rounds meetings and medication activities are given. Methods The communicative acts profiles are based on empirical data from an observational study performed at a Norwegian university hospital. A fifth-year medical student spent 20 days in two different hospital wards, following one physician at a time in daily, patient-centred work. The observer recorded the clinicians’ information and communication activities during several ward situations such as pre-rounds meetings, ward rounds, and patient discharge. The data was recorded by means of an observation form consisting of a mixture of codes and free-text fields. The recorded data was post-processed by associating each event with one predefined communicative act, and resulting profiles for three individual physicians in different situations have been created as radar graphs. Results/conclusion The approach is an efficient and useful means for studying clinicians’ information and communication patterns in hospital wards. The method can be used to illustrate variations among individual clinicians in similar situations and to compare profiles of different roles or hospital wards. Given proper validation, the approach may serve as an important tool to inform the design of new clinical information systems.
URL: https://www.sciencedirect.com/science/article/pii/S1386505609001270


Reference Type:  Journal Article
Record Number: 8087
Author: J. Andrés Díaz Pace, Marcelo R. Campo
Year: 2001
Title: Analyzing the role of aspects in software design
Journal: Commun. ACM
Volume: 44
Issue: 10
Pages: 66-73
Short Title: Analyzing the role of aspects in software design
ISSN: 0001-0782
DOI: 10.1145/383845.383859
Legal Note: 383859
Abstract: This article analyzes the role of aspect-oriented programming in software design. There is a growing agreement in the software community about the limitations of object orientation to cope with the problem of building highly reusable, adaptable and extensible software systems. Aspect-oriented programming (AOP) is one of the most promising alternatives to improve object-oriented programming techniques. AOP aims at providing better means of addressing the well-known problem of separation of concerns by using specialized mechanisms to encapsulate concerns whose behavior crosscuts essential application functionality. The article discusses three basic approaches to addressing the process of separation of concerns namely a linguistic view, a pure object-oriented view and an architecture-oriented view. The authors have carried out a simulation case study to empirically compare both object-oriented solutions against aspect-oriented ones, and aspect technologies against each other. According to the authors, the central problem of aspect technologies is not just about crosscutting or separation of concerns, but it involves deeper research about how to understand a number of software parts as separated artifacts and then integrate some of them into a coherent system.


Reference Type:  Conference Paper
Record Number: 8237
Author: Sharma, Tushar, Samarthyam, Ganesh and Suryanarayana, Girish
Year: 2015
Title: Applying Design Principles in Practice
Conference Name: Proceedings of the 8th India Software Engineering Conference
Conference Location: Bangalore, India
Publisher: ACM
Pages: 200-201
DOI: 10.1145/2723742.2723764
Place Published: 2723764
Abstract: It is widely recognized that the systematic application of relevant design principles plays a key role in taming the complexity involved in real-world software development. In our experience as consultant architects and trainers on software architecture and design in a corporate setting, we find that software engineers have a theoretical understanding of design principles but sorely lack knowledge about how to properly apply them to in real-world situations to achieve high-quality design. This half-day tutorial is geared towards bridging this gap. It first introduces fundamental design principles (viz. abstraction, encapsulation, modularization, and hierarchy) and describes how these can be applied using a set of corresponding enabling techniques. Next, it discusses how design smells can be viewed as violations of these enabling techniques, and explains how these design smells can be refactored via the application of relevant design principles. Finally, it highlights useful tools, processes, and practical techniques that support the application of design principles in real-world software projects.


Reference Type:  Journal Article
Record Number: 8428
Author: Ramírez, Aurora, Romero, José Raúl and Ventura, Sebastián
Year: 2015
Title: An approach for the evolutionary discovery of software architectures
Journal: Information Sciences
Volume: 305
Pages: 234-255
Date: 6/1/
Short Title: An approach for the evolutionary discovery of software architectures
ISSN: 0020-0255
DOI: https://doi.org/10.1016/j.ins.2015.01.017
Keywords: Search based software engineering
Software architecture discovery
Evolutionary algorithms
Ranking aggregation fitness
Abstract: Software architectures constitute important analysis artefacts in software projects, as they reflect the main functional blocks of the software. They provide high-level analysis artefacts that are useful when architects need to analyse the structure of working systems. Normally, they do this process manually, supported by their prior experiences. Even so, the task can be very tedious when the actual design is unclear due to continuous uncontrolled modifications. Since the recent appearance of search based software engineering, multiple tasks in the area of software engineering have been formulated as complex search and optimisation problems, where evolutionary computation has found a new area of application. This paper explores the design of an evolutionary algorithm (EA) for the discovery of the underlying architecture of software systems. Important efforts have been directed towards the creation of a generic and human-oriented process. Hence, the selection of a comprehensible encoding, a fitness function inspired by accurate software design metrics, and a genetic operator simulating architectural transformations all represent important characteristics of the proposed approach. Finally, a complete parameter study and experimentation have been performed using real software systems, looking for a generic evolutionary approach to help software engineers towards their decision making process.
Notes: Development of an algorithm for decision support - no human behavior (just partly)
URL: https://www.sciencedirect.com/science/article/pii/S0020025515000559


Reference Type:  Conference Proceedings
Record Number: 9200
Author: Bertolino, A., Inverardi, P., Muccini, H. and Rosetti, A.
Year of Conference: 1997
Title: An approach to integration testing based on architectural descriptions
Conference Name: Proceedings. Third IEEE International Conference on Engineering of Complex Computer Systems (Cat. No.97TB100168)
Pages: 77-84
Date: 8-12 Sep 1997
Short Title: An approach to integration testing based on architectural descriptions
DOI: 10.1109/ICECCS.1997.622299
Keywords: data flow graphs
program testing
software engineering
CHAM formalism
architectural descriptions
coverage strategy
formal architectural descriptions
integration testing
software architectures
unit testing
Computer architecture
Performance evaluation
Phase detection
Programming
Software architecture
Software maintenance
Software systems
Software testing
Synthetic aperture sonar
System testing
Abstract: Software architectures can play a role in improving the testing process of complex systems. In particular descriptions of the software architecture can be useful to drive integration testing, since they supply information about how the software is structured in parts and how those parts (are expected to) interact. We propose to use formal architectural descriptions to model the &ldquo;interesting&rdquo; behaviour of the system. This model is at a right level of abstraction to be used as a formal base on which integration test strategies can be devised. Starting from a formal description of the software architecture (given in the CHAM formalism), we first derive a graph of all the possible behaviours of the system in terms of the interactions between its components. This graph contains altogether the information we need for the planning of integration testing. On this comprehensive model, we then identify a suitable set of reduced graphs, each highlighting specific architectural properties of the system. These reduced graphs can be used for the generation of integration tests according to a coverage strategy, analogously to what happens with the control and data flow graphs in unit testing
Notes: Testing procedure - not about behavior


Reference Type:  Conference Proceedings
Record Number: 8939
Author: Ameller, D., Collell, O. and Franch, X.
Year of Conference: 2012
Title: ArchiTech: Tool support for NFR-guided architectural decision-making
Conference Name: 2012 20th IEEE International Requirements Engineering Conference (RE)
Pages: 315-316
Date: 24-28 Sept. 2012
Short Title: ArchiTech: Tool support for NFR-guided architectural decision-making
ISBN: 1090-705X
DOI: 10.1109/RE.2012.6345821
Keywords: Computer architecture
Decision making
Information systems
Simulated annealing
Software
Software architecture
Non-functional requirement
architectural decision
computer-aided support system
Abstract: Researchers from requirements engineering and software architecture had emphasized the importance of NonFunctional Requirements and their influence in the architectural design process. To improve this process we have designed a tool, ArchiTech, which aims to support architects during the design process by suggesting alternative architectural decisions that can improve some types of non-functional requirements in a particular project, and facilitate the reuse of architectural knowledge shared between projects of the same architectural domain (e.g., web-based applications).
Notes: Tool


Reference Type:  Conference Proceedings
Record Number: 9381
Author: Vickers, B.
Year of Conference: 2004
Title: Architecting a software architect
Conference Name: 2004 IEEE Aerospace Conference Proceedings (IEEE Cat. No.04TH8720)
Volume: 6
Pages: 4155-4161 Vol.6
Date: 6-13 March 2004
Short Title: Architecting a software architect
ISBN: 1095-323X
DOI: 10.1109/AERO.2004.1368238
Keywords: aerospace computing
aerospace engineering
educational courses
industrial training
on-the-job training
software architecture
Jet Propulsion Laboratory
aerospace software development
aerospace systems
educational program
software architect program
software engineering
software engineers
software systems
Educational programs
Programming
Propulsion
Software development management
Software standards
Standards development
Abstract: Software architecture is a relatively new software engineering discipline that has emerged as a response to the growing complexity of software systems and the problems these systems attempt to solve. Software is becoming the dominant component of most aerospace systems and it is necessary for the aerospace software development community to develop new practices, principles, and standards to manage this growing complexity. The Jet Propulsion Laboratory (JPL) has developed and implemented a year-long educational program designed to develop expertise in software architectures and to train future software architects. Now in its third year, the software architect program (SWAP) selects senior software engineers and then apprentices them as software architects. The objective of this paper is to describe the structure of the SWAP, the program's background, how the program has evolved, and the lessons learned from the implementation of this educational program.


Reference Type:  Conference Paper
Record Number: 8043
Author: Zdun, Uwe, Avgeriou, Paris, Hentrich, Carsten and Dustdar, Schahram
Year: 2008
Title: Architecting as decision making with patterns and primitives
Conference Name: Proceedings of the 3rd international workshop on Sharing and reusing architectural knowledge
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 11-18
DOI: 10.1145/1370062.1370066
Place Published: 1370066
Abstract: The application of patterns is used as a foundation for many central design decisions in software architecture, but because of the informal nature of patterns, these design decisions are usually not precisely documented in the models. In our earlier work, we had proposed pattern primitives as a solution to precisely model the patterns in the corresponding architectural views. Building upon that approach, this paper introduces a pattern-based architecting process that aims at inexpensively documenting design decisions in the architectural views alongside the natural flow of design. The decisions that are made explicit, concern the selection of patterns, their variants and the corresponding primitives, as well as the resolution of inconsistencies between the architectural views. The approach is demonstrated in the domain of process-driven SOA for two architectural views: Component-and-Connector and Process Flow.
Notes: just framework, no research on behavior


Reference Type:  Conference Paper
Record Number: 7974
Author: Haitzer, Thomas, Navarro, Elena and Zdun, Uwe
Year: 2015
Title: Architecting for decision making about code evolution
Conference Name: Proceedings of the 2015 European Conference on Software Architecture Workshops
Conference Location: Dubrovnik, Cavtat, Croatia
Publisher: ACM
Pages: 1-7
DOI: 10.1145/2797433.2797487
Place Published: 2797487
Abstract: During software evolution, it is important to evolve not only the source code, but also its architecture to prevent architecture drift and architecture erosion. This is a complex activity, especially for large software projects, with multiple development teams that might be located in different countries or on different continents. To ease this kind of evolution, we have developed a domain-specific language for making decisions about the evolution. It supports the definition of architectural changes based on multiple implementation tasks that can have temporal dependencies among each other. Then, by means of a model-to-model transformation, we automatically create a constraint model that we use to generate, by means of the Alloy model analyzer, the possible alternative decisions for executing the implementation tasks. The tight integration with architecture abstractions enables architects to automatically check the changes related to an implementation task in relation to the architecture description. This helps keeping architecture and code in sync, avoiding drift and erosion.
Notes: Tool to document - no behavior


Reference Type:  Conference Paper
Record Number: 7975
Author: Shahin, Mojtaba
Year: 2015
Title: Architecting for DevOps and Continuous Deployment
Conference Name: Proceedings of the ASWEC 2015 24th Australasian Software Engineering Conference
Conference Location: Adelaide, SA, Australia
Publisher: ACM
Pages: 147-148
DOI: 10.1145/2811681.2824996
Place Published: 2824996
Abstract: Development and Operations (DevOps) in the context of Continuous Deployment (CD) have emerged as an attractive software development movement, which tries to establish a strong connection between development and operations teams. CD is defined as the ability to quickly put new releases into production. We believe that DevOps/CD brings new challenges for architects, which considerably impacts both on their (architectural) design decisions and their organizational responsibilities. We assert that there is an important and urgent need of sufficient research work to gain a deep understanding of how DevOps/CD adoption can influence architecting, architectural decision-making processes and their outcomes in an organization. This PhD research is aimed at understanding and addressing new challenges for designing architectures for supporting DevOps in the context of CD.


Reference Type:  Journal Article
Record Number: 8586
Author: Folmer, Eelke and Bosch, Jan
Year: 2004
Title: Architecting for usability: a survey
Journal: Journal of Systems and Software
Volume: 70
Issue: 1–2
Pages: 61-78
Date: 2//
Short Title: Architecting for usability: a survey
ISSN: 0164-1212
DOI: https://doi.org/10.1016/S0164-1212(02)00159-0
Keywords: Software architecture
Usability
Design for quality attributes
Abstract: Over the years the software engineering community has increasingly realized the important role software architecture plays in fulfilling the quality requirements of a system. The quality attributes of a software system are, to a large extent determined by the system’s software architecture. In recent years, the software engineering community has developed various tools and techniques that allow for design for quality attributes, such as performance or maintainability, at the software architecture level. We believe this design approach can be applied not only to “traditional” quality attributes such as performance or maintainability but also to usability. This survey explores the feasibility of such a design approach. Current practice is surveyed from the perspective of a software architect. Are there any design methods that allow for design for usability at the architectural level? Are there any evaluation tools that allow assessment of architectures for their support of usability? What is usability? A framework is presented which visualizes these three research questions. Usability should drive design at all stages, but current usability engineering practice fails to fully achieve this goal. Our survey shows that there are no design techniques or assessment tools that allow for design for usability at the architectural level.
URL: https://www.sciencedirect.com/science/article/pii/S0164121202001590


Reference Type:  Conference Paper
Record Number: 7881
Author: Cataldo, Marcelo and Herbsleb, James D.
Year: 2010
Title: Architecting in software ecosystems: interface translucence as an enabler for scalable collaboration
Conference Name: Proceedings of the Fourth European Conference on Software Architecture: Companion Volume
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 65-72
DOI: 10.1145/1842752.1842772
Place Published: 1842772
Abstract: Software ecosystems are emerging as an alternative approach for the development of complex software systems. The potentially transformational benefits of software ecosystems stems, primarily, from two basic principles that software ecosystems have embraced: transparency, a pillar in open source development, and modular system design. Despite the benefits associated with transparency and modularity, there are also important challenges that deserve attention. In this paper, we introduce the concept of interface translucence as an architectural mechanism that seeks to overcome challenges faced by transparency and modular system design. Interface translucence leverages the important technical role that interfaces play in software architectures to bridge the technical and socio-organizational dimensions of software development in ecosystems. We present an application of the concept of interface translucence in the context of architecting a software system as well as in the context of implementing it. We conclude with a discussion of future research work.
Notes: Not on behavior focused


Reference Type:  Journal Article
Record Number: 9064
Author: Woods, E.
Year: 2015
Title: Architecting in the Gaps: A Metaphor for Architecture Work
Journal: IEEE Software
Volume: 32
Issue: 4
Pages: 33-35
Short Title: Architecting in the Gaps: A Metaphor for Architecture Work
ISSN: 0740-7459
DOI: 10.1109/MS.2015.98
Keywords: software architecture
software architect role
software development teams
system overall efficiency
Software development
software design
software engineering
Abstract: The metaphor "architecting in the gaps" can help software development teams clearly understand the software architect's role and how architecture contributes to a system's overall efficiency.


Reference Type:  Journal Article
Record Number: 8582
Author: Ferrari, Remo N. and Madhavji, Nazim H.
Year: 2008
Title: Architecting-problems rooted in requirements
Journal: Information and Software Technology
Volume: 50
Issue: 1–2
Pages: 53-66
Date: 1//
Short Title: Architecting-problems rooted in requirements
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2007.10.012
Keywords: Requirements engineering
Software architecture
Software quality
Process improvement
Empirical study
Abstract: Requirements permeate many parts of the software development process outside the requirements engineering (RE) process. It is thus important to determine whether software developers in these other areas of software development face any requirements-oriented (RO) problems in carrying out their tasks. Feedback so obtained can be invaluable for improving both requirements and RE technologies. In this paper, we describe an exploratory case study of requirements-oriented problems experienced by 16 architecting teams designing the same banking application. The study found that there were several different types of RO problems, of varying severity, which the architects faced in using the given requirements; those architects with RE background also faced RO problems; and about a third of all problems were RO problems. There was much concurrence of our findings with software-expert opinion from a large insurance company. There were also areas where there were relatively few RO problems. The paper also describes some implications of the findings for the RE field, particularly in the areas of: expression of quality requirements for different stakeholders; empirical studies on quality scenarios; tighter integration of RE and software architecting processes; and requirements to architecture mapping. There are opportunities for further research based on two emergent hypotheses which are also described in this paper.
Notes: student
URL: https://www.sciencedirect.com/science/article/pii/S095058490700119X
'File' Attachments: internal-pdf://0781279421/Architecting-problems rooted in requirements.pdf


Reference Type:  Journal Article
Record Number: 8912
Author: Faber, R.
Year: 2010
Title: Architects as Service Providers
Journal: IEEE Software
Volume: 27
Issue: 2
Pages: 33-40
Short Title: Architects as Service Providers
ISSN: 0740-7459
DOI: 10.1109/MS.2010.37
Keywords: encoding
software architecture
software development management
agile development projects
application developers
architects
coding activities
service providers
system qualities
agile development
development teams
management
software engineering
software engineering process
software process models
Abstract: Architects provide those system qualities as values to their customers, communicating and implementing them in close cooperation with developers. In this way, architects also can and should play an important role in agile development projects. As a service to application developers, architects participate in coding activities and sustain the architecture's effectiveness throughout a project's lifetime.


Reference Type:  Journal Article
Record Number: 9351
Author: Tamburri, D. A., Kazman, R. and Fahimi, H.
Year: 2016
Title: The Architect's Role in Community Shepherding
Journal: IEEE Software
Volume: 33
Issue: 6
Pages: 70-79
Short Title: The Architect's Role in Community Shepherding
ISSN: 0740-7459
DOI: 10.1109/MS.2016.144
Keywords: organisational aspects
software architecture
software quality
architecture component design
architecture qualities
community shepherding
organizational rewiring
project stakeholders
software architects
Computer architecture
Cultural differences
Professional aspects
architectural social debt
social debt management
software architecture shepherds
software communities
software community smells
software development
software engineering
software organizational structure
software social debt
Abstract: Software architects don't just design architecture components or champion architecture qualities; they often must guide and harmonize the entire community of project stakeholders. The community-shepherding aspects of the architect's role have been gaining attention, given the increasing importance of complex "organizational rewiring" scenarios such as DevOps, open source strategies, transitions to agile development, and corporate acquisitions. In these scenarios, architects would benefit by having effective models to align communities with architectures. This article discusses the "smells" indicating that a community isn't functioning efficiently, offers a set of mitigations for those smells, and provides an overview of community types.


Reference Type:  Journal Article
Record Number: 8793
Author: Weinreich, R. and Groher, I.
Year: 2016
Title: The Architect's Role in Practice: From Decision Maker to Knowledge Manager?
Journal: IEEE Software
Volume: 33
Issue: 6
Pages: 63-69
Short Title: The Architect's Role in Practice: From Decision Maker to Knowledge Manager?
ISSN: 0740-7459
DOI: 10.1109/MS.2016.143
Keywords: personnel
software architecture
software development management
European software architects
US software architects
United States
advisor
coordinator
decision maker
knowledge manager
Computer architecture
Interviews
architectural decision making
industrial interview study
software architecture knowledge management
software development
software engineering
Abstract: Interviews with European and US software architects show not only a diverse practice of architecting but also the architect's transformation from primary decision maker to coordinator, advisor, and knowledge manager.
'File' Attachments: internal-pdf://2001325740/The Architect's Role in Practice From Decision.pdf


Reference Type:  Conference Paper
Record Number: 7987
Author: Amorim, Simone da Silva, McGregor, John D., Almeida, Eduardo Santana de and Chavez, Christina von Flach G.
Year: 2017
Title: The Architect's Role in Software Ecosystems Health
Conference Name: Proceedings of the 2nd Workshop on Social, Human, and Economic Aspects of Software
Conference Location: Salvador, Brazil
Publisher: ACM
Pages: 1-4
DOI: 10.1145/3098322.3098324
Place Published: 3098324
Abstract: Software ecosystems have adopted many different strategies to achieve success and good health. The role of software architect is one of the main contributors to that success. Their activities are crucial for realizing the business strategy of their organization. Software ecosystems define multi-sided markets that require different strategies from a traditional two-sided market. The architectural practices in the multi-sided market must support the need for flexibility and rapid reaction. These new demands broaden our understanding of the software architect's role and the impact of their action on ecosystem structure. In particular the need to understand how to operate in a collaborative, cooperative environment to exploit competition. In this position paper, we discuss how software architect's actions influence the ecosystem health through their indicators: productivity, niche creation, and robustness.


Reference Type:  Conference Paper
Record Number: 7890
Author: Bernini, Diego
Year: 2010
Title: Architectural abstractions for space and time awareness: the case of responsive environments
Conference Name: Proceedings of the Fourth European Conference on Software Architecture: Companion Volume
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 12-16
DOI: 10.1145/1842752.1842757
Place Published: 1842757
Abstract: Space and time are common high-level concepts in several classes of systems, however they seldom are first class concerns at the software architecture level. In particular they have a crucial role in responsive environments, i.e. technology-augmented ordinary environments which are able to sense and respond to their inhabitants. The paper presents the Ph.D. proposal of the author, which aims to define suitable architectural abstractions to manage space and time in responsive environments. The paper first outlines the problem, then presents the related work and finally describes the proposed solution approach, the expected results and their validation plan.
Notes: Framework instead of behavior


Reference Type:  Conference Proceedings
Record Number: 7683
Author: Zimmermann, O., Wegmann, L., Koziolek, H. and Goldschmidt, T.
Year of Conference: 2015
Title: Architectural Decision Guidance Across Projects - Problem Space Modeling, Decision Backlog Management and Cloud Computing Knowledge
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 85-94
Date: 4-8 May 2015
Short Title: Architectural Decision Guidance Across Projects - Problem Space Modeling, Decision Backlog Management and Cloud Computing Knowledge
DOI: 10.1109/WICSA.2015.29
Keywords: Unified Modeling Language
cloud computing
knowledge management
project management
software architecture
ADMentor
Sparx enterprise architect
UML model linkage
architectural decision guidance
architectural knowledge management
cloud application design decisions
cloud computing knowledge
control system architectures
decision backlog management
knowledge application
knowledge maintenance
meta-information
open AKM problems
problem space modeling
project-specific decision guidance
question-option-criteria diagram support
reusable knowledge
solution space management
workflow management decisions
Communities
Computational modeling
Documentation
Knowledge engineering
Software
UML
agile practices
architectural decisions
architectural synthesis
patterns
Abstract: Architectural Knowledge Management (AKM) has been a major topic in software architecture research since 2004. Open AKM problems include an effective, seamless transition from reusable knowledge found in patterns books and technology blogs to project-specific decision guidance and an efficient, practical approach to knowledge application and maintenance. We extended our previous work with concepts for problem space modeling, focusing on reusable knowledge, as well as solution space management, focusing on project-level decisions. We implemented these concepts in ADMentor, an extension of Sparx Enterprise Architect. AD Mentor features rapid problem space modeling, UML model linkage, question-option-criteria diagram support, meta-information for model tailoring, as well as decision backlog management. We validated ADMentor by modeling and applying 85 cloud application design decisions and 75 workflow management decisions, creating one problem and three sample solution spaces covering control system architectures, and obtaining user feedback on tool and model content.
Notes: Focus on tool development (even behavorial aspects in the introduction are interesting)


Reference Type:  Conference Proceedings
Record Number: 9091
Author: Harrison, N. B., Gubler, E. and Skinner, D.
Year of Conference: 2016
Title: Architectural Decision-Making in Open-Source Systems -- Preliminary Observations
Conference Name: 2016 1st International Workshop on Decision Making in Software ARCHitecture (MARCH)
Pages: 16-21
Date: 5-5 April 2016
Short Title: Architectural Decision-Making in Open-Source Systems -- Preliminary Observations
DOI: 10.1109/MARCH.2016.7
Keywords: decision making
public domain software
software architecture
OSS projects
architectural decision-making
architectural decisions
architectural documentation
decision making process
open-source projects
open-source software projects
open-source systems
preliminary observations
unified architectural decisions
Architecture
Chaos
Computer architecture
Documentation
Open source software
Evolution
rchitectural Decisions
Abstract: Participants in open-source software projects are often geographically dispersed, and may work in different companies, and have different visions of the software. These present special challenges to creating unified architectural decisions. Yet open-source projects are often successful. We studied architectural documentation of forty-four open-source (OSS) projects, and found some evidence of how architectural decisions were made. It appears that the decision making process is not significantly different from that in traditional software projects. In particular, it was characterized by careful, intentional software design, with attention to quality attributes. In general, the architectural decisions tended to be controlled by a very small team or a single individual.
'File' Atttachments: internal-pdf://1410670074/Architectural Decision-Making in Open-Source S.pdf


Reference Type:  Conference Paper
Record Number: 7945
Author: Prause, Christian R. and Durdik, Zoya
Year: 2012
Title: Architectural design and documentation: waste in agile development?
Conference Name: Proceedings of the International Conference on Software and System Process
Conference Location: Zurich, Switzerland
Publisher: IEEE Press
Pages: 130-134
Place Published: 2664380
Abstract: There is a problem with documentation and architectural design in agile projects. This is the result of interviews we have conducted with 37 software engineering experts from industry and academia. In our paper, we analyze the interview results and the origins of the revealed issues. We propose ways to integrate software design methodologies into agile development, and reputation mechanism to solve documentation problems. The contributions of this paper are (i) an investigation of expert opinions on design and documentation problems, (ii) an analysis of problem origins, and (iii) proposals for future improvements of agile processes.


Reference Type:  Conference Proceedings
Record Number: 9556
Author: Prause, C. R. and Durdik, Z.
Year of Conference: 2012
Title: Architectural design and documentation: Waste in agile development?
Conference Name: 2012 International Conference on Software and System Process (ICSSP)
Pages: 130-134
Date: 2-3 June 2012
Short Title: Architectural design and documentation: Waste in agile development?
DOI: 10.1109/ICSSP.2012.6225956
Keywords: integrated software
project management
software architecture
software prototyping
system documentation
agile project development
architectural design
documentation
expert opinion
integrated software design methodology
software engineering
Industries
Interviews
Programming
Software quality
agile development
reputation
software design
Abstract: There is a problem with documentation and architectural design in agile projects. This is the result of interviews we have conducted with 37 software engineering experts from industry and academia. In our paper, we analyze the interview results and the origins of the revealed issues. We propose ways to integrate software design methodologies into agile development, and reputation mechanism to solve documentation problems. The contributions of this paper are (i) an investigation of expert opinions on design and documentation problems, (ii) an analysis of problem origins, and (iii) proposals for future improvements of agile processes.
'File' Atttachments: internal-pdf://3986397288/Architectural design and documentation Waste i.pdf


Reference Type:  Conference Proceedings
Record Number: 9449
Author: Che, M. and Perry, D. E.
Year of Conference: 2014
Title: Architectural Design Decisions in Open Software Development: A Transition to Software Ecosystems
Conference Name: 2014 23rd Australian Software Engineering Conference
Pages: 58-61
Date: 7-10 April 2014
Short Title: Architectural Design Decisions in Open Software Development: A Transition to Software Ecosystems
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2014.37
Keywords: knowledge management
public domain software
software architecture
ADD management
architectural design decisions
architectural knowledge management
architecture decision-making process
knowledge evaporation
open ecosystem community
open software development paradigm
software architecture research
software development process
software ecosystems
software engineering processes
Communities
Computer architecture
Ecosystems
Organizations
Software
architectural knowledge
open software development
Abstract: Managing architectural design decisions (ADDs) in software development process is an essential task for architectural knowledge management. As software ecosystems become a new software development paradigm in software engineering processes, it is important and necessary to capture and represent ADDs in open software development, and to evolve architectural knowledge with minimum knowledge evaporation in the open ecosystem community. So far, little work has been done on managing architectural decisions in software ecosystems in current software architecture research and practice. In this research position paper, we discuss the typical characteristics of software ecosystems which may influence architecture decision-making processes in software development, and identify the essential aspects that should be considered for managing ADDs in the context of software ecosystem. In addition, we discuss major challenges of managing ADDs for software ecosystems, and we also propose possible directions in research to solve the problems.


Reference Type:  Conference Proceedings
Record Number: 9018
Author: Tyree, J.
Year of Conference: 2005
Title: Architectural Design Decisions Session Report
Conference Name: 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05)
Pages: 285-286
Date: 6-10 Nov. 2005
Short Title: Architectural Design Decisions Session Report
DOI: 10.1109/WICSA.2005.14
Keywords: Best practices
Computer architecture
Decision making
Knowledge management
Message service
Ontologies
Prototypes
Software architecture
Software prototyping
Time factors
Abstract: In the architectural design decisions session, we discussed tools, techniques, and processes with respect to architectural design decision-making. The importance of making good decisions was highlighted through an examination of several software architecture case studies.


Reference Type:  Conference Proceedings
Record Number: 8821
Author: Lopes, S. V. F. and Junior, P. T. A.
Year of Conference: 2017
Title: Architectural Design Group Decision-Making in Agile Projects
Conference Name: 2017 IEEE International Conference on Software Architecture Workshops (ICSAW)
Pages: 210-215
Date: 5-7 April 2017
Short Title: Architectural Design Group Decision-Making in Agile Projects
DOI: 10.1109/ICSAW.2017.24
Keywords: decision making
software architecture
software prototyping
software quality
agile projects
architectural design group decision-making
design alternatives
quality attributes
Collaboration
Computer architecture
Conferences
Industries
Stakeholders
Scrum
agile
group decision-making
Abstract: Software architecture has many definitions. One widely accepted definition of software architecture is that it is a composition of a set of architectural design decisions. Hence, designing a software architecture is a decision-making process. Agile methods drastically changed the way of designing a software architecture. In projects using agile methods (e.g. Scrum), making architectural design decisions is not the responsibility of a single person, but rather the whole development team. Despite the popularity of such methods in the industry, little research exists on how to make these decisions from the perspective of a group effectively. Current techniques usually focus on the identification of quality attributes and design alternatives, not addressing the whole decision-making process. The quality of decisions directly reflects the quality of the software architecture. Therefore poor decisions lead to bad software architectures. In this paper, we discuss current research on group decision-making in software architecture and the proposal of a combination of concepts from two architecture definition methods into a single approach that can be used in agile projects and addresses the most critical concerns of group decision-making. This proposal is part of a master's research project.


Reference Type:  Conference Proceedings
Record Number: 7630
Author: Soliman, M., Galster, M., Salama, A. R. and Riebisch, M.
Year of Conference: 2016
Title: Architectural Knowledge for Technology Decisions in Developer Communities: An Exploratory Study with StackOverflow
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 128-133
Date: 5-8 April 2016
Short Title: Architectural Knowledge for Technology Decisions in Developer Communities: An Exploratory Study with StackOverflow
DOI: 10.1109/WICSA.2016.13
Keywords: decision making
knowledge management
software architecture
technology management
StackOverflow
architecture knowledge management
software development community
software system
technology decision
Computer architecture
Media
Middleware
Programming
Telecommunications
Architecture knowledge
architecture design decisions
empirical study
knowledge capturing
Abstract: Architectural decisions have a big influence on basic properties of a software system, and are difficult to change once implemented. Technology decisions deserve special attention because they are one of the most frequently occurring types of architectural decisions. Architectural knowledge is crucial for good decisions. Current architecture knowledge management approaches try to support architects by offering a rich base of architectural solutions and design decision rules. However, they mostly depend on manually capturing and maintaining the architectural knowledge. In this paper, we utilize the most popular online software development community (StackOverflow) as a source of knowledge for technology decisions to support architecture knowledge management approaches with a more efficient methods for knowledge capturing. We conducted an exploratory study, and followed a qualitative and quantitative content analysis approach. We analysed the posts in this community to identify architecture-relevant and technology-related knowledge, and to classify the posts into different types for the purpose of knowledge structuring. In addition, we evaluated our findings through feedback from practitioners.
'File' Atttachments: internal-pdf://1264029490/Architectural Knowledge for Technology Decisio.pdf


Reference Type:  Conference Proceedings
Record Number: 8894
Author: Bardram, J. E., Christensen, H. B. and Hansen, K. M.
Year of Conference: 2004
Title: Architectural prototyping: an approach for grounding architectural design and learning
Conference Name: Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004)
Pages: 15-24
Date: 12-15 June 2004
Short Title: Architectural prototyping: an approach for grounding architectural design and learning
DOI: 10.1109/WICSA.2004.1310686
Keywords: software architecture
software prototyping
architectural qualities
knowledge transfer
software architectural learning
software architectural prototyping
software architecture design
software system development
Buildings
Computer architecture
Grounding
Mars
Planets
Prototypes
Vehicles
Veins
Abstract: A major part of software architecture design is learning how specific architectural designs balance the concerns of stakeholders. We explore the notion of "architectural prototypes", correspondingly architectural prototyping, as a means of using executable prototypes to investigate stakeholders' concerns with respect to a system under development. An architectural prototype is primarily a learning and communication vehicle used to explore and experiment with alternative architectural styles, features, and patterns in order to balance different architectural qualities. The use of architectural prototypes in the development process is discussed, and we argue that such prototypes can play a role throughout the entire process. The use of architectural prototypes is illustrated by three distinct cases of creating software systems. We argue that architectural prototyping can provide key insights that may otherwise be difficult to obtain before a system is built. Furthermore, they define skeleton systems that serve as communication means and knowledge transfer among stakeholders.


Reference Type:  Journal Article
Record Number: 8862
Author: Monroe, R. T., Kompanek, A., Melton, R. and Garlan, D.
Year: 1997
Title: Architectural styles, design patterns, and objects
Journal: IEEE Software
Volume: 14
Issue: 1
Pages: 43-52
Short Title: Architectural styles, design patterns, and objects
ISSN: 0740-7459
DOI: 10.1109/52.566427
Keywords: object-oriented methods
software reusability
architectural styles
design patterns
object-oriented design
software design
software reuse
system design knowledge
Design engineering
Knowledge engineering
Power engineering and energy
Process design
Protocols
Software architecture
Software systems
Systems engineering and theory
Terminology
Abstract: Architectural styles, object-oriented design and design patterns all hold promise as approaches that simplify software design and reuse by capturing and exploiting system design knowledge. This article explores the capabilities and roles of the various approaches, their strengths and their limitations


Reference Type:  Conference Proceedings
Record Number: 8786
Author: Linden, T., Marsh, J. and Dove, D.
Year of Conference: 1986
Title: Architecture and early experience with planning for the ALV
Conference Name: Proceedings. 1986 IEEE International Conference on Robotics and Automation
Volume: 3
Pages: 2035-2042
Date: Apr 1986
Short Title: Architecture and early experience with planning for the ALV
DOI: 10.1109/ROBOT.1986.1087518
Keywords: Artificial intelligence
Computer architecture
Decision making
Land vehicles
Mobile robots
Real time systems
Remotely operated vehicles
Software algorithms
Software architecture
Technology planning
Abstract: This paper describes the software architecture and the initial algorithms that have proved to be effective for a real time robot planning system. The architecture is designed to incorporate planning technology from research on artificial intelligence while at the same time supporting the high performance decision making needed to control a fast-moving autonomous vehicle. The symbolic representation of the vehicle's plan is a key element in this architecture. Our initial algorithms use an especially efficient version of dynamic programming to find the best routes. The route is then translated into a symbolic plan. Replanning happens at several levels with the cost of replanning proportionate to the scope of the changes. This software is currently running in an environment which simulates the vehicle and perception systems, but it will be transferred to the DARPA Autonomous Land Vehicle built by Martin Marietta Denver Aerospace [Lowrie 86].
Notes: System development for algorithms


Reference Type:  Conference Paper
Record Number: 8112
Author: Kruchten, Phillippe
Year: 1995
Title: Architecture blueprints&mdash;the &ldquo;4+1&rdquo; view model of software architecture
Conference Name: Tutorial proceedings on TRI-Ada '91: Ada's role in global markets: solutions for a changing complex world
Conference Location: Anaheim, California, USA
Publisher: ACM
Pages: 540-555
DOI: 10.1145/216591.216611
Place Published: 216611
Notes: Specific usage of one view - more tool


Reference Type:  Conference Paper
Record Number: 8234
Author: LuperFoy, Susann, Loehr, Dan, Duff, David, Miller, Keith, Reeder, Florence and Harper, Lisa
Year: 1998
Title: An architecture for dialogue management, context tracking, and pragmatic adaptation in spoken dialogue systems
Conference Name: Proceedings of the 17th international conference on Computational linguistics - Volume 2
Conference Location: Montreal, Quebec, Canada
Publisher: Association for Computational Linguistics
Pages: 794-801
DOI: 10.3115/980432.980700
Place Published: 980700
Abstract: This paper details a software architecture for discourse processing in spoken dialogue systems, where the three component tasks of discourse processing are (1) Dialogue Management, (2) Context Tracking, and (3) Pragmatic Adaptation. We define these three component tasks and describe their roles in a complex, near-future scenario in which multiple humans interact with each other and with computers in multiple, simultaneous dialogue exchanges. This paper reports on the software modules that accomplish the three component tasks of discourse processing, and an architecture for the interaction among these modules and with other modules of the spoken dialogue system. A motivation of this work is reusable discourse processing software for integration with non-discourse modules in spoken dialogue systems. We document the use of this architecture and its components in several prototypes, and also discuss its potential application to spoken dialogue systems defined in the near-future scenario.
Notes: Example system - not relevant


Reference Type:  Conference Paper
Record Number: 8106
Author: Sangwan, Raghvinder S. and Ros, Johannes
Year: 2008
Title: Architecture leadership and management in globally distributed software development
Conference Name: Proceedings of the first international workshop on Leadership and management in software architecture
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 17-22
DOI: 10.1145/1373307.1373313
Place Published: 1373313
Abstract: Globally distributed software development is inherently difficult. The fundamental problem is that communication, coordination and control mechanisms that operate so naturally and invisibly in co-located projects are not available or not as effective for distributed teams. Maintaining a shared up-to-date understanding of the system under design among distributed teams separated by physical, temporal, and cultural distances, therefore, becomes challenging. Under such circumstances the role of a project architect takes on an added significance. The architect must bridge the gaps that exist among the distributed teams especially those with interrelated tasks. Bridging gaps across teams requires proactive effort to create, among distributed teams, a shared level of understanding of the system context, its problem domain and an overarching vision of the system to be designed. We call this a shared project context. Establishing a shared project context goes a long way in creating architectural artifacts, understanding dependencies across software elements of the architecture and the allocation of their development to the distributed teams. Lack of such a context leads to the creation of multiple realities promoting ignorance, confusion and frustration, which subsequently undermine mutual trust and make inter-team communications less effective. This vicious cycle leads to dysfunctional teams, inefficiencies in the project and ultimately to poorly designed architectures.


Reference Type:  Journal Article
Record Number: 9078
Author: Erdogmus, H.
Year: 2009
Title: Architecture Meets Agility
Journal: IEEE Software
Volume: 26
Issue: 5
Pages: 2-4
Short Title: Architecture Meets Agility
ISSN: 0740-7459
DOI: 10.1109/MS.2009.121
Keywords: Communication system control
Computer architecture
Costs
Documentation
Programming
Risk management
Software architecture
Stability
Vehicles
Yarn
agile software development
software engineering
Abstract: The concept of architecture has a major role to play in expanding the traditional scope of agile software development.


Reference Type:  Conference Proceedings
Record Number: 9003
Author: Rostami, K., Stammel, J., Heinrich, R. and Reussner, R.
Year of Conference: 2015
Title: Architecture-based assessment and planning of change requests
Conference Name: 2015 11th International ACM SIGSOFT Conference on Quality of Software Architectures (QoSA)
Pages: 21-30
Date: 4-8 May 2015
Short Title: Architecture-based assessment and planning of change requests
DOI: 10.1145/2737182.2737198
Keywords: software architecture
software maintenance
software quality
KAMP
Karlsruhe architectural maintainability prediction
architecture decisions
architecture-based assessment
change propagation
change requests planning
context information
information systems
software development process
software engineering artefacts
software evolution
Analytical models
Computer architecture
Context
Context modeling
Software
Change Request
Impact Analysis
Abstract: Software architecture reflects important decisions on structure, used technology and resources. Architecture decisions influence to a large extent requirements on software quality. During software evolution change requests have to be implemented in a way that the software maintains its quality, as various potential implementations of a specific change request influence the quality properties differently. Software development processes involve various organisational and technical roles. Thus, for sound decision making it is important to understand the consequences of the decisions on the various software engineering artefacts (e.g. architecture, code, test cases, build, or deployments) when analysing the impact of a change request. However, existing approaches do not use sufficient architecture descriptions or are limited to software development without taking management tasks into account. In this paper, we present the tool-supported approach Karlsruhe Architectural Maintainability Prediction (KAMP) to analyse the change propagation caused by a change request in a software system based on the architecture model. Using context information annotated on the architecture KAMP enables project members to assess the effects of a change request on various technical and organisational artefacts and tasks during software life cycle. We evaluate KAMP in an empirical study, which showed that it improves scalability of analysis for information systems due to automatically generated task lists containing more complete and precise context annotations than manually created ones.
Notes: Development of tool (even interesting)


Reference Type:  Conference Paper
Record Number: 8076
Author: Winbladh, Kristina, Alspaugh, Thomas A., Ziv, Hadar and Richardson, Debra
Year: 2006
Title: Architecture-based testing using goals and plans
Conference Name: Proceedings of the ISSTA 2006 workshop on Role of software architecture for testing and analysis
Conference Location: Portland, Maine
Publisher: ACM
Pages: 64-68
DOI: 10.1145/1147249.1147258
Place Published: 1147258
Abstract: This paper presents a specification-based testing approach that compares software specifications defined at different levels of abstraction, e.g. architecture and implementation, against specified system goals. We believe that a goal-driven approach that connects several development artifacts through verification of specified goals provides useful traceability links between those artifacts as well as an efficient testing technique. Our approach begins with a system goal graph in which high-level goals are step-wise refined into low-level functional goals that can be realized as code components. Each of the architectural components is associated with a plan that describes the component's functional behavior. Source code is annotated with goals from plans and events that achieve the goals; code is then precompiled to emit those goals and events at run time. Plans are automatically translated into a rule-based recognizer. An oracle is produced from the pre- and post-conditions associated with the plan's goals. When the program executes, the goals and events emitted are automatically tested against the plans and expected results. As components achieve their component-level plans, a higher-level plan recognizer, concerned with the integration of components, can verify correct system behavior over the interaction trace of a collection of lower-level plans. A small example illustrates the concept.
Notes: Not behavior


Reference Type:  Conference Proceedings
Record Number: 9531
Author: Bosch, J.
Year of Conference: 2002
Title: Architecture-centric software engineering
Conference Name: Proceedings of the 24th International Conference on Software Engineering. ICSE 2002
Pages: 681-682
Date: 25-25 May 2002
Short Title: Architecture-centric software engineering
Keywords: software architecture
architecture-centric software engineering
bottom-up design
industrial cases
organizational viewpoint
process viewpoint
software architect role
software architecture assessment
software architecture design
software architecture evaluation
software artefact variability management
software components
software infrastructure
software product lines
technical perspective
top-down design
tutorial
Companies
Computer architecture
Computer industry
Permission
Programming
Reflection
Software engineering
Software quality
Software reusability
Abstract: Many software organizations are in the transition from project-centric to architecture-centric engineering of software. This tutorial addresses this development by providing an overview and in-depth treatment of the issues surrounding the architecture-centric engineering of software. Topics include software architecture design in the presence of existing components and infrastructure (top-down versus bottom-up), architecture evaluation and assessment, software artefact variability management, software product lines and the role of the software architect. These topics are, in addition to the technical perspective, discussed from process and organizational viewpoints. The topics are extensively illustrated by examples and experiences from many industrial cases. The tutorial presents our experiences, reflections and research results concerning architecture-centric software engineering.


Reference Type:  Conference Proceedings
Record Number: 9321
Author: Miller, J. A. and Madhavji, N. H.
Year of Conference: 2007
Title: The Architecture-Requirements Interaction
Conference Name: 2007 Working IEEE/IFIP Conference on Software Architecture (WICSA'07)
Pages: 24-24
Date: 6-9 Jan. 2007
Short Title: The Architecture-Requirements Interaction
DOI: 10.1109/WICSA.2007.40
Keywords: decision making
software architecture
systems analysis
architecture-requirements interaction
requirements decision-making
requirements engineering processes
Banking
Computer architecture
Computer science
Councils
Documentation
Sampling methods
Software tools
Abstract: The interaction between software architecture (SA) and requirements engineering (RE) processes is generating interest within the research community. We explored the role of SA documentation in requirements decision-making. This paper describes the findings from this study.


Reference Type:  Conference Paper
Record Number: 8318
Author: Nafus, Dawn, Denman, Pete, Durham, Lenitra, Florez, Omar, Nachman, Lama, Sahay, Saurav, Savage, Evan, Sharma, Sangita, Strawn, Devon and Wouhaybi, Rita H.
Year: 2016
Title: As Simple as Possible but No Simpler: Creating Flexibility in Personal Informatics
Conference Name: Proceedings of the 2016 CHI Conference Extended Abstracts on Human Factors in Computing Systems
Conference Location: San Jose, California, USA
Publisher: ACM
Pages: 1445-1452
DOI: 10.1145/2851581.2892541
Place Published: 2892541
Abstract: Personal informatics has become a widespread practice, yet even expert users still face challenges in synthesizing and making sense of data. We suggest that these challenges are related to the complexities introduced once personal context is taken seriously. Through ethnographic research in the Quantified Self community, and an iterative software design process for a project called Data Sense, we offer early indications of what those challenges are, and describe how we approached solving them. We found that users had an easier time of working with data when they could use their own files, when temporal recurrences were surfaced and reminded them of other patterns, and when they could "grab" data directly from visualizations. However, the system did require more user learning than we anticipated.
Notes: System development


Reference Type:  Conference Proceedings
Record Number: 9561
Author: Williams, A.
Year of Conference: 2003
Title: Assessing genre as rhetorical performance in software design
Conference Name: IEEE International Professional Communication Conference, 2003. IPCC 2003. Proceedings.
Pages: 6 pp.
Date: 21-24 Sept. 2003
Short Title: Assessing genre as rhetorical performance in software design
DOI: 10.1109/IPCC.2003.1245500
Keywords: outsourcing
software engineering
technical presentation
professional communication
rhetorical genre theory
rhetorical performance
software design
software development
technical communication
Collaborative software
Computer industry
Employment
Environmental management
Knowledge management
Process design
Shape
Abstract: When organizations outsource, seeking expert help from external companies or consultants, often those in consulting roles will introduce new texts in order to help manage workflows and transform known work processes, all with the intention of improving work practices. Such scenarios challenge a key claim in rhetorical genre studies which perceives genres as actions that respond to situations that recur. As much as genre studies' notion of recurrence helps us understand texts' ability to facilitate communication in recurring workplace processes, it offers little insight into theoretical or methodological approaches for professional or technical communicators who may want to address, in theory, research, or practice, how workers use texts that have been imposed upon them with the purpose of creating situations entirely new to them and with the expectation that the new situation will stabilize and recur over time (as what often happens when companies merge or outsource). This kind of abrupt introduction of texts into the workplace marks phenomena called "genre dumping." In this paper, rhetorical genre theory and its application to genre dumping in technical communication has been examined, which have two aims: (a) to discuss how genre studies gives shape to what we know about how texts work in professional settings where technical work happens; and (b) to assess issues that genre dumping presents to rhetorical genre theory.
Notes: not fitting, different topic


Reference Type:  Conference Paper
Record Number: 7993
Author: Fresa, A., Nucera, G., Peciola, E. and Santucci, G.
Year: 2002
Title: Assessment of software architectures: a case study
Conference Name: Proceedings of the 14th international conference on Software engineering and knowledge engineering
Conference Location: Ischia, Italy
Publisher: ACM
Pages: 699-706
DOI: 10.1145/568760.568881
Place Published: 568881
Abstract: Producing high quality software is a very hard task. In the last years a big effort has been spent in devising techniques for estimating and/or measuring software properties. This ranges from forecasting, in a very early stage, the cost of software production to measuring several subcharacterics in order to assess the internal and external software quality. The role of predicting vs. measuring is gaining an increas ing relevance. As an example, the recently revised ISO 9126 standard [1] introduces the concept of Estimated (Predicted) Product Quality. It is clear that the sooner estimated figures are available, the better is possible to modify some design choices. Among all the aspects involved in software developing, a central role is played by the chosen software architecture. Estimating the quality characteristics of such architecture is a strategic activity that can drive several following design decision. In this paper we report the experience of an architectural assessment performed in Ericsson Lab Italy. The assessment was performed according to the framework presented by Jan Bosch in [2].
Notes: software architecture, but not the software architect itself


Reference Type:  Conference Proceedings
Record Number: 8032
Author: Anvaari, Mohsen, S, Carl-Fredrik, #248, rensen and Zimmermann, Olaf
Year of Conference: 2016
Title: Associating architectural issues with quality attributes: a survey on expert agreement
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-7
Short Title: Associating architectural issues with quality attributes: a survey on expert agreement
DOI: 10.1145/2993412.3004847
Place Published: 3004847
Abstract: The architectural decision-making process is a complex and crucial endeavor in companies that develop large and distributed software systems. In this process, choosing and evaluating a solution for each architectural issue depends on decision drivers. The drivers are mainly the business factors (e.g., cost, time-to-market, etc.) and software quality attributes (e.g., security, adaptability, etc.). This paper examines whether there is agreement among experts in associating (i.e., relating) architectural issues with relevant quality attributes. We conducted a survey with 37 experts from several industrial domains who, at least once a month, make one or more architectural decisions. The results show there is poor agreement among these experts in identifying and scoring relevant quality attributes for each architectural issue. Poor agreement implies that the associating task is subjective, and that experts inconsistently define and interpret the relevance of various quality attributes for a given architectural issue that may hurt the sustainability of their architectural decisions. This paper suggests that practitioners in their decision-making should employ approaches that are more systematic. The approaches should be supported by methods and tools designed to diminish the biases of intuitive, experience-based approaches of associating architectural issues with quality attributes.
'File' Atttachments: internal-pdf://0397144427/Associating architectural issues with quality.pdf


Reference Type:  Journal Article
Record Number: 8424
Author: Yang, Chen, Liang, Peng and Avgeriou, Paris
Year: 2018
Title: Assumptions and their management in software development: A systematic mapping study
Journal: Information and Software Technology
Volume: 94
Pages: 82-110
Date: 2//
Short Title: Assumptions and their management in software development: A systematic mapping study
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2017.10.003
Keywords: Software development
Assumption
Assumptions management
Systematic mapping study
Abstract: AbstractContext Assumptions are constantly made by stakeholders or generated automatically in software development. However, there is a lack of systematic analysis and comprehensive understanding of the research and practice regarding assumptions and their management. Objective This work aims to explore and analyze the state of the art on assumptions and their management in software development. Method A systematic mapping study that covers the literature from January 2001 to December 2015 on assumptions and their management in software development. Results 134 studies were included: (1) The studies were published in 94 venues, which indicates that assumptions and their management has been a broad topic in software engineering. (2) Only 21 studies defined the assumption concept. (3) Most assumptions are made for or related to the artifacts in requirements engineering and software design, which demonstrates that assumptions should be managed from the early phases of software development. (4) Much effort has been put on Assumptions Making, Description, and Evaluation. Assumptions Maintenance received moderate attention. More than half of the tools identified aim to support assume-guarantee reasoning. For the other tools, most of them can be used to support Assumptions Description. (5) All the identified types of stakeholders are involved in Assumptions Making, followed by Evaluation and Description. Stakeholders involved in requirements engineering, software design, and software construction play a central role in assumptions management. (6) The main challenge is the difficulty of performing assumptions management activities in software development. (7) The identified assumptions management approaches, tools, benefits, and lessons learned are limited to their specific contexts (e.g., context of use). (8) Most of the negative consequences are caused by invalid or implicit assumptions. Conclusions This work provides researchers and practitioners with a reflection of the past fifteen years of research and practice on assumptions and their management in software development.
Notes: Literature review - excluded
URL: https://www.sciencedirect.com/science/article/pii/S0950584916304189


Reference Type:  Conference Proceedings
Record Number: 9516
Author: Harrison, T. C. and Campbell, A. P.
Year of Conference: 2011
Title: Attempting to Understand the Progress of Software Architecture Decision-Making on Large Australian Defence Projects
Conference Name: 2011 Ninth Working IEEE/IFIP Conference on Software Architecture
Pages: 42-45
Date: 20-24 June 2011
Short Title: Attempting to Understand the Progress of Software Architecture Decision-Making on Large Australian Defence Projects
DOI: 10.1109/WICSA.2011.15
Keywords: computational complexity
decision theory
military computing
software architecture
software development management
Australian defence projects
architecture knowledge management
de facto decision theory
dynamic complexity
model of software system architecture decision making
ubiquitous normative decision theory
Biological system modeling
Computer architecture
Decision making
Humans
Modeling
Presses
USA Councils
agent-based modeling
decision-making
decisions
simulation
Abstract: This short paper details exploratory research into architecture knowledge management (AKM) at the very early stages of architectural design. This is a departure from traditional AKM, instead of a focus on decisions, the focus shifts to decision making. Additional decision theories and decision-making philosophies are needed to supplement the ubiquitous normative decision theory and its associated rational decision-making, which is assumed by AKM to-date as the de facto decision theory. Extensions to the agent model paradigm have been explored to portray the evolution of a set of architecture decisions according to multiple decision theories sourced from the human sciences of neurology, psychology, and sociology. Model Of Software System Architecture Decision-making (MOSSAD) uses agent-based modeling and simulation in an attempt to understand the dynamic complexity of interdependencies &amp; interactions found in decision-to-decision relationships amongst hundreds of decisions and their asynchronous evolutions over time. If understanding is possible, this should lead to knowledge for legitimate progress of architectural decision-making. This in turn should lead to a new theory about the time period necessary for architectural design on a project.


Reference Type:  Conference Paper
Record Number: 8005
Author: Cosmo, Roberto Di, Lienhardt, Michael, Treinen, Ralf, Zacchiroli, Stefano, Zwolakowski, Jakub, Eiche, Antoine and Agahi, Alexis
Year: 2014
Title: Automated synthesis and deployment of cloud applications
Conference Name: Proceedings of the 29th ACM/IEEE international conference on Automated software engineering
Conference Location: Vasteras, Sweden
Publisher: ACM
Pages: 211-222
DOI: 10.1145/2642937.2642980
Place Published: 2642980
Abstract: Complex networked applications are assembled by connecting software components distributed across multiple machines. Building and deploying such systems is a challenging problem which requires a significant amount of expertise: the system architect must ensure that all component dependencies are satisfied, avoid conflicting components, and add the right amount of component replicas to account for quality of service and fault-tolerance. In a cloud environment, one also needs to minimize the virtual resources provisioned upfront, to reduce the cost of operation. Once the full architecture is designed, it is necessary to correctly orchestrate the deployment phase, to ensure all components are started and connected in the right order.

We present a toolchain that automates the assembly and deployment of such complex distributed applications. Given as input a high-level specification of the desired system, the set of available components together with their requirements, and the maximal amount of virtual resources to be committed, it synthesizes the full architecture of the system, placing components in an optimal manner using the minimal number of available machines, and automatically deploys the complete system in a cloud environment.
Notes: building system instead of behavior


Reference Type:  Conference Paper
Record Number: 7963
Author: Freeman, Peter
Year: 1973
Title: Automating software design
Conference Name: Proceedings of the 10th Design Automation Workshop
Publisher: IEEE Press
Pages: 62-67
Place Published: 804000
Abstract: The author summarizes the Workshop on Automating Software Design, held August 25, 1988, at the annual conference of the America Association for Artificial Intelligence. Sixty researchers from North America, Europe, and Japan met to discuss recent advances in knowledge-based software engineering. The interests of participants ranged from using AI techniques for managing large software projects to automatic programming.
Notes: just summary - exclude quality criteria


Reference Type:  Journal Article
Record Number: 8523
Author: Suh, Nam P. and Do, Sung-Hee
Year: 2000
Title: Axiomatic Design of Software Systems
Journal: CIRP Annals
Volume: 49
Issue: 1
Pages: 95-100
Date: //
Short Title: Axiomatic Design of Software Systems
ISSN: 0007-8506
DOI: https://doi.org/10.1016/S0007-8506(07)62904-7
Keywords: software
axiomatic
design
Abstract: Software is playing an increasingly important role in manufacturing. Many manufacturing firms have problems with software development. Software engineering is still labor- intensive and prone to errors. Industrial firms are under pressure to shorten the lead-time required in introducing new software, increase the reliability of their software, and increase their market share. Software must be designed correctly from the beginning to end. With this end in mind, axiomatic design theory has been applied to software design. This paper presents how the combination of axiomatic design has been combined with the object-oriented programming method to create a large software system.
Notes: special implementation
URL: https://www.sciencedirect.com/science/article/pii/S0007850607629047


Reference Type:  Journal Article
Record Number: 8450
Author: Martínez-Fernández, Silverio, Ayala, Claudia P., Franch, Xavier and Marques, Helena Martins
Year: 2017
Title: Benefits and drawbacks of software reference architectures: A case study
Journal: Information and Software Technology
Volume: 88
Pages: 37-52
Date: 8//
Short Title: Benefits and drawbacks of software reference architectures: A case study
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2017.03.011
Keywords: Software architecture
Reference architecture
Empirical software engineering
Case study
Benefits
Drawbacks
Abstract: AbstractContext Software Reference Architectures (SRAs) play a fundamental role for organizations whose business greatly depends on the efficient development and maintenance of complex software applications. However, little is known about the real value and risks associated with SRAs in industrial practice. Objective To investigate the current industrial practice of SRAs in a single company from the perspective of different stakeholders. Method An exploratory case study that investigates the benefits and drawbacks perceived by relevant stakeholders in nine SRAs designed by a multinational software consulting company. Results The study shows the perceptions of different stakeholders regarding the benefits and drawbacks of SRAs (e.g., both SRA designers and users agree that they benefit from reduced development costs; on the contrary, only application builders strongly highlighted the extra learning curve as a drawback associated with mastering SRAs). Furthermore, some of the SRA benefits and drawbacks commonly highlighted in the literature were remarkably not mentioned as a benefit of SRAs (e.g., the use of best practices). Likewise, other aspects arose that are not usually discussed in the literature, such as higher time-to-market for applications when their dependencies on the SRA are managed inappropriately. Conclusions This study aims to help practitioners and researchers to better understand real SRAs projects and the contexts where these benefits and drawbacks appeared, as well as some SRA improvement strategies. This would contribute to strengthening the evidence regarding SRAs and support practitioners in making better informed decisions about the expected SRA benefits and drawbacks. Furthermore, we make available the instruments used in this study and the anonymized data gathered to motivate others to provide similar evidence to help mature SRA research and practice.
Notes: specific implementation examined, not the role of architects/designers
URL: https://www.sciencedirect.com/science/article/pii/S0950584916304438


Reference Type:  Conference Proceedings
Record Number: 8867
Author: Ven, J. S. v. d. and Bosch, J.
Year of Conference: 2016
Title: Busting Software Architecture Beliefs: A Survey on Success Factors in Architecture Decision Making
Conference Name: 2016 42th Euromicro Conference on Software Engineering and Advanced Applications (SEAA)
Pages: 42-49
Date: Aug. 31 2016-Sept. 2 2016
Short Title: Busting Software Architecture Beliefs: A Survey on Success Factors in Architecture Decision Making
ISBN: 2376-9505
DOI: 10.1109/SEAA.2016.35
Keywords: decision making
software architecture
software development management
statistical analysis
architectural decisions
architecture decision making
architecture documentation
project failure
project success
software architecture beliefs
software development
Companies
Computer architecture
Documentation
Software
Architectural Design Decisions
Software Processes
Survey
Abstract: As software development changes, also the myths and beliefs around it come and go. In different communities, different beliefs are kept, usually strengthened by success or failure stories. In this research, we study the beliefs surrounding software architecture. The beliefs range from the amount of effort needed for architecture documentation, to the size of the team or the persons responsible for making the architectural decisions. Most beliefs are based on the idea that the outcome of the project is highly dependent on the methods used during the design and development of software. We conducted a survey with 39 architects where we evaluated 54 architectural decisions. In this survey, we assessed the way in which decisions were made, the success factors of the decisions, as well as the properties of the projects. We conduct statistical analysis in order to evaluate some of the beliefs that currently exist in software development. We conclude that for most of the beliefs, no statistical evidence can be found, making these beliefs folklore for the tales, instead of useful guidelines for predicting projects success or failure.
'File' Atttachments: internal-pdf://1752083816/Busting Software Architecture Beliefs A Survey.pdf


Reference Type:  Conference Paper
Record Number: 7894
Author: Tofan, Dan and Galster, Matthias
Year: 2014
Title: Capturing and Making Architectural Decisions: an Open Source Online Tool
Conference Name: Proceedings of the 2014 European Conference on Software Architecture Workshops
Conference Location: Vienna, Austria
Publisher: ACM
Pages: 1-4
DOI: 10.1145/2642803.2642836
Place Published: 2642836
Abstract: Architectural decisions (such as selecting patterns, technologies, or decomposing systems) and their rationale are a significant aspect of architectural knowledge. In this paper, we present a tool that helps architects capture tacit knowledge about architectural decisions. Furthermore, the tool helps architects and other stakeholders analyze decisions. Finally, the tool supports group decision making. The tool is based on theoretical and conceptual foundations created and evaluated in previous work. We developed the tool as a research tool in an academic environment, and we used the tool with industrial practitioners. The tool is web-based and available as an open source project. In this paper we highlight the underlying research contributions of the tool and show how research approaches and findings have been transferred into a working tool.
Notes: just a tool


Reference Type:  Conference Paper
Record Number: 8069
Author: Monroe, Robert T.
Year: 1996
Title: Capturing design expertise in software architecture design environments
Conference Name: Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops
Conference Location: San Francisco, California, USA
Publisher: ACM
Pages: 87-89
DOI: 10.1145/243327.243616
Place Published: 243616


Reference Type:  Conference Proceedings
Record Number: 9343
Author: Balland, E., Consel, C., Kaoua, B. N' and Sauzéon, H.
Year of Conference: 2013
Title: A case for human-driven software development
Conference Name: 2013 35th International Conference on Software Engineering (ICSE)
Pages: 1229-1232
Date: 18-26 May 2013
Short Title: A case for human-driven software development
ISBN: 0270-5257
DOI: 10.1109/ICSE.2013.6606685
Keywords: human computer interaction
simulation languages
software engineering
user interfaces
HCI techniques
UI design language
human-computer interaction
human-driven software development methodology
software design
tool suite
user interface
user modeling language
Abstracts
Computational modeling
Context
Electronic mail
Programming
Software
Abstract: Human-Computer Interaction (HCI) plays a critical role in software systems, especially when targeting vulnerable individuals (e.g., assistive technologies). However, there exists a gap between well-tooled software development methodologies and HCI techniques, which are generally isolated from the development toolchain and require specific expertise. In this paper, we propose a human-driven software development methodology making User Interface (UI) a full-fledged dimension of software design. To make this methodology useful in practice, a UI design language and a user modeling language are integrated into a tool suite that guides the stakeholders during the development process, while ensuring the conformance between the UI design and its implementation.
Notes: about tools


Reference Type:  Journal Article
Record Number: 8734
Author: Ockerman, Jennifer J. and Mitchell, Christine M.
Year: 1999
Title: Case-based design browser to support software reuse: theoretical structure and empirical evaluation
Journal: International Journal of Human-Computer Studies
Volume: 51
Issue: 5
Pages: 865-893
Date: 11//
Short Title: Case-based design browser to support software reuse: theoretical structure and empirical evaluation
ISSN: 1071-5819
DOI: https://doi.org/10.1006/ijhc.1999.0253
Abstract: With the proliferation of large, complex software systems, reuse of previous software designs and software artifacts, such as operation concepts, requirements, specifications and source code, is an important issue for both industry and government. Reuse has long been expected to result in substantial productivity and quality gains. To date, this expectation has been largely unmet. One reason may be the lack of tools to support software reuse. This research proposes the development of one such tool, the Design Browser. The Design Browser is a software architecture intended to support designers of large software systems in the early stages of software design, specifically conceptual design. The Design Browser is based on principles derived from cognitive engineering (e.g. Woods &amp; Roth, 1988 a); naturalistic decision-making, particularly Klein's (1989) recognition-primed decision making model; and Kolodner's (1993) approach to case-based reasoning. As a proof-of-concept demonstration, the Design Browser was implemented for a NASA satellite control sub-system—the command management system (CMS). An empirical evaluation was conducted. It used the CMS Design Browser and participants who were part of the three user groups often involved in large-scale commercial software development. These groups are the software design team, the users and management. The results of the evaluation show that all three groups found the CMS Design Browser quite useful as demonstrated by actual performance and subjective rating.
Notes: tool development
URL: https://www.sciencedirect.com/science/article/pii/S1071581999902537


Reference Type:  Conference Paper
Record Number: 8174
Author: Rugaber, Spencer
Year: 2006
Title: Cataloging design abstractions
Conference Name: Proceedings of the 2006 international workshop on Role of abstraction in software engineering
Conference Location: Shanghai, China
Publisher: ACM
Pages: 11-18
DOI: 10.1145/1137620.1137624
Place Published: 1137624
Abstract: Abstractions are the essence of software design, and various enterprises, such as design patterns, architectural styles, programming clichés and idioms, attempt to capture, organize and present them to software engineers. This position paper explores the possibility of mounting a more comprehensive effort to catalog abstractions. Related efforts such as the design of textual and electronic dictionaries, markup languages for software artifacts and ontologies of computer science topics are surveyed to inform the effort. A set of derivative questions is presented to explore the problem space.


Reference Type:  Conference Proceedings
Record Number: 7552
Author: Me, G., Procaccianti, G. and Lago, P.
Year of Conference: 2017
Title: Challenges on the Relationship between Architectural Patterns and Quality Attributes
Conference Name: 2017 IEEE International Conference on Software Architecture (ICSA)
Pages: 141-144
Date: 3-7 April 2017
Short Title: Challenges on the Relationship between Architectural Patterns and Quality Attributes
DOI: 10.1109/ICSA.2017.19
Keywords: object-oriented methods
software architecture
software quality
architectural patterns
architectural tactics
design decisions
quality attributes
relationship patterns-QAs
Computer architecture
Context
Decision making
Fault tolerance
Security
Stakeholders
Architectural Pattern
Quality Attribute
Tactic
Abstract: Among other knowledge, software architecture design decision-making relies on the relation between architectural patterns and quality attributes (QAs). However, this relation is often implicit, or in the best case informally and partially defined. This leads to sub-optimal understanding of the impact of the architecture design on the desired level of quality. In this work, we aim to shed light on the relation patterns-QAs in the context of an important architectural mechanism, architectural tactics. Tactics are design decisions that address a specific quality attribute. In turn, the implementation of a tactic has a different impact according to the used pattern. From a previous systematic literature review, we selected and analyzed 13 primary studies with a clear focus on tactics. From our analysis, we extracted three overarching challenges on the relationship patterns-QAs that are yet unsolved by research. The essence of these challenges suggests that further research is needed to identify a clear and precise link between the functional nature of architectural elements and non-functional quality properties.
Notes: literature review


Reference Type:  Conference Proceedings
Record Number: 8796
Author: Díaz, J., Pérez, J., Garbajosa, J. and Yagüe, A.
Year of Conference: 2013
Title: Change-Impact Driven Agile Architecting
Conference Name: 2013 46th Hawaii International Conference on System Sciences
Pages: 4780-4789
Date: 7-10 Jan. 2013
Short Title: Change-Impact Driven Agile Architecting
ISBN: 1530-1605
DOI: 10.1109/HICSS.2013.127
Keywords: Computer architecture
Decision making
Documentation
Planning
Software
Software architecture
Variable speed drives
Agile Architecting
Agile Software Development
Architectural Knowledge
Change Impact Analysis
Abstract: Software architecture is a key factor to scale up Agile Software Development (ASD) in large software-intensive systems. Currently, software architectures are more often approached through mechanisms that enable to incrementally design and evolve software architectures (aka. agile architecting). Agile architecting should be a light-weight decision-making process, which could be achieved by providing knowledge to assist agile architects in reasoning about changes. This paper presents the novel solution of using change-impact knowledge as the main driver for agile architecting. The solution consists of a Change Impact Analysis technique and a set of models to assist agile architects in the change (decision-making) process by retrieving the change-impact architectural knowledge resulting from adding or changing features iteration after iteration. To validate our approach, we have put our solution into practice by running a project of a metering management system in electric power networks in an i-smart software factory.


Reference Type:  Journal Article
Record Number: 9111
Author: Spinellis, D.
Year: 2016
Title: The Changing Role of the Software Architect
Journal: IEEE Software
Volume: 33
Issue: 6
Pages: 4-6
Short Title: The Changing Role of the Software Architect
ISSN: 0740-7459
DOI: 10.1109/MS.2016.133
Keywords: software architecture
software quality
software reusability
quality elements
software agility
software architect
software development
software industry
software reuse
software testability
software engineering
Abstract: Being a good software architect has never been easy. Changes in the software industry are making the job even more challenging. The key drivers are the rising role of software in systems and their operation; more emphasis on reuse, agility, and testability during software development; and several quality elements increasingly affected by architectural choices.


Reference Type:  Conference Paper
Record Number: 8105
Author: Melleg\, Niklas, \#229, rd and Staron, Miroslaw
Year: 2010
Title: Characterizing model usage in embedded software engineering: a case study
Conference Name: Proceedings of the Fourth European Conference on Software Architecture: Companion Volume
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 245-252
DOI: 10.1145/1842752.1842800
Place Published: 1842800
Abstract: During development of complex products, such as automotive software, models -- formal and informal -- are used throughout the development process by different roles and for different purposes -- as requirement, as implementation or as documentation. This paper reports results from a case-study of the development of embedded software at a Swedish vehicle manufacturer. We investigated use of models from high-level product planning to low-level requirements specifications for software components. Furthermore, we investigated the distribution of effort among the models, requirements and other artefacts. The goal was to explore the spectrum of modelling techniques, methods and languages used and to establish a baseline for comparison with the state-of-the-art and other companies. The results show that there exist at least 8 different modelling notations. Moreover, we found that the majority of effort was spent on behaviour models, while static models -- such as high-level design and requirements -- were considered most important.
Notes: Model usage not in focus


Reference Type:  Conference Proceedings
Record Number: 8964
Author: Paulisch, F. and Zimmerer, P.
Year of Conference: 2016
Title: Collaboration of Software Architect and Test Architect Helps to Systematically Bridge Product Lifecycle Gap
Conference Name: 2016 IEEE/ACM 1st International Workshop on Bringing Architectural Design Thinking Into Developers' Daily Activities (BRIDGE)
Pages: 11-13
Date: 17-17 May 2016
Short Title: Collaboration of Software Architect and Test Architect Helps to Systematically Bridge Product Lifecycle Gap
DOI: 10.1109/Bridge.2016.011
Keywords: computer science education
life cycle costing
on-the-job training
program testing
software architecture
software development management
BRIDGE workshop
high-level design
joint venture
low-level implementation
organization-wide qualification and training program
product lifecycle gap
software architect
test architect
Collaboration
Computer architecture
Conferences
Qualifications
Requirements engineering
Software
Testing
Software architecture
software architect
software testing
test architect
software engineering
education
Abstract: In this position paper for the BRIDGE workshop we describe an approach used at Siemens to address the gap between high-level design and low-level implementation. This approach is a key part of our organization-wide qualification and training program for software-related roles. These roles include both a &#x201C;software architect&#x201D; and a &#x201C;test architect&#x201D; and these roles (as well as other roles) must collaborate closely as a kind of &#x201C;joint venture&#x201D;.


Reference Type:  Conference Proceedings
Record Number: 9082
Author: DeFranco-Tommarello, J. and Deek, F. P.
Year of Conference: 2002
Title: Collaborative software development: a discussion of problem solving models and groupware technologies
Conference Name: Proceedings of the 35th Annual Hawaii International Conference on System Sciences
Pages: 568-577
Date: 7-10 Jan. 2002
Short Title: Collaborative software development: a discussion of problem solving models and groupware technologies
DOI: 10.1109/HICSS.2002.993937
Keywords: groupware
human factors
human resource management
professional aspects
software development management
software tools
collaboration models
collaborative problem solving
collaborative problem solving techniques
collaborative software development
collaborative structures
decision making
group cognition
groupware technologies
groupware theory
problem solving
problem solving model
problem solving models
psychology
software design
software development domain
software development process
teamwork
Collaborative software
Collaborative tools
Collaborative work
Heart
Paper technology
Problem-solving
Programming
Abstract: Teamwork is always challenging. Adding the complication of problem solving and software design only amplifies this challenge. The challenges of developing software as a team can be reduced by using groupware to coordinate and communicate the intricate details involved in the process. The study sets out to determine if in fact there are tools available to assist in the collaborative problem solving and software development process. It must be understood at the outset that problem solving is at the heart of software development. Without amplifying the collaborative problem solving steps required for developing an effective and efficient solution, a much less then accurate solution will result. The paper provides a review of collaborative problem solving techniques and groupware in the software development domain, covering both methodology and technology. There are three areas of focus in the paper: collaborative problem solving and decision making; groupware theory and tools; and group cognition and psychology. The review is followed by analysis of the collaboration models and tools as well as their potential impact on software development. The paper ends with a discussion of future work that will include developing a tool which incorporates a problem solving model and collaborative structures for the software development domain.


Reference Type:  Conference Paper
Record Number: 8098
Author: Maras, Josip, Ljiljana, #352, eri, #263, Maja, #352, tula, Uki, Nenad and #263
Year: 2015
Title: Combining education, industry, and empirical studies in Software Engineering: an experience report
Conference Name: Proceedings of the 2015 European Conference on Software Architecture Workshops
Conference Location: Dubrovnik, Cavtat, Croatia
Publisher: ACM
Pages: 1-5
DOI: 10.1145/2797433.2797472
Place Published: 2797472
Abstract: Software industry is one of the most pervasive industries today and has a great impact on our day-to-day lives. At the same time, the quality of software systems is directly related to the quality of software engineers -- it is the responsibility of software engineering educators to provide students with relevant skills needed for the development of high-quality software systems. Amongst the cornerstones of developing high-quality software systems are industry-relevant experience and the ability to quantify certain aspects of the software development process. In this paper, we describe our experience of performing an empirical study on students, during a software engineering course, on an industry-relevant topic taught by an industry expert -- the understandability of models in model-driven engineering.
Notes: on students - exclusion


Reference Type:  Journal Article
Record Number: 8062
Author: Ocker, Rosalie J. and Fjermestad, Jerry
Year: 2008
Title: Communication differences in virtual design teams: findings from a multi-method analysis of high and low performing experimental teams
Journal: SIGMIS Database
Volume: 39
Issue: 1
Pages: 51-67
Short Title: Communication differences in virtual design teams: findings from a multi-method analysis of high and low performing experimental teams
ISSN: 0095-0033
DOI: 10.1145/1341971.1341977
Legal Note: 1341977
Abstract: This multi-method study distinguishes between four high performing and four low performing fully distributed virtual design teams, through an analysis of their asynchronous communication. Results indicate that these teams were similar in terms of the number of messages exchanged, the amount of communication devoted to aspects of design, and the amount and proportion of communication spent on team coordination, supportive commentary, and "other" topics. However, high performing teams were more verbose---they communicated more words. They also spent less time in brainstorming activities. Rather, high performing teams engaged in more critical commentary and active debate, compared to low performing teams. High performing teams conducted more in-depth discussions in the form of argumentation, as ideas were developed through an interactive debate of the pros and cons of issues. This debate resulted in the need for summaries, which served a dual role as they became intermediate steps in the process of writing the report deliverable
Notes: students
'File' Attachments: internal-pdf://2982054805/Communication differences in virtual design te.pdf


Reference Type:  Conference Proceedings
Record Number: 9048
Author: Budgen, D. and Pohthong, A.
Year of Conference: 1999
Title: Component reuse in software design: an observational study
Conference Name: Software Technology and Engineering Practice, 1999. STEP '99. Proceedings
Pages: 63-72
Date: 1999
Short Title: Component reuse in software design: an observational study
DOI: 10.1109/STEP.1999.798480
Keywords: Unix
software reusability
subroutines
system documentation
Unix processes
component documentation
component-based software development
goodness of fit
opportunistic strategy
software component reuse
software design
software engineering research
Component architectures
Computer science
Decision making
Design methodology
Documentation
Electrical capacitance tomography
Electronic switching systems
Process design
Programming
Abstract: The adoption of a component-based strategy for software development is likely to require a major paradigm shift in design practices in order to incorporate such factors as reuse and goodness of fit. This paper describes an empirical study that we have performed to investigate how designers' strategies evolve when using Unix processes as components. Our results suggest that, as they gain confidence, designers adopt a more strongly opportunistic strategy, and we particularly identify the importance of having access to component documentation when making design decisions, regardless of a designer's detailed solution strategy. We conclude by identifying some of the attributes that will be needed in any tools and environments that are intended to support component-based software development, and discuss the role that studies of this type can play in software engineering research
Notes: students
'File' Atttachments: internal-pdf://4163133649/Component reuse in software design an observat.pdf


Reference Type:  Journal Article
Record Number: 8190
Author: Riehle, Dirk
Year: 1997
Title: Composite design patterns
Journal: SIGPLAN Not.
Volume: 32
Issue: 10
Pages: 218-228
Short Title: Composite design patterns
ISSN: 0362-1340
DOI: 10.1145/263700.263739
Legal Note: 263739
Abstract: Software  design  patterns  are  the  core  abstractions  from  successful  recurring  problem  solutions  in  software  design. Composite design patterns are the core abstractions from successful recurring frameworks. A composite design pattern is a pattern that is best described as the composition of further patterns the integration of which shows a synergy that makes  the  composition  more  than  just  the  sum  of  its  parts.  This  paper  presents  examples  of  composite  patterns,  discusses  a  role-based  analysis  and  composition  technique,  and  demonstrates  that  composite  patterns  extend  the  pattern idea from single problem solutions to object-oriented frameworks.
Notes: just example of patterns


Reference Type:  Conference Proceedings
Record Number: 9208
Author: Keller, R. K. and Schauer, R.
Year of Conference: 1998
Title: A compositional approach to software design
Conference Name: Proceedings of the Thirty-First Hawaii International Conference on System Sciences
Volume: 5
Pages: 386-395 vol.5
Date: 6-9 Jan 1998
Short Title: A compositional approach to software design
DOI: 10.1109/HICSS.1998.648334
Keywords: object-oriented methods
software quality
software reusability
subroutines
changeable software architectures
component software models
component-based software development
compositional approach
concreteness
design components
design composition
design environment
design process
formal expertise
independently evolving building blocks
informal expertise
object-oriented design
prefabricated configurable building blocks
reified design patterns
reusable software architectures
scope
software design
specificity
systems implementation
Application software
Assembly
Councils
Electronic mail
Object oriented modeling
Process design
Programming profession
Software engineering
Abstract: Component software models promote software development by the assembly of prefabricated, configurable and independently evolving building blocks. Although effective for systems implementation, this approach is inadequate for the creation of reusable and changeable software architectures. Design patterns address these shortcomings of component-based software development by capturing the formal and informal expertise that is necessary for a reusable solution to a recurring problem. However, so far, there is no methodical approach to providing these building blocks in a tangible, flexible and composable form. To address this limitation, we introduce design components, which are reified design patterns fitted for component software. We detail the activities of design composition and illustrate them as a process within a 3D space of concreteness, specificity and scope. To evaluate design components and put them into perspective, we discuss their contribution in respect to important software quality properties
Notes: just example - not skill


Reference Type:  Conference Paper
Record Number: 8072
Author: Popovic, Kresimir and Hocenski, Zeljko
Year: 2009
Title: Conflict management
Conference Name: Proceedings of the 2009 ICSE Workshop on Leadership and Management in Software Architecture
Publisher: IEEE Computer Society
Pages: 15-19
DOI: 10.1109/lmsa.2009.5074859
Place Published: 1564683
Abstract: Project managers must learn to recognize the signs and symptoms of disruptive conflict. Such signs would include poor communication among team members, a lack of openness, a lack of respect, unclear requirements, change between managers and employees, broken boundaries of social norms or groups, different backgrounds (educational, economic, cultural, political, etc.). The worst cases can disintegrate into personal stress, burnout, and workplace travesties. Once conflict has reached this stage, it will require a large amount of management time in order to deal with it. This will cause an additional decrease in productivity and efficiency rates, along with the accompanying added costs, risks, and duration delays. If left unmanaged, this type of conflict can even lead to employee sabotage and sometimes workplace violence. This position paper provides insight into qualities and social role that project manager as mediator and leader must possess because sometimes team members can't resolve conflicts collectively.
Notes: focused on project managers to help teams


Reference Type:  Conference Proceedings
Record Number: 8904
Author: Levendel, I.
Year of Conference: 2006
Title: The consequences of variability in software
Conference Name: 12th IEEE International On-Line Testing Symposium (IOLTS'06)
Pages: 1 pp.
Date: 10-12 July 2006
Short Title: The consequences of variability in software
ISBN: 1942-9398
DOI: 10.1109/IOLTS.2006.60
Keywords: program testing
software metrics
software reliability
model analysis
software defects
software development
software instability
software model
software production
software variance
Analysis of variance
Application software
Computer industry
Human factors
Production
Programming
Software architecture
Software development management
Software testing
Abstract: Summary form only given. Contrary to many other industrial processes, software production is characterized by an unusually high variance. This directly results from the significant role of the human factor in all the phases of its realization, and this will likely remain the case for a long time to come. In order to set the record straight, this presentation first analyzes various aspects of software metrics that demonstrate the heterogeneous nature of software and the variance in the software production process. We propose a new software model susceptible to acknowledge software variance and take advantage of it for managing the software development process. This model allows the identification of areas of software instability that are caused by the concentration of software defects. Two major applications are derived from the model analysis. First, the model provides a method for evaluating the "goodness" of the software architecture. The model can also be used to balance the budgeting of the testing effort among the various software functionalities and their interactions. We also discuss potential applications of the recognition of software variability for developing reactive real-time methods for improving software dependability
Notes: does not focus on behavior


Reference Type:  Conference Proceedings
Record Number: 9376
Author: Nakagawa, E. Y., Guessi, M., Maldonado, J. C., Feitosa, D. and Oquendo, F.
Year of Conference: 2014
Title: Consolidating a Process for the Design, Representation, and Evaluation of Reference Architectures
Conference Name: 2014 IEEE/IFIP Conference on Software Architecture
Pages: 143-152
Date: 7-11 April 2014
Short Title: Consolidating a Process for the Design, Representation, and Evaluation of Reference Architectures
DOI: 10.1109/WICSA.2014.25
Keywords: control engineering computing
robots
software architecture
ProSA-RA process
ad-hoc approach
design expertise
reference architecture design
reference architecture evaluation
reference architecture representation
robotics domain
software system development
software system evolution
software system standardization
specific domain understanding
Architecture
Computer architecture
Ontologies
Software systems
Unified modeling language
Reference architecture
reference architecture model
robotics
Abstract: Reference architectures have emerged as a special type of software architecture that achieves well-recognized understanding of specific domains, promoting reuse of design expertise and facilitating the development, standardization, and evolution of software systems. Because of their advantages, several reference architectures have been proposed and have been also successfully used, including in the industry. However, the most of these architectures are still built using an ad-hoc approach, lacking of a systematization to their construction. If existing, these approaches could motivate and promote the building of new architectures and also support evolution of existing ones. In this scenario, the main contribution of this paper is to present the evolution of ProSA-RA, a process that systematizes the design, representation, and evaluation of reference architectures. ProSA-RA has been already applied in the establishment of reference architectures for different domains and this experience was used to evolve our process. In this paper, we illustrate an application of ProSA-RA in the robotics domain. Results achieved through the use of ProSA-RA have showed us that it is a viable, efficient process and, as a consequence, it could contribute to the reuse of knowledge in several applications domains, by promoting the establishment of new reference architectures.
Notes: focus on reference architecture, not behavior


Reference Type:  Conference Proceedings
Record Number: 8825
Author: Berg, M. v. d., Tang, A. and Farenhorst, R.
Year of Conference: 2009
Title: A Constraint-Oriented Approach to Software Architecture Design
Conference Name: 2009 Ninth International Conference on Quality Software
Pages: 396-405
Date: 24-25 Aug. 2009
Short Title: A Constraint-Oriented Approach to Software Architecture Design
ISBN: 1550-6002
DOI: 10.1109/QSIC.2009.59
Keywords: software architecture
constraint-oriented approach
design constraint characteristics
software architecture design
Australia
Computer architecture
Connectors
Decision making
Process design
Software design
Software engineering
Software quality
Space technology
Constraints
Design
Abstract: Software architecture design constraints exist and they bound the solution space in some ways. However,in research and practice little is known about the characteristics of these constraints and how they influence decision making. In this paper we report our findings on design constraint characteristics based on case studies in two countries. We discovered how constraints typically manifest themselves in the architecture design process, and how they impact the architectural decisions taken. Based on these insights we suggest a number of implications and strategies to support architectural design.


Reference Type:  Journal Article
Record Number: 8540
Author: Ramiller, Neil C.
Year: 2007
Title: Constructing safety: System designs, system effects, and the play of heterogeneous interests in a behavioral health care setting
Journal: International Journal of Medical Informatics
Volume: 76, Supplement 1
Pages: S196-S204
Date: 6//
Short Title: Constructing safety: System designs, system effects, and the play of heterogeneous interests in a behavioral health care setting
ISSN: 1386-5056
DOI: https://doi.org/10.1016/j.ijmedinf.2006.05.025
Keywords: Information systems
Software design
Safety
Behavioral medicine
Abstract: Objective This paper considers the utility of actor-network theory as a basis for uncovering the mutual interdependencies between system design and system impact in an evolving project, and for exploring the implications that these interdependencies hold for the production of safety in behavioral health care. Methods Drawing on a field study of a systems project in a human-services firm, the paper applies key concepts from actor-network theory in the analysis of a design crisis that emerged during the course of the project. Results Actor-network theory provides a compelling framework in this situation for identifying the diverse interests involved, revealing their complex interactions, and illuminating the importance of the emerging system as an organizational actor in its own right. Conclusion Actor-network theory shows promise for use in other analyses concerned with the role of information technology in the construction of safety in health care settings.
Notes: Framework development
URL: https://www.sciencedirect.com/science/article/pii/S1386505606001468


Reference Type:  Conference Proceedings
Record Number: 9060
Author: Kassab, M.
Year of Conference: 2017
Title: A Contemporary View on Software Quality Requirements in Agile and Software Architecture Practices
Conference Name: 2017 IEEE 25th International Requirements Engineering Conference Workshops (REW)
Pages: 260-267
Date: 4-8 Sept. 2017
Short Title: A Contemporary View on Software Quality Requirements in Agile and Software Architecture Practices
DOI: 10.1109/REW.2017.60
Keywords: software architecture
software product lines
software prototyping
software quality
agile architecture
software architectural decisions
software products
software quality requirements
Computer architecture
Industries
Security
Software systems
Agile
Software Industrial Practices
Abstract: Quality can be a very elusive concept that can be approached from a number of perspectives dependent on once take and interest. Evidence that relates software process to quality is often anecdotal or, when data is presented, it is to some extent contradictory or clashes with opposite evidence coming from different samples. Also, the influence of quality on software architecture is mostly described in a qualitative fashion based on architects expertise. Little contemporary data exists to document the actual perception from software experts in industry towards quality requirements for software products. Therefore, a comprehensive survey of software professionals was conducted to attempt to discover these practices. In this paper, we present a view of the captured data from this survey with a focus on investigating the influence of quality requirements on the software architectural decisions in practice.
'File' Atttachments: internal-pdf://0881909128/A Contemporary View on Software Quality Requir.pdf


Reference Type:  Conference Proceedings
Record Number: 7551
Author: Bang, J. Y., Brun, Y. and Medvidovic, N.
Year of Conference: 2017
Title: Continuous Analysis of Collaborative Design
Conference Name: 2017 IEEE International Conference on Software Architecture (ICSA)
Pages: 97-106
Date: 3-7 April 2017
Short Title: Continuous Analysis of Collaborative Design
DOI: 10.1109/ICSA.2017.45
Keywords: cloud computing
groupware
programming environments
software architecture
FLAME
Framework for Logging and Analyzing Modeling Events
cloud resources
collaborative design
design conflict detection technique
nonintrusive conflict detection
prioritization algorithm
Adaptation models
Analytical models
Collaboration
Engines
Fires
Synchronization
Tools
conflict detection
proactive conflict detection
speculative analysis
Abstract: In collaborative design, architects' individual design decisions may conflict and, when joined, may violate system consistency rules or non-functional requirements. These design conflicts can hinder collaboration and result in wasted effort. Proactive detection of code-level conflicts has been shown to improve collaborative productivity, however, the computational resource requirements for proactively computing design conflicts have hindered its applicability in practice. Our survey and interviews of 50 architects from six large software companies find that 60% of their projects involve collaborative design, that architects consider integration costly, and that design conflicts are frequent and lead to lost work. To aid collaborative design, we re-engineer FLAME, our prior design conflict detection technique, to use cloud resources and a novel prioritization algorithm that, together, achieve efficient and nonintrusive conflict detection, and guarantee a bound on the time before a conflict is discovered. Two controlled experiments with 90 students trained in software architecture in a professional graduate program, demonstrate that architects using FLAME design more efficiently, produce higher-quality designs, repair conflicts faster, and prefer using FLAME. An empirical performance evaluation demonstrates FLAME's scalability and verifies its time-bound guarantees.
Notes: students involved


Reference Type:  Conference Paper
Record Number: 8038
Author: Carriere, Jeromy, Kazman, Rick and Ozkaya, Ipek
Year: 2010
Title: A cost-benefit framework for making architectural decisions in a business context
Conference Name: Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 2
Conference Location: Cape Town, South Africa
Publisher: ACM
Pages: 149-157
DOI: 10.1145/1810295.1810317
Place Published: 1810317


Reference Type:  Conference Proceedings
Record Number: 9298
Author: Carriere, J., Kazman, R. and Ozkaya, I.
Year of Conference: 2010
Title: A cost-benefit framework for making architectural decisions in a business context
Conference Name: 2010 ACM/IEEE 32nd International Conference on Software Engineering
Volume: 2
Pages: 149-157
Date: 2-8 May 2010
Short Title: A cost-benefit framework for making architectural decisions in a business context
ISBN: 0270-5257
DOI: 10.1145/1810295.1810317
Keywords: commerce
cost-benefit analysis
decision making
software architecture
IT-intensive organization
Vistaprint Corporation
architectural decisions
business context
cost-benefit framework
decision-making
developer productivity
risk reduction
software components
structural transformation
system architecture decisions
Computer architecture
Couplings
Estimation
Measurement
Organizations
Training
architecture
dependency structure matrix
design structure matrix
quality attributes
software metrics
Abstract: In any IT-intensive organization, it is useful to have a model to associate a value with software and system architecture decisions. More generally, any effort-a project undertaken by a team-needs to have an associated value to offset its labor and capital costs. Unfortunately, it is extremely difficult to precisely evaluate the benefit of "architecture projects"-those that aim to improve one or more quality attributes of a system via a structural transformation without (generally) changing its behavior. We often resort to anecdotal and informal "hand-waving" arguments of risk reduction or increased developer productivity. These arguments are typically unsatisfying to the management of organizations accustomed to decision-making based on concrete metrics. This paper will discuss research done to address this long-standing dilemma. Specifically, we will present a model derived from analyzing actual projects undertaken at Vistaprint Corporation. The model presented is derived from an analysis of effort tracked against modifications to specific software components before and after a significant architectural transformation to the subsystem housing those components. In this paper, we will discuss the development, implementation, and iteration of the model and the results that we have obtained.
Notes: not focus on behavior


Reference Type:  Conference Paper
Record Number: 7971
Author: Sharp, Helen
Year: 2016
Title: Creativity and Collaboration in Software Design and Development
Conference Name: Proceedings of the European Conference on Cognitive Ergonomics
Conference Location: Nottingham, United Kingdom
Publisher: ACM
Pages: 1-3
DOI: 10.1145/2970930.2970967
Place Published: 2970967
Abstract: This extended abstract summarises some key points regarding the role of representations in software design and development, specifically how physical, virtual and hybrid representations support creativity and collaboration.
Notes: extended abstract, not research


Reference Type:  Conference Proceedings
Record Number: 8344
Author: Barcellini, Flore, Fran, #231, D, oise, #233, tienne and Burkhardt, Jean Marie
Year of Conference: 2007
Title: Cross-participants: fostering design-use mediation in an open source software community
Conference Name: Proceedings of the 14th European conference on Cognitive ergonomics: invent! explore!
Conference Location: London, United Kingdom
Publisher: ACM
Pages: 57-64
Short Title: Cross-participants: fostering design-use mediation in an open source software community
DOI: 10.1145/1362550.1362564
Place Published: 1362564
Abstract: Motivation - This research aims at investigating emerging roles and forms of participation fostering design-use mediation during the Open Source Software design process Research approach - We compare online interactions for a successful "pushed-by-users" design process with unsuccessful previous proposals. The methodology developed, articulate structural analyses of the discussions (organization of discussions, participation) to actions to the code and documentation made by participants to the project. We focus on the useroriented and the developer-oriented mailing-lists of the Python project. Findings/Design - We find that key-participants, the cross-participants, foster the design process and act as boundary spanners between the users and the developers' communities. Research limitations/Implications - These findings can be reinforced developing software to automate the structural analysis of discussions and actions to the code and documentation. Further analyses, supported by these tools, will be necessary to generalise our results. Originality/Value - The analysis of participation among the three interaction spaces of OSS design (discussion, documentation and implementation) is the main originality of this work compared to other OSS research that mainly analyse one or two spaces. Take away message - Beside the idealistic picture that users may intervene freely in the process, OSS design is boost and framed by some key-participants and specific rules and there can be barriers to users' participation 
'File' Atttachments: internal-pdf://0608179516/Cross-participants fostering design-use mediat.pdf


Reference Type:  Conference Proceedings
Record Number: 7730
Author: Braude, E. J.
Year of Conference: 2014
Title: Cumulative Software Architecture Development
Conference Name: 2014 IEEE/IFIP Conference on Software Architecture
Pages: 163-166
Date: 7-11 April 2014
Short Title: Cumulative Software Architecture Development
DOI: 10.1109/WICSA.2014.26
Keywords: software architecture
software prototyping
agile development context
cumulative software architecture development
least-commitment process
software architecture creation
Computer architecture
Conferences
Context
Context modeling
Software
User interfaces
agile development
software design
Abstract: An approach to software architecture creation is described in the context of agile development. It eschews the traditional separation of top-down and bottom-up design. A concrete, cumulative, least-commitment process is demonstrated that establishes an architecture core likely to remain stable as requirements are added.
Notes: not behavior focus


Reference Type:  Conference Proceedings
Record Number: 8876
Author: Malavolta, I. and Capilla, R.
Year of Conference: 2017
Title: Current Research Topics and Trends in the Software Architecture Community: ICSA 2017 Workshops Summary
Conference Name: 2017 IEEE International Conference on Software Architecture Workshops (ICSAW)
Pages: 1-4
Date: 5-7 April 2017
Short Title: Current Research Topics and Trends in the Software Architecture Community: ICSA 2017 Workshops Summary
DOI: 10.1109/ICSAW.2017.28
Keywords: Automotive engineering
Computer architecture
Conferences
Decision making
Market research
Software
Software architecture
IoT
architectural knowledge
automotive systems
micro-services
organizational dimensions
Abstract: This summary reports the workshops accepted in the 1st International Conference on Software Architecture (ICSA 2017), held by Chalmers University at Gothenburg (Sweden). We gather the description of current and new research trends in different software architecture topics to provide a wide view to researchers and practitioners about the current status and trends in the field. ICSA is a premier software architecture conference that encompasses WICSA and COMPARCH conferences in one single event.
Notes: just a summary


Reference Type:  Conference Proceedings
Record Number: 7674
Author: Martini, A. and Bosch, J.
Year of Conference: 2015
Title: The Danger of Architectural Technical Debt: Contagious Debt and Vicious Circles
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 1-10
Date: 4-8 May 2015
Short Title: The Danger of Architectural Technical Debt: Contagious Debt and Vicious Circles
DOI: 10.1109/WICSA.2015.31
Keywords: software architecture
software maintenance
software metrics
architectural technical debt
contagious debt
context-specific metrics
quality model
socio-technical phenomenon
software development
technical debt items
vicious circles
Companies
Computer architecture
Concrete
Conferences
Interviews
Software
Taxonomy
agile software development
effort
multiple case-study
qualitative model
socio-technical phenomena
Abstract: A known problem in large software companies is to balance the prioritization of short-term with long-term viability. Specifically, architecture violations (Architecture Technical Debt) taken to deliver fast might hinder future feature development. However, some technical debt requires more interest to be paid than other. We have investigated which Technical Debt items generate more effort and how this effort is manifested during software development. We conducted a multiple-case embedded case study comprehending 7 sites at 5 large international software companies. We found that some Technical Debt items are contagious, causing other parts of the system to be contaminated with the same problem, which may lead to non-linear growth of interest. We also identify another socio-technical phenomenon, for which a combination of weak awareness of debt, time pressure and refactoring creates Vicious Circles of events during the development. Such phenomena need to be identified and stopped before the development is led to a crisis point. Finally, this paper presents a taxonomy of the most dangerous items identified during the qualitative investigation and a model of their effects that can be used for prioritization, for further investigation and as a quality model for extracting more precise and context-specific metrics.
Notes: not my focus


Reference Type:  Conference Paper
Record Number: 7877
Author: Esfahani, Naeem, Razavi, Kaveh and Malek, Sam
Year: 2012
Title: Dealing with uncertainty in early software architecture
Conference Name: Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering
Conference Location: Cary, North Carolina
Publisher: ACM
Pages: 1-4
DOI: 10.1145/2393596.2393621
Place Published: 2393621
Abstract: Changing early architectural decisions of a system is both difficult and costly. It is very important for the architect to get them "right". However, in early design, the architect is often forced to make these decisions under uncertainty, i.e., not knowing the precise impact of those decisions on system's properties (e.g., scalability) as well as stakeholder concerns (e.g., cost). In this paper, we provide an overview of GuideArch, a framework aimed at systematic exploration of the architectural solution space under uncertainty to help with making early architectural decisions.
Notes: tool development


Reference Type:  Journal Article
Record Number: 8602
Author: Orlov, Sergey and Vishnyakov, Andrei
Year: 2017
Title: Decision Making for the Software Architecture Structure Based on the Criteria Importance Theory
Journal: Procedia Computer Science
Volume: 104
Pages: 27-34
Date: //
Short Title: Decision Making for the Software Architecture Structure Based on the Criteria Importance Theory
ISSN: 1877-0509
DOI: https://doi.org/10.1016/j.procs.2017.01.050
Keywords: Multicriteria decision analysis
Hierarchical criterion
Criteria importance theory
Software architecture
Architecture metric
Abstract: Software architectural decisions have a significant impact on the software development process as well as on the quality of developed software systems. In this paper, the technique that allows selecting the optimal software architecture among several alternatives is proposed. This selection technique is reduced to the criteria importance theory for decision-making problems with a hierarchical criterion structure. For applying it, we need to pick up a set of metrics that assess the characteristics of the software architecture. Next, we need to determine metrics scale and create the hierarchical criterion structure with all the relations between software metric groups. The results allow us making conclusions about usefulness of the proposed technique during architecture design phase for software systems.
URL: https://www.sciencedirect.com/science/article/pii/S1877050917300510


Reference Type:  Journal Article
Record Number: 8521
Author: van Vliet, Hans and Tang, Antony
Year: 2016
Title: Decision making in software architecture
Journal: Journal of Systems and Software
Volume: 117
Pages: 638-644
Date: 7//
Short Title: Decision making in software architecture
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2016.01.017
Keywords: Software architecture
Design decisions
Abstract: Traditionally, software architecture is seen as the result of the software architecture design process, the solution, usually represented by a set of components and connectors. Recently, the why of the solution, the set of design decisions made by the software architect, is complementing or even replacing the solution-oriented definition of software architecture. This in turn leads to the study of the process of making these decisions. We outline some research directions that may help us understand and improve the software architecture design process.
URL: https://www.sciencedirect.com/science/article/pii/S0164121216000157


Reference Type:  Conference Proceedings
Record Number: 8958
Author: Abdesselam, Redouane
Year of Conference: 2007
Title: A decision making model for software design
Conference Name: 2007 IEEE International Conference on Systems, Man and Cybernetics
Pages: 2687-2692
Date: 7-10 Oct. 2007
Short Title: A decision making model for software design
ISBN: 1062-922X
DOI: 10.1109/ICSMC.2007.4413795
Keywords: decision making
design
formal specification
object-oriented programming
software maintenance
software packages
application requirements
commercial off-the-shelf paradigm
decision making model
formal model specification
ideal component
small-scale systems
software design
software maintainability
structured first order predicate calculus
vendor viability
Application software
Calculus
Costs
Equations
Software engineering
Software performance
Software systems
Time to market
Abstract: Selecting the right components to design a software system involve some deep thoughts and difficult decisions to make. In this paper, we present a model to ease the decision making process. The model is based on commercial off-the-shelf (COTS) paradigm. COTS techniques aim to reduce development time and hence decrease cost compared to a traditional system development. First, an identification of components from the application requirements is made. Then, for each component, we specify a formal model, which is called the ideal-component. A structured first order predicate calculus is used as a tool to formalize application requirements and obtain these formal models. The evaluation of a possible-component, from a vendor, begins with understanding the features and then an acceptance indicator is calculated. The acceptance equation combines three key factors: requirements and features match, vendor-viability and maintainability. Maintainability is a costly phase in any software system and this model caters for this issue during the evaluation process. The model is being investigated in small-scale systems with successful results.


Reference Type:  Journal Article
Record Number: 8724
Author: Sabry, Ahmed E.
Year: 2015
Title: Decision Model for Software Architectural Tactics Selection Based on Quality Attributes Requirements
Journal: Procedia Computer Science
Volume: 65
Pages: 422-431
Date: //
Short Title: Decision Model for Software Architectural Tactics Selection Based on Quality Attributes Requirements
ISSN: 1877-0509
DOI: https://doi.org/10.1016/j.procs.2015.09.111
Keywords: Software Architecture
Architecture Styles and Tactics
Quality Attributes (QA)
Mining Techniques
Business Intelligence (BI)
Abstract: Due to increasing industrial demands toward software systems with increasing complexity and challenging quality requirements, software architecture and implementation mechanisms become an important activity. The decisions made during architecture design have significant implications on quality goals. As addressed, there is a lack of available standard models, architectures or frameworks for enabling implementation of quality attributes specially for business intelligence environment and applications in order to rapidly and efficiently supports decision-making. In addition, a lack of researches related to Quality Attributes (QA) requirements, its implementation tactics, and interrelations or correlations between them. The increasing systems complexity mandates software architects to choose from a growing number of design options (decisions) when searching for an optimal architecture design in a specific domain with respect to a defined (set of) quality attributes and constraints. This results in a design space search that is over human capabilities and makes the architectural design task more complicated. In this paper, researcher aimed to reveal most of quality attributes implementation tactics affecting applications architectures, properties. Several quality attributes of software investigated using applied research methods with mixed quantitative (linear) and non-linear analysis techniques. It proposes an initiative for finding an easy and systematic way of addressing quality attributes requirements to a set of implementing architectural tactics. Finally, the findings analyzed and visualized in a way that can support decision stakeholders in addition to a new concept of “safe-tactics” introduced as reduced (pruned) set of tactics that are claimed to be better used in general refactoring cases. In addition, a software tool is developed throughout this research effort as result of gained knowledge and addressing the research findings.
Notes: more a system/framework
URL: https://www.sciencedirect.com/science/article/pii/S1877050915029415


Reference Type:  Conference Paper
Record Number: 7903
Author: Papatheocharous, Efi, Petersen, Kai, Cicchetti, Antonio, #233, Sentilles, verine, Shah, Syed Muhammad Ali and Gorschek, Tony
Year: 2015
Title: Decision support for choosing architectural assets in the development of software-intensive systems: The GRADE taxonomy
Conference Name: Proceedings of the 2015 European Conference on Software Architecture Workshops
Conference Location: Dubrovnik, Cavtat, Croatia
Publisher: ACM
Pages: 1-7
DOI: 10.1145/2797433.2797483
Place Published: 2797483
Abstract: Engineering software-intensive systems is a complex process that typically involves making many critical decisions. A continuous challenge during system design, analysis and development is deciding on the reference architecture that could reduce risks and deliver the expected functionality and quality of a product or a service to its users. The lack of evidence in documenting strategies supporting decision-making in the selection of architectural assets in systems and software engineering creates an impediment in learning, improving and also reducing the risks involved. In order to fill this gap, ten experienced researchers in the field of decision support for the selection of architectural assets in engineering software-intensive systems conducted a workshop to reduce traceability of strategies and define a dedicated taxonomy. The result was the GRADE taxonomy, whose key elements can be used to support decision-making as exemplified through a real case instantiation for validation purposes. The overall aim is to support future work of researchers and practitioners in decision-making in the context of architectural assets in the development of software-intensive systems. The taxonomy may be used in three ways: (i) identify new opportunities in structuring decisions; (ii) support the review of alternatives and enable informed decisions; and (iii) evaluate decisions by describing in a retrospective fashion decisions, factors impacting the decision and the outcome.
Notes: System


Reference Type:  Conference Proceedings
Record Number: 9106
Author: Moaven, S., Habibi, J., Ahmadi, H. and Kamandi, A.
Year of Conference: 2008
Title: A Decision Support System for Software Architecture-Style Selection
Conference Name: 2008 Sixth International Conference on Software Engineering Research, Management and Applications
Pages: 213-220
Date: 20-22 Aug. 2008
Short Title: A Decision Support System for Software Architecture-Style Selection
DOI: 10.1109/SERA.2008.26
Keywords: decision support systems
fuzzy reasoning
inference mechanisms
software architecture
software maintenance
DSS
decision support system
fuzzy inference
multi criteria decision making problem
software architecture-style selection
software development process
software engineering
software systems
Computer architecture
Conference management
Decision making
Fuzzy logic
Software design
Technology management
Aggregation Tool
Architecture-Styles
Abstract: Due to the enlargement and complexity of software systems and the need for maintenance and update, success of systems depends strongly on their architecture. Software architecture has been a key element in software development process in two past decades. Therefore, choosing the correct architecture is a critical issue in software engineering domain, with respect to the extremely extension of architecture-driven designs. Moreover, software architecture selection is a multi-criteria decision-making problem in which different goals and objectives should be considered. In this paper, a decision support system (DSS) has been designed which provides software architects with more precise and suitable decisions in architecture styles selection. The DSS uses fuzzy inference to support decisions of software architects and exploits properties of styles in the best way while making decisions.
Notes: A system


Reference Type:  Journal Article
Record Number: 9235
Author: Kruchten, P., Capilla, R. and Dueñas, J. C.
Year: 2009
Title: The Decision View's Role in Software Architecture Practice
Journal: IEEE Software
Volume: 26
Issue: 2
Pages: 36-42
Short Title: The Decision View's Role in Software Architecture Practice
ISSN: 0740-7459
DOI: 10.1109/MS.2009.52
Keywords: software architecture
software maintenance
software metrics
software quality
distributed production
maintenance operations
software crisis
software development
system complexity
Collaborative software
Computer architecture
Context modeling
Costs
Production systems
Software design
Software systems
Standards development
architectural design decision
architectural knowledge
architecture views
decision view
Abstract: Software development has to deal with many challenges-increasing system complexity, requests for better quality, the burden of maintenance operations, distributed production, and high staff turnover, to name just a few. Increasingly, software companies that strive to reduce their products' maintenance costs demand flexible, easy-to-maintain designs. Software architecture constitutes the cornerstone of software design, key for facing these challenges. Several years after the "software crisis" began in the mid-1970s, software architecture practice emerged as a mature (although still growing) discipline, capable of addressing the increasing complexity of new software systems.
Notes: Tool, not behavior


Reference Type:  Journal Article
Record Number: 7856
Author: Falessi, Davide, Cantone, Giovanni, Kazman, Rick and Kruchten, Philippe
Year: 2011
Title: Decision-making techniques for software architecture design: A comparative survey
Journal: ACM Comput. Surv.
Volume: 43
Issue: 4
Pages: 1-28
Short Title: Decision-making techniques for software architecture design: A comparative survey
ISSN: 0360-0300
DOI: 10.1145/1978802.1978812
Legal Note: 1978812
Abstract: The architecture of a software-intensive system can be defined as the set of relevant design decisions that affect the qualities of the overall system functionality; therefore, architectural decisions are eventually crucial to the success of a software project. The software engineering literature describes several techniques to choose among architectural alternatives, but it gives no clear guidance on which technique is more suitable than another, and in which circumstances. As such, there is no systematic way for software engineers to choose among decision-making techniques for resolving tradeoffs in architecture design. In this article, we provide a comparison of existing decision-making techniques, aimed to guide architects in their selection. The results show that there is no “best” decision-making technique; however, some techniques are more susceptible to specific difficulties. Hence architects should choose a decision-making technique based on the difficulties that they wish to avoid. This article represents a first attempt to reason on meta-decision-making, that is, the issue of deciding how to decide.


Reference Type:  Conference Paper
Record Number: 7902
Author: Silva, Italo Carlo Lopes, Brito, Patrick H. S., Neto, Baldoino F. dos S., Costa, Evandro and Silva, Andre Almeida
Year: 2015
Title: A decision-making tool to support architectural designs based on quality attributes
Conference Name: Proceedings of the 30th Annual ACM Symposium on Applied Computing
Conference Location: Salamanca, Spain
Publisher: ACM
Pages: 1457-1463
DOI: 10.1145/2695664.2695928
Place Published: 2695928
Abstract: The success of a software project is strongly related with architectural design. However, designing the right Software Architecture is a very subjective task and takes a long time, being much influenced by architect's experience and the quality of requirements engineering. This architectural knowledge, usually, is not documented, since it is considered tacit knowledge of architects or other stakeholders, and eventually dissipates. The objective of this paper is to present a tool that supports young architects by recommending a suitable architectural style, based on the system's requirements, particularly the quality attributes of the system. The tool encompasses both trade-off resolution over quality attributes and recommendation of architectural styles based on quality attributes. The proposed solution has been evaluated in the context of a specific domain of Learning Management System (LMS), in order to illustrate the tool support in the execution of an architectural design process.
Notes: Tool


Reference Type:  Journal Article
Record Number: 9387
Author: Willhoft, B. and Willhoft, R.
Year: 2017
Title: Decoding Software Design
Journal: Computing in Science & Engineering
Volume: 19
Issue: 3
Pages: 86-87
Short Title: Decoding Software Design
ISSN: 1521-9615
DOI: 10.1109/MCSE.2017.41
Keywords: Decoding
Design methodology
Software engineering
book review
scientific computing
software design
Abstract: Blaine Willhoft and Rob Willhoft review &#x0022;Software Design Decoded: 66 Ways Experts Think&#x0022; by Marian Petre and Andr&#x00E9; van der Hoek, a collection of short, one-paragraph observations on the habits that successful engineers have developed or learned over time.


Reference Type:  Conference Proceedings
Record Number: 9454
Author: Chang, H. F. and Lu, S. C. Y.
Year of Conference: 2009
Title: Decomposition and Traceability in Software Design
Conference Name: 2009 33rd Annual IEEE International Computer Software and Applications Conference
Volume: 2
Pages: 13-18
Date: 20-24 July 2009
Short Title: Decomposition and Traceability in Software Design
ISBN: 0730-3157
DOI: 10.1109/COMPSAC.2009.201
Keywords: object-oriented programming
program diagnostics
software maintenance
software quality
AD-based software design traceability
axiomatic design theory
decomposition method
functional dependency
object-oriented software design
shorter delivery time
software maintainability
Application software
Computer applications
Computer science
Design engineering
Engineering management
Process design
Software design
Software development management
Software systems
USA Councils
Axiomatic Design
Complex Software Design
Conceptual Design
Decision Making
Object Oriented Design
Abstract: Decomposition is a common practice in design of technical systems to manage abstractions and to create components that can be developed separately. However, the hierarchical decomposition methods used in current software design are unable to control the dependency and provide the traceability of decisions effectively. As the difficulty of software systems rises along with increasing demands for more function, lower cost, higher quality and shorter delivery time, this shortcoming has become a major challenge in the software design community. One reason for this shortcoming is the failure of clearly differentiating between the functional and physical notions during the design process. To remedy this deficiency, we employ the axiomatic design (AD) theory developed from engineering design to augment object-oriented software design. This paper explains the features of axiomatic design approach and compare it with traditional software design methods. A case study that compares our proposed AD-based software design results with that from traditional object-oriented design approaches is included to demonstrate its applications and benefits in software design. The results show that explicitly managing functional dependencies at early design stages and focusing on decision traceability along the design process can lead to better software systems with higher quality and maintainability.


Reference Type:  Conference Proceedings
Record Number: 7628
Author: Valdeón, J. M. C., Cortés, A. R. and Toro, M.
Year of Conference: 2016
Title: Defeasible Argumentation of Software Architectures
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 115-121
Date: 5-8 April 2016
Short Title: Defeasible Argumentation of Software Architectures
DOI: 10.1109/WICSA.2016.48
Keywords: reasoning about programs
software architecture
Hastings method
Twitter
defeasible argumentation
dialogical structure
eBay
legal reasoning
scientific reasoning
software architectural evaluation
Cognition
Computer architecture
Context
Pipelines
Servers
Software architectures
architectural evaluation
argumentation schemes
design rationale
Abstract: Defeasible argumentation is typical of legal and scientific reasoning. A defeasible argument is one in which the conclusion can be accepted tentatively in relation with the evidence known so far, but may need to be retracted as new evidence comes in. This paper analyses the role of defeasible argumentation in the explanation and evaluation of architectural decisions. We analyse technical explanations offered by engineers at Twitter and eBay about several architectural decisions adopted in those systems. We generalize these examples in four argumentation schemes. We also study the typical case of reasoning with a formal model of an architecture, and we infer a fifth argumentation scheme. Finally, we apply Hastings' method of attaching a set of critical questions to each scheme. We show that the existence of critical questions reveals that the inferred schemes are defeasible: in argumentation theory, if a respondent asks one of the critical questions matching a scheme and the proponent of an argument fails to offer an adequate answer, the argument defaults and the conclusion is retracted. This dialogical structure is the basis of typical architectural evaluations. We conclude that the provided evidence supports the hypothesis that defeasible argumentation is employed in architectural evaluation. In this context, a rich catalogue of argumentation schemes is a useful tool for the architect to organize his or her reasoning, critical questions assist the architect in identifying the weak points of his or her explanations, and provide the evaluation team with a checklist of issues to be raised.


Reference Type:  Journal Article
Record Number: 8678
Author: Shum, Simon Buckingham and Hammond, Nick
Year: 1994
Title: Delivering HCI modelling to designers: A framework and case study of cognitive modelling
Journal: Interacting with Computers
Volume: 6
Issue: 3
Pages: 314-341
Date: 9//
Short Title: Delivering HCI modelling to designers: A framework and case study of cognitive modelling
ISSN: 0953-5438
DOI: https://doi.org/10.1016/0953-5438(94)90019-1
Keywords: Human-computer interaction
cognitive modelling
evaluation
Abstract: The human-computer interaction (HCI) research community is generating a large number of usability-oriented models and design frameworks. However, a critical factor which will determine whether any of these achieve significant penetration into the real world of software design is the effort required by practitioners to understand and apply them. In short, analytic tools for usability design must themselves be usable. In response to this challenge, we present a framework which identifies four different ‘gulfs’ between user-centred modelling and design approaches, and their intended users. These gulfs are potential opportunities to support designers if a given analytic approach can be encapsulated in appropriate forms. We then illustrate the framework's application with a concrete example. An evaluation is reported which investigates gulfs associated with an approach which uses an expert system to automate cognitive modelling for human factors designers. An early prototype was evaluated in order to assess the knowledge required to use it. The study demonstrates that whilst this tool does shield users from the complexities of the underlying modelling, they need to understand the way in which it builds its description of the task and user interface. Implications for bridging the different gulfs are then considered.
Notes: framework
URL: https://www.sciencedirect.com/science/article/pii/0953543894900191


Reference Type:  Journal Article
Record Number: 8763
Author: Kim, S. J., Suh, N. P. and Kim, S. G.
Year: 1991
Title: Design of Software System Based on Axiomatic Design
Journal: CIRP Annals
Volume: 40
Issue: 1
Pages: 165-170
Date: //
Short Title: Design of Software System Based on Axiomatic Design
ISSN: 0007-8506
DOI: https://doi.org/10.1016/S0007-8506(07)61959-3
Keywords: Software
Design
Axioms
Abstract: The ability to utilize the fully automated flexible manufacturing systems (FMS) or develop a reliable computer-integrated manufacturing (CIM) system will depend on our ability to develop reliable and reusable softwares for large complex systems on a timely basis. To date, software design has not gone beyond the ad hoc trail-and-error stage. Consequently, the development of software is slow, expensive, unreliable, and unmanageable. The purpose of this paper is to provide a scientific basis for designing software. The approach used here is the axiomatic design, which is based on two design axioms: the Independence Axiom and the Information Axiom. The axiomatic approach is based on the recognition of the following common elements in design: the existence of independent domains (i.e., the consumer domain. the functional domain, the physical domain, and the process domain); the need to map between various domains during the design process: the decomposition of the characteristic vectors (i.e., functional requirements, design parameters, and process variables) in their respective domains: the zigzagging required between the domains for decomposition; and the need to satisfy the design axioms during the design process. The axiomatic approach discussed in this paper provides decision making tools for software design in addition to systematic means of knowledge and data representation, synthesis and analysis of software, and the construction of the module-junction structure diagram.
Notes: framework, not behavior
URL: https://www.sciencedirect.com/science/article/pii/S0007850607619593


Reference Type:  Journal Article
Record Number: 8137
Author: Riehle, Dirk
Year: 2009
Title: Design pattern density defined
Journal: SIGPLAN Not.
Volume: 44
Issue: 10
Pages: 469-480
Short Title: Design pattern density defined
ISSN: 0362-1340
DOI: 10.1145/1639949.1640125
Legal Note: 1640125
Abstract: Design pattern density is a metric that measures how much of an object-oriented design can be understood and represented as instances of design patterns. Expert developers have long believed that a high design pattern density implies a high maturity of the design under inspection. This paper presents a quantifiable and observable definition of this metric. The metric is illustrated and qualitatively validated using four real-world case studies. We present several hypotheses of the metric’s meaning and their implications, including the one about design maturity. We propose that the design pattern density of a maturing framework has a fixed point and we show that if software design patterns make learning frameworks easier, a framework’s design pattern density is a measure of how much easier it will become.
Notes: more about understanding design


Reference Type:  Conference Proceedings
Record Number: 8061
Author: Zamora, Paula Gomez and Do, Ellen Yi-Luen
Year of Conference: 2009
Title: Design patterns in creative design processes
Conference Name: Proceedings of the seventh ACM conference on Creativity and cognition
Conference Location: Berkeley, California, USA
Publisher: ACM
Pages: 373-374
Short Title: Design patterns in creative design processes
DOI: 10.1145/1640233.1640307
Place Published: 1640307
Abstract: The paper presents the analysis of nine architects design processes with different design experience and expertise levels. The main goal is to visualize and analyze patterns between their design processes, design phases, design iterations, and software used to support creative process in every design phase. This study focused on four major components for analysis: lengths of design processes, naming of design phases, flows of design directions, and the number and types of software used in each phase. The future goal is to investigate whether specific software capabilities would increase or hinder creative behavior patterns during the design process.
Notes: mostly students...
'File' Atttachments: internal-pdf://3415529326/Design patterns in creative design processes.pdf


Reference Type:  Conference Paper
Record Number: 8232
Author: Mel, #211, Cinn, #233, ide and Fagan, Paddy
Year: 2006
Title: Design patterns: the devils in the detail
Conference Name: Proceedings of the 2006 conference on Pattern languages of programs
Conference Location: Portland, Oregon, USA
Publisher: ACM
Pages: 1-9
DOI: 10.1145/1415472.1415511
Place Published: 1415511
Abstract: The application of a design pattern in an industrial context is frequently a much more involved task than is described the pattern description itself. In this experience paper we report on a number of problems encountered in the application of several common patterns in commercial software systems. The problems we examine range in nature from details of the runtime environment that hamper pattern implementation (Singleton), to the software upgrade process breaking a pattern’s promise (Abstract Factory), to the consequences of the tight source code coupling produced by pattern application (Facade). Our conclusion is that while design patterns are indeed useful in industrial software development, there are more potential pitfalls in this area than is generally realised. In applying a design pattern, more must be taken into account than just the design context into which the pattern fits; issues to do with the low-level runtime environment as well as the higher-level software architecture, software process and social environment also play a role. 1.
Notes: focus on patterns, not decision and behavior


Reference Type:  Journal Article
Record Number: 8550
Author: Ball, Linden J., Onarheim, Balder and Christensen, Bo T.
Year: 2010
Title: Design requirements, epistemic uncertainty and solution development strategies in software design
Journal: Design Studies
Volume: 31
Issue: 6
Pages: 567-589
Date: 11//
Short Title: Design requirements, epistemic uncertainty and solution development strategies in software design
ISSN: 0142-694X
DOI: https://doi.org/10.1016/j.destud.2010.09.003
Keywords: software design
design strategy
uncertainty
mental simulation
design requirements
Abstract: This paper investigates the potential involvement of “epistemic uncertainty” in mediating between complex design requirements and strategic switches in software design strategies. The analysis revealed that the designers produced an initial “first-pass” solution to the given design brief in a breadth-first manner, with this solution addressing several easy-to-handle requirements. The designers then focused on adding relatively complex-to-handle requirements to this initial solution in what appeared to be a depth-first manner, as reflected, for example, by detailed mental simulations that spanned many transcript segments. Furthermore, such depth-first development of complex requirements was linked to increases in epistemic uncertainty, a finding that supports the predicted role of uncertainty in mediating between complex requirements and depth-first design. Overall these findings support a view of software design as involving a mixed breadth-first and depth-first solution development approach, with strategic switching to depth-first design being triggered by requirement complexity and being mediated by associated feelings of uncertainty.
URL: https://www.sciencedirect.com/science/article/pii/S0142694X10000657
'File' Attachments: internal-pdf://3088841241/Design requirements, epistemic uncertainty and.pdf


Reference Type:  Conference Paper
Record Number: 8168
Author: Ko, Andrew J. and Chilana, Parmit K.
Year: 2011
Title: Design, discussion, and dissent in open bug reports
Conference Name: Proceedings of the 2011 iConference
Conference Location: Seattle, Washington, USA
Publisher: ACM
Pages: 106-113
DOI: 10.1145/1940761.1940776
Place Published: 1940776
Abstract: While studies have considered computer-mediated decision-making in several domains, few have considered the unique challenges posed in software design. To address this gap, a qualitative study of 100 contentious open source bug reports was performed. The results suggest that the immeasurability of many software qualities and conflicts between achieving original design intent and serving changing user needs led to a high reliance on anecdote, speculation, and generalization. The visual presentation of threaded discussions aggravated these problems making it difficult to view design proposals and comparative critiques. The results raise several new questions about the interaction between authority and evidence in online design discussions.


Reference Type:  Conference Paper
Record Number: 7968
Author: Zimmermann, Olaf
Year: 2016
Title: Designed and delivered today, eroded tomorrow?: towards an open and lean architecting framework balancing agility and sustainability
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-1
DOI: 10.1145/2993412.3014339
Place Published: 3014339
Abstract: Architecting for cost-effectiveness, longevity and endurance has multiple, often conflicting dimensions. For instance, agile practices emphasize the need for speed in software design, development and delivery, but do not necessarily prioritize mid- to long-term qualities such as extensibility and knowledge preservation. Risk- and cost-driven architecture design methods, pragmatic modeling, and technical debt management can help practicing architects to focus their efforts, but have to be tailored to be effective (e.g., according to project context, organizational constraints, and cultural factors). Architectural styles such as service-oriented architectures and its currently trending microservices incarnation promise to improve flexibility and maintainability through their principles and patterns, but still have to prove their cost-benefit efficiency in the long run (e.g., over the multi-decade lifetime of business information systems).

This keynote presentation distills a set of open, lean and sustainable architecture practices and techniques from industrial experiences and existing work in the software architecture literature, and reports on the progress towards blending these practices and techniques into a comprehensive, yet comprehensible architecture framework. The featured assets include quality stories [1], C4 architecture modeling [2], decision sharing with Y-statements [3], architecturally evident coding styles [4], architectural refactoring [1], (micro-)services principles and patterns [5], and architecture roadmapping [6]. Examples drawn from actual case studies in multiple business sectors and industries demonstrate the applicability of these practices and techniques.

The presentation concludes with a discussion of the changes to the role of the software architect in the digital age [7]. These ongoing changes drive the identification of research problems and challenges for the practical adoption and lasting impact of the practices and techniques in the framework (and other contributions to the body of knowledge on sustainable architectures).
Notes: keynote, not research


Reference Type:  Conference Proceedings
Record Number: 9147
Author: Taylor, P.
Year of Conference: 2000
Title: Designerly thinking: what software methodology can learn from design theory
Conference Name: Proceedings International Conference on Software Methods and Tools. SMT 2000
Pages: 107-116
Date: 2000
Short Title: Designerly thinking: what software methodology can learn from design theory
DOI: 10.1109/SWMT.2000.890426
Keywords: design engineering
history
social aspects of automation
software engineering
academic design
architecture
design act
design expertise
design languages
design science
design theory
designerly thinking
engineering process
holistic views
industrial design
modern software product development
non-software domains
social context
software creation
software methodology
Computer architecture
Computer science
Construction industry
Design methodology
Process design
Software design
Software quality
Abstract: Design lies at the core of software creation and construction. Software methodology has traditionally conceptualised design as an engineering process, and attempted to express the design act as process steps and model transformations. The paper examines design from the rather different perspective of the non-software domains: architecture, industrial design and the academic design disciplines that have spawned `design science'. This community dealt with design methods in the 1960s and 70s, and has subsequently moved on to more relative and holistic views of design that integrate artefact and context closely. Three themes dominate the comparative exclusion into this territory: the inappropriateness of process to prescribe the act of synthesis, the need to consider the product's wider context including its history and social context, and the need to legitimise and manage internal ways of transferring designs, design expertise and design languages. A case is made for a broader based notion of software design, a kind of `designerly thinking' to help balance the intense demands on modern software product development, quality, and use
Notes: not about software development


Reference Type:  Journal Article
Record Number: 8705
Author: Norcio, A. F. and Chmura, L. J.
Year: 1988
Title: Designing complex software
Journal: Journal of Systems and Software
Volume: 8
Issue: 3
Pages: 165-184
Date: 6//
Short Title: Designing complex software
ISSN: 0164-1212
DOI: https://doi.org/10.1016/0164-1212(88)90020-9
Abstract: Since 1978, the goal of the Software Cost Reduction (SCR) project has been to demonstrate the effectiveness of certain software engineering techniques for developing complex software. The application is the redevelopment of the operational flight program for the A-7E aircraft. Also since then, the Software Technology Evaluation (STE) project has been monitoring SCR project activity in order to provide an objective evaluation of the SCR methodology. SCR project activity data are collected from SCR personnel on a weekly basis. Over 55000 hours of SCR design, code, test and other activity data have been captured and recorded in a computer data base. Analyses of SCR module design data show that there are parameters that can be used to characterize and predict design progress. One example is the ratio between cumulative design discussing activities and cumulative design creating activities. This ratio is referred to as the Progress Indicator Ratio (PIR) and seems to be an accurate metric for design completeness. This and other results suggest that discussion activity among software engineers may play a major role in the software design process and may be a leading indicator of design activity progress.
URL: https://www.sciencedirect.com/science/article/pii/0164121288900209


Reference Type:  Journal Article
Record Number: 8616
Author: de Souza, M. A. F. and Ferreira, M. A. G. V.
Year: 2002
Title: Designing reusable rule-based architectures with design patterns
Journal: Expert Systems with Applications
Volume: 23
Issue: 4
Pages: 395-403
Date: 11//
Short Title: Designing reusable rule-based architectures with design patterns
ISSN: 0957-4174
DOI: https://doi.org/10.1016/S0957-4174(02)00075-1
Keywords: Rule-based systems
Reuse in rule-based systems
Design patterns
Abstract: Rule-based systems or production systems still have great importance in the construction of knowledge systems. In these systems, the domain expertise to solve a problem is encoded in the form of ‘if–then’ rules, enabling a modular description of the knowledge, thus facilitating its maintenance and updating. Although they have been extensively described in the Artificial Intelligence literature, their design process is at times repeated because of the lack of common software architecture and the restrictions offered by some off-the-shelf libraries and systems. This paper proposes a reusable architecture for rule-based systems described through design patterns. The aim of these patterns is to constitute a design catalog that can be used by designers to understand and create new rule-based systems, thus promoting reuse in these systems. Additionally, the use of the described patterns in the design of an intelligent tutoring system architecture is exemplified.
Notes: Pattern description
URL: https://www.sciencedirect.com/science/article/pii/S0957417402000751


Reference Type:  Conference Paper
Record Number: 8269
Author: Chilana, Parmit K., Ko, Andrew J. and Wobbrock, Jacob O.
Year: 2009
Title: Designing software for unfamiliar domains
Conference Name: Proceedings of the 2009 ICSE Workshop on Cooperative and Human Aspects on Software Engineering
Publisher: IEEE Computer Society
Pages: 22
DOI: 10.1109/chase.2009.5071405
Place Published: 1572208
Abstract: In recent years, software has become indispensable in complex domains such as science, engineering, biomedicine, and finance. Unfortunately, software developers and user researchers, who are usually experts in programming and Human-Computer Interaction (HCI) methods, respectively, often find that the insight needed to design for complex domains only comes with years of domain experience. How can everyone on a software design team acquire just enough knowledge to design effective software, especially user interfaces, without having to become domain experts? We are performing a series of studies to investigate this question, with the ultimate goal of designing tools to help software teams better capture, manage and explore domain knowledge.
Notes: just summary, no actual studies
'File' Attachments: internal-pdf://0720343905/Designing software for unfamiliar domains.pdf


Reference Type:  Conference Paper
Record Number: 7908
Author: Maur, #237, Aniche, cio, Aur, Marco, #233, Gerosa, lio and Treude, Christoph
Year: 2016
Title: Developers' Perceptions on Object-Oriented Design and Architectural Roles
Conference Name: Proceedings of the 30th Brazilian Symposium on Software Engineering
Conference Location: Maring&aacute;, Brazil
Publisher: ACM
Pages: 63-72
DOI: 10.1145/2973839.2973846
Place Published: 2973846
Abstract: Software developers commonly rely on well-known software architecture patterns, such as MVC, to build their applications. In many of these patterns, classes play specific roles in the system, such as Controllers or Entities, which means that each of these classes has specific characteristics in terms of object-oriented class design and implementation. Indeed, as we have shown in a previous study, architectural roles are different from each other in terms of code metrics. In this paper, we present a study in a software development company in which we captured developers' perceptions on object-oriented design aspects of the architectural roles in their system and whether these perceptions match the source code metric analysis. We found that their developers do not have a common perception of how their architectural roles behave in terms of object-oriented design aspects, and that their perceptions also do not match the results of the source code metric analysis. This phenomenon also does not seem to be related to developers' experience. We find these results alarming, and thus, we suggest software development teams to invest in education and knowledge sharing about how their system's architectural roles behave.
Notes: Source code roles


Reference Type:  Conference Proceedings
Record Number: 7528
Author: Soliman, M., Galster, M. and Riebisch, M.
Year of Conference: 2017
Title: Developing an Ontology for Architecture Knowledge from Developer Communities
Conference Name: 2017 IEEE International Conference on Software Architecture (ICSA)
Pages: 89-92
Date: 3-7 April 2017
Short Title: Developing an Ontology for Architecture Knowledge from Developer Communities
DOI: 10.1109/ICSA.2017.31
Keywords: ontologies (artificial intelligence)
software architecture
software quality
software reusability
Stack Overflow
architectural knowledge concepts
architecture-relevant information
coding problems
inter-coder reliability tests
online developer communities
ontology
qualitative analyses
reusable knowledge quality
structure architectural knowledge
Computer architecture
Encoding
Ontologies
Reliability
Semantics
Software
architecture design decisions
architecture knowledge
developer communities
Abstract: Software architecting is a knowledge-intensive activity. However, obtaining and evaluating the quality of relevant and reusable knowledge (and ensuring that this knowledge is up-to-date) requires significant effort. In this paper, we explore how online developer communities (e.g., Stack Overflow), traditionally used by developers to solve coding problems, can help solve architectural problems. We develop an ontology that covers architectural knowledge concepts in Stack Overflow. The ontology provides a description of architecture-relevant information to represent and structure architectural knowledge in Stack Overflow. The ontology is empirically grounded through qualitative analyses of different Stack Overflow posts, as well as inter-coder reliability tests. Our results show that the architecture knowledge ontology in Stack Overflow captures architecture-relevant information and supports achieving practitioners' requirements and concerns.
'File' Atttachments: internal-pdf://2075461472/Developing an Ontology for Architecture Knowle.pdf


Reference Type:  Conference Paper
Record Number: 7992
Author: Pidgeon, Christopher W. and Freeman, Peter A.
Year: 1985
Title: Development concerns for a software design quality expert system
Conference Name: Proceedings of the 22nd ACM/IEEE Design Automation Conference
Conference Location: Las Vegas, Nevada, USA
Publisher: IEEE Press
Pages: 562-568
Place Published: 317946


Reference Type:  Conference Proceedings
Record Number: 9406
Author: Pidgeon, C. W. and Freeman, P. A.
Year of Conference: 1985
Title: Development Concerns for a Software Design Quality Expert System
Conference Name: 22nd ACM/IEEE Design Automation Conference
Pages: 562-568
Date: 23-26 June 1985
Short Title: Development Concerns for a Software Design Quality Expert System
ISBN: 0738-100X
DOI: 10.1109/DAC.1985.1585999
Keywords: Automata
Computer architecture
Costs
Expert systems
Humans
Productivity
Software design
Software engineering
Technology transfer
Visualization
Abstract: This paper presents some developmental concerns for an expert system in the domain of software design. We discuss the context for such a system and explore the synergism between the human designer and automaton. A gross architecture for the automation is given. A scenario of interaction between the designer and automaton is presented.
Notes: Not fitting - tool development


Reference Type:  Journal Article
Record Number: 8493
Author: Liebowitz, Jay
Year: 1986
Title: Development of an expert system prototype for determining software functional requirements for command management activities at NASA goddard
Journal: Telematics and Informatics
Volume: 3
Issue: 1
Pages: 47-79
Date: //
Short Title: Development of an expert system prototype for determining software functional requirements for command management activities at NASA goddard
ISSN: 0736-5853
DOI: https://doi.org/10.1016/S0736-5853(86)80037-5
Abstract: At NASA Goddard, the role of the command management system (CMS) is to transform general requests for spacecraft operations into detailed operational plans to be uplinked to the spacecraft. The CMS is part of the NASA Data System which entails the downlink of science and engineering data from NASA near-earth satellites to the user, and the uplink of command and control data to the spacecraft. Presently, it takes one to three years, with meetings once or twice a week, to determine functional requirements for CMS software design. As an alternative approach to the present technique of developing CMS software functional requirements, an expert system prototype was developed to aid in this function. Specifically, the knowledge base was formulated through interactions with domain experts, and was then linked to an existing expert system application generator called “Knowledge Engineering System.” Knowledge base development focused on four major steps: (1) develop the problem-oriented attribute hierarchy; (2) determine the knowledge management approach; (3) encode the knowledge base; and (4) validate, test, certify, and evaluate the knowledge base and the expert system prototype as a whole. Backcasting was accomplished for validating and testing the expert system prototype. Knowledge refinement, evaluation, and implementation procedures of the expert system prototype were then transacted.
Notes: tool development
URL: https://www.sciencedirect.com/science/article/pii/S0736585386800375


Reference Type:  Conference Proceedings
Record Number: 8947
Author: Ming, H., Chang, C. K. and Yang, J.
Year of Conference: 2015
Title: Dimensional Situation Analytics: From Data to Wisdom
Conference Name: 2015 IEEE 39th Annual Computer Software and Applications Conference
Volume: 1
Pages: 50-59
Date: 1-5 July 2015
Short Title: Dimensional Situation Analytics: From Data to Wisdom
DOI: 10.1109/COMPSAC.2015.199
Keywords: data handling
knowledge management
parallel processing
(MR)<sup>2</sup> paradigm
DIKW hierarchy
cognitive category
decision making
dimensional situation analytics
functional MapReduce computing paradigm
human centric situation studies
knowledge transformation
Computer science
Context
Electronic mail
Ontologies
Software design
Data
Information
Knowledge
MapReduce
Ontology
Situ framework
Situation Analytics
Situation theory
Wisdom (DIKW)
Abstract: In the late 80s, Ackoff first proposed a cognitive category upon the content of human mind, which included Data, Information, Knowledge and Wisdom, or DIKW. Since then, the DIKW hierarchy has attracted a flurry of further research studies. Its applications include ontology composition, decision making theory, domain specific engineering theory, software design thought process automation, etc., to name a few. Partially based on our previous work on human centric situation studies, we propose a dimensional situation analytics towards a new view on the DIKW hierarchy. By incorporating functional MapReduce computing paradigm, we present in this paper a novel (MR)2 paradigm, which refers to two consecutive MapReduce that cut across the boundaries between Data, Information, Knowledge and Wisdom. We argue that our (MR)2 paradigm promotes comprehensive decision making and therefore, offers new insights in knowledge transformation from data to wisdom.
Notes: Some implementation not connected


Reference Type:  Conference Proceedings
Record Number: 7622
Author: Sobernig, S. and Zdun, U.
Year of Conference: 2016
Title: Distilling Architectural Design Decisions and Their Relationships Using Frequent Item-Sets
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 61-70
Date: 5-8 April 2016
Short Title: Distilling Architectural Design Decisions and Their Relationships Using Frequent Item-Sets
DOI: 10.1109/WICSA.2016.9
Keywords: data mining
software architecture
architectural knowledge artifact
data-mining
distilled decision
frequent item-sets
guidance model
reusable architectural decision model
Computer architecture
Context
Decision making
Documentation
Encoding
Software
Systematics
architectural design decision
design-decision relationship
reusable architectural design-decision model
Abstract: Much attention is paid nowadays to software architecture of a system as a set of design decisions providing the rationale for the system design. To document and share proven architectural design decisions, decisions made in concrete development projects are mined and distilled into reusable architectural decision models (a.k.a. guidance models). The available distillation approaches, however, remain ad hoc and biased towards the personal experience of few expert architects. Relationships between distilled decisions are not systematically explored. We propose an approach for distilling reusable architectural design decisions with emphasis on their relationships. Architectural knowledge artifacts (e.g., architecture documentation, interviews) are systematically coded for the occurrence of architectural design decisions and their details. Co-occurrences of coded design decisions are then processed for different relationship types using an established data-mining technique: frequent item-sets. The distilled relationships enter the construction of a reusable architectural decision model and contribute to organizing the design space based on empirical data (i.e., frequency patterns of co-occurrences). We report on distilling design-decision relationships from decision data collected during a three-year project on language architectures of 80 UML-based domain-specific modeling languages.
Notes: Relation between decisions, however no behavior focus


Reference Type:  Conference Paper
Record Number: 8295
Author: Daily, Mike, Howard, Mike, Jerald, Jason, Lee, Craig, Martin, Kevin, McInnes, Doug and Tinker, Pete
Year: 2000
Title: Distributed design review in virtual environments
Conference Name: Proceedings of the third international conference on Collaborative virtual environments
Conference Location: San Francisco, California, USA
Publisher: ACM
Pages: 57-63
DOI: 10.1145/351006.351013
Place Published: 351013
Abstract: In large distributed corporations, distributed design review offers the potential for cost savings, reduced time to market, and improved efficiency. It also has the potential to improve the design process by enabling wider expertise to be incorporated in design reviews. This paper describes the integration of several components to enable distributed virtual design review in mixed multi-party, heterogeneous multi-site 2D and immersive 3D environments. The system provides higher layers of support for collaboration including avatars, high fidelity audio, and shared artifact manipulation. The system functions across several interface environments ranging from CAVEs to Walls to desktop workstations. At the center of the software architecture is the Human Integrating Virtual Environment (HIVE) [6], a collaboration infrastructure and toolset to support research and development of multi-user, geographically distributed, 2D and 3D shared applications. The HIVE functions with VisualEyes software for visualizing 3D data in virtual environments. We also describe in detail the configuration and lessons learned in a two site, heterogeneous multi-user demonstration of the system between HRL Laboratories in Malibu, California and GM R&D in Warren, Michigan.
Notes: Tool description


Reference Type:  Conference Proceedings
Record Number: 9499
Author: Oliveira, E. and Allian, A. P.
Year of Conference: 2015
Title: Do reference architectures can contribute to standardizing variability management tools?
Conference Name: 2015 1st International Workshop on Exploring Component-based Techniques for Constructing Reference Architectures (CobRA)
Pages: 1-4
Date: 4-8 May 2015
Short Title: Do reference architectures can contribute to standardizing variability management tools?
Keywords: open systems
software architecture
software product lines
software reusability
software tools
VM tools
interoperability
mass customization
product customization
product derivation
product standardization
reference architectures
software products
variability management tool standardization
Analytical models
Computer architecture
Documentation
Industries
Software
Standardization
Systematics
Variability Management Tools
Abstract: Variability Management (VM) is one of the core activities for the success of software reuse. Several VM tools developed in academia and industry support mass customization of new software products and decrease time to market. Despite of a signi cant number of VM tools, in most cases, industry has adopted different techniques for managing variability, including producing their own tools. Such a heterogeneity provides difficulties in establishing VM, product customization and derivation, and standardization. From another perspective, reference architectures (RA) are a special type of software architecture as it encompasses specific domain knowledge, making it easier the development, standardization and evolution of software systems. Concepts from reference architectures can mitigate the lacking of VM tools standardization. Therefore, this position paper presents a vision towards supporting architectural standardization of VM tools, through reference architectures, for achieving a well-recognized understanding of such a domain and promoting reuse of design expertise. In this context, the main contribution of this paper is providing a discussion with regard to reference architectures and variability management tools towards supporting answering the following research question: Do reference architectures can contribute to standardizing VM tools?". Such standardization is useful as it fosters interoperability and reuse.
Notes: Focusing on tools


Reference Type:  Conference Proceedings
Record Number: 9367
Author: Yskout, K., Scandariato, R. and Joosen, W.
Year of Conference: 2015
Title: Do Security Patterns Really Help Designers?
Conference Name: 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering
Volume: 1
Pages: 292-302
Date: 16-24 May 2015
Short Title: Do Security Patterns Really Help Designers?
ISBN: 0270-5257
DOI: 10.1109/ICSE.2015.49
Keywords: security of data
software architecture
realistically-sized banking system
security pattern
software design
Banking
Context
IEEE catalogs
Productivity
Security
Software
Training
Abstract: Security patterns are well-known solutions to security-specific problems. They are often claimed to benefit designers without much security expertise. We have performed an empirical study to investigate whether the usage of security patterns by such an audience leads to a more secure design, or to an increased productivity of the designers. Our study involved 32 teams of master students enrolled in a course on software architecture, working on the design of a realistically-sized banking system. Irrespective of whether the teams were using security patterns, we have not been able to detect a difference between the two treatment groups. However, the teams prefer to work with the support of security patterns.
Notes: students


Reference Type:  Conference Proceedings
Record Number: 9101
Author: Stettina, C. J., Heijstek, W. and Fægri, T. E.
Year of Conference: 2012
Title: Documentation Work in Agile Teams: The Role of Documentation Formalism in Achieving a Sustainable Practice
Conference Name: 2012 Agile Conference
Pages: 31-40
Date: 13-17 Aug. 2012
Short Title: Documentation Work in Agile Teams: The Role of Documentation Formalism in Achieving a Sustainable Practice
DOI: 10.1109/Agile.2012.7
Keywords: Unified Modeling Language
software architecture
software prototyping
sustainable development
system documentation
RUP templates
SAD group
UML group
agile software development
agile teams
documentation allocation
documentation formalism role
documentation work
high-level software architecture
iterative documentation practices
low-level software design
sustainable practice
task specialization
textual description
textual documentation
Documentation
Encoding
Software design
Teamwork
knowledge sharing
organizational management and coordination
process improvement
project management
software development
Abstract: As its second guiding principle, agile software development promotes working software over comprehensive documentation. In this paper we investigate alignment between two different documentation practices and agile development. We report upon an experiment conducted to explore the impact of formalism and media type on various dimensions of documentation practice in agile teams. 28 students in 8 teams were divided into two groups: SAD and UML. Group SAD was to update and deliver their high-level software architecture in form of a textual description defined by RUP templates. Group UML was instructed to update and deliver their low-level software design in form of UML models. Our results show that iterative documentation practices led to more extensive and more detailed textual documentation. We found that writing documentation was perceived as a intrusive task leading to task specialization and allocation of documentation to less qualified team members. Consequently, this hampered collaboration within the team. Based in our findings, we suggest that if documentation is to be delivered with the project, producing documentation should be communicated and accepted by the team as a proper product. Furthermore, we argue that codification of internal development knowledge should be a non-intrusive task.
Notes: just about documentation as a product


Reference Type:  Journal Article
Record Number: 8403
Author: Jahnke, Isa
Year: 2010
Title: Dynamics of social roles in a knowledge management community
Journal: Computers in Human Behavior
Volume: 26
Issue: 4
Pages: 533-546
Date: 7//
Short Title: Dynamics of social roles in a knowledge management community
ISSN: 0747-5632
DOI: https://doi.org/10.1016/j.chb.2009.08.010
Keywords: Socio-Technical Communities
Roles
Social structures
Community change
Design-based research
Qualitative paradigm
Abstract: With the emergence of community-oriented Information and Communication Technology (ICT) applications, e.g., Wikipedia, the popularity of socio-technical phenomena in society has increased. This development emphasises the need to further our understanding of how computer-supported social group structures change over time and what forms emerge. This contribution presents the results of a qualitative field study of a Socio-Technical Community (STC). The STC is described from its founding (in 2001) to its sustainable development (in 2006) as well as its transformation phase (2007–2008). The design-based research approach revealed changes of social structures by social roles within the STC over time. The central conclusion is that such STC’s – networks of computer-mediated communication and human interaction – evolve a specific kind of social structure, which is formal rather than informal. The results indicate that a group evolves from an informal trust-based community with few formal roles to a STC where the social mechanisms, and not the software architecture, supports knowledge management processes.
URL: https://www.sciencedirect.com/science/article/pii/S0747563209001411


Reference Type:  Journal Article
Record Number: 8394
Author: Shneiderman, Ben and Carroll, John M.
Year: 1988
Title: Ecological studies of professional programmers
Journal: Commun. ACM
Volume: 31
Issue: 11
Pages: 1256-1258
Short Title: Ecological studies of professional programmers
ISSN: 0001-0782
DOI: 10.1145/50087.214900
Legal Note: 214900
Abstract: For over two decades, software psychology researchers have been developing insights to software productivity and quality by investigating builders and users of software. This research has been diverse in both its approach and its impacts. It has introduced systematic behavioral measurement into the software development process and into research on new software techniques and technologies, and has also opened up new social and cognitive interpretations of software processes [5, 12]. We now see evidence of a new thrust in software psychology coming to the fore, one in which usability researchers are direct participants in the definition and creation of new software artifacts. We call this paradigm Ecological Design, to emphasize (1) that realistic software situations are being confronted on their own terms, and (2) that the work is directed toward design results, not merely toward evaluation and description in the service of design goals. The reorientation towards studying teamwork was prompted in 1971 by Weinberg and followed by a few researchers at that time, but the movement has accelerated with the recent and intense interest in computer supported collaborative work [15]. This was apparent in the papers presented at the two workshops on Empirical Studies of Programmers [10, 13]. An accompanying shift has also occurred in the software engineering community. The traditional waterfall model of software development with the precise specification of a provable topdown design is giving way to newer exploratory styles of program development that emphasize rapid prototyping and iterative refinement. The shift from product to process also puts greater emphasis on team organization, group processes, management policies, reusability, development tools, design methods, debugging strategies, and maintenance [6]. The three papers in this special section exemplify this new paradigm. Rosson, Maass, and Kellogg and Curtis, Krasner, and Iscoe describe highly qualitative studies of professional designers that produced specific technical proposals for improving software tools and the coordination of project management, an assessment of major bottlenecks, and a new framework for thinking about software design as a learning and communication process. Soloway, Pinto, Letovsky, Littman, and Lampert describe the design and exploration of software documentation that grew out of similarly qualitative studies of program maintenance. We caution that this research paradigm is still in its infancy: setting design requirements and developing prototypes are not traditional activities of psychological researchers. These roles are still emerging, still being reconciled with the earlier paradigms. The particular projects highlighted here are only the beginning; the field continues to evolve, as more researchers are attracted, as more topics are explored, as more methods are developed. Thus, despite the shortcomings of any particular project, the trajectory of this paradigm seems clear to us: it is the development of ideas that directly impact productivity and quality in software. Indeed, part of our intention in presenting this special section is to encourage more and more rapid development of the new paradigm.
Notes: several studies, not a single one...


Reference Type:  Conference Proceedings
Record Number: 9448
Author: Clements, P. C.
Year of Conference: 2007
Title: An Economic Model for Software Architecture Decisions
Conference Name: 2007 First International Workshop on the Economics of Software and Computation
Pages: 1-1
Date: 20-26 May 2007
Short Title: An Economic Model for Software Architecture Decisions
DOI: 10.1109/ESC.2007.2
Keywords: decision making
product development
simulation languages
software architecture
software cost estimation
software reusability
economic modeling language
software product line
Application software
Assembly
Computer architecture
Cost function
Documentation
Software design
Software engineering
Software testing
Abstract: Software architecture is touted as essential for system development, but its benefits are almost never quantified. Further, architects are faced with decisions about architecture (such as deciding when an architecture has outlived its usefulness) that should be answered on an economic basis. This paper presents an simple economic modeling language that has been useful in the realm of software product lines, and argues that a similar language would be equally useful in the realm of architecture decision-making.
Notes: economic not interest


Reference Type:  Journal Article
Record Number: 8858
Author: Booch, G.
Year: 2007
Title: The Economics of Architecture-First
Journal: IEEE Software
Volume: 24
Issue: 5
Pages: 18-20
Short Title: The Economics of Architecture-First
ISSN: 0740-7459
DOI: 10.1109/MS.2007.146
Keywords: economics
software architecture
agile software development process
architecture-first approach
software life cycle
software-intensive system architecture
Acceleration
Command and control systems
Companies
Computer architecture
Costs
Defense industry
History
Intellectual property
Investments
Resilience
best practices
software economics
Abstract: Architecture is an artifact that's governed throughout the software life cycle - from conception through development to deployment and finally evolution, then to adaptation, assimilation, replacement, or abandonment. Similarly, the architect, either as an individual, a role, or a team, lovingly crafts, grows, and governs that architecture as it emerges from the thousands of individual design decisions of which it's composed. In this sense, an architecture-first approach appears to be a reflection of sound development practices. Now, strict agilists might counter that an architecture-first approach is undesirable because we should allow a system's architecture to emerge over time. More than just a reflection, however, a software development process that swirls around the growth of a software-intensive system's architecture has considerable material value.
Notes: More overall structure and growing of architecture, not focused enough


Reference Type:  Conference Paper
Record Number: 8278
Author: Shihab, Emad, Bird, Christian and Zimmermann, Thomas
Year: 2012
Title: The effect of branching strategies on software quality
Conference Name: Proceedings of the ACM-IEEE international symposium on Empirical software engineering and measurement
Conference Location: Lund, Sweden
Publisher: ACM
Pages: 301-310
DOI: 10.1145/2372251.2372305
Place Published: 2372305
Abstract: Branching plays a major role in the development process of large software. Branches provide isolation so that multiple pieces of the software system can be modified in parallel without affecting each other during times of instability. However, branching has its own issues. The need to move code across branches introduces addition-al overhead and branch use can lead to integration failures due to conflicts or unseen dependencies. Although branches are used ex-tensively in commercial and open source development projects, the effects that different branch strategies have on software quality are not yet well understood. In this paper, we present the first empirical study that evaluates and quantifies the relationship between soft-ware quality and various aspects of the branch structure used in a software project. We examine Windows Vista and Windows 7 and compare components that have different branch characteristics to quantify differences in quality. We also examine the effectiveness of two branching strategies -- branching according to the software architecture versus branching according to organizational structure. We find that, indeed, branching does have an effect on software quality and that misalignment of branching structure and organiza-tional structure is associated with higher post-release failure rates.
Notes: focus on branching, not behavior research


Reference Type:  Journal Article
Record Number: 9334
Author: Antonino, P. O., Morgenstern, A. and Kuhn, T.
Year: 2016
Title: Embedded-Software Architects: It's Not Only about the Software
Journal: IEEE Software
Volume: 33
Issue: 6
Pages: 56-62
Short Title: Embedded-Software Architects: It's Not Only about the Software
ISSN: 0740-7459
DOI: 10.1109/MS.2016.142
Keywords: embedded systems
personnel
software architecture
software development management
electromechanical devices
embedded software architects
embedded systems development
Computational modeling
Computer architecture
domain-specific architectures
integration and modeling
real-time and embedded systems
software architect
software development
software engineering
system architecture
Abstract: Owing to the increasing amount of computation in electromechanical devices, the role of software architect is often found in embedded-systems development. However, because computer scientists usually have limited knowledge of embedded-systems concepts such as controllers, actuators, and buses, embedded-software architects are often engineers with no education in software architecture basics, which is normally a topic in computer science courses. In these environments, serious architectural problems can occur, such as contradictory architecture decisions and inconsistencies between the architecture design and the architecture drivers. This article discusses the current profile of embedded-software architects, characteristics of embedded architectures designed by architects with no computer science background, and the shortcomings of architects whose knowledge is limited to information systems. The authors also discuss how to overcome these challenges.
Notes: focused on embedded software


Reference Type:  Conference Proceedings
Record Number: 9338
Author: Bril, R. J., Postma, A. and Krikhaar, R. L.
Year of Conference: 2003
Title: Embedding architectural support in industry
Conference Name: International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings.
Pages: 348-357
Date: 22-26 Sept. 2003
Short Title: Embedding architectural support in industry
ISBN: 1063-6773
DOI: 10.1109/ICSM.2003.1235442
Keywords: industries
program verification
software architecture
software development management
software maintenance
software tools
systems analysis
architectural maintenance
architectural support
commercial-off-the-shelf
industrial computing
professional systems
software development
software recovery
software verification
software visualization
Biomedical imaging
Business communication
Consumer electronics
Context
Humans
Medical control systems
Programming
Visualization
Abstract: Software architecture plays a vital role in the development (and hence maintenance) of large complex systems with a long lifetime. It is therefore required that the software architecture is also maintained, i.e. sufficiently documented, clearly communicated, and explicitly controlled. In our experience, these requirements cannot be met without appropriate support. Commercial-off-the-shelf support for architectural maintenance is still scarcely available, if at all, implying the need to develop appropriate proprietary means. In this paper, we briefly report upon an overall approach taken within three organizations within Philips that develop professional systems. We extensively describe the experience gained with the embedding of architectural support in these three organizations. We focus on architectural support in the area of software architecture recovery, visualization, analysis, and verification. In our experience, the support must be carried by a number of elements of software development, and all of these elements have to go through a change process to ensure sustainable embedding. We distinguish four of these elements, i.e. process, organization, software development environment, and humans, and present our experience in terms of those elements.
'File' Atttachments: internal-pdf://3976104186/Embedding architectural support in industry.pdf


Reference Type:  Conference Proceedings
Record Number: 9204
Author: Dilip, Soni, Nord, R. L. and Liang, Hsu
Year of Conference: 1993
Title: An empirical approach to software architectures
Conference Name: Proceedings of 1993 IEEE 7th International Workshop on Software Specification and Design
Pages: 47-51
Date: 6-7 Dec 1993
Short Title: An empirical approach to software architectures
DOI: 10.1109/IWSSD.1993.315515
Keywords: professional aspects
software engineering
architectural properties
description languages
empirical approach
practical results
pragmatic role
productivity
quality
research community
software architectures
software development activities
software engineering research community
verification
Buildings
Computer architecture
Control systems
Instruments
Programming
Quality management
Software architecture
Software safety
Taxonomy
Technology management
Abstract: The research community in the emerging area of software architecture has developed little consensus over the definition of architecture except that architecture is related to the structure of a system and the interaction among its components. Current efforts of building models of architecture have focused on taxonomy, description languages, and verification of architectural properties. What is missing is the focus on the pragmatic role of architecture in software development activities. We describe the state of the practice and the problems faced by architects and engineers. The challenge for the software engineering research community is to address these problems and produce scalable, practical results that will have a real impact on the developers, improving their productivity and the quality of systems they build.


Reference Type:  Journal Article
Record Number: 8634
Author: Tofan, Dan, Galster, Matthias, Lytra, Ioanna, Avgeriou, Paris, Zdun, Uwe, Fouche, Mark-Anthony, de Boer, Remco and Solms, Fritz
Year: 2016
Title: Empirical evaluation of a process to increase consensus in group architectural decision making
Journal: Information and Software Technology
Volume: 72
Pages: 31-47
Date: 4//
Short Title: Empirical evaluation of a process to increase consensus in group architectural decision making
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2015.12.002
Keywords: Software architecture
Group architecture decisions
Decision making
Abstract: AbstractContext Many software architectural decisions are group decisions rather than decisions made by individuals. Consensus in a group of decision makers increases the acceptance of a decision among decision makers and their confidence in that decision. Furthermore, going through the process of reaching consensus means that decision makers understand better the decision (including the decision topic, decision options, rationales, and potential outcomes). Little guidance exists on how to increase consensus in group architectural decision making. Objective We evaluate how a newly proposed process (named GADGET) helps architects increase consensus when making group architectural decisions. Specifically, we investigate how well GADGET increases consensus in group architectural decision making, by understanding its practical applicability, and by comparing GADGET against group architectural decision making without using any prescribed approach. Method We conducted two empirical studies. First, we conducted an exploratory case study to understand the practical applicability of GADGET in industry. We investigated whether there is a need to increase consensus, the effort and benefits of GADGET, and potential improvements for GADGET. Second, we conducted an experiment with 113 students from three universities to compare GADGET against group architectural decision making without using any prescribed approach. Results GADGET helps decision makers increase their consensus, captures knowledge on architectural decisions, clarifies the different points of view of different decision makers on the decision, and increases the focus of the group discussions about a decision. From the experiment, we obtained causal evidence that GADGET increases consensus better than group architectural decision making without using any prescribed approach. Conclusions There is a need to increase consensus in group architectural decisions. GADGET helps inexperienced architects increase consensus in group architectural decision making, and provides additional benefits, such as capturing rationale of decisions. Future work is needed to understand and improve other aspects of group architectural decision making.
Notes: students
URL: https://www.sciencedirect.com/science/article/pii/S0950584915002049


Reference Type:  Journal Article
Record Number: 8541
Author: Christensen, Henrik Bærbak and Hansen, Klaus Marius
Year: 2010
Title: An empirical investigation of architectural prototyping
Journal: Journal of Systems and Software
Volume: 83
Issue: 1
Pages: 133-142
Date: 1//
Short Title: An empirical investigation of architectural prototyping
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2009.07.049
Keywords: Software architecture
Architectural prototyping
Architectural analysis
Architectural evaluation
Empirical software architecture
Abstract: Architectural prototyping is the process of using executable code to investigate stakeholders’ software architecture concerns with respect to a system under development. Previous work has established this as a useful and cost-effective way of exploration and learning of the design space of a system and in addressing issues regarding quality attributes, architectural risks, and the problem of knowledge transfer and conformance. However, the actual industrial use of architectural prototyping has not been thoroughly researched so far. In this article, we report from three studies of architectural prototyping in practice. First, we report findings from an ethnographic study of practicing software architects. Secondly, we report from a focus group on architectural prototyping involving architects from four companies. And, thirdly, we report from a survey study of 20 practicing software architects and software developers. Our findings indicate that architectural prototyping plays an important and frequent role in resolving problems experimentally, but less so in exploring alternative solutions. Furthermore, architectural prototypes include end-user or business related functionality rather than purely architectural functionality. Based on these observations we provide recommendations for effective industrial architectural prototyping.
URL: https://www.sciencedirect.com/science/article/pii/S0164121209001903
'File' Attachments: internal-pdf://2575378885/An empirical investigation of architectural pr.pdf


Reference Type:  Conference Proceedings
Record Number: 9046
Author: Astudillo, H., Valdés, G. and Becerra, C.
Year of Conference: 2012
Title: Empirical Measurement of Automated Recovery of Design Decisions and Structure
Conference Name: 2012 VI Andean Region International Conference
Pages: 105-108
Date: 7-9 Nov. 2012
Short Title: Empirical Measurement of Automated Recovery of Design Decisions and Structure
DOI: 10.1109/Andescon.2012.33
Keywords: software architecture
system recovery
Toeska rationale extraction design
anecdotic evidence
architecture structure recovery
automated recovery
design decision
experimental design
manual TREx
tool-supported TREx
Computer architecture
Data mining
Instruments
Measurement
Software
Training
software desig
Abstract: Several notations and techniques have been proposed to capture and represent software architecture decisions and structures. Previous work has suggested that using automated techniques to recover decisions and structures from whichever project artifacts are actually kept may be a reasonable solution, but empirical evaluations of this claim are scarce. This article describes: (1) the TREx design decision and architecture structure recovery technique and tool, (2) precision and recall measures of recovery effectiveness for system structure, and (3) an experimental design to evaluate design decision and structure recovery approaches. An initial experimental evaluation of manual versus tool-supported TREx shows that using the tool increases recall, but yield mixed results on precision: decrease structure recovery precision, but increase decision recovery. Also anecdotic evidence suggest that only Experts were systematically better in recovering decisions without tool-support. A replicable experimental package has been published.
Notes: tool for ADDs


Reference Type:  Conference Proceedings
Record Number: 7617
Author: Galster, M. and Weyns, D.
Year of Conference: 2016
Title: Empirical Research in Software Architecture: How Far have We Come?
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 11-20
Date: 5-8 April 2016
Short Title: Empirical Research in Software Architecture: How Far have We Come?
DOI: 10.1109/WICSA.2016.10
Keywords: software architecture
empirical research
systematic mapping method
state-of-practice
Abstract: Context: Empirical research helps gain well-founded insights about phenomena. Furthermore, empirical research creates evidence for the validity of research results. Objective: We aim at assessing the state-of-practice of empirical research in software architecture. Method: We conducted a comprehensive survey based on the systematic mapping method. We included all full technical research papers published at major software architecture conferences between 1999 and 2015. Results: 17% of papers report empirical work. The number of empirical studies in software architecture has started to increase in 2005. Looking at the number of papers, empirical studies are about equally frequently used to a) evaluate newly proposed approaches and b) to explore and describe phenomena to better understand software architecture practice. Case studies and experiments are the most frequently used empirical methods. Almost half of empirical studies involve human participants. The majority of these studies involve professionals rather than students. Conclusions: Our findings are meant to stimulate researchers in the community to think about their expectations and standards of empirical research. Our results indicate that software architecture has become a more mature domain with regards to applying empirical research. However, we also found issues in research practices that could be improved (e.g., when describing study objectives and acknowledging limitations).
Notes: Literature review


Reference Type:  Conference Paper
Record Number: 7885
Author: Galster, Matthias and Avgeriou, Paris
Year: 2011
Title: Empirically-grounded reference architectures: a proposal
Conference Name: Proceedings of the joint ACM SIGSOFT conference -- QoSA and ACM SIGSOFT symposium -- ISARCS on Quality of software architectures -- QoSA and architecting critical systems -- ISARCS
Conference Location: Boulder, Colorado, USA
Publisher: ACM
Pages: 153-158
DOI: 10.1145/2000259.2000285
Place Published: 2000285
Abstract: A reference architecture describes core elements of the software architecture for systems that stem from the same domain. A reference architecture ensures interoperability of systems through standardization. It also facilitates the instantiation of new concrete architectures. However, we currently lack procedures for systematically designing reference architectures that are empirically-grounded. Being empirically-grounded would increase the validity and reusability of a reference architecture. We therefore present an approach which helps systematically design reference architectures. Our approach consists of six steps performed by the software architect and domain experts. It helps design reference architectures either from scratch, or based on existing architecture artifacts. We also illustrate how our approach could be applied to the design of two existing reference architectures found in literature.
Notes: Reference architecture design


Reference Type:  Journal Article
Record Number: 9610
Author: Miller, A.
Year: 1989
Title: Engineering design: its importance for software
Journal: IEEE Potentials
Volume: 8
Issue: 2
Pages: 14-16
Short Title: Engineering design: its importance for software
ISSN: 0278-6648
DOI: 10.1109/45.31589
Keywords: software engineering
maintenance
reliability
software design methodology
software development
software quality
software reuse
structure charts
testing
Costs
Design engineering
Design methodology
Programming
Robotic assembly
Software packages
Text analysis
Writing
Abstract: The importance of having a software design methodology is discussed. Its role in software reuse and in promoting software quality and reliability is examined. The waterfall model of software development, which allows a natural progression of steps to be followed during the course of a project, and the use of structure charts are described. Software testing and maintenance are briefly considered.<<ETX>>
Notes: bit too old - Waterfall?


Reference Type:  Conference Paper
Record Number: 7897
Author: Hess, Steffen, Knodel, Jens, Naab, Matthias and Trapp, Marcus
Year: 2016
Title: Engineering roles for constructing ecosystems
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-4
DOI: 10.1145/2993412.3003385
Place Published: 3003385
Abstract: The digital transformation of nearly all industrial sectors leads and will lead to a disruptive change. Instead of traditional linear value chains, we will move towards networked, interconnected value creation - digital ecosystems where multiple organizations and their software systems interact with each other. We can observe an increasing number of ecosystems that strongly gain value by contributions added by other organizations. However, what does this mean for engineering skills needed to initiate and grow an ecosystem with software systems being developed, evolved and operated? In this position paper, we introduce new roles and skill profiles required for engineering software ecosystems. We derived the initial role description based on practical experiences in projects we conducted over the past five years and found these roles to be crucial for the overall success of the organization within a digital ecosystem. Key capabilities we found are strength in business and technology at the same time, the ability to think end-to-end in the ecosystem, and interdisciplinarity regarding software engineering disciplines.


Reference Type:  Conference Proceedings
Record Number: 7691
Author: Soliman, M., Riebisch, M. and Zdun, U.
Year of Conference: 2015
Title: Enriching Architecture Knowledge with Technology Design Decisions
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 135-144
Date: 4-8 May 2015
Short Title: Enriching Architecture Knowledge with Technology Design Decisions
DOI: 10.1109/WICSA.2015.14
Keywords: decision making
software architecture
architecture knowledge approach
design process
software architecture design
technology design decision making
Computer architecture
Interviews
Java
Usability
User interfaces
architectural solution
architecture design decisions
architecture knowledge
technologies
technology design decision
Abstract: Decision-making is at the core of software architecture design. However, in order for the architect to take the right design decisions, assistance is required for exploring the architectural knowledge, which encompasses the various architectural solutions, their relationships and distinctions. In the past decades, the number of available technology options has increased significantly, while existing architecture knowledge approaches support technology decisions by representing relations between the different technology solutions, as well as design problems. However, they do not differentiate the candidate technologies according to their offered qualities and drawbacks. Our main goal in this exploratory study is to understand how technology solutions are being considered by the architects during the design process, and how can we enhance existing architecture knowledge concepts to support technology decision making. Our contribution in this paper is differentiating the different technology solutions' features based on a set of architecturally significant aspects, to facilitate considering technologies during the architecture design decisions. In addition, we proposed an extension for existing architecture knowledge models, which characterise the technology design decisions, and their reasoning. We evaluated our results through real examples from practitioners. Moreover, we conducted interviews with experts to validate our proposed concepts.
'File' Atttachments: internal-pdf://3926587751/2015-05-04-soliman-wicsa2015-enriching-archite.pdf


Reference Type:  Conference Paper
Record Number: 8145
Author: Yin, B. H. and Winchester, J. W.
Year: 1978
Title: The establishment and use of measures to evaluate the quality of software designs
Conference Name: Proceedings of the software quality assurance workshop on Functional and performance issues
Publisher: ACM
Pages: 45-52
DOI: 10.1145/800283.811099
Place Published: 811099
Abstract: It has been recognized that success in producing designs that realize reliable software, even using Structured Design, is intimately dependent on the experience level of the designer. The gap in this methodology is the absence of easily applied quantitative measures of quality that ease the dependence of reliable systems on the rare availability of expert designers. Several metrics have been devised which, when applied to design structure charts, can pinpoint sections of a design that may cause problems during coding, debugging, integration, and modification. These metrics can help provide an independent, unbiased evaluation of design quality. These metrics have been validated against program error data of two recently completed software projects at Hughes. The results indicate that the metrics can provide a predictive measure of program errors experienced during program development. Guidelines for interpreting the design metric values are summarized and a brief description of an interactive structure chart graphics system to simplify metric value calculation is presented.


Reference Type:  Conference Paper
Record Number: 8051
Author: Noppen, Joost and Tamzalit, Dalila
Year: 2010
Title: ETAK: tailoring architectural evolution by (re-)using architectural knowledge
Conference Name: Proceedings of the 2010 ICSE Workshop on Sharing and Reusing Architectural Knowledge
Conference Location: Cape Town, South Africa
Publisher: ACM
Pages: 21-28
DOI: 10.1145/1833335.1833339
Place Published: 1833339
Abstract: When an architect is faced with architectural evolution needs, he can opt to apply an existing evolution pattern. This is useful for well-known evolutions but at times is only partly sufficient. When he faces more specific evolutions, the architect needs to rely on expertise and intuition to extend the evolution beyond the pattern, a risky, error-prone evolution activity. In particular when the architect wants to assess the relevance of potential evolutions, he has no systematic assistance for analysing architectural knowledge. We propose ETAK as a framework for providing such automated assistance. ETAK allows the architect to define architectural traits he has in mind and the specific architectural knowledge he wants to consider. ETAK establishes the relevance of these traits for the new architecture, which can be used to decide whether to include them. We thus propose tailored architectural evolutions, drawing on intuition of the architect and architectural knowledge.
Notes: tool support


Reference Type:  Journal Article
Record Number: 8623
Author: Thomson, Alan J. and Schmoldt, Daniel L.
Year: 2001
Title: Ethics in computer software design and development
Journal: Computers and Electronics in Agriculture
Volume: 30
Issue: 1–3
Pages: 85-102
Date: 2//
Short Title: Ethics in computer software design and development
ISSN: 0168-1699
DOI: https://doi.org/10.1016/S0168-1699(00)00158-7
Keywords: Ethics
Software design and development
Traditional ecological knowledge
Indigenous knowledge
Intellectual property
Information ecologies
Abstract: Over the past 20 years, computer software has become integral and commonplace for operational and management tasks throughout agricultural and natural resource disciplines. During this software infusion, however, little thought has been afforded human impacts, both good and bad. This paper examines current ethical issues of software system design and development in relation to privacy, accuracy, property, accessibility, and effects on quality of life. These issues are explored in the context of simulation models, databases, geographic information systems and artificial intelligence programs, especially expert systems. New approaches to system development place a much higher emphasis on the effects of system deployment within a complex human environment. Software design decisions often depend on more than one ethical issue, possibly conflicting, where the appropriate ethical choice is not always clear cut. Professional codes of ethics do little to change peoples’ behavior; rather, incentives for using an ethical approach to software development may lie in significantly increased likelihood of system success.
URL: https://www.sciencedirect.com/science/article/pii/S0168169900001587


Reference Type:  Conference Proceedings
Record Number: 9522
Author: Babar, M. A.
Year of Conference: 2007
Title: Evaluating Product Line Architectures: Methods and Techniques
Conference Name: 14th Asia-Pacific Software Engineering Conference (APSEC'07)
Pages: 13-13
Date: 4-7 Dec. 2007
Short Title: Evaluating Product Line Architectures: Methods and Techniques
ISBN: 1530-1362
DOI: 10.1109/ASPEC.2007.10
Keywords: decision making
product development
software architecture
software performance evaluation
software quality
software reusability
design decision making
functional requirements
product line architecture
quality requirements
software architecture evaluation
Australia
Biographies
Collaborative tools
Computer architecture
Computer industry
Knowledge management
Research and development
Software engineering
Abstract: Summary form only given. Good software architecture is one of the key factors in successfully developing and evolving a system or a family of systems. Software architecture provides the key framework for the earliest design decisions taken to achieve functional and quality requirements. In addition, it has a profound influence on project organizations' functioning and structure. Poor architecture usually results in project inefficiencies, poor communication, and poor decision making. Software architecture for a family of systems also helps identify the commonality among different systems and explicitly document variability. Since software architecture plays a significant role in the life of a system, it is important to evaluate a system's architecture as early as possible. Architecture evaluation is considered one of the most important and effective techniques of addressing quality related issues at the software architecture level and mitigating architectural risks. Moreover, architecture evaluation sessions are an effective means of sharing and capturing architecture design rationale, reasoning behind architecture design decisions. This tutorial highlights the benefits and challenges in evaluating software architectures. It discusses theoretical and practical concepts underpinning some of the well-known scenario-based architecture evaluation methods and various approaches to characterize quality attributes using scenarios. The use of the presented methods, techniques, and tools will be demonstrated with a case study based on an industrial project.
Notes: Evaluation of architecture


Reference Type:  Conference Proceedings
Record Number: 9543
Author: Zayaraz, G., Vijayalakshmi, S. and Vijayalakshmi, V.
Year of Conference: 2009
Title: Evaluation of software architectures using multicriteria fuzzy decision making technique
Conference Name: 2009 International Conference on Intelligent Agent & Multi-Agent Systems
Pages: 1-5
Date: 22-24 July 2009
Short Title: Evaluation of software architectures using multicriteria fuzzy decision making technique
DOI: 10.1109/IAMA.2009.5228013
Keywords: decision making
fuzzy set theory
matrix algebra
software architecture
architecture selection method
multicriteria fuzzy decision making technique
product development costs
product development cycle
software architecture evaluation
software design
software development
Broadcasting
Computer architecture
Educational institutions
Feeds
Monitoring
Programming
Real time systems
Software systems
Fuzzy Decision Making
Quality attributes
Abstract: Software architectures is a critical aspect in the design and development of software. Architecture of software is a collection of design decisions that are expensive to change. A correct architecture has the largest single impact on cost and quality of the product. Though architecting constitutes 10% of the product development cycle, it determines 90% of the product development costs. Given the impact that software architecture has on a project's success, the need to choose the right architecture assumes significance. Organizations often need to choose software architecture for future development from several competing candidate architectures. In this paper, a new architecture selection method based on multicriteria fuzzy decision making technique has been developed and validated using a suitable case study.


Reference Type:  Journal Article
Record Number: 8573
Author: Ince, D. D.
Year: 1984
Title: The evaluation of software design metrics
Journal: Design Studies
Volume: 5
Issue: 4
Pages: 239-247
Date: 10//
Short Title: The evaluation of software design metrics
ISSN: 0142-694X
DOI: https://doi.org/10.1016/0142-694X(84)90059-0
Keywords: design matrices
software life cycle
Abstract: One of the major problems facing software developers is their inability to rely on metric which quantify the quality of their products. One area where quantitative measures of quality is needed is software design. This paper examines the work that has been carried out in the area of program code metrics and how the results of this work can be used in the evaluation of software design metrics. Finally, the role of such metrics is examined with respect to future developments in software engineering in the UK.
URL: https://www.sciencedirect.com/science/article/pii/0142694X84900590


Reference Type:  Conference Paper
Record Number: 7875
Author: Qureshi, Nadia, Usman, Muhammad and Ikram, Naveed
Year: 2013
Title: Evidence in software architecture, a systematic literature review
Conference Name: Proceedings of the 17th International Conference on Evaluation and Assessment in Software Engineering
Conference Location: Porto de Galinhas, Brazil
Publisher: ACM
Pages: 97-106
DOI: 10.1145/2460999.2461014
Place Published: 2461014
Abstract: Context: Software architecture (SA) plays pivotal role in development and maintenance of large software systems. Architectural decisions impact all subsequent phases in software development life cycle. Structure of large software systems has been in discussion since early 70s but software architecture started emerging as separate discipline since mid-90s. Objective: Researchers have been publishing empirical studies (i.e. case studies, experiments, experience reports) in SA discipline. Empirical literature has been aggregated in other disciplines of software engineering but no such effort has been made in SA. Objective of this study is to aggregate and synthesize the empirical evidence from literature of software architecture to report the trends, patterns and knowledge gaps. Method: To synthesize the empirical work in SA, we conducted a systematic literature review (SLR). This study reports the results of SLR based on 247 included primary studies. Results: Based on the percentage of 247 primary studies we identified that SA Evaluation (28%), non- functional requirements related work (22%) and SA Design (12%) are relatively mature sub areas of SA. Most of the empirical work (59%) in SA uses case study research method. Experiments (20%) and experience reports (14%) are also employed in empirical SA work. Conclusion: SA discipline is maturing as few sub areas of SA are mature and some areas are new and being developed. We have also identified few emerging trends in SA i.e. service oriented architecture, Product line architecture, Aspect oriented architecture, and model driven architecture.
Notes: Literature review


Reference Type:  Conference Proceedings
Record Number: 9514
Author: Goaer, O. Le, Tamzalit, D., Oussalah, M. and Seriai, A. D.
Year of Conference: 2008
Title: Evolution Shelf: Reusing Evolution Expertise within Component-Based Software Architectures
Conference Name: 2008 32nd Annual IEEE International Computer Software and Applications Conference
Pages: 311-318
Date: July 28 2008-Aug. 1 2008
Short Title: Evolution Shelf: Reusing Evolution Expertise within Component-Based Software Architectures
ISBN: 0730-3157
DOI: 10.1109/COMPSAC.2008.104
Keywords: software architecture
software reliability
software reusability
EOTS
evolution style
evolution-of-the-shelf
reuse techniques
reusing evolution expertise
semantic description format
software development
software evolution step
software system
Application software
Books
Computer applications
Computer architecture
Knowledge engineering
Laboratories
Programming
Software libraries
Software systems
Reuse Library
Software Evolution
Abstract: Despite that reuse libraries are now well adopted during software development step, software evolution step is not yet covered by this kind of beneficial approach. In this paper we present the "evolution shelf", a generic infrastructure to achieve for-reuse and by-reuse techniques within the field of software evolution. The basic idea behind that is to propose and encourage the reuse of recurring and reliable evolution expertises to achieve the structural evolution of a software system at the architectural level. For that purpose, the shelf assists architects in classifying, storing and selecting reusable architectural evolution operations. The underlying concept that we propose to capitalize the expertises is called "evolution style" and it mixes a syntactic and a semantic description format. These ideas form a core for a long-term vision in which it is possible to build a business model of evolution-of-the-shelf (EOTS) with the special objective to decrease the efforts and the risks related to the evolution activities.
Notes: System to improve reuse


Reference Type:  Conference Paper
Record Number: 8248
Author: Goaer, Olivier Le, Tamzalit, Dalila, Oussalah, Mourad Chabane and Seriai, Abdelhak-Djamel
Year: 2008
Title: Evolution styles to the rescue of architectural evolution knowledge
Conference Name: Proceedings of the 3rd international workshop on Sharing and reusing architectural knowledge
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 31-36
DOI: 10.1145/1370062.1370071
Place Published: 1370071
Abstract: The core idea is to consider software-architecture evolution tasks as a knowledge that must be clearly modeled and properly managed. The main expected benefit is the reuse of existing and already available evolution expertise rather than reinventing it, sometimes awkwardly and thus avoid time-consuming redundant evolution activities. For this purpose, we propose to use the evolution style concept as a neutral interchange format to capitalize and transfer knowledge about domain-specific evolution tasks. In this paper we put the focus on how it is possible to reason on evolution-styles description libraries through a classification scheme. Specifically, we present the "evolution shelf", an infrastructure to perform (a) incremental acquisition of new evolution descriptions and (b) retrieval of evolution descriptions matching with a given context. Our shelf, dedicated to software architects, relies on well-known repository techniques while updating them to support and exploit the evolution-style concept.
Notes: focus on reuse


Reference Type:  Conference Paper
Record Number: 8130
Author: Tamai, Tetsuo
Year: 2002
Title: Evolvable programming based on collaboration-field and role model
Conference Name: Proceedings of the International Workshop on Principles of Software Evolution
Conference Location: Orlando, Florida
Publisher: ACM
Pages: 1-5
DOI: 10.1145/512035.512037
Place Published: 512037
Abstract: This is a brief introduction to our research on a collaboration field and role model aiming to support evolvable software design and programming.
Notes: not research, just introduction


Reference Type:  Conference Proceedings
Record Number: 9530
Author: Heijstek, W., Kuhne, T. and Chaudron, M. R. V.
Year of Conference: 2011
Title: Experimental Analysis of Textual and Graphical Representations for Software Architecture Design
Conference Name: 2011 International Symposium on Empirical Software Engineering and Measurement
Pages: 167-176
Date: 22-23 Sept. 2011
Short Title: Experimental Analysis of Textual and Graphical Representations for Software Architecture Design
ISBN: 1949-3770
DOI: 10.1109/ESEM.2011.25
Keywords: computer graphics
document handling
software architecture
English
graphical representations
software architecture design documentation
software developers
textual artifacts
textual representations
visual artifacts
Computer architecture
Data mining
Documentation
Media
Software
Unified modeling language
controlled experiment
global software development
software architecture design
textual notation
visual notation
Abstract: Software architecture design documentation should communicate design decisions effectively. However, little is known about the way recipients respond to the different types of media used in documentation. We therefore conducted a controlled experiment to study whether visual or textual artifacts are more effective in communicating architecture software design decisions to software developers. Our participant group consisted of 47 participants from both industry and academia. Our results show that neither diagrams nor textual descriptions proved to be significantly more efficient in terms of communicating software architecture design decisions. Remarkably, participants who predominantly used text, scored significantly better, overall and with respect to topology related questions. Furthermore, surprisingly, diagrams were not able to alleviate the difficulties participants with a native language other than English had in extracting information from the documentation. In combination, these findings at the very least question the role of diagrams in software architecture documentation.
Notes: students...
'File' Atttachments: internal-pdf://4101295963/Experimental Analysis of Textual and Graphical.pdf


Reference Type:  Journal Article
Record Number: 8438
Author: Weinreich, Rainer, Groher, Iris and Miesbauer, Cornelia
Year: 2015
Title: An expert survey on kinds, influence factors and documentation of design decisions in practice
Journal: Future Generation Computer Systems
Volume: 47
Pages: 145-160
Date: 6//
Short Title: An expert survey on kinds, influence factors and documentation of design decisions in practice
ISSN: 0167-739X
DOI: https://doi.org/10.1016/j.future.2014.12.002
Keywords: Software architecture knowledge management
Design decisions
Design decision classification
Design decision influence factors
Design decision documentation
Abstract: Support for capturing architectural knowledge has been identified as an important research challenge. As the basis for an approach to recovering design decisions and capturing their rationale, we performed an expert survey in practice to gain insights into the different kinds, influence factors, and sources for design decisions and also into how they are currently captured in practice. The survey was conducted with 25 software architects, software team leads, and senior developers from 22 different companies in 10 different countries with more than 13 years of experience in software development on average. The survey confirms earlier work by other authors on design decision classification and influence factors, and also identifies additional kinds of decisions and influence factors not mentioned in previous work. In addition, we gained insight into the practice of capturing, the relative importance of different decisions and influence factors, and into potential sources for recovering decisions.
URL: https://www.sciencedirect.com/science/article/pii/S0167739X14002556
'File' Attachments: internal-pdf://2677002452/An expert survey on kinds, influence factors a.pdf


Reference Type:  Conference Proceedings
Record Number: 9152
Author: Annaiahshetty, K. and Prasad, N.
Year of Conference: 2013
Title: Expert System for Multiple Domain Experts Knowledge Acquisition in Software Design and Development
Conference Name: 2013 UKSim 15th International Conference on Computer Modelling and Simulation
Pages: 196-201
Date: 10-12 April 2013
Short Title: Expert System for Multiple Domain Experts Knowledge Acquisition in Software Design and Development
DOI: 10.1109/UKSim.2013.124
Keywords: expert systems
knowledge acquisition
software engineering
SDLC
agile development methodology
design artifact
domain expert knowledge acquisition
expert system
iterative methodology
scrum methodology
software analysis
software design
software development
software development life cycle
software organization
software realization
software requirements
v-model methodology
waterfall methodology
Business
Computers
Software
AI
Domain Experts
Knowledge Base
Abstract: In the software development life cycle (SDLC), the highly complex part of developing successful software's largely depends in the initial phases, such as analysis and requirements gathering to produce right design artifacts. Today the software organization adapted many development methodologies, beginning from waterfall, scrum, v-model, iterative to agile development methodologies, different frameworks, design tools, and domain model tools. But the foremost role and deciding factor for success or failure of the software is largely depends on the Domain Experts (Architects, Business Analyst, Design Engineers and Stack Holders), in the current software realization. This paper will attempt to design and develop an expert system to assist the software developer in the complete software development life cycle with multiple domain experts' such as Telecom, Banking, Insurance, Logistics, Healthcare, Satellite and many more knowledge acquisition. The specific goals of this research include knowledge acquisition specific to the problems of using multiple domain experts, design and development of a prototype expert system for software development, and validation of the prototype expert system.
Notes: expert system
'File' Atttachments: internal-pdf://0277972532/Expert System for Multiple Domain Experts.pdf


Reference Type:  Journal Article
Record Number: 7810
Author: Sonnentag, Sabine
Year: 1998
Title: Expertise in professional software design: A process study
Journal: Journal of Applied Psychology
Volume: 83
Issue: 5
Pages: 703-715
Short Title: Expertise in professional software design: A process study
ISSN: 1939-1854(Electronic),0021-9010(Print)
DOI: 10.1037/0021-9010.83.5.703
Keywords: *Computer Software
*Employee Characteristics
*Job Knowledge
*Job Performance
*Professional Personnel
Job Experience Level
Abstract: Forty professional software designers participated in a study in which they worked on a software design task and reported strategies for accomplishing that task. High performers were identified by a peer-nomination method and performance on a design. Verbal protocol analysis based on a comparison of 12 high and 12 moderate performers indicated that high performers structured their design process by local planning and showed more feedback processing, whereas moderate performers were more engaged in analyzing requirements and verbalizing task-irrelevant cognitions. High performers more often described problem comprehension and cooperation with colleagues as useful strategies. High and moderate performers did not differ with respect to length of experience. None of the differences between the two performance groups could be explained by length of experience.
'File' Attachments: internal-pdf://1443479783/Expertise in professional software design A pr.pdf


Reference Type:  Book Section
Record Number: 7809
Author: Sonnentag, Sabine, Niessen, Cornelia and Volmer, Judith
Year: 2009
Title: Expertise in software design
Editor: Ericsson, K. Anders, Charness, Neil, Feltovich, Paul J. and Hoffman, Robert R.
Book Title: Cambridge handbook of expertise and expert performance
Place Published: Cambridge
Publisher: Cambridge Univesity Press
Short Title: Expertise in software design
ISBN: 9780521600811
Abstract: In this chapter, we review research evidence on expertise in software design, computer programming, and related tasks. Research in this domain is particularly interesting because it refers both to rather general features and processes associated with expertise (e.g., knowledge representation, problem-solving strategies) and to specific characteristics of high performers in an economically relevant real-world setting. Therefore, in this chapter we draw on literature from various £elds, mainly from cognitive psychology, but also from work and organizational psychology and from the software-design literature within computer science. Our chapter is organized as follows: In the first main section we provide a brief description of the domain and give an overview of tasks in software development. Next, we briefly describe the expertise concept and distinguish between a conceptualization of expertise as years of experience and expertise as high performance. The third main se ction is the core part of this chapter. In this section, we review empirical research on expertise in tasks such as software design, programming, program comprehension, testing, and debugging. Moreover, we describe how expert performers differ from non-experts with respect to knowledge as well as communication and cooperation processes. In the final section, we present directions for future research and discuss some practical implications. 
URL: https://opus4.kobv.de/opus4-bamberg/frontdoor/index/index/docId/25079


Reference Type:  Journal Article
Record Number: 8735
Author: Miller, James A., Ferrari, Remo and Madhavji, Nazim H.
Year: 2010
Title: An exploratory study of architectural effects on requirements decisions
Journal: Journal of Systems and Software
Volume: 83
Issue: 12
Pages: 2441-2455
Date: 12//
Short Title: An exploratory study of architectural effects on requirements decisions
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2010.07.006
Keywords: Software architecture
Requirements engineering
Empirical study
Software quality
Process improvement
Quantitative and qualitative research
Architecture and requirements technology
Abstract: The question of the “manner in which an existing software architecture affects requirements decision-making” is considered important in the research community; however, to our knowledge, this issue has not been scientifically explored. We do not know, for example, the characteristics of such architectural effects. This paper describes an exploratory study on this question. Specific types of architectural effects on requirements decisions are identified, as are different aspects of the architecture together with the extent of their effects. This paper gives quantitative measures and qualitative interpretation of the findings. The understanding gained from this study has several implications in the areas of: project planning and risk management, requirements engineering (RE) and software architecture (SA) technology, architecture evolution, tighter integration of RE and SA processes, and middleware in architectures. Furthermore, we describe several new hypotheses that have emerged from this study, that provide grounds for future empirical work. This study involved six RE teams (of university students), whose task was to elicit new requirements for upgrading a pre-existing banking software infrastructure. The data collected was based on a new meta-model for requirements decisions, which is a bi-product of this study.
Notes: university student research
URL: https://www.sciencedirect.com/science/article/pii/S0164121210001779


Reference Type:  Conference Proceedings
Record Number: 9317
Author: Babar, M. A.
Year of Conference: 2009
Title: An exploratory study of architectural practices and challenges in using agile software development approaches
Conference Name: 2009 Joint Working IEEE/IFIP Conference on Software Architecture & European Conference on Software Architecture
Pages: 81-90
Date: 14-17 Sept. 2009
Short Title: An exploratory study of architectural practices and challenges in using agile software development approaches
DOI: 10.1109/WICSA.2009.5290794
Keywords: software architecture
software development management
agile software development approach
architectural challenges
architectural practices
Bridges
Computer architecture
Computer industry
Costs
Data analysis
Large-scale systems
Programming
Software systems
agile approaches
empirical studies
qualitative research
Abstract: Agile software development approaches have recently gained popularity as a mechanism for reducing cost and increasing ability to handle change in dynamic market conditions. However, there is also a significant concern about the role and importance of the issues related to the software architecture of a system being developed using agile approaches. There is to date little empirical evidence available on what software architecture related practices are followed by teams using agile approaches and the kinds of architectural challenges resulting from using agile approaches. This paper reports a case study aimed to empirically identify and understand the architectural practices and challenges of teams using agile approaches. The findings provide useful information about the researched issues and also highlight the areas that need to be focused on for integrating agile and architecture-centric approaches.
'File' Atttachments: internal-pdf://1470541689/An exploratory study of architectural practice.pdf


Reference Type:  Journal Article
Record Number: 8461
Author: de Graaf, K. A., Liang, P., Tang, A., van Hage, W. R. and van Vliet, H.
Year: 2014
Title: An exploratory study on ontology engineering for software architecture documentation
Journal: Computers in Industry
Volume: 65
Issue: 7
Pages: 1053-1064
Date: 9//
Short Title: An exploratory study on ontology engineering for software architecture documentation
ISSN: 0166-3615
DOI: https://doi.org/10.1016/j.compind.2014.04.006
Keywords: Ontology engineering
Software architecture
Software ontology
Ontology-based documentation
Knowledge acquisition
Knowledge management
Abstract: The usefulness of Software Architecture (SA) documentation depends on how well its Architectural Knowledge (AK) can be retrieved by the stakeholders in a software project. Recent findings show that the use of ontology-based SA documentation is promising. However, different roles in software development have different needs for AK, and building an ontology to suit these needs is challenging. In this paper we describe an approach to build an ontology for SA documentation. This approach involves the use of typical questions for eliciting and constructing an ontology. We outline eight contextual factors, which influence the successful construction of an ontology, especially in complex software projects with diverse AK users. We tested our ‘typical question’ approach in a case study and report how it can be used for acquiring and modeling AK needs.
Notes: model data structure
URL: https://www.sciencedirect.com/science/article/pii/S0166361514000840


Reference Type:  Journal Article
Record Number: 8987
Author: Díaz-Pace, J. A. and Campo, M. R.
Year: 2008
Title: Exploring Alternative Software Architecture Designs: A Planning Perspective
Journal: IEEE Intelligent Systems
Volume: 23
Issue: 5
Pages: 66-77
Short Title: Exploring Alternative Software Architecture Designs: A Planning Perspective
ISSN: 1541-1672
DOI: 10.1109/MIS.2008.78
Keywords: planning (artificial intelligence)
software architecture
software quality
Al-based tool
DesignBots framework
artificial intelligence
decision making
hierarchical mixed-initiative planning model
software architecture design
software quality-attribute requirement
AI planning
architectural design framework
quality attributes
tool support
Abstract: Software architecture designs give us blueprints to build systems, enabling key early decisions that can help us achieve a system's functional and quality-attribute requirements. Architectural decisions have far-reaching effects on development in terms of quality, time, and cost. Architects apply technical knowledge and experience to guide their decision making, choosing among multiple design solutions to find a reasonable balance of quality attributes such as performance, modifiability, or security. This is complex and time consuming because qualities can conflict and lead to trade-offs. A trade-off means that the improvement of one quality comes at the cost of degrading another for example, modifiability versus performance. The DesignBots framework supports architects in searching for design alternatives by capturing quality-attribute design concepts into a hierarchical, mixed-initiative planning model. Overall, this work reinforces the argument that Al-based tools can facilitate the design of architectures driven by quality-attribute issues.
Notes: tool support for alternatives


Reference Type:  Conference Proceedings
Record Number: 7688
Author: Harper, K. E. and Zheng, J.
Year of Conference: 2015
Title: Exploring Software Architecture Context
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 123-126
Date: 4-8 May 2015
Short Title: Exploring Software Architecture Context
DOI: 10.1109/WICSA.2015.22
Keywords: IEC standards
IEEE standards
ISO standards
software architecture
IEC
IEEE 42010
ISO
architecture description elements
architecture design context
architecture framework metamodel
decision force
industry stakeholders
software architecture context
system environment
Computer architecture
Conferences
Context
Documentation
Force
Software
architecture decisions
architecture descriptions
architecture viewpoints
Abstract: Architecture description can be modeled as a set of alternative choices and decisions, where the rationale and tradeoffs for each decision are documented and understood as needed to inform subsequent decisions. Each decision, based on ISO/IEC/IEEE 42010, pertains to one or more stakeholder concerns. These concerns combined with the system environment and scenarios provide architecture design context that clarifies the motivation for decisions. Subsequent authors have introduced the notion of an influencing decision force, using a many-to-many relationship with concern, to provide further context for decisions. For both concerns and forces it is left to the architect to identify the nature of this context. This paper proposes a systematic process for identifying and documenting design context in support of architectural decisions. For our work decision force is used as a central unifying aspect of the architecture framework metamodel. We extend the decision Forces Viewpoint to capture detailed design context descriptions, and add features for tagging the architecture description elements to facilitate identification of commonality, classification, and specialization. Initial feedback from industry stakeholders indicates this approach should be explored further.
Notes: Extend architecture rationale, not skills


Reference Type:  Conference Proceedings
Record Number: 9297
Author: Juric, R.
Year of Conference: 2000
Title: Extreme programming and its development practices
Conference Name: ITI 2000. Proceedings of the 22nd International Conference on Information Technology Interfaces (Cat. No.00EX411)
Pages: 97-104
Date: 16-16 June 2000
Short Title: Extreme programming and its development practices
ISBN: 1330-1012
Keywords: programming
software architecture
automated tests
code generation
collective code-ownership
conceptual modelling
extreme programming
intensive software systems
oral communications
pair programming
rational unified process
software architecture solutions
software engineering practice
storytelling culture
Automatic programming
Automatic testing
Electronic mail
Employment
Object oriented modeling
Oral communication
Software engineering
Software systems
Unified modeling language
Abstract: Extreme programming (XP) has attracted attention because of its fierce denial of many well-accepted software engineering practices considered as a sound approach to the development of intensive software systems. XP has been declared to be a new way of software development: a lightweight methodology, which is efficient, low-risk, flexible, predictable, scientific, and distinguishable from any other methodology. In the core of XP practices are programming activities, with strong emphasis on oral communications, automated tests, pair programming, storytelling culture and collective code-ownership at any time in the XP project. The paper gives an overview of XP practices and raises some serious concerns regarding their role in conceptual modelling and code generation; which directly affects software architecture solutions. The paper also tackles similarities between rational unified process (RUP) and XP, which have often been juxtaposed by software developers.
Notes: just about XP


Reference Type:  Conference Proceedings
Record Number: 9074
Author: Werf, J. M. E. M. v. d., Feijter, R. d., Bex, F. and Brinkkemper, S.
Year of Conference: 2017
Title: Facilitating Collaborative Decision Making with the Software Architecture Video Wall
Conference Name: 2017 IEEE International Conference on Software Architecture Workshops (ICSAW)
Pages: 137-140
Date: 5-7 April 2017
Short Title: Facilitating Collaborative Decision Making with the Software Architecture Video Wall
DOI: 10.1109/ICSAW.2017.27
Keywords: audio recording
data mining
decision making
groupware
software architecture
architecture rationale documentation
argumentation mining
audio recordings
collaborative decision making
design decisions
discussion participants
screenplay
software architecture video wall
whiteboard
Collaboration
Computer architecture
Documentation
Software
Stakeholders
architecture design
argument mining
Abstract: Although capturing and documenting the design making process in software architecture is an important task, few tools exist to support the architect in this task. Often, such decisions are made during discussions with other stakeholders, but typically these remain implicit. We envision the Software Architecture Video Wall as a collaborative decision making tool for the software architect. The video wall serves as a whiteboard for discussions that automatically records the screenplay. Combined with the audio recordings of the discussion participants, a rich data set is obtained that may serve as input to track design decisions, and argumentation mining, to generate architecture rationale documentation. The video wall serves different uses as explained in several possible scenarios. However, as shown in the paper, much research is still required to realize this vision.
Notes: tool to document


Reference Type:  Conference Paper
Record Number: 7952
Author: Bonfanti, Silvia, Centurelli, Valentina, Riccobene, Elvinia and Scandurra, Patrizia
Year: 2017
Title: The female contribution in architecting a set of tools for a formal method: role of women in software architecture (short paper)
Conference Name: Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings
Conference Location: Canterbury, United Kingdom
Publisher: ACM
Pages: 12-15
DOI: 10.1145/3129790.3129823
Place Published: 3129823
Abstract: This paper presents the female contribution on engineering a reference software architecture for ASMETA, a framework for an integrated use of tools developed around the Abstract State Machine formal method. Based on our experience in such a development project, we discuss how feminine mindset and skills can bring concrete advantages, but some disadvantages too, in the creative process of metamodeling, architecting and maintaining software.
Notes: just about women... not general


Reference Type:  Journal Article
Record Number: 8441
Author: Capra, Eugenio, Francalanci, Chiara, Merlo, Francesco and Rossi-Lamastra, Cristina
Year: 2011
Title: Firms’ involvement in Open Source projects: A trade-off between software structural quality and popularity
Journal: Journal of Systems and Software
Volume: 84
Issue: 1
Pages: 144-161
Date: 1//
Short Title: Firms’ involvement in Open Source projects: A trade-off between software structural quality and popularity
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2010.09.004
Keywords: Open Source Community Projects
Firm participation
Internal software design quality
Open Source projects popularity
Structural Equation Modeling
Abstract: Open Source (OS) was born as a pragmatic alternative to the ideology of Free Software and it is now increasingly seen by companies as a new approach to developing and making business upon software. Whereas the role of firms is clear for commercial OS projects, it still needs investigation for projects based on communities. This paper analyses the impact of firms’ participation on popularity and internal software design quality for 643 SourceForge.net projects. Results show that firms’ involvement improves the ranking of OS projects, but, on the other hand, puts corporate constraints to OS developing practices, thus leading to lower structural software design quality.
Notes: OSS project...
URL: https://www.sciencedirect.com/science/article/pii/S016412121000244X


Reference Type:  Conference Proceedings
Record Number: 9568
Author: Beer, W., Dorninger, B. and Winterer, M.
Year of Conference: 2013
Title: Flexible and reliable software architecture for industrial user interfaces
Conference Name: 2013 IEEE 18th Conference on Emerging Technologies & Factory Automation (ETFA)
Pages: 1-6
Date: 10-13 Sept. 2013
Short Title: Flexible and reliable software architecture for industrial user interfaces
ISBN: 1946-0740
DOI: 10.1109/ETFA.2013.6648064
Keywords: production facilities
program visualisation
software architecture
user interfaces
complex production process
flexible application platform
industrial user interfaces
large scale enterprise integration capabilities
machine control systems
modern industrial software systems
modular runtime framework
production machines
user interaction
visualization software
Engines
Runtime
Software reliability
Software systems
Abstract: Visualization software plays a major role in controlling and monitoring production machines and facilities. In recent years these software systems have undergone major changes in terms of flexibility, user interaction and large scale enterprise integration capabilities. While traditional machine control systems tend to operate in isolation, modern industrial software systems are integrated in complex production processes that demand for flexibility and openness, also in terms of dynamic change of functionality at runtime. Despite this increased demand for flexibility, the most important requirement for industrial software systems remains reliability and stable operation. Within this work we present an architectural approach for abstracting industrial application models on top of a dynamic and modular runtime framework (OSGi) and a flexible application platform (Eclipse). This approach allows to add functionality at runtime as well as to adapt the rendering of the UI to various technologies.
Notes: tool support


Reference Type:  Conference Proceedings
Record Number: 7765
Author: Heesch, U. van, Avgeriou, P. and Hilliard, R.
Year of Conference: 2012
Title: Forces on Architecture Decisions - A Viewpoint
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 101-110
Date: 20-24 Aug. 2012
Short Title: Forces on Architecture Decisions - A Viewpoint
DOI: 10.1109/WICSA-ECSA.212.18
Keywords: software architecture
system documentation
architecture decision
decision force viewpoint
documentation approach
standard ISO/IEC/IEEE 42010
Computer architecture
Documentation
Force
IEC standards
ISO
Software
ISO/IEC/IEEE 42010
architecture decisions
forces
Abstract: In this paper, the notion of forces as influences upon architecture decisions is introduced. To facilitate the documentation of forces as a part of architecture descriptions, we specify a decision forces viewpoint, which extends our existing framework for architecture decisions, following the conventions of the international architecture description standard ISO/IEC/IEEE 42010. The applicability of the viewpoint was validated in three case studies, in which senior software engineering students used it to document decisions in software projects, two of which conducted for industrial customers. The results show that the forces viewpoint is a well-received documentation approach, satisfying stakeholder concerns related to traceability between decision forces and architecture decisions.
Notes: done by students


Reference Type:  Conference Paper
Record Number: 7878
Author: Schmid, Klaus
Year: 2013
Title: A formal approach to technical debt decision making
Conference Name: Proceedings of the 9th international ACM Sigsoft conference on Quality of software architectures
Conference Location: Vancouver, British Columbia, Canada
Publisher: ACM
Pages: 153-162
DOI: 10.1145/2465478.2465492
Place Published: 2465492
Abstract: The notion of technical debt attracts significant attention, especially in the context of reconciling architecture and agile development. However, most work on technical debt is still largely informal and if it provides a formalization it is often ad-hoc. In this paper, we provide a detailed, formal analysis of decision making on technical debt in development. Using this formalization, we show that optimal decision making is not effectively computable in real-world situations and provide several well-defined approximations that allow to handle the problem nevertheless in practical situations. Combining these approximations in a single method leads to a light-weight approach that can be effectively applied in iterative software development, including agile approaches.


Reference Type:  Conference Paper
Record Number: 8079
Author: Fischbein, Dario, Uchitel, Sebastian and Braberman, Victor
Year: 2006
Title: A foundation for behavioural conformance in software product line architectures
Conference Name: Proceedings of the ISSTA 2006 workshop on Role of software architecture for testing and analysis
Conference Location: Portland, Maine
Publisher: ACM
Pages: 39-48
DOI: 10.1145/1147249.1147254
Place Published: 1147254
Abstract: Software product lines or families represent an emerging paradigm that is enabling companies to engineer applications with similar functionality and user requirements more effectively. Behaviour modelling at the architecture level has the potential for supporting behaviour analysis of entire product lines, as well as defining optional and variable behaviour for different products of a family. However, to do so rigorously, a well defined notion of behavioural conformance of a product to its product line must exist. In this paper we provide a discussion on the shortcomings of traditional behaviour modelling formalisms such as Labelled Transition Systems for characterising conformance and propose Modal Transition Systems as an alternative. We discuss existing semantics for such models, exposing their limitations and finally propose a novel semantics for Modal Transition Systems, branching semantics, that can provide the formal underpinning for a notion of behaviour conformance for software product line architectures.
Notes: specific for software product lines


Reference Type:  Journal Article
Record Number: 8035
Author: Kurkovsky, Stan
Year: 2008
Title: Four roles of instructor in software engineering projects
Journal: SIGCSE Bull.
Volume: 40
Issue: 3
Pages: 354-354
Short Title: Four roles of instructor in software engineering projects
ISSN: 0097-8418
DOI: 10.1145/1597849.1384396
Legal Note: 1384396
Abstract: As a practice-oriented discipline, Software Engineering (SE) is most effectively taught by using a variety of hands-on experiences. Team-based projects where students can practice their technical and soft skills are a key feature of many software engineering courses aimed to prepare students for the realities of industrial software development.

Current research indicates that projects offered in SE courses should have a close connection to the real world, be large scale and complex. On the one hand, students should be able to relate to the requirements and understand them without spending much time acquiring domain knowledge. On the other hand, students should be exposed to changing and evolving requirements, which is one of the main challenges of real-world software projects. Software projects should be large enough and have enough features to engage all members of the student team while enabling them to practice some degree of specialization and experience the advantages and challenges of teamwork. Software projects should be rich enough to allow students practice all previously acquired SE concepts, bring together knowledge from other specialized CS disciplines, and apply a number of modern tools and technologies.

One of the most effective ways to learn SE is to expose students to an environment that resembles an industrial setting as much as possible. As a part of an academic program, SE courses can achieve this objective by offering students a balanced combination of three components: teamwork involving up-to-date technology grounded in a solid theoretical foundation. Instructors in SE courses are uniquely positioned to help maintain this balance by simultaneously playing four roles described below.

As a customer who contracts a student team to implement a particular project, the instructor may provide a verbal or written description of the project. It is the students? responsibility to conduct the requirements elicitation interviews and to prepare formal requirements specification for subsequent validation with the customer and possible adjustment. The instructor may act as a customer during the acceptance testing throughout the project to make sure that the team is on the right track at every iteration of the project. The instructor acting as a customer can also act as a proxy if the project has been offered by an industrial partner, or some other department or organization on campus.

As an architect initially specifying the overall structure of the solution, the instructor can help students choose the right software architecture. This is a very important choice that has to be made early because it impacts the overall flow of the project. Later architectural changes can be extremely costly and can significantly jeopardize meeting the deadlines. Most likely, students do not have experience in making such architectural decisions and, therefore, it is crucial for the instructor to provide some guidance in this important process.

As a team manager concerned with risk management, the instructor needs to pay attention that the team efforts are not jeopardized due to a potential lack of students? soft skills and that these skills are built up as the project progresses. Although it is the students? responsibility to create all artifacts emerging from the project, the instructor can help the team adhere to the schedule by providing feedback based on the inspection of all produced artifacts. In this respect, the roles of the team manager and the customer may somewhat overlap because the same person will be providing feedback to the team from the technical point of view (artifact inspection), as well as from the customer point of view (verification of product implementation at each iteration).

In addition to the traditional role of giving lectures, the instructor needs to be a mentor offering guidance to each team and individual students addressing their specific needs and answering questions unique to their projects and the responsibilities in the context of the project. Furthermore, the instructor is uniquely positioned to advise individual students on how to resolve potential conflicts within a team. Such an advice given at the right time could make a difference between completing the project on time and allowing interpersonal tensions completely ruin any chance of collaboration between the team members.
Notes: about students


Reference Type:  Conference Paper
Record Number: 7928
Author: Shakiba, Abbas, Green, Robert and Dyer, Robert
Year: 2016
Title: FourD: do developers discuss design? revisited
Conference Name: Proceedings of the 2nd International Workshop on Software Analytics
Conference Location: Seattle, WA, USA
Publisher: ACM
Pages: 43-46
DOI: 10.1145/2989238.2989244
Place Published: 2989244
Abstract: Software repositories contain a variety of information that can be mined and utilized to enhance software engineering processes. Patterns stored in software repository meta-data can provide useful and informative information about different aspects of a project, particularly those that may not be obvious for developers. One such aspect is the role of software design in a project. The messages connected to each commit in the repository note not only what changes have been made to project files, but potentially if those changes have somehow manipulated the design of the software.

In this paper, a sample of commit messages from a random sample of projects on GitHub and SourceForge are manually classified as "design" or "non-design" based on a survey. The resulting data is then used to train multiple machine learning algorithms in order to determine if it is possible to predict whether or not a single commit is discussing software design. Our results show the Random Forest classifier performed best on our combined data set with a G-mean of 75.01.
Notes: not about behavior, instead classification tool


Reference Type:  Journal Article
Record Number: 8532
Author: Angelov, Samuil, Grefen, Paul and Greefhorst, Danny
Year: 2012
Title: A framework for analysis and design of software reference architectures
Journal: Information and Software Technology
Volume: 54
Issue: 4
Pages: 417-431
Date: 4//
Short Title: A framework for analysis and design of software reference architectures
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2011.11.009
Keywords: Software reference architecture
Software domain architecture
Software architecture design
Software product line architecture
Abstract: Context A software reference architecture is a generic architecture for a class of systems that is used as a foundation for the design of concrete architectures from this class. The generic nature of reference architectures leads to a less defined architecture design and application contexts, which makes the architecture goal definition and architecture design non-trivial steps, rooted in uncertainty. Objective The paper presents a structured and comprehensive study on the congruence between context, goals, and design of software reference architectures. It proposes a tool for the design of congruent reference architectures and for the analysis of the level of congruence of existing reference architectures. Method We define a framework for congruent reference architectures. The framework is based on state of the art results from literature and practice. We validate our framework and its quality as analytical tool by applying it for the analysis of 24 reference architectures. The conclusions from our analysis are compared to the opinions of experts on these reference architectures documented in literature and dedicated communication. Results Our framework consists of a multi-dimensional classification space and of five types of reference architectures that are formed by combining specific values from the multi-dimensional classification space. Reference architectures that can be classified in one of these types have better chances to become a success. The validation of our framework confirms its quality as a tool for the analysis of the congruence of software reference architectures. Conclusion This paper facilitates software architects and scientists in the inception, design, and application of congruent software reference architectures. The application of the tool improves the chance for success of a reference architecture.
Notes: about reference architecture
URL: https://www.sciencedirect.com/science/article/pii/S0950584911002333


Reference Type:  Journal Article
Record Number: 8624
Author: Wijnstra, Jan Gerben
Year: 2003
Title: From problem to solution with quality attributes and design aspects
Journal: Journal of Systems and Software
Volume: 66
Issue: 3
Pages: 199-211
Date: 6/15/
Short Title: From problem to solution with quality attributes and design aspects
ISSN: 0164-1212
DOI: https://doi.org/10.1016/S0164-1212(02)00077-8
Keywords: Quality attributes
Design aspects
Concerns
Views
Software architecture
Product family
Abstract: It is commonly accepted that quality attributes shape the architecture of a system. There are several means via which the architecture can support certain quality attributes. For example, to deal with reliability the system can be decomposed into a number of fault containment units, thus avoiding fault propagation. In addition to structural issues of architecture, qualities also influence architectural rules and guidelines, such as coding standards. In this paper we will focus on design aspects as a means of supporting quality attributes. An example of a design aspect is error handling functionality, which supports reliability. Quality attributes play a role in the problem domain; design aspects are elements in the solution domain. We will use an industrial case to illustrate our ideas. The discussion ranges from how design aspects are defined in the architecture based on quality attributes, to how design aspects can be used to verify the realized system against the prescribed architecture. The industrial case is a product family of medical imaging systems. For this product family, the family members are constructed from a component-based platform. Here, it is especially useful to achieve aspect-completeness of components, allowing system composition without worrying about individual design aspects.
Notes: more about reaching specified design quality criteria, not behavior
URL: https://www.sciencedirect.com/science/article/pii/S0164121202000778


Reference Type:  Conference Paper
Record Number: 8033
Author: Bidian, Catalin
Year: 2006
Title: From stakeholder goals to product features: towards a role-based variability framework with decision boundary
Conference Name: Proceedings of the 2006 International Conference on Privacy, Security and Trust: Bridge the Gap Between PST Technologies and Business Services
Conference Location: Markham, Ontario, Canada
Publisher: ACM
Pages: 1-5
DOI: 10.1145/1501434.1501526
Place Published: 1501526
Abstract: Variability in complex software systems arises from the diverse characteristics, views, preferences, and goals of stakeholders. Recent variability research focuses on stakeholders' goals, using models, to analyze the space of alternative solutions for software functionalities. In our study we extend the goals-requirements-features approach by considering variability along multiple product development stages. We depict variability at the early and late requirements definition stage, architecture design, detailed design, and runtime, proposing a role-based framework for variability analysis. Variability design involves the placement of a decision boundary to identify the space of alternative features that can be left 'open' for the next stage of product decisions. We also analyze softgoals variability to allow early identification of variation points in the product architecture.
Notes: focus on quality criteria of architecture


Reference Type:  Conference Paper
Record Number: 7998
Author: Daugherty, Paul R.
Year: 2009
Title: The future of software architectures for large-scalebusiness solutions: modularity, scalability, andseparation of concerns
Conference Name: Proceedings of the 8th ACM international conference on Aspect-oriented software development
Conference Location: Charlottesville, Virginia, USA
Publisher: ACM
Pages: 1-2
DOI: 10.1145/1509239.1509241
Place Published: 1509241
Abstract: Modern software projects are of large scale, often involving years of development, tens of thousands of days of work effort, and millions of lines of code. This complexity is aggravated by the fact that development is often distributed over several geographic locations, as dictated by cost considerations, the availability of domain specialists, legal requirements, and other factors. Despite advances in development tools and techniques, software initiatives have lagged behind in utilizing novel software engineering methods and techniques effectively to reduce the complexity of large-scale software. The results can be seen in Corporate and Government IT budgets - based on Accenture and Industry research, IT cost overruns are still commonplace, and the cost to "keep the lights on" for fragile legacy applications typically consumes up to 60% IT budgets.

Increased adoption of advanced software engineering techniques holds great promise for solving these key business challenges. For example, modularization holds a promise in reducing complexity of software design by hiding low-level implementations in well-defined units of deployment. Specifically, vendors build platforms that allow architects to design large-scale systems that can be composed out of services on the fly. For example, JBoss built a platform that allows architects to seamlessly integrate Service-Oriented Architecture (SOA) with application and business-process management (BPM) in enterprise distributions. According to research with Accenture's CIO Council, at least 58% of global organizations are implementing or piloting SOA.

Proper separation of concerns is a key to effective modularization. While separation of concerns is more of art than science in the work of software architects, novel technologies that enable effective separation of concerns are gaining traction. Most recently Accenture used AOP on a government project to do audit tracking. It was very successful and the techniques are currently being incorporated in Accenture Delivery Architecture (ADA), which is a standards-based architecture used for very large scale software development. A large focus of our efforts is in making advanced software engineering techniques more "consumable" by across our network of developers - this is done through standardized architectures, reference applications, and training.

The talk will focus on progress that has been made, and challenges ahead in driving further business value through use of these types of techniques. In addition to the areas mentioned, we will focus on related issues such as: requirements traceability, automated software quality assurance, role of DSLs andMDA, and Agile techniques.
Notes: Talk, not research


Reference Type:  Conference Proceedings
Record Number: 8990
Author: Saadatmand, M. and Tahvili, S.
Year of Conference: 2015
Title: A Fuzzy Decision Support Approach for Model-Based Tradeoff Analysis of Non-functional Requirements
Conference Name: 2015 12th International Conference on Information Technology - New Generations
Pages: 112-121
Date: 13-15 April 2015
Short Title: A Fuzzy Decision Support Approach for Model-Based Tradeoff Analysis of Non-functional Requirements
DOI: 10.1109/ITNG.2015.24
Keywords: Unified Modeling Language
decision support systems
fuzzy logic
NFR UML profile
design decisions
fuzzy decision support approach
model transformation techniques
model-based tradeoff analysis
nonfunctional requirements
Analytical models
Decision making
Fuzzy sets
Security
Fuzzy
Multi-Criteria Decision Making
Non-Functional Requirements
Optimization
Software Architecture
TOPSIS
Tradeoff Analysis
Abstract: One of the main challenges in addressing Non-Functional Requirements (NFRs) in designing systems is to take into account their interdependencies and mutual impacts. For this reason, they cannot be considered in isolation and a careful balance and tradeoff among them should be established. This makes it a difficult task to select design decisions and features that lead to the satisfaction of all different NFRs in the system, which becomes even more difficult when the complexity of a system grows. In this paper, we introduce an approach based on fuzzy logic and decision support systems that helps to identify different design alternatives that lead to higher overall satisfaction of NFRs in the system. This is achieved by constructing a model of the NFRs and then performing analysis on the model. To build the model, we use a modified version of the NFR UML profile which we have introduced in our previous works, and using model transformation techniques we automate the analysis of the model.
Notes: building of tool


Reference Type:  Conference Proceedings
Record Number: 8890
Author: Moaven, S., Habibi, J., Ahmadi, H. and Kamandi, A.
Year of Conference: 2008
Title: A Fuzzy Model for Solving Architecture Styles Selection Multi-Criteria Problem
Conference Name: 2008 Second UKSIM European Symposium on Computer Modeling and Simulation
Pages: 388-393
Date: 8-10 Sept. 2008
Short Title: A Fuzzy Model for Solving Architecture Styles Selection Multi-Criteria Problem
DOI: 10.1109/EMS.2008.45
Keywords: decision making
fuzzy reasoning
software architecture
architecture styles selection multicriteria problem
continuing process
fuzzy inference
fuzzy model
multicriteria decision-making problem
software development
software evaluation
software production
software systems enlargement
Computational modeling
Computer architecture
Computer simulation
Design engineering
Fuzzy logic
Programming
Software design
Software systems
Architecture Styles
fuzzy modeling
multicriteria problem
Abstract: The continuing process of software systems enlargement in size and complexity becomes system design extremely important for software production. In this way, the role of software architecture is significantly important in software development. It serves as an evaluation and implementation plan for software development and software evaluation. Consequently, choosing the correct architecture is a critical issue in software engineering domain. Moreover, software architecture selection is a multicriteria decision-making problem in which different goals and objectives must be taken into consideration. In this paper, more precise and suitable decisions in selection of architecture styles have been presented by using fuzzy inference to support decisions of software architects in order to exploit properties of styles in the best way.


Reference Type:  Journal Article
Record Number: 7990
Author: Huff, Chuck
Year: 2002
Title: Gender, software design, and occupational equity
Journal: SIGCSE Bull.
Volume: 34
Issue: 2
Pages: 112-115
Short Title: Gender, software design, and occupational equity
ISSN: 0097-8418
DOI: 10.1145/543812.543842
Legal Note: 543842
Abstract: After reviewing the work on gender bias in software design, a model of gender-role influenced achievement choice taken from Eccles [7] is presented. The paper concludes that (1) though laudable, reduction of gender bias in software design is not the most straightforward way to reduce gender inequity in the choice of computing as a career, (2) the model itself makes more clear some of the ethical issues involved in attempting to achieve gender equity on computing, and (3) efforts to reduce gender inequity in the choice of computing as a career need to be evaluated in the light of this model.
Notes: Focus on gender


Reference Type:  Conference Proceedings
Record Number: 9598
Author: Wojcik, R.
Year of Conference: 2006
Title: Getting in Touch with Your Feelings about Software Architecture
Conference Name: 5th IEEE/ACIS International Conference on Computer and Information Science and 1st IEEE/ACIS International Workshop on Component-Based Software Engineering,Software Architecture and Reuse (ICIS-COMSAR'06)
Pages: 2-4
Date: 10-12 July 2006
Short Title: Getting in Touch with Your Feelings about Software Architecture
DOI: 10.1109/ICIS-COMSAR.2006.42
Abstract: In this keynote address, the presenter will attend to these questions by discussing the nature of software architecture in terms of architectural structures, the role that software architecture plays in an organization, the technical, business, and social influences on software architectures, and the role of quality attribute requirements in architectural design.
Notes: Keynote, no research


Reference Type:  Journal Article
Record Number: 8776
Author: Patton, J.
Year: 2008
Title: Getting Software RITE
Journal: IEEE Software
Volume: 25
Issue: 3
Pages: 20-21
Short Title: Getting Software RITE
ISSN: 0740-7459
DOI: 10.1109/MS.2008.62
Keywords: program testing
program verification
user centred design
user interfaces
formal usability testing
rapid iterative testing and evaluation
software design validation
software testing
user centered design
Digital cameras
Programming
Software design
Software measurement
Software prototyping
Usability
Watches
RITE
agile
quality
testing
usability testing
Abstract: In traditional software development environments, many designers don't routinely put their software in front of users. If the ultimate measure of well-designed software is how effectively it serves its intended purpose, then validating that it does so is critical, and the sooner the better. Many user-centered design practitioners do this with usability testing. A formal usability test is a rather sciencey affair. It involves a number of different people in different roles. This paper deals with software design validation. This test-fix-test-fix cycle continues until the software starts to feel pretty tight. This approach is called RITE (Rapid Iterative Testing and Evaluation).
Notes: technique for getting user feedback


Reference Type:  Conference Paper
Record Number: 7912
Author: Nowak, Marcin and Pautasso, Cesare
Year: 2011
Title: Goals, questions and metrics for architectural decision models
Conference Name: Proceedings of the 6th International Workshop on SHAring and Reusing Architectural Knowledge
Conference Location: Waikiki, Honolulu, HI, USA
Publisher: ACM
Pages: 21-28
DOI: 10.1145/1988676.1988682
Place Published: 1988682
Abstract: Architectural decisions are the key element behind the design process leading to a software architecture. Making software architects aware of the implications of their decisions is only the beginning of what can be achieved by capturing the rationale and the constraints influencing the decision making process in a reusable body of architectural knowledge. In this paper we propose a metric-based approach to the analysis of architectural decision models. Using a hierarchically-structured approach we identify a number of useful goals and stakeholders involved in the architectural design process. Next, we sketch a set of metrics to provide data for the evaluation of the aforementioned goals. Our aim is to stimulate a discussion on how to find indicators relevant for software architects by measuring the intrinsic properties of architectural knowledge.


Reference Type:  Conference Paper
Record Number: 7854
Author: Stal, Michael
Year: 2011
Title: Good is not good enough: evaluating and improving software architecture
Conference Name: Proceedings of the joint ACM SIGSOFT conference -- QoSA and ACM SIGSOFT symposium -- ISARCS on Quality of software architectures -- QoSA and architecting critical systems -- ISARCS
Conference Location: Boulder, Colorado, USA
Publisher: ACM
Pages: 73-74
DOI: 10.1145/2000259.2000272
Place Published: 2000272
Abstract: Software engineering has an increasing impact on the diverse products, services, and solutions offered by technology-oriented industries. For example, within SIEMENS AG over 60% of revenues depend on software. Consequently, failures in software development projects lead to significant costs. If software is so important, we need sustainable software architectures designed by well-educated and skilled software architects as backbone of high quality software systems.

However, due to the complexity of problem and solution domains and the increased desiderata of customers, software systems cannot be created in a big bang approach. Instead, software architectures must be systematically designed and then implemented using piecemeal growth which implies that software architects need to incrementally and iteratively refine, assess, and improve a software system. Otherwise, wrong or inefficient design decisions will be hard and costly to detect and eliminate inevitably causing design erosion to creep in.

Thus, Software Architecture Evaluation and Improvement play an important role in the development of sustainable software systems.

But how can we seamlessly integrate Software Architecture and Improvement into the architecture design process?

A systematic process for creating software architecture comprises among many other ingredients

    the (stepwise) clarification and prioritization of requirements,
    the incremental and iterative evolution of the software architecture driven by requirements and risks,
    Continuous quality assessment for assuring that the software system meets its internal and external qualities as well as its functional expectations.

For continuous quality assessment Test-Driven Development and Design for Testability denote approaches that are applicable when the implementation is available. In order to assess the architecture itself, even in absence of a (full) implementation, qualitative and quantitative architecture assessment methods are available. For example, the experience-based industry review method applies a SWOT analysis to identify potential threats and weaknesses as well as potential means to resolve these issues. Architecture Analysis tools support software architects in this endeavor. But how can software architects improve the internal or external quality of the software system after they detected some architecture smells? It is essential to get rid of these issues by continuous software architecture improvement which exactly is the place where architecture refactoring, reengineering, and rewriting come in.


Reference Type:  Conference Proceedings
Record Number: 8957
Author: Esfahani, N., Malek, S. and Razavi, K.
Year of Conference: 2013
Title: GuideArch: Guiding the exploration of architectural solution space under uncertainty
Conference Name: 2013 35th International Conference on Software Engineering (ICSE)
Pages: 43-52
Date: 18-26 May 2013
Short Title: GuideArch: Guiding the exploration of architectural solution space under uncertainty
ISBN: 0270-5257
DOI: 10.1109/ICSE.2013.6606550
Keywords: decision making
software architecture
GuideArch
architectural solution space
quantitative exploration
Batteries
Computer architecture
Hardware
Software engineering
Synthetic aperture sonar
Time factors
Uncertainty
Abstract: A system's early architectural decisions impact its properties (e.g., scalability, dependability) as well as stakeholder concerns (e.g., cost, time to delivery). Choices made early on are both difficult and costly to change, and thus it is paramount that the engineer gets them &#x201C;right&#x201D;. This leads to a paradox, as in early design, the engineer is often forced to make these decisions under uncertainty, i.e., not knowing the precise impact of those decisions on the various concerns. How could the engineer make the &#x201C;right&#x201D; choices in such circumstances? This is precisely the question we have tackled in this paper. We present GuideArch, a framework aimed at quantitative exploration of the architectural solution space under uncertainty. It provides techniques founded on fuzzy math that help the engineer with making informed decisions.


Reference Type:  Conference Proceedings
Record Number: 9087
Author: Fernández-Sánchez, C., Díaz, J., Pérez, J. and Garbajosa, J.
Year of Conference: 2014
Title: Guiding Flexibility Investment in Agile Architecting
Conference Name: 2014 47th Hawaii International Conference on System Sciences
Pages: 4807-4816
Date: 6-9 Jan. 2014
Short Title: Guiding Flexibility Investment in Agile Architecting
ISBN: 1530-1605
DOI: 10.1109/HICSS.2014.590
Keywords: decision making
software architecture
software prototyping
storage management
MAKE Flexi
agile architecting
agile software development
data storage technologies
guiding flexibility investment
software product architectures
Computer architecture
Cost accounting
Decision trees
Estimation
Investment
Software
agile
architecture
real options
technical debt
Abstract: Agile software development pursues to deal with continuous change. But software product architectures without enough flexibility can restrict how products cope with change. However, designing for flexibility often entails high costs and risk that comes with the assumption that change will happen. Actually, in software architecture the flexibility investment decision making problem has become challenging. This paper presents a process to assist architects in Making decisions about Flexibility investment in Software Architecture (MAKE Flexi). MAKE Flexi is based on technical debt and real options approaches. Technical debt allows for estimating the additional cost derived from the lack of flexibility in software architectures, whereas the real options valuation allows for estimating the value of the flexibility that a design option could provide. MAKE Flexi has been applied to an industry project for smart grids to assist architects in making decisions about designing for flexibility to vary data storage technologies.


Reference Type:  Journal Article
Record Number: 8537
Author: Ainger, A. W. S. and Schmid, F.
Year: 1995
Title: The helical approach to software design
Journal: Computer Integrated Manufacturing Systems
Volume: 8
Issue: 2
Pages: 105-115
Date: 5//
Short Title: The helical approach to software design
ISSN: 0951-5240
DOI: https://doi.org/10.1016/0951-5240(95)00004-D
Keywords: software design
Helical Project LifeCycle
Abstract: This paper is used to outline a relatively recent approach to the development of software products. Practical experience of employing the traditional waterfall lifecycle model, the Spiral Model and concurrent engineering approaches in both small and large (pan-European) software projects provide the foundation on which to present, discuss and propose a new lifecycle model; the Helical LifeCycle Approach. The authors of the paper distinguish between prototypes, and model and postulate the need for the formalization of a new software engineering job role which is focused around the Helical Project LifeCycle.
URL: https://www.sciencedirect.com/science/article/pii/095152409500004D


Reference Type:  Conference Paper
Record Number: 7901
Author: Golden, Elspeth
Year: 2009
Title: Helping software architects design for usability
Conference Name: Proceedings of the 1st ACM SIGCHI symposium on Engineering interactive computing systems
Conference Location: Pittsburgh, PA, USA
Publisher: ACM
Pages: 317-320
DOI: 10.1145/1570433.1570493
Place Published: 1570493
Abstract: In spite of the goodwill and best efforts of software engineers and usability professionals, systems continue to be built and released with glaring usability flaws that are costly and difficult to fix after the system has been designed and/or built. Although user interface (UI) designers, be they usability or design experts, communicate usability requirements to software development teams, usability features often fail to be implemented as expected. If, as seems likely, software developers intend to implement what UI designers specify and simply do not know how to interpret the architectural ramifications of usability requirements, then Usability-Supporting Architectural Patterns (USAPs) will help to bridge the gap between UI designers and software engineers to produce software architecture solutions that successfully address usability requirements. USAPs achieve this goal by embedding usability concepts in templates that can be used procedurally to guide software engineers' thinking during the complex task of software architecture design. A tool design supports delivery of USAPs to software architects for use in the early stages of the design process.
Notes: tool development


Reference Type:  Journal Article
Record Number: 9202
Author: Smyth, B., Keane, M. T. and Cunningham, P.
Year: 2001
Title: Hierarchical case-based reasoning integrating case-based and decompositional problem-solving techniques for plant-control software design
Journal: IEEE Transactions on Knowledge and Data Engineering
Volume: 13
Issue: 5
Pages: 793-812
Short Title: Hierarchical case-based reasoning integrating case-based and decompositional problem-solving techniques for plant-control software design
ISSN: 1041-4347
DOI: 10.1109/69.956101
Keywords: automatic programming
case-based reasoning
industrial control
problem solving
CBR
Deja Vu
automated software design
case based organization
complex problem solving tasks
decompositional problem-solving techniques
future problem solving
hierarchical case based reasoning
hierarchical problem solving
multiple case reuse
past experience
plant-control software design automation
Artificial intelligence
Computer Society
Concrete
Probes
Problem-solving
Software design
Abstract: Case based reasoning (CBR) is an artificial intelligence technique that emphasises the role of past experience during future problem solving. New problems are solved by retrieving and adapting the solutions to similar problems, solutions that have been stored and indexed for future reuse as cases in a case-base. The power of CBR is severely curtailed if problem solving is limited to the retrieval and adaptation of a single case, so most CBR systems dealing with complex problem solving tasks have to use multiple cases. The paper describes and evaluates the technique of hierarchical case based reasoning, which allows complex problems to be solved by reusing multiple cases at various levels of abstraction. The technique is described in the context of Deja Vu, a CBR system aimed at automating plant-control software design
Notes: tool based on certain technique


Reference Type:  Conference Proceedings
Record Number: 9435
Author: Barik, L. B., Chandrakar, O., Patel, B. and Barik, A.
Year of Conference: 2011
Title: HKDA &#x2014; Design pattern system architecture
Conference Name: 2011 2nd International Conference on Computer and Communication Technology (ICCCT-2011)
Pages: 118-123
Date: 15-17 Sept. 2011
Short Title: HKDA &#x2014; Design pattern system architecture
DOI: 10.1109/ICCCT.2011.6075124
Keywords: data mining
inference mechanisms
intelligent tutoring systems
object-oriented methods
software architecture
HKDA system
ITS
adaptive learning environment
communication knowledge
design pattern system architecture
domain knowledge
domain model
human knowledge discovery agent system
inference mechanism
knowledge management
pedagogical experts
pedagogical module
presentation planner
software design pattern
software development
student knowledge-base
student modeller
Adaptation models
Data models
Educational institutions
Knowledge based systems
Learning systems
Materials
Design Pattern
Knowledge Component
Multi-agent HKDA System
Abstract: Software Design Patterns (DPs) have been recognized as very important and useful in real software development since they provide an elegant way of getting around problems that often occur. Researcher has built an ITS known as Human Knowledge Discovery Agent System-HKDA, which provides adaptive learning environment for the students by providing personalized instructions. The HKDA System makes inferences about student knowledge and interacts intelligently with students based upon individual representations of their knowledge. The design pattern system architecture of HKDA consists of eight main components. In this research, researchers are going to discuss about Student Modeller and Pedagogical Module. However, to provide a clear idea about design patterns, a small description about other components such as Domain Knowledge/Domain Model, Knowledge Management, Student Knowledge-base, Presentation Planner, Pedagogical Experts and Communication Knowledge are also given.
Notes: students


Reference Type:  Conference Proceedings
Record Number: 9182
Author: Bang, J. Y., Krka, I., Medvidovic, N., Kulkarni, N. and Padmanabhuni, S.
Year of Conference: 2013
Title: How software architects collaborate: Insights from collaborative software design in practice
Conference Name: 2013 6th International Workshop on Cooperative and Human Aspects of Software Engineering (CHASE)
Pages: 41-48
Date: 25-25 May 2013
Short Title: How software architects collaborate: Insights from collaborative software design in practice
DOI: 10.1109/CHASE.2013.6614730
Keywords: distributed processing
groupware
software architecture
collaboration cost drivers
collaborative software design
distributed engineering
geographic distribution
global software solutions
software architecture collaboration
software systems
Collaborative software
Computer architecture
Interviews
Organizations
Software
Topology
Abstract: The increasingly complex software systems are developed by globally distributed engineering teams consisting of a number of members who collaborate to gather the requirements, as well as design, implement, and test the system. Unlike other development activities, collaborative software design has not yet been studied extensively, and thus it is not fully understood how it is conducted in practice. We have commenced a series of studies to address this. As the first step, we have interviewed architects at a global software solutions provider to observe how collaborative software design works in practice. In this paper, we report the observations and insights we gained from the interviews related to (1) the various roles of software architects in collaborative software design, (2) the project-specific networks of software architects, (3) the impacts of geographic distribution, and (4) the collaboration cost drivers. We also discuss how we are using these insights to shape up our subsequent research.
'File' Atttachments: internal-pdf://3159035491/How software architects collaborate Insights f.pdf


Reference Type:  Journal Article
Record Number: 9201
Author: Mangano, N., LaToza, T. D., Petre, M. and Hoek, A. van der
Year: 2015
Title: How Software Designers Interact with Sketches at the Whiteboard
Journal: IEEE Transactions on Software Engineering
Volume: 41
Issue: 2
Pages: 135-156
Short Title: How Software Designers Interact with Sketches at the Whiteboard
ISSN: 0098-5589
DOI: 10.1109/TSE.2014.2362924
Keywords: software engineering
reasoning activity
software design
software development
visual syntactic elements
whiteboard sketch
Cognition
Encoding
Syntactics
Videos
Visualization
Interaction styles
systems analysis and design
user-centered design
Abstract: Whiteboard sketches play a crucial role in software development, helping to support groups of designers in reasoning about a software design problem at hand. However, little is known about these sketches and how they support design `in the moment', particularly in terms of the relationships among sketches, visual syntactic elements within sketches, and reasoning activities. To address this gap, we analyzed 14 hours of design activity by eight pairs of professional software designers, manually coding over 4000 events capturing the introduction of visual syntactic elements into sketches, focus transitions between sketches, and reasoning activities. Our findings indicate that sketches serve as a rich medium for supporting design conversations. Designers often use general-purpose notations. Designers introduce new syntactic elements to record aspects of the design, or re-purpose sketches as the design develops. Designers constantly shift focus between sketches, using groups of sketches together that contain complementary information. Finally, sketches play an important role in supporting several types of reasoning activities (mental simulation, review of progress, consideration of alternatives). But these activities often leave no trace and rarely lead to sketch creation. We discuss the implications of these and other findings for the practice of software design at the whiteboard and for the creation of new electronic software design sketching tools.
'File' Attachments: internal-pdf://0907774221/How Software Designers Interact with Sketches.pdf


Reference Type:  Journal Article
Record Number: 8425
Author: Morschheuser, Benedikt, Hassan, Lobna, Werder, Karl and Hamari, Juho
Title: How to design gamification? A method for engineering gamified software
Journal: Information and Software Technology
Short Title: How to design gamification? A method for engineering gamified software
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2017.10.015
Keywords: Gamification
Software engineering
Design science research
Persuasive technology
Gameful design
Playfulness
Game design
Abstract: AbstractContext Since its inception around 2010, gamification has become one of the top technology and software trends. However, gamification has also been regarded as one of the most challenging areas of software engineering. Beyond traditional software design requirements, designing gamification requires the command of disciplines such as (motivational/behavioral) psychology, game design, and narratology, making the development of gamified software a challenge for traditional software developers. Gamification software inhabits a finely tuned niche of software engineering that seeks for both high functionality and engagement; beyond technical flawlessness, gamification has to motivate and affect users. Consequently, it has also been projected that most gamified software is doomed to fail. Objective This paper seeks to advance the understanding of designing gamification and to provide a comprehensive method for developing gamified software. Method We approach the research problem via a design science research approach; firstly, by synthesizing the current body of literature on gamification design methods and by interviewing 25 gamification experts, producing a comprehensive list of design principles for developing gamified software. Secondly, and more importantly, we develop a detailed method for engineering of gamified software based on the gathered knowledge and design principles. Finally, we conduct an evaluation of the artifacts via interviews of ten gamification experts and implementation of the engineering method in a gamification project. Results As results of the study, we present the method and key design principles for engineering gamified software. Based on the empirical and expert evaluation, the developed method was deemed as comprehensive, implementable, complete, and useful. We deliver a comprehensive overview of gamification guidelines and shed novel insights into the nature of gamification development and design discourse. Conclusion This paper takes first steps towards a comprehensive method for gamified software engineering.
Notes: specific solution
URL: https://www.sciencedirect.com/science/article/pii/S095058491730349X


Reference Type:  Conference Proceedings
Record Number: 7534
Author: Tang, A., Razavian, M., Paech, B. and Hesse, T. M.
Year of Conference: 2017
Title: Human Aspects in Software Architecture Decision Making: A Literature Review
Conference Name: 2017 IEEE International Conference on Software Architecture (ICSA)
Pages: 107-116
Date: 3-7 April 2017
Short Title: Human Aspects in Software Architecture Decision Making: A Literature Review
DOI: 10.1109/ICSA.2017.15
Keywords: decision making
human factors
software architecture
architectural design practices
decision making behavior
decision making practice
human aspects
human behaviors
mental activity
software architecture decision making
Bibliographies
Conferences
Economics
Software
Tools
human behavior
methods and tools
Abstract: Despite past efforts, we have little understanding and limited research efforts on how architects make decisions in the real-world settings. It seems that software architecture researchers make implicit assumption that decision making by software architects can be a rational and prescribed process. Such an assumption is disputed in other fields such as economics and decision research. This paper studies the current state of software architecture decision making research in terms of human behaviors and practice. We carried out a literature review on software architecture decision making. We classified papers into decision making behavior and decision making practice and identified the research relationships between them. We found that decision making is a mental activity. Research into the behavioral aspects of software architecture decision making for incorporation into architectural design practices is required. We suggest three research topics on human aspects to improve software architecture practices.
Notes: Literature review


Reference Type:  Conference Proceedings
Record Number: 8847
Author: Chepken, C., Blake, E. and Marsden, G.
Year of Conference: 2013
Title: ICTs and survival tactics for the day-labour workers: Implications for design
Conference Name: 2013 IST-Africa Conference & Exhibition
Pages: 1-8
Date: 29-31 May 2013
Short Title: ICTs and survival tactics for the day-labour workers: Implications for design
Keywords: Digital Divide
decision making
human factors
mobile radio
ICTs
Nairobi Kenya
day-labour market
day-labour workers
digital divide gap reduction
mobile phone services
network tariffs
policy formulation
software design decision making
survival tactics
Cities and towns
Interviews
Mobile communication
Mobile handsets
Organizations
Software systems
DLM
Day-labourer
tariffs
Abstract: In this paper, we show how results of data collected on the survival tactics of day-labour workers with regard to the cost of using mobile phone services played a role in software systems design. The paper uses findings from Nairobi Kenya. The results showed that workers, depending on the choice of available network tariffs adopt different survival tactics which range from being personal to involving others. In conclusion, workers as mobile phone users adopt the different survival tactics depending on what the market provides. The competitiveness of the market dictates the options available. Lessons from this research were used in making software design decisions for the day-labour market. They can also be used, among other things, by Information and Communication Technology researchers who wish to intervene for the poor in society. Other uses include for policy formulation, especially those that touch on reducing the digital divide gap.


Reference Type:  Conference Proceedings
Record Number: 9139
Author: Thurimella, A. K., Bruegge, B. and Creighton, O.
Year of Conference: 2008
Title: Identifying and Exploiting the Similarities between Rationale Management and Variability Management
Conference Name: 2008 12th International Software Product Line Conference
Pages: 99-108
Date: 8-12 Sept. 2008
Short Title: Identifying and Exploiting the Similarities between Rationale Management and Variability Management
DOI: 10.1109/SPLC.2008.14
Keywords: knowledge management
product development
software development management
software reusability
distributed stakeholders
issue-based variability modeling
product line organization
rationale management
requirements engineering
variability management
Collaboration
Collaborative software
Collaborative work
Conference management
Decision making
Engineering management
Globalization
Investments
Software design
empirical software engineering
Abstract: Modeling variability is a challenging issue in product line requirements engineering. Particular problems include, the instantiation of variations for individual products, the long-term evolution of the product line, and the support of collaboration between stakeholders. These problems are even more complicated when the product line organization is globally distributed. To address theses problems, this paper identifies four higher-level similarities between rationale management (which focus on knowledge management during software design) and variability management. Furthermore, exploiting the similarities, rationale management is combined with variability management to contribute issue-based variability modeling. Issue-based variability modeling was implemented and empirically evaluated based on a series of case studies with multi-case design. The results of the evaluation show that our approach improves the instantiation and evolution of variability, enables better informal collaboration between distributed stakeholders with different levels of modeling expertise and enhances the longevity of product lines.
Notes: about decision management


Reference Type:  Conference Proceedings
Record Number: 8976
Author: Sherman, S. and Hadar, I.
Year of Conference: 2012
Title: Identifying the need for a sustainable architecture maintenance process
Conference Name: 2012 5th International Workshop on Co-operative and Human Aspects of Software Engineering (CHASE)
Pages: 132-134
Date: 2-2 June 2012
Short Title: Identifying the need for a sustainable architecture maintenance process
DOI: 10.1109/CHASE.2012.6223010
Keywords: software architecture
software development management
system documentation
architectural documentation
software development
supporting tools
sustainable architecture maintenance process
well-defined process
Architecture
Computer architecture
Documentation
Maintenance engineering
Software
Variable speed drives
maintenanc
qualitative research
Abstract: Documentation plays a significant role in software development in general and in software architecture in particular. In large and complex systems, many changes affecting architecture and architectural documentation occur. This derives the need for constant changes within architecture documents in order to keep them up to date. This research in-progress aims to understand the current state of architecture maintenance towards proposing a solution for improving this practice via a well-defined process and supporting tools.
Notes: just documentation


Reference Type:  Conference Proceedings
Record Number: 9476
Author: Stevanetic, S., Javed, M. A. and Zdun, U.
Year of Conference: 2015
Title: The Impact of Hierarchies on the Architecture-Level Software Understandability - A Controlled Experiment
Conference Name: 2015 24th Australasian Software Engineering Conference
Pages: 98-107
Date: Sept. 28 2015-Oct. 1 2015
Short Title: The Impact of Hierarchies on the Architecture-Level Software Understandability - A Controlled Experiment
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2015.21
Keywords: software architecture
software quality
source code (software)
architecture-level software understandability
large-size software system
source code
Business
Computer architecture
Context
Software systems
Unified modeling language
controlled experiment
hierarchies
understandability
Abstract: Architectural component models represent high level designs and are frequently used as a central view of architectural descriptions of software systems. They play a crucial role in the whole development process and in achieving the desired software qualities. This paper presents an empirical study that examines the impact of hierarchies on the architecture-level software understand ability. In particular we have studied three different architectural representations of a large-size software system, one with a hierarchical representation where architectural components at all abstraction levels in the hierarchy are shown, and two that do not contain hierarchical abstractions but concentrate only on the lowest level or on the highest level components in the hierarchy. We conducted a controlled experiment in which participants of three groups received one of the three architecture documentations plus the source code of the system and had to answer understand ability related questions. Our results show that using the hierarchical architecture leads to: 1) higher quantity of correctly retrieved elements, 2) lower quantity of incorrectly retrieved elements, and 3) higher overall quality of retrieved elements. The obtained results provide empirical evidence that hierarchies play an important role in the context of architectural component models from the viewpoint of the architecture-level software understandability.
Notes: architecture structure, not about architects


Reference Type:  Conference Proceedings
Record Number: 9303
Author: Heijstek, W. and Chaudron, M. R. V.
Year of Conference: 2010
Title: The Impact of Model Driven Development on the Software Architecture Process
Conference Name: 2010 36th EUROMICRO Conference on Software Engineering and Advanced Applications
Pages: 333-341
Date: 1-3 Sept. 2010
Short Title: The Impact of Model Driven Development on the Software Architecture Process
ISBN: 1089-6503
DOI: 10.1109/SEAA.2010.63
Keywords: software architecture
specification languages
code generator
domain-specific language
large-scale industrial software development project
model driven development
software architecture process
Business
DSL
Interviews
Lead
Programming
Software
Unified modeling language
Industrial Case Study
Model Driven Development (MDD)
Abstract: While Model-Driven Development (MDD) is an increasingly popular software development approach, its impact on the development process in large-scale, industrial practice is not yet clear. For this study the application of MDD in a large-scale industrial software development project is analyzed over a period of two years. Applying a grounded theory approach we identified 14 factors which impact the architectural process. We found that scope creep is more likely to occur, late changes can imply more extensive rework and that business engineers need to be more aware of the technical impact of their decisions. In addition, the introduced Domain-Specific Language (DSL) provides a new common idiom that can be used by more team members and will ease communication among team members and with clients. Also, modelers need to be much more explicit and complete in their descriptions. Parallel development of a code generator and defining a proper meta-model require additional time investments. Lastly, the more central role of software architecture design documentation requires more structured, detailed and complete architectural information and consequently, more frequent reviews.
Notes: development process


Reference Type:  Conference Paper
Record Number: 8078
Author: Synder, Charles
Year: 1995
Title: Implementing a software architecture
Conference Name: Proceedings of the conference on TRI-Ada '95: Ada's role in global markets: solutions for a changing complex world
Conference Location: Anaheim, California, USA
Publisher: ACM
Pages: 299-305
DOI: 10.1145/376503.376598
Place Published: 376598
Notes: no abstract available


Reference Type:  Journal Article
Record Number: 8475
Author: Gomes, Paulo, Seco, Nuno, Pereira, Francisco C., Paiva, Paulo, Carreiro, Paulo, Ferreira, José L. and Bento, Carlos
Year: 2006
Title: The importance of retrieval in creative design analogies
Journal: Knowledge-Based Systems
Volume: 19
Issue: 7
Pages: 480-488
Date: 11//
Short Title: The importance of retrieval in creative design analogies
ISSN: 0950-7051
DOI: https://doi.org/10.1016/j.knosys.2006.04.006
Keywords: Creative design
Analogy
Case-based reasoning
Software design
Abstract: Analogy is an important reasoning process in creative design. It enables the generation of new design artifacts using ideas from semantically distant domains. Candidate selection is a crucial process in the generation of creative analogies. Without a good set of candidate sources, the success of subsequent phases can be compromised. Two main types of selection have been identified: semantics-based retrieval and structure-based retrieval. This paper presents an empirical study on the importance of the analogy retrieval strategy in the domain of software design. We argue that both types of selection are important, but they play different roles in the process.
Notes: Tool build that is then empirical validated
URL: https://www.sciencedirect.com/science/article/pii/S095070510600061X
'File' Attachments: internal-pdf://1088938409/The importance of retrieval in creative design.pdf


Reference Type:  Conference Proceedings
Record Number: 8910
Author: Lindgren, M., Norstrom, C., Wall, A. and Land, R.
Year of Conference: 2008
Title: Importance of Software Architecture during Release Planning
Conference Name: Seventh Working IEEE/IFIP Conference on Software Architecture (WICSA 2008)
Pages: 253-256
Date: 18-21 Feb. 2008
Short Title: Importance of Software Architecture during Release Planning
DOI: 10.1109/WICSA.2008.10
Keywords: software architecture
decision making
release planning
Companies
Computer industry
Computer science
Costs
Force measurement
Process planning
Product development
Proposals
Time to market
role of the software architect
Abstract: Release planning is the process of deciding what to include in future release(s) of a product. In this paper we look at how software architects are involved during release planning in industry today, and how architectural issues are considered during this phase.
'File' Atttachments: internal-pdf://0388462590/Importance of Software Architecture during Rel.pdf


Reference Type:  Journal Article
Record Number: 8637
Author: Hertzum, Morten
Year: 2002
Title: The importance of trust in software engineers' assessment and choice of information sources
Journal: Information and Organization
Volume: 12
Issue: 1
Pages: 1-18
Date: 1//
Short Title: The importance of trust in software engineers' assessment and choice of information sources
ISSN: 1471-7727
DOI: https://doi.org/10.1016/S1471-7727(01)00007-0
Keywords: Trust
Information seeking
Communication by engineers
Information sources
Abstract: Engineers such as systems developers get most of their information from colleagues and internal reports. In the literature on engineers' information-seeking practices the generally agreed-upon explanation of this preference for close-by, internal information sources is that engineers follow a principle of least effort by choosing their information sources on the basis of ease of access rather than quality of contents. This study argues that engineers' preference for internal sources such as their colleagues is just as much a preference for sources with a known or easily determinable trustworthiness as it is a preference for information that is easily accessible. Trust is of central importance because quality is a perceived property and, thus, assessing the quality of an information source is essentially a matter of establishing to what extent one is willing to place trust in it. This can be done with greater ease and precision for familiar sources. A field study of the meetings in a software design project shows that in discussing and selecting information sources the software engineers devote significantly more attention to quality-related factors than to cost-related factors. It is also normal conversational practice at the meetings to accompany the mentioning of information sources that may be unknown to some project participants by information that puts them in context. Systems for managing knowledge and sharing expertise must recognise these rich means of forming a perception of the credibility of individual pieces of information.
URL: https://www.sciencedirect.com/science/article/pii/S1471772701000070


Reference Type:  Conference Proceedings
Record Number: 8807
Author: McCollum, B., Purnell, V., Corr, P. H. and Milligan, P.
Year of Conference: 1998
Title: The improvement of a software design methodology by encapsulating knowledge from code
Conference Name: Proceedings. 24th EUROMICRO Conference (Cat. No.98EX204)
Volume: 2
Pages: 913-918 vol.2
Date: 25-27 Aug 1998
Short Title: The improvement of a software design methodology by encapsulating knowledge from code
ISBN: 1089-6503
DOI: 10.1109/EURMIC.1998.708121
Keywords: expert systems
knowledge acquisition
neural nets
programming environments
software maintenance
systems re-engineering
KATT
development environment
dusty-deck systems
knowledge encapsulation
legacy codes
neural networks
reengineering
restructuring knowledge
sequential architectures
sequential codes
software design methodology
software engineering methodologies
Costs
Data analysis
Java
Modems
Multiprocessing systems
Software design
Software engineering
Workstations
Abstract: While numerous software engineering methodologies exist, are well documented, and are widely used, e.g. JSD, SSADM, etc., it can be argued that none cater for the specific problems associated with reengineering legacy, or dusty-deck systems. This paper reports on a development environment, KATT, that enshrines a methodology which enables the development of new codes or the reengineering of existing legacy codes. The system is designed to enable sequential codes to be translated for execution on either parallel or sequential architectures, e.g. moving Fortran 77 to a workstation cluster or translating Cobol to Java. The approach involves the encapsulation and application of restructuring knowledge via the use of expert systems and neural networks
Notes: tool


Reference Type:  Conference Proceedings
Record Number: 9293
Author: Gopalakrishnan, A.
Year of Conference: 2015
Title: Improving decision making and reuse in software systems using Domain Specific reference Architectures
Conference Name: 2015 IEEE International Conference on Electronics, Computing and Communication Technologies (CONECCT)
Pages: 1-6
Date: 10-11 July 2015
Short Title: Improving decision making and reuse in software systems using Domain Specific reference Architectures
DOI: 10.1109/CONECCT.2015.7383933
Keywords: decision making
decision trees
program diagnostics
software architecture
software reusability
abstraction structures
architecture patterns
domain specific reference architectures
intraorganizational reuse
program code
software architects
software design
software engineering
software system reusability
technical decision making
Business
Computer architecture
Microgrids
Performance evaluation
Software
Design Patterns
Domain Specific Software Architecture
Technical Decisions
Abstract: Software Engineering has evolved over many years but stays human centric as it relies significantly on the technical decisions made by humans. Modeling the problem statement and arriving at the architecture and design revolves in the minds of software architects and designers. Many of the decisions stays in architect's minds and are only present in the models. The abstraction structures in software design are deeper than in other disciplines, since the final design is program code. This distinction leads to software architecture and design a highly interwoven process. The early design decisions are otherwise termed architectural decisions which compose software architecture. The architectural decisions are at an intermediate abstraction level with higher probability of reuse, but still not effectively reused even within the same organization. The most effective cases of reuse in software is with architecture patterns and design patterns. The paper points to the fact that patterns are successfully reused due to the quality of the descriptions which include problem, solution pair and supporting example. The paper focuses on intra-organizational reuse, based on Domain Specific Software Architectures and the descriptions containing domain model, decision trees, architectural schema and rationale. It further tries to analyze three different use cases in the light of these elements and analyze if major hindrance of reuse is `Rationale of decisions not well understood' than the commonly stated `Not Invented here', supported with a survey of software engineers.


Reference Type:  Journal Article
Record Number: 8529
Author: McDermid, J. A.
Year: 1991
Title: In praise of architects
Journal: Information and Software Technology
Volume: 33
Issue: 8
Pages: 566-574
Date: 10//
Short Title: In praise of architects
ISSN: 0950-5849
DOI: https://doi.org/10.1016/0950-5849(91)90115-R
Keywords: software crisis
software design
software system architecture
requirements analysis
Abstract: There are many documented cases of unsuccessful software development projects and it is possible to identify a number of key technical and managerial difficulties that underlie the problems of many projects. It is argued that software development could gain by adopting and adapting some principles from the building profession — especially giving more prominence, and a more pivotal role in development, to the software system architecture. The nature of a software architecture (specification) and some of the issues in developing architectures are discussed. A number of conclusions is drawn, including a consideration of the commercial implications of the establishment of ‘software architects’ practices.
URL: https://www.sciencedirect.com/science/article/pii/095058499190115R


Reference Type:  Conference Paper
Record Number: 8169
Author: Boer, Remco C. de and Farenhorst, Rik
Year: 2008
Title: In search of `architectural knowledge'
Conference Name: Proceedings of the 3rd international workshop on Sharing and reusing architectural knowledge
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 71-78
DOI: 10.1145/1370062.1370080
Place Published: 1370080
Abstract: The software architecture community puts more and more emphasis on 'architectural knowledge'. However, there appears to be no commonly accepted definition of what architectural knowledge entails, which makes it a fuzzy concept. In order to obtain a better understanding of how different authors view 'architectural knowledge', we have conducted a systematic review to examine how architectural knowledge is defined and how the different definitions in use are related. From this review it became clear that many authors do not provide a concrete definition of what they think architectural knowledge entails. What is more intriguing, though, is that those who do give a definition seem to agree that architectural knowledge spans from problem domain through decision making to solution; an agreement that is not obvious from the definitions themselves, but which is only brought to light after careful systematic comparison of the different studies.
Notes: literature review


Reference Type:  Conference Proceedings
Record Number: 7738
Author: Manteuffel, C., Tofan, D., Koziolek, H., Goldschmidt, T. and Avgeriou, P.
Year of Conference: 2014
Title: Industrial Implementation of a Documentation Framework for Architectural Decisions
Conference Name: 2014 IEEE/IFIP Conference on Software Architecture
Pages: 225-234
Date: 7-11 April 2014
Short Title: Industrial Implementation of a Documentation Framework for Architectural Decisions
DOI: 10.1109/WICSA.2014.32
Keywords: decision making
document handling
software architecture
architectural decisions
architecture capturing
architecture decision documentation
decision documentation tool
decision sharing feature
documentation framework
enterprise architect
exploratory case study
reporting feature
viewpoint-based decision documentation framework
Computer architecture
Concrete
Context
Documentation
Interviews
Software
Unified modeling language
architectural viewpoints
architecture decisions
industrial case study
tool-support
Abstract: Architecture decisions are often not explicitly documented in practice but reside in the architect's mind as tacit knowledge, even though explicit capturing and documentation of architecture decisions has been associated with a multitude of benefits. As part of a research collaboration with ABB, we developed a tool to document architecture decisions. This tool is an add-in for Enterprise Architect and is an implementation of a viewpoint-based decision documentation framework. To validate the add-in, we conducted an exploratory case study with ABB architects. In the study, we assessed the status quo of architecture decision documentation, identified architects' expectations of the ideal decision documentation tool, and evaluated the new add-in. We found that although awareness of decision documentation is increasing at ABB, several barriers exist that limit the use of decisions in practice. Regarding their ideal tool, architects want a descriptive and efficient approach. Supplemental features like reporting or decision sharing are requested. The new add-in, was well-perceived by the architects. As a result of the study, we propose a clearer separation of problem, outcomes, and alternatives for the decision documentation framework.
Notes: implementation of a tool


Reference Type:  Journal Article
Record Number: 8598
Author: Svahnberg, Mikael
Year: 2004
Title: An industrial study on building consensus around software architectures and quality attributes
Journal: Information and Software Technology
Volume: 46
Issue: 12
Pages: 805-818
Date: 9/15/
Short Title: An industrial study on building consensus around software architectures and quality attributes
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2004.02.001
Keywords: Architecture candidates
Architecture tradeoff analysis method
Framework for architecture structure
Abstract: When creating an architecture for a software system it is important to consider many aspects and different sides of these aspects at an early stage, lest they are misunderstood and cause problems at later stages during development. In this paper, we report from an industry study to understand and select between different architecture candidates. The company uses a method that focuses discussions of architecture candidates to where there are disagreements between the participating domain experts. The results indicate that the used method pinpoints for the company where further investigations are necessary and that the decision concerning which architecture to use is taken with more confidence as a result of the focused discussions.
URL: https://www.sciencedirect.com/science/article/pii/S0950584904000266
'File' Attachments: internal-pdf://1864746796/An industrial study on building consensus arou.pdf


Reference Type:  Conference Paper
Record Number: 7887
Author: Petre, Marian
Year: 2009
Title: Insights from expert software design practice
Conference Name: Proceedings of the the 7th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering
Conference Location: Amsterdam, The Netherlands
Publisher: ACM
Pages: 233-242
DOI: 10.1145/1595696.1595731
Place Published: 1595731
Abstract: Software is a designed artifact. In other design disciplines, such as architecture, there is a well-established tradition of design studies which inform not only the discipline itself but also tool design, processes, and collaborative work. The 'challenge' of this paper is to consider software from such a 'design studies' perspective. This paper will present a series of observations from empirical studies of expert software designers, and will draw on examples from actual professional practice. It will consider what experts' mental imagery, software visualisations, and sketches suggest about software design thinking. It will also discuss some of the deliberate practices experts use to promote innovation. Finally, it will open discussion on the tensions between observed software design practices and received methodology in software engineering.
Notes: Talk - not research
'File' Attachments: internal-pdf://3034364825/Insights from expert software design practice.pdf


Reference Type:  Journal Article
Record Number: 8740
Author: Jelassi, M. Tawfik and Beauclair, Renée A.
Year: 1987
Title: An integrated framework for group decision support systems design
Journal: Information & Management
Volume: 13
Issue: 3
Pages: 143-153
Date: 10//
Short Title: An integrated framework for group decision support systems design
ISSN: 0378-7206
DOI: https://doi.org/10.1016/0378-7206(87)90022-X
Keywords: Group decision making
Group decision support systems
Behavioral issues
System development
Software design
Abstract: Proposed approaches for the development of Group Decision Support Systems (gdss) address behavioral and technical aspects of these systems. However, these approaches generally address only one of these aspects at a time. This paper reviews these approaches and suggests a framework for developing gdss based on an integrated perspective. This proposed framework is comprehensive and integrative as it combines the behavioral characteristics of group decision making with the technical specifications that drive gdss. Software design and future research issues are discussed.
Notes: tool development
URL: https://www.sciencedirect.com/science/article/pii/037872068790022X


Reference Type:  Conference Proceedings
Record Number: 9326
Author: Chanda, N. and Liu, X. F.
Year of Conference: 2015
Title: Intelligent analysis of software architecture rationale for collaborative software design
Conference Name: 2015 International Conference on Collaboration Technologies and Systems (CTS)
Pages: 287-294
Date: 1-5 June 2015
Short Title: Intelligent analysis of software architecture rationale for collaborative software design
DOI: 10.1109/CTS.2015.7210436
Keywords: decision making
formal specification
groupware
management of change
program diagnostics
program verification
software architecture
address change management
collaborative software design
design decision making process
intelligent software architecture rationale analysis
requirement satisfaction system
requirement traceability
software architecture elements
software requirements
software system maintainability
textual analysis
traceability matrix
Artificial intelligence
Collaboration
Computer architecture
Software
Architecture Knowledge Capture
Collaborative (Global) Software Development
Collaborative Conflict Management
Collaborative Decision Making and Support
Collaborative Knowledge Management
Collaborative Software Architecture Design
Collective Intelligence
Abstract: A set of principle design decisions drives architects to design software architecture for a system satisfying requirements. The design decision making process involves a group of stakeholders exchanging their viewpoints to address various concerns and reach a consensus. Often the architecture rationale behind various design decisions is not fully captured and hence affects the maintainability of software systems. In this paper, we identify three research challenges to analyze the architecture rationale in various perspectives to provide stakeholders with a more detailed view that aids them in decision making. Firstly, we determine collective opinions of a group on different viewpoints and detect viewpoints which have gained a significant attention into the online discussion. Secondly, we propose a method to develop a traceability matrix that links various software architecture elements to its related software requirements. The requirements traceability helps to maintain software systems and address change management. Thirdly, We perform textual analysis of stakeholders' views to determine the topics that are most discussed. In order to capture and maintain the software architecture rationale for analysis, we briefly present the design of an intelligent software architecture rationale capture system that enables stakeholders to participate in an online discussion to resolve a design issue collaboratively. The system captures a structured design rationale which maintains its links to software requirements and architecture elements. Finally, a comprehensive empirical study is presented. The results from the study indicate that our system is effective in capturing and supporting stakeholders in a collaborative decision making.
Notes: tool


Reference Type:  Conference Proceedings
Record Number: 9206
Author: Taylor, P.
Year of Conference: 2001
Title: Interpreting Mayall's 'Principles in Design'
Conference Name: Proceedings 2001 Australian Software Engineering Conference
Pages: 297-305
Date: 2001
Short Title: Interpreting Mayall's 'Principles in Design'
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2001.948523
Keywords: professional aspects
software engineering
contemporary software design
current attitudes
perceptions
software design
Computer architecture
Computer science
Design engineering
Engineering management
Fabrics
Production
Productivity
Programming
Abstract: Design-a foundation of software engineering-has its own base of theory originating in architecture and spanning diverse disciplines. The paths of software and design theory separated when software design aligned with the engineering and production metaphors in the interests of manageability and formalism. The two disciplines have continued independent discourses, despite some important similarities. However, economic pressures and technology convergence may be forcing a reconciliation of sorts. As software becomes a pervasive design fabric, designers working in a range of media will converge, and from a systems perspective, lightweight development paradigms appear to be challenging the overheads of incumbent process-intensive engineering models. It is timely to go back to the point of divergence to see just how far modern software design norms have strayed from basic design theory of several decades ago. This paper examines Mayall's 'Principles in Design' (1979) and presents an interpretation of how contemporary software design relates to this unofficial design canon. Mayall's ten principles are treated as an assessment instrument, to provide a mirror on current attitudes and perceptions of the role of design in software engineering
Notes: Review/extension


Reference Type:  Conference Proceedings
Record Number: 7914
Author: Shahin, Mojtaba, Babar, Muhammad Ali and Zhu, Liming
Year of Conference: 2016
Title: The Intersection of Continuous Deployment and Architecting Process: Practitioners' Perspectives
Conference Name: Proceedings of the 10th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement
Conference Location: Ciudad Real, Spain
Publisher: ACM
Pages: 1-10
Short Title: The Intersection of Continuous Deployment and Architecting Process: Practitioners' Perspectives
DOI: 10.1145/2961111.2962587
Place Published: 2962587
Abstract: Context: Development and Operations (DevOps) is an emerging software industry movement to bridge the gap between software development and operations teams. DevOps supports frequently and reliably releasing new features and products-- thus subsuming Continuous Deployment (CD) practice. Goal: This research aims at empirically exploring the potential impact of CD practice on architecting process. Method: We carried out a case study involving interviews with 16 software practitioners. Results: We have identified (1) a range of recurring architectural challenges (i.e., highly coupled monolithic architecture, team dependencies, and ever-changing operational environments and tools) and (2) five main architectural principles (i.e., small and independent deployment units, not too much focus on reusability, aggregating logs, isolating changes, and testability inside the architecture) that should be considered when an application is (re-) architected for CD practice. This study also supports that software architecture can better support operations if an operations team is engaged at an early stage of software development for taking operational aspects into considerations. Conclusion: These findings provide evidence that software architecture plays a significant role in successfully and efficiently adopting continuous deployment. The findings contribute to establish an evidential body of knowledge about the state of the art of architecting for CD practice
'File' Atttachments: internal-pdf://1903914556/The Intersection of Continuous Deployment and.pdf


Reference Type:  Conference Proceedings
Record Number: 8824
Author: Riebisch, M. and Wohlfarth, S.
Year of Conference: 2007
Title: Introducing Impact Analysis for Architectural Decisions
Conference Name: 14th Annual IEEE International Conference and Workshops on the Engineering of Computer-Based Systems (ECBS'07)
Pages: 381-392
Date: 26-29 March 2007
Short Title: Introducing Impact Analysis for Architectural Decisions
DOI: 10.1109/ECBS.2007.46
Keywords: decision making
decision theory
software architecture
software quality
task analysis
architectural decisions
architectural quality
contemporary software systems
impact analysis
refactoring
Application software
Delay
Informatics
Process design
Software engineering
Software systems
Uncertainty
Reengineering
Abstract: Architectural quality constitutes a critical factor for contemporary software systems, especially because of their size and the needs for frequent, quick changes. For success-critical business systems, architectural decisions are of high risk for the market share and even for the existence of enterprises. These decisions are important for design processes as well as for refactoring. Because of the complexity of the decisions, e.g., uncertain, contradicting goals, unknown effects and risky conditions, decision-making is a difficult and risky task. Risks can be minimized if the decisions are made systematically. In an earlier paper, we introduced methods of decision theory to perform such decisions in a rational way. This paper introduces a method for evaluating alternatives of architectural decisions, for both architectural design and refactoring. This method adopts elements of the scenario-based evaluation method ALMA (Bengtsson et al., 2004). A practical example illustrates the application of the improved decision process
Notes: framework/process


Reference Type:  Journal Article
Record Number: 8804
Author: Booch, G.
Year: 2007
Title: The Irrelevance of Architecture
Journal: IEEE Software
Volume: 24
Issue: 3
Pages: 10-11
Short Title: The Irrelevance of Architecture
ISSN: 0740-7459
DOI: 10.1109/MS.2007.93
Keywords: program testing
software architecture
systems analysis
design decisions
software-intensive system architecture
system behavior
system life cycle
system tests
Buildings
Computer architecture
Economies of scale
Life testing
Programming profession
Project management
Quality management
Risk management
Software testing
System testing
stakeholder roles
Abstract: The architecture of a software-intensive system is largely irrelevant to its end users. Far more important to these stakeholders is the system's behavior, exhibited by raw, naked, running code. Most interesting system tests should be based on the use cases that are identified incrementally over the system's life cycle, the same use cases that the system's architects used to guide their design decisions. Testers can conduct other system tests only after the system's architecture is crisp. Just as analysts use a system's architecture as scaffolding along which to climb and examine the details of every edge, so too can testers use a system's architecture to devise tests that are relevant to the particular texture of that implementation
Notes: focus on end user


Reference Type:  Conference Proceedings
Record Number: 9282
Author: Xu, B.
Year of Conference: 2006
Title: Knowledge Based Micro-Estimation in Task Arrangement for Cooperative Global Software Design
Conference Name: 2006 International Conference on Machine Learning and Cybernetics
Pages: 682-686
Date: 13-16 Aug. 2006
Short Title: Knowledge Based Micro-Estimation in Task Arrangement for Cooperative Global Software Design
ISBN: 2160-133X
DOI: 10.1109/ICMLC.2006.258417
Keywords: cost-benefit analysis
groupware
project management
scheduling
software cost estimation
software development management
PERT technique
cooperative global software design
cost estimation
historic project data
knowledge based microestimation
task arrangement
task estimation
task scheduling
Collaborative software
Computer science
Costs
Cybernetics
Delay estimation
Educational institutions
Internet
Machine learning
Programming
Software design
Virtual groups
Communication delay
Global cooperative software design
Knowledge based micro-estimation
Abstract: Communication and coordination are main factors impacting global software design. As a result, task estimation and task scheduling should be well performed so as to reduce the impact of communication delay and promote the coordination. Accurate duration and cost estimation is critical so far, there are many variables for accurate estimate of cost or duration including the type of application and domain, the environment, the team organization, people's expertise, the culture involved, and the relationship between all stakeholders. This paper presents a micro-estimation solution based on historic project data so as to well arrange tasks in cooperative global software design. PERT technique has been adopted, and the veracity of the estimation can be identified and adjusted


Reference Type:  Journal Article
Record Number: 8684
Author: Guindon, Raymonde
Year: 1990
Title: Knowledge exploited by experts during software system design
Journal: International Journal of Man-Machine Studies
Volume: 33
Issue: 3
Pages: 279-304
Date: 9//
Short Title: Knowledge exploited by experts during software system design
ISSN: 0020-7373
DOI: https://doi.org/10.1016/S0020-7373(05)80120-8
Abstract: High-level software design is characterized by incompletely specified requirements, no predetermined solution path, and by the integration of multiple domains of knowledge at various levels of abstraction. The application of data-driven knowledge rules characterizes expertise. A verbal protocol study describes these domains of knowledge and how experts exploit their rich knowledge during design. It documents how designers heavily rely on problem domain scenario simulations throughout solution development. These simulations trigger the inferences of new requirements and complete the requirement specification. Designers recognize partial solutions at various levels of abstraction in the design decomposition through the application of data-driven rules. Designers also rely heavily on simulations of their design solutions. but these are shallow, that is, limited to one level of abstraction in the solution. The findings also illustrate how designers capitalize on design methods, notations, and specialized software design schemas. Finally, the study describes how designers exploit powerful heuristics and personalized evaluation criteria to constrain the design process and select a satisfactory solution. Studies, such as this one, help map the road to understanding expertise in complex tasks.
URL: https://www.sciencedirect.com/science/article/pii/S0020737305801208
'File' Attachments: internal-pdf://1528994201/Knowledge exploited by experts during software.pdf


Reference Type:  Journal Article
Record Number: 8401
Author: Figueiredo, Mayara Costa, de Souza, Cleidson R. B., Pereira, Marcelo Zílio, Prikladnicki, Rafael and Audy, Jorge Luis Nicolas
Year: 2014
Title: Knowledge transfer, translation and transformation in the work of information technology architects
Journal: Information and Software Technology
Volume: 56
Issue: 10
Pages: 1233-1252
Date: 10//
Short Title: Knowledge transfer, translation and transformation in the work of information technology architects
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2014.04.001
Keywords: IT architecture
Software architecture
Architect roles
Abstract: AbstractContext Information Technology (IT) architects are the professionals responsible for designing the information systems for an organization. In order to do that, they take into account many aspects and stakeholders, including customers, software developers, the organization’s business, and its current IT infrastructure. Therefore, different aspects influence their work. Objective This paper presents results of research into how IT architects perform their work in practice and how different aspects are taken into account when an information system is developed. An understanding of IT architects’ activities allows us to better support their work. This paper extends our own previous work (Figueiredo et al., 2012) [30] by discussing aspects of knowledge management and tool support. Method A qualitative study was conducted using semi-structured interviews for data collection and grounded theory methods (Strauss and Corbin, 1998) [5] for data analysis. Twenty-seven interviews were conducted with twenty-two interviewees from nine different companies through four cycles of data collection and analysis. Results Companies divide IT architecture activities among different roles. Although these roles receive different names in different organizations, all organizations follow a similar pattern based on 3 roles: enterprise, solutions and software architects. These architects perform both the technical activities related to the IT architecture and the social activities regarding the communication and coordination with other stakeholders and among themselves. Furthermore, current tools used by IT architects lack adequate support for all these aspects. Conclusion The activities of the different IT architects are highly interconnected and have a huge influence in the way the requirements are handled in every phase of the development of an information system. The activities of IT architects are also important for knowledge transfer, translation and transformation, since they receive from and spread information to different groups of stakeholders. We also conclude that they lack appropriate tool support, especially regarding support for their collaborative work.
URL: https://www.sciencedirect.com/science/article/pii/S0950584914000810
'File' Attachments: internal-pdf://2014457079/Knowledge transfer, translation and transforma.pdf


Reference Type:  Conference Paper
Record Number: 8177
Author: Nakagawa, Elisa Yumi, Becker, Martin, Jos, #233 and Maldonado, Carlos
Year: 2012
Title: A knowledge-based framework for reference architectures
Conference Name: Proceedings of the 27th Annual ACM Symposium on Applied Computing
Conference Location: Trento, Italy
Publisher: ACM
Pages: 1197-1202
DOI: 10.1145/2245276.2231964
Place Published: 2231964
Abstract: Software architectures play a major role in determining system quality, since they form the backbone of any successful software-intensive system. In this context, reference architectures refer to a special type of software architecture that capture the essence of the system architectures of a given domain, encompassing the knowledge about how to develop, standardize, and evolve systems of that domain. However, in spite of the considerable number of reference architectures available, no good understanding exists regarding knowledge contained in reference architectures. The main contribution of this work is to provide a better understanding of such knowledge and to propose a framework which presents a comprehensive panorama of this knowledge. An analysis of this framework is presented based on a relevant, well-known reference architecture widely used in industry. As its main result, this framework could provide a better understanding of the contents of such architectures, enabling the development of more complete, efficient reference architectures.
Notes: just tool


Reference Type:  Journal Article
Record Number: 9086
Author: Tsai, J. J. P.
Year: 1988
Title: A knowledge-based system for software design
Journal: IEEE Journal on Selected Areas in Communications
Volume: 6
Issue: 5
Pages: 828-841
Short Title: A knowledge-based system for software design
ISSN: 0733-8716
DOI: 10.1109/49.634
Keywords: PROLOG
expert systems
heuristic programming
software tools
IBM 4341 computer
domain knowledge
encoded
environment information
frame-and-rule oriented requirements language
front-end dialogue system
functional decomposition
inference engine
knowledge-based system
program transformation process
software design heuristic guidelines
software system
stepwise refinement
Artificial intelligence
Documentation
Knowledge based systems
Knowledge engineering
Production systems
Programming
Software design
Software development management
Software prototyping
Software systems
Abstract: A knowledge-based system to support software design is presented. The knowledge-based system consists of a frame-and-rule oriented requirements language (FRORL), a knowledge base, an inference engine, and a front-end dialogue system. The FRORL is developed to facilitate the documentation and analysis of a software system. The software design heuristic guidelines (e.g. stepwise refinement, functional decomposition) and the domain knowledge are encoded using Prolog and are stored in a knowledge base. An inference mechanism is implemented to interpret the FRORL specification, that uses the design expertise in the knowledge base to perform a program transformation process. The front-end dialogue system is used to obtain the environment information from users to facilitate the transformation process. The knowledge-based system is implemented in Prolog on an IBM 4341 computer. Results indicate that the system can incrementally accumulate design experience and facilitate the software design process. Examples are also given to illustrate this system
Notes: just tool


Reference Type:  Conference Proceedings
Record Number: 9057
Author: Wu, B. H.
Year of Conference: 2011
Title: Let's enforce a simple visualization rule in Software Architecture
Conference Name: International Conference on Information Science and Technology
Pages: 427-433
Date: 26-28 March 2011
Short Title: Let's enforce a simple visualization rule in Software Architecture
ISBN: 2164-4357
DOI: 10.1109/ICIST.2011.5765283
Keywords: data visualisation
software architecture
software development management
software development life cycle
software-centric system
visualization rule
Computer architecture
Hardware
Microprogramming
Software
Software measurement
Visualization
Abstract: Many software architecture books have been written during the past decade. Taylor et al. have made their latest attempt to settle a standard in their large volume book, Software Architecture: Foundations, Theory, and Practice. As a software development practitioner, the author of this paper, who worked on many software-centric systems in both Aerospace and Telecommunication industries, will provide a unique analysis of software architecture roles in the software development life cycle. Based on the view that the essential purpose of software architecture is to communicate the design of the software to its stakeholders, this paper proposes a simple approach to visualization in software architecture as a rule of thumb to achieve an effective communication in software development.
Notes: technique


Reference Type:  Conference Paper
Record Number: 8179
Author: Banerjee, Somo, Mattmann, Chris A., Medvidovic, Nenad and Golubchik, Leana
Year: 2005
Title: Leveraging architectural models to inject trust into software systems
Conference Name: Proceedings of the 2005 workshop on Software engineering for secure systems&mdash;building trustworthy applications
Conference Location: St. Louis, Missouri
Publisher: ACM
Pages: 1-7
DOI: 10.1145/1082983.1083213
Place Published: 1083213
Abstract: Existing software systems have become increasingly durable and their lifetimes have significantly lengthened. They are increasingly distributed and decentralized. Our dependence on them has grown tremendously. As such, the issues of trustworthiness and security have become prime concerns in designing, constructing, and evolving software systems. However, the exact meanings of these concepts are not universally agreed upon, nor is their role in the different phases of the software development lifecycle. In this paper, we argue that trustworthiness is a more broadly encompassing term than security, and that the two are often interdependent. We then identify a set of dimensions of trustworthiness. Finally, we analyze how the key elements of a software system's architecture can be leveraged in support of those trustworthiness dimensions. Our ultimate goal is to apply these ideas in the context of a concrete software architecture project. The goal of this paper is more modest: to understand the problem area and its relation to software architecture.


Reference Type:  Conference Proceedings
Record Number: 9456
Author: Xu, B., Huang, Z. and Wei, O.
Year of Conference: 2010
Title: Making Architectural Decisions Based on Requirements: Analysis and Combination of Risk-Based and Quality Attribute-Based Methods
Conference Name: 2010 7th International Conference on Ubiquitous Intelligence & Computing and 7th International Conference on Autonomic & Trusted Computing
Pages: 392-397
Date: 26-29 Oct. 2010
Short Title: Making Architectural Decisions Based on Requirements: Analysis and Combination of Risk-Based and Quality Attribute-Based Methods
DOI: 10.1109/UIC-ATC.2010.74
Keywords: decision making
decision support systems
inference mechanisms
software architecture
software quality
architectural decisions
architectural design
linkage
quality attribute-based methods
quality requirement
risk-based reasoning
software systems
system requirements
systematic analysis
Cognition
Computer architecture
Concrete
Couplings
Software
Quality Attribute-Based Method
Requirements
Abstract: Software architecture is critical to the success of large software systems. It has long been recognized that architectural design has profound impact on the achievement of system requirements. Two typical methods have been proposed to help users to make architectural decisions based on requirements. One method uses risk-based reasoning to help choosing good architectural design that can meet both system requirements and resource limitations, the other one, using quality attribute model as the linkage, enables deriving a fragment of architectural design that is focused on achieving certain quality requirement. However, there is little effort on comparing the two methods to discover similarities and differences. In this paper, we conduct a systematic analysis of the two methods, and compare them from the aspects of system requirements, architectural decisions, and mapping approach. We then propose a procedure to combine the two methods that provides better support to architectural design decision making.


Reference Type:  Journal Article
Record Number: 9333
Author: Nord, R. L., Ozkaya, I. and Sangwan, R. S.
Year: 2012
Title: Making Architecture Visible to Improve Flow Management in Lean Software Development
Journal: IEEE Software
Volume: 29
Issue: 5
Pages: 33-39
Short Title: Making Architecture Visible to Improve Flow Management in Lean Software Development
ISSN: 0740-7459
DOI: 10.1109/MS.2012.109
Keywords: software architecture
software development management
workflow management software
cycle time
feature-based high priority functionality
flow management
lean software management
release plan
software development
work in process
Agile manufacturing
Computer architecture
Product life cycle management
Productivity
Programming
Software management
release planning
software engineering management
waste
Abstract: Lean practices use the principle of Little's law to improve the flow of value to the end user by eliminating sources of waste from a software development process. Little's law defines throughput as a ratio of work in process and cycle time. Increasing throughput (or productivity) requires continuously improving (that is, decreasing) cycle time while ensuring that the work-in-process limit doesn't exceed the capacity available to process the work. This article shares experiences regarding the role architecture plays in lean software management practices. Release plans that give as much emphasis to architecturally significant tasks as to feature-based high-priority functionality can achieve better outcomes by avoiding conditions that lead to wasted time and effort. The application of lean software development practices can improve with better practical guidance on how to manage architecture flow as well as feature flow.
Notes: development process


Reference Type:  Conference Proceedings
Record Number: 9302
Author: Rodrigues, C. S. C. and Werner, C. M. L.
Year of Conference: 2011
Title: Making the comprehension of software architecture attractive
Conference Name: 2011 24th IEEE-CS Conference on Software Engineering Education and Training (CSEE&T)
Pages: 416-420
Date: 22-24 May 2011
Short Title: Making the comprehension of software architecture attractive
ISBN: 1093-0175
DOI: 10.1109/CSEET.2011.5876116
Keywords: Unified Modeling Language
computer aided instruction
computer science education
software architecture
3D visualization
UML models
VisAr3D approach
software architecture attractive
software architecture teaching
Computer architecture
Education
Solid modeling
Three dimensional displays
Visualization
Abstract: Visualization stimulates the cognitive capacity of humans and facilitates the understanding of a subject. It performs a crucial role in teaching software architecture. As systems become more complex, new education proposals have been introduced in the classroom, especially those that make teaching more attractive to students. This paper presents the VisAr3D approach which was designed to provide a 3D visualization of UML models, where the user should intuitively understand architectural elements in this 3D environment. It includes exploration, interaction and simulation resources to establish a practical and pleasant learning activity, focusing in large scale systems.
Notes: tool development


Reference Type:  Journal Article
Record Number: 8454
Author: Cortellessa, Vittorio, Mirandola, Raffaela and Potena, Pasqualina
Year: 2015
Title: Managing the evolution of a software architecture at minimal cost under performance and reliability constraints
Journal: Science of Computer Programming
Volume: 98, Part 4
Pages: 439-463
Date: 2/1/
Short Title: Managing the evolution of a software architecture at minimal cost under performance and reliability constraints
ISSN: 0167-6423
DOI: https://doi.org/10.1016/j.scico.2014.06.001
Keywords: Software evolution
Software cost
Software reliability
Software performance
Optimization model
Abstract: Managing a software architecture after the deployment phase is a very complex task due to frequent changes in the software requirements and environment. The software architecture must evolve in order to tackle such changes. The goal of this paper is to provide support for the decisions that software architects make after deployment. This approach is based on an optimization model whose solution suggests the “best” actions to be taken according to a given change scenario (i.e., a set of new requirements that induce changes in the structural and behavioral aspects of the software architecture). The model aims to minimize the costs while keeping the reliability and the performance of the software architecture within certain thresholds. The approach has been implemented as a framework named SHEPhERd, which is composed of a UML case tool, a model builder and a model solver. We show how SHEPhERd works on a smartphone mobile application example, and we highlight its potential to drive architectural decisions through sensitivity analysis. The achieved results are compared with those obtained by two groups of (human) maintainers composed of experts and non-experts with respect to the system and the execution environment, and we show that SHEPhERd outperforms the human judgment-based approaches.
Notes: tool
URL: https://www.sciencedirect.com/science/article/pii/S0167642314002792


Reference Type:  Conference Proceedings
Record Number: 9358
Author: Chavarriaga, J., Noguera, C., Casallas, R. and Jonckers, V.
Year of Conference: 2015
Title: Managing trade-offs among architectural tactics using feature models and feature-solution graphs
Conference Name: 2015 10th Computing Colombian Conference (10CCC)
Pages: 124-132
Date: 21-25 Sept. 2015
Short Title: Managing trade-offs among architectural tactics using feature models and feature-solution graphs
DOI: 10.1109/ColumbianCC.2015.7333406
Keywords: Internet
database management systems
formal specification
software architecture
software quality
architectural tactics
conflicting alternative selection
conflicting tactics
database-based Web applications
design alternatives
feature model
feature-solution graphs
nonconflicting tactics
quality attributes
trade-off decision
trade-off point detection
Computer architecture
Concurrent computing
Databases
Feature extraction
Redundancy
Servers
Software
Software Product Lines
Abstract: In Software Architecture, several approaches focus first on selecting architectural tactics to address quality attributes and later use the corresponding design alternatives to create application architectures. Regrettably, sometimes the alternatives used to improve some quality attributes inhibit or reduce the achievement of others. These conflicts, known as trade-off points, lead to trade-off decisions to solve them. Usually, detection of trade-off points and guidance for trade-off decisions rely on the expertise of software architects. The architect has to (1) identify and analyze the conflict on design alternatives, (2) determine which quality attributes and tactics motivated the selection of conflicting alternatives, and (3) decide about which set of non-conflicting tactics to use. This paper presents an approach based on feature models to help manage trade-offs. It is based on the specification of relationships between architectural tactics and design alternatives that describe, for each tactic, which combination of designs can be used or must not be used. When a set of tactics are selected to implement an architecture, these relationships serve to determine the set of alternatives to use. In addition, they aid to detect trade-off points and determine the tactics to consider in a trade-off decision. We present a formalization of our approach and illustrate it using a case study on tactics and patterns for database-based web applications.


Reference Type:  Conference Proceedings
Record Number: 8921
Author: Heesch, U. v. and Avgeriou, P.
Year of Conference: 2011
Title: Mature Architecting - A Survey about the Reasoning Process of Professional Architects
Conference Name: 2011 Ninth Working IEEE/IFIP Conference on Software Architecture
Pages: 260-269
Date: 20-24 June 2011
Short Title: Mature Architecting - A Survey about the Reasoning Process of Professional Architects
DOI: 10.1109/WICSA.2011.42
Keywords: decision making
inference mechanisms
software architecture
industrial software architects
mature architecting
professional architects
reasoning process
Cognition
Computer architecture
Concrete
Context
Software
design reasoning
empirical study
survey
Abstract: Architecting is to a large extent a decision-making process. While many approaches and tools exist to support architects during the various activities of architecting, little guidance exists to support the reasoning part of decision-making. This is partly due to our limited understanding of how professional architects make decisions. We report on findings of a survey that we have conducted with 53 industrial software architects to find out how they reason in real projects. The results of the survey are interpreted with respect to the industrial context and the architecture literature. We derive reasoning best practices that can support especially inexperienced architects with optimizing their decision-making process.
'File' Atttachments: internal-pdf://1373501598/Mature Architecting - A Survey about the Reaso.pdf


Reference Type:  Conference Proceedings
Record Number: 9640
Author: Braeuer, J.
Year of Conference: 2015
Title: Measuring Object-Oriented Design Principles
Conference Name: 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE)
Pages: 882-885
Date: 9-13 Nov. 2015
Short Title: Measuring Object-Oriented Design Principles
DOI: 10.1109/ASE.2015.17
Keywords: knowledge based systems
object-oriented methods
object-oriented programming
software quality
source code (software)
metric-based model
object-oriented design
rule-based quality reference model
software design
software development
source-code quality
Context
Object oriented modeling
Software engineering
Software measurement
design model
design principles
software-design quality
softwaredesign assessment method
Abstract: The idea of automatizing the assessment of object-oriented design is not new. Different approaches define and apply their own quality models, which are composed of single metrics or combinations thereof, to operationalize software design. However, single metrics are too fine-grained to identify core design flaws and they cannot provide hints for making design improvements. In order to deal with these weaknesses of metric-based models, rules-based approaches have proven successful in the realm of source-code quality. Moreover, for developing a well-designed software system, design principles play a key role, as they define fundamental guidelines and help to avoid pitfalls. Therefore, this thesis will enhance and complete a rule-based quality reference model for operationalizing design principles and will provide a measuring tool that implements these rules. The validation of the design quality model and the measurement tool will be based on various industrial projects. Additionally, quantitative and qualitative surveys will be conducted in order to get validated results on the value of object-oriented design principles for software development.
Notes: Tool concept


Reference Type:  Journal Article
Record Number: 8566
Author: Petre, Marian
Year: 2010
Title: Mental imagery and software visualization in high-performance software development teams
Journal: Journal of Visual Languages & Computing
Volume: 21
Issue: 3
Pages: 171-183
Date: 6//
Short Title: Mental imagery and software visualization in high-performance software development teams
ISSN: 1045-926X
DOI: https://doi.org/10.1016/j.jvlc.2009.11.001
Keywords: Software visualization
Empirical studies
High-performance programming
Teamwork
Abstract: This paper considers the relationship between mental imagery and software visualization in professional, high-performance software development. It presents overviews of four empirical studies of professional software developers in high-performing teams: (1) expert programmers’ mental imagery, (2) how experts externalize their mental imagery as part of teamwork, (3) experts’ use of commercially available visualization software, and (4) what tools experts build themselves, how they use the tools they build for themselves, and why they build tools for themselves. Through this series of studies, the paper provides insight into a relationship between how experts reason about and imagine solutions, and their use of and requirements for external representations and software visualization. In particular, it provides insight into how experts use visualization in reasoning about software design, and how their requirements for the support of design tasks differ from those for the support of other software development tasks. The paper draws on theory from other disciplines to explicate issues in this area, and it discusses implications for future work in this field.
Notes: literature review (or kind of)
URL: https://www.sciencedirect.com/science/article/pii/S1045926X09000755


Reference Type:  Journal Article
Record Number: 8639
Author: Petre, Marian and Blackwell, Alan F.
Year: 1999
Title: Mental imagery in program design and visual programming
Journal: International Journal of Human-Computer Studies
Volume: 51
Issue: 1
Pages: 7-30
Date: 7//
Short Title: Mental imagery in program design and visual programming
ISSN: 1071-5819
DOI: https://doi.org/10.1006/ijhc.1999.0267
Abstract: There is widespread anecdotal evidence that expert programmers make use of visual mental images when they are designing programs. This evidence is used to justify the use of diagrams and visual programming languages during software design. This paper reports the results of two studies. In the first, expert programmers were directly questioned regarding the nature of their mental representations while they were engaged in a design task. This investigative technique was used with the explicit intention of eliciting introspective reports of mental imagery. In the second, users of a visual programming language responded to a questionnaire in which they were asked about cognitive processes. The resulting transcripts displayed a considerable number of common elements. These suggests that software design shares many characteristics of more concrete design disciplines. The reports from participants in the two studies, together with previous research into imagery use, indicate potential techniques for further investigation of software development support tools and design strategies.
Notes: included in other work, use most recent
URL: https://www.sciencedirect.com/science/article/pii/S1071581999902677


Reference Type:  Journal Article
Record Number: 8638
Author: Far, Behrouz H., Ohmori, Mari, Baba, Takeshi, Yamasaki, Yasukiyo and Koono, Zenya
Year: 1996
Title: Merging CASE tools with knowledge-based technology for automatic software design
Journal: Decision Support Systems
Volume: 18
Issue: 1
Pages: 73-82
Date: 9//
Short Title: Merging CASE tools with knowledge-based technology for automatic software design
ISSN: 0167-9236
DOI: https://doi.org/10.1016/0167-9236(96)00019-X
Keywords: Software design
Expert system
Specification description language (SDL)
CASE tool
Abstract: An approach towards developing a Knowledge Based Software Engineering (KBSE) tool by merging a conventional CASE tool with the expert system technology is introduced. This is found useful in assisting human designers. Experimental expert systems CREATOR2 and CREATOR3 are introduced and applied to the design of switching software. The CREATOR2 has the following features: representing software design knowledge, composed of design product knowledge and design process knowledge, using frame technology; and integrating knowledge based reasoning techniques with a SDL CASE tool. CREATOR3 is an extension of the CREATOR2 system. It enables one with additional design schemas for splitting a process, adding events, etc., and additional representation power, such as using pictorial elements and designers' comments in the frame representation. This leads to a uniform modeling and advanced reasoning environment for software design. Experiments on designing switching software are reported.
Notes: Tool development
URL: https://www.sciencedirect.com/science/article/pii/016792369600019X


Reference Type:  Conference Proceedings
Record Number: 8057
Author: Bhat, Manoj, Shumaiev, Klym, Biesdorf, Andreas, Hohenstein, Uwe, Hassel, Michael and Matthes, Florian
Year of Conference: 2016
Title: Meta-model based framework for architectural knowledge management
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-7
Short Title: Meta-model based framework for architectural knowledge management
DOI: 10.1145/2993412.3004848
Place Published: 3004848
Abstract: The need to support a software architect’s day-to-day activities through efficient tool support has been highlighted both in research and industry. However, managing enterprises’ Architectural Knowledge (AK) to support scenarios such as decision making, what-if analysis, and collaboration during the execution of large industrial projects is still a challenge. In this paper, we propose the architecture of an AK management framework to support software architects to manage AK. The components of this framework including SyncPipes and rule engine allow software architects to consolidate projects’ data from disparate sources and to define domain-specific rules to address the challenges in inconsistency analysis, context-sensitive recommendations, and tracking of artifacts within projects. The technical details for realizing the components of the framework are also presented. The proposed AK management framework has been successfully implemented as part of an industrial project and is currently being evaluated in different domains.
Notes: not focused on behavior


Reference Type:  Conference Paper
Record Number: 7874
Author: Gon, Marcelo Benites, #231, alves, Oquendo, Flavio and Nakagawa, Elisa Yumi
Year: 2015
Title: A meta-process to construct software architectures for system of systems
Conference Name: Proceedings of the 30th Annual ACM Symposium on Applied Computing
Conference Location: Salamanca, Spain
Publisher: ACM
Pages: 1411-1416
DOI: 10.1145/2695664.2695737
Place Published: 2695737
Abstract: Nowadays, complex software systems tend to be the result of operationally independent, constituent systems working together, arising a new class of software systems called Systems of Systems (SoS). In another perspective, software architectures are essential to promote the success and quality of software systems, even more on SoS. However, the construction of SoS software architectures is typically ad-hoc without well-defined and standardized architecting approaches. In this context, the main contribution of this paper is the proposal of a "Meta-process for SoS Software Architectures" (SOAR), which supports the authoring of processes to construct SoS software architectures. SOAR is also independent of application domains and it is based on a broad, deep literature review as well as knowledge of experts. In order to evaluate the feasibility of SOAR, we conducted a survey with experts in SoS software architecture. The results of this survey indicate a good acceptance of SOAR among experts that also provided insights for improving SOAR. Our intention is to use SOAR as a framework to support the authoring of architecting processes for SoS and, further, to provide specialized versions including architectural decisions for specific application domains. Therefore, in some extent, we hope to contribute to the development projects of the new, important class of SoS software systems.
Notes: literature review


Reference Type:  Conference Proceedings
Record Number: 8924
Author: Shepperd, M.
Year of Conference: 1989
Title: A metrics based tool for software design
Conference Name: Second International Conference on Software Engineering for Real Time Systems, 1989.
Pages: 45-49
Date: 18-20 Sep 1989
Short Title: A metrics based tool for software design
Keywords: software reliability
software tools
systems analysis
design metrics
design stage
intra-system level
metrics based tool
new architectures
potentially problematic designs
safety critical systems
software design
software engineers
software tool
system architecture
system level
Abstract: Decision making is an essential part of the design process. Unfortunately, software engineers are frequently forced to make important, and for safety critical systems, vital decisions in the absence of feedback. A software tool is presented which addresses this need for input at the design stage by building a model of the system architecture over which a number of metrics may be defined. At a system level these design metrics enable the characterisation and comparison of differing architectures for the same specification. At an intra-system level the metrics can help pinpoint weaknesses and thus facilitate the generation of new architectures. Empirical work suggests that such measures can be very effective at identifying potentially problematic designs and design components. In addition the tool allows the user to tailor the metrics to his or her specific needs and environment
Notes: tool development


Reference Type:  Conference Paper
Record Number: 8095
Author: Zimmermann, Olaf
Year: 2015
Title: Metrics for architectural synthesis and evaluation: requirements and compilation by viewpoint: an industrial experience report
Conference Name: Proceedings of the Second International Workshop on Software Architecture and Metrics
Conference Location: Florence, Italy
Publisher: IEEE Press
Pages: 8-14
Place Published: 2821330
Abstract: During architectural analysis and synthesis, architectural metrics are established tacitly or explicitly. In architectural evaluation, these metrics then can be consulted to assess whether architectures are fit for purpose and in line with recommended practices and published architectural knowledge. This experience report presents a personal retrospective of the author's use of architectural metrics during 20 years in IT architect roles in professional services as well as research and development. This reflection drives the identification of use cases, critical success factors and elements of risk for architectural metrics management. An initial catalog of architectural metrics is then compiled, which is organized by viewpoints and domains. The report concludes with a discussion of practical impact of architectural metrics and potential research topics in this area.


Reference Type:  Journal Article
Record Number: 8746
Author: Shepperd, M. and Ince, D.
Year: 1989
Title: Metrics, outlier analysis and the software design process
Journal: Information and Software Technology
Volume: 31
Issue: 2
Pages: 91-98
Date: 3//
Short Title: Metrics, outlier analysis and the software design process
ISSN: 0950-5849
DOI: https://doi.org/10.1016/0950-5849(89)90088-8
Keywords: software design
methodologies
metrics
outlier analysis
information flow metric
Abstract: The tutorial paper considers the question of how the software designer is to make use of the many design metrics that have been proposed by researchers over the past few years. The activity of software design is an iterative process of decision making. Design methodologies provide qualitative criteria for this decision-making process. In contrast, design metrics claim to provide objective, quantitative guidance. Three application methods for metrics are identified: prediction, quality control, and outlier analysis. Strong evidence is presented to show that, at present, the field of design metrics is only sufficiently mature to allow outlier analysis to be recommended as a useful aid to the software design process. The paper demonstrates this technique by evaluating an example design using the information flow metric.
URL: https://www.sciencedirect.com/science/article/pii/0950584989900888


Reference Type:  Conference Proceedings
Record Number: 9601
Author: Samarthyam, G., Suryanarayana, G., Sharma, T. and Gupta, S.
Year of Conference: 2013
Title: MIDAS: A design quality assessment method for industrial software
Conference Name: 2013 35th International Conference on Software Engineering (ICSE)
Pages: 911-920
Date: 18-26 May 2013
Short Title: MIDAS: A design quality assessment method for industrial software
ISBN: 0270-5257
DOI: 10.1109/ICSE.2013.6606640
Keywords: expert systems
program testing
software architecture
software performance evaluation
software quality
CT DC AA
MIDAS
Siemens Corporate Development Center Asia Australia
design analysis tools
design assessment practices
design quality assessment method
expert-based method
ility-based quality model
industrial software
method for intensive design assessments
project-specific constraints
software applications
software architects
software design quality
software engineering community
Analytical models
Context
Design methodology
Manuals
Quality assessment
Software design
software design assessment method
Abstract: Siemens Corporate Development Center Asia Australia (CT DC AA) develops and maintains software applications for the Industry, Energy, Healthcare, and Infrastructure & Cities sectors of Siemens. The critical nature of these applications necessitates a high level of software design quality. A survey of software architects indicated a low level of satisfaction with existing design assessment practices in CT DC AA and highlighted several shortcomings of existing practices. To address this, we have developed a design assessment method called MIDAS (Method for Intensive Design ASsessments). MIDAS is an expert-based method wherein manual assessment of design quality by experts is directed by the systematic application of design analysis tools through the use of a three view-model consisting of design principles, project-specific constraints, and an &#x201C;ility&#x201D;-based quality model. In this paper, we describe the motivation for MIDAS, its design, and its application to three projects in CT DC AA. We believe that the insights from our MIDAS experience not only provide useful pointers to other organizations and practitioners looking to assess and improve software design quality but also suggest research questions for the software engineering community to explore.
Notes: tool development


Reference Type:  Conference Paper
Record Number: 7862
Author: Xu, Lihua
Year: 2008
Title: Moda - multiple objective decision analysis: balancing quality attributes in software architectures
Conference Name: Companion of the 30th international conference on Software engineering
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 1019-1022
DOI: 10.1145/1370175.1370227
Place Published: 1370227
Abstract: A high-quality software architecture facilitates in developing a high quality software-intensive system. To design such architecture, the architect must consider multiple stakeholders' inconsistent, contradictory, and partially understood objectives, and balance the myriad tradeoffs among them. Our approach proposes to balance quality attributes in software architectures by identify the important-yet-to-be-addressed quality attributes during the design process and provide architecture analysis methods to help compare the resulting architecture candidates with respect to required quality attributes.


Reference Type:  Conference Proceedings
Record Number: 9092
Author: Zhang, J., Liu, Y., Sun, J., Dong, J. S. and Sun, J.
Year of Conference: 2012
Title: Model Checking Software Architecture Design
Conference Name: 2012 IEEE 14th International Symposium on High-Assurance Systems Engineering
Pages: 193-200
Date: 25-27 Oct. 2012
Short Title: Model Checking Software Architecture Design
ISBN: 1530-2059
DOI: 10.1109/HASE.2012.12
Keywords: formal verification
health care
libraries
software architecture
ADL
LTS
Labeled Transition System
TRMCS
Wright# architecture description language
architecture style library
dedicated model checking module
formal description
formal syntax
high level description
model checking software architecture design
process analysis toolkit
software engineering practice
system design
teleservices and remote medical care system
Computer architecture
Connectors
Semantics
Syntactics
Model Checking
PAT
Wright
Abstract: Software Architecture plays an essential role in the high level description of a system design. Despite its importance in the software engineering practice, the lack of formal description and verification support hinders the development of quality architectural models. In this paper, we present an automated approach to the modeling and verification of software architecture designs using the Process Analysis Toolkit (PAT). We present the formal syntax of the Wright# architecture description language together with its operational semantics in Labeled Transition System (LTS). A dedicated model checking module for Wright# is implemented in the PAT verification framework based on the proposed formalism. The module - ADL supports verification and simulation of software architecture models in PAT. We advance our work via defining an architecture style library that embodies commonly used architecture patterns to facilitate the modeling process. Finally, a case study of the Teleservices and Remote Medical Care System (TRMCS) modeling and verification is presented to evaluate the effectiveness and scalability of our approach.
Notes: tool development


Reference Type:  Journal Article
Record Number: 8707
Author: Zannier, Carmen, Chiasson, Mike and Maurer, Frank
Year: 2007
Title: A model of design decision making based on empirical results of interviews with software designers
Journal: Information and Software Technology
Volume: 49
Issue: 6
Pages: 637-653
Date: 6//
Short Title: A model of design decision making based on empirical results of interviews with software designers
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2007.02.010
Keywords: Design decision
Rational decision making
Naturalistic decision making
Interviewing
Abstract: Despite the impact of design decisions on software design, we have little understanding about how design decisions are made. This hinders our ability to provide design metrics, processes and training that support inherent design work. By interviewing 25 software designers and using content analysis and explanation building as our analysis technique, we provide qualitative and quantitative results that highlight aspects of rational and naturalistic decision making in software design. Our qualitative multi-case study results in a model of design decision making to answer the question: how do software designers make design decisions? We find the structure of the design problem determines the aspects of rational and naturalistic decision making used. The more structured the design decision, the less a designer considers options.
URL: https://www.sciencedirect.com/science/article/pii/S0950584907000122
'File' Attachments: internal-pdf://3319608413/A model of design decision making based on emp.pdf


Reference Type:  Conference Proceedings
Record Number: 8774
Author: Ahmed, F., Capretz, L. F. and Babar, M. A.
Year of Conference: 2008
Title: A Model of Open Source Software-Based Product Line Development
Conference Name: 2008 32nd Annual IEEE International Computer Software and Applications Conference
Pages: 1215-1220
Date: July 28 2008-Aug. 1 2008
Short Title: A Model of Open Source Software-Based Product Line Development
ISBN: 0730-3157
DOI: 10.1109/COMPSAC.2008.126
Keywords: public domain software
software architecture
OSS
SPL
open source software
product line development
software product line
Application software
Asset management
Computer applications
Computer architecture
Educational institutions
Information technology
Programming
Software development management
component development
process model
Abstract: Software product line (SPL) and open source software (OSS) have emerged as successful modes of developing software. There is an increased interest in developing suitable approaches for combining the promised advantages of SPL and OSS. Researchers and practitioners have been emphasizing the need of exploiting the ever growing repositories of OSS components for developing SPLs. However, there is no conceptual model for guiding the process of developing OSS-based SPLs. In this paper, we propose a model for developing software product line using open source software. This paper identifies and elaborates the essential phases and activities of the proposed model of developing OSS-based SPLs. This model emphasizes the vital role of software architecture and asserts that software architectures of OSS can be exploited to establish a SPL. To demonstrate this, we have evaluated Eclipse's architecture for its potential to support different flavors of a system.
Notes: Inspects some architecture


Reference Type:  Conference Proceedings
Record Number: 9572
Author: Chen, L., Babar, M. A. and Liang, H.
Year of Conference: 2010
Title: Model-Centered Customizable Architectural Design Decisions Management
Conference Name: 2010 21st Australian Software Engineering Conference
Pages: 23-32
Date: 6-9 April 2010
Short Title: Model-Centered Customizable Architectural Design Decisions Management
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2010.31
Keywords: computer aided analysis
software architecture
ADD
AK
architectural knowledge
fixed data models
model centered customizable architectural design decisions management
software architecture process
Australia
Conference management
Data models
Engineering management
Knowledge management
Programming
Research and development management
Software development management
Software engineering
Architectural design decisions
customizability
Abstract: Architectural Design Decisions (ADD) form a key element of Architectural Knowledge (AK), which plays a vital role in the software architecture process. To help manage ADDs, several tools have been proposed. However, most of them have prescribed fixed data models to be followed and do not provide sufficient customizability. Mismatches between a tool's data model and users' specific needs make the tool less usable, or even unusable. We propose a highly customizable solution that enables users to define specialized ADD models according to the specific needs of their individual preferences and working situations to achieve perfect fitness between the required model by users and the provided model by the tool. The results of the initial evaluation of the proposed solution are encouraging.
Notes: ADDs, not behavior


Reference Type:  Conference Proceedings
Record Number: 9613
Author: Perovich, D., Bastarrica, M. C. and Rojas, C.
Year of Conference: 2009
Title: Model-Driven approach to Software Architecture design
Conference Name: 2009 ICSE Workshop on Sharing and Reusing Architectural Knowledge
Pages: 1-8
Date: 16-16 May 2009
Short Title: Model-Driven approach to Software Architecture design
DOI: 10.1109/SHARK.2009.5069109
Keywords: object-oriented programming
software architecture
software quality
systems analysis
enterprise application
model transformation
model-driven engineering
software architecture design
software development
software system design
software system quality attribute
Application software
Computer architecture
Design for quality
Design methodology
Model driven engineering
Programming
Proposals
Software design
Software systems
Abstract: Software Architecture (SA) allows for early assessment of and design for quality attributes of a software system, and it plays a critical role in current software development. However, there is no consensus on fundamental issues such as design methods and representation organization and languages, and current proposals lack specificity and preciseness. Thus, it is extremely difficult to build a complete and appropriate software architecture, even though it is recognized as a fundamental artifact. In this paper we define an architecture design method that enables the systematic and assisted construction of the SA of enterprise applications, taking into account major quality attributes involved in this family of systems. We apply Model-Driven Engineering techniques to achieve this goal. The architecture is treated as a mega-model (a model composed of related models) and the application of design decisions is encoded in terms of model transformations. The architectural rationale is explicitly registered as the set of transformations that yields the complete SA from scratch. We illustrate the application of the approach by designing the SA of a case study from the literature.
Notes: Framework/Model


Reference Type:  Conference Proceedings
Record Number: 9030
Author: Tang, A. and Vliet, H. van
Year of Conference: 2009
Title: Modeling constraints improves software architecture design reasoning
Conference Name: 2009 Joint Working IEEE/IFIP Conference on Software Architecture & European Conference on Software Architecture
Pages: 253-256
Date: 14-17 Sept. 2009
Short Title: Modeling constraints improves software architecture design reasoning
DOI: 10.1109/WICSA.2009.5290813
Keywords: formal specification
software architecture
alloy tool
constraint verification
design constraints specification
fundamental mechanisms
software architecture design reasoning
Australia
Coherence
Decision making
Humans
Logic design
Process design
Psychology
Shape memory alloys
Software design
Abstract: Requirements and project-related factors influence architectural design in intricate and multivariate ways. We are only beginning to understand some of the tacit but fundamental mechanisms involved in reasoning about design decisions, and one of them concerns the role of design constraints. This paper examines design constraints and how they shape design solutions. We introduce a design constraint model and an architectural design reasoning process for specifying design constraints and checking for design conflicts. We experiment with using logic for constraint verification with the alloy tool.
Notes: tool development


Reference Type:  Conference Proceedings
Record Number: 9176
Author: Pedraza-García, G., Astudillo, H. and Correal, D.
Year of Conference: 2014
Title: Modeling Software Architecture Process with a Decision-Making Approach
Conference Name: 2014 33rd International Conference of the Chilean Computer Science Society (SCCC)
Pages: 1-6
Date: 8-14 Nov. 2014
Short Title: Modeling Software Architecture Process with a Decision-Making Approach
ISBN: 1522-4902
DOI: 10.1109/SCCC.2014.27
Keywords: business data processing
decision making
software architecture
BPMN
architectural decisions
architectural views
as-is process definition
business process management notation
decision making activities
decision making process
modeling software architecture process
software architecture design processes
software system
system stakeholders
to-be process transformation
Computer architecture
Process control
Security
Stakeholders
decision-making approach
software architecture design
Abstract: The architecture of a software system is the result of balancing concerns expressed by system stakeholders using a decision-making process. Several industrial approaches have been proposed that recognize the importance of architectural decisions and their rationale, but most do not provide mechanisms to systematically formalize and manage this decision-making. This article proposes a strategy to enrich the activities of software architecture design, by using Business Process Management Notation (BPMN) in a clear, structured and consistent manner to keep the focus on decisions. This strategy consists of (1) an "as-is" process definition, analysis and improvement of the original process, and (2) a "to-be" process transformation, allowing to derive an enriched process. The approach is illustrated using the security perspective to architectural views in Rozanski and Wood's V&P method. This approach is a step towards the systematic consideration of software architecture design processes as decision-making activities.


Reference Type:  Journal Article
Record Number: 8086
Author: Littlewood, Bev, Popov, Peter and Strigini, Lorenzo
Year: 2001
Title: Modeling software design diversity: a review
Journal: ACM Comput. Surv.
Volume: 33
Issue: 2
Pages: 177-208
Short Title: Modeling software design diversity: a review
ISSN: 0360-0300
DOI: 10.1145/384192.384195
Legal Note: 384195
Abstract: Design diversity has been used for many years now as a means of achieving a degree of fault tolerance in software-based systems. While there is clear evidence that the approach can be expected to deliver some increase in reliability compared to a single version, there is no agreement about the extent of this. More importantly, it remains difficult to evaluate exactly how reliable a particular diverse fault-tolerant system is. This difficulty arises because assumptions of independence of failures between different versions have been shown to be untenable: assessment of the actual level of dependence present is therefore needed, and this is difficult. In this tutorial, we survey the modeling issues here, with an emphasis upon the impact these have upon the problem of assessing the reliability of fault-tolerant systems. The intended audience is one of designers, assessors, and project managers with only a basic knowledge of probabilities, as well as reliability experts without detailed knowledge of software, who seek an introduction to the probabilistic issues in decisions about design diversity.
Notes: more introduction than research


Reference Type:  Conference Proceedings
Record Number: 8801
Author: Szlenk, M., Zalewski, A. and Kijas, S.
Year of Conference: 2012
Title: Modelling Architectural Decisions under Changing Requirements
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 211-214
Date: 20-24 Aug. 2012
Short Title: Modelling Architectural Decisions under Changing Requirements
DOI: 10.1109/WICSA-ECSA.212.31
Keywords: decision making
software architecture
software maintenance
system documentation
architectural decision documenting
architectural decision modelling
changing requirement
decision making process
graphical modelling notation
software architecture documention
software architecture evolution
software architecture maintenance
Computer architecture
Context
Context modeling
Lead
Software
architectural decisions
graphical models
requirement changes
Abstract: One of the approaches for documenting software architecture is to treat it as a set of architectural design decisions. Such decisions are always made in the context of requirements that must be fulfilled and in the context of decisions that were made before. Currently, models for representing architectural decisions are mainly concentrated on showing the decision making process of the initial architectural design. However, decisions that have been made in such a process may need to be changed during further evolution and maintenance of the software architecture, typically in response to the new or changed requirements. A graphical modelling notation for documenting architectural decisions (Maps of Architectural Decisions) has been developed by our team. In this paper, it is presented how this notation could be used to model architectural decisions under changing requirements. It is proposed how one decision change could be effectively propagated through the rest of the architectural decision model and how a rigorous and tool-supported process of updating such models could be organized.
Notes: tool for ADDs


Reference Type:  Journal Article
Record Number: 8478
Author: Woods, Eoin and Bashroush, Rabih
Year: 2015
Title: Modelling large-scale information systems using ADLs – An industrial experience report
Journal: Journal of Systems and Software
Volume: 99
Pages: 97-108
Date: 1//
Short Title: Modelling large-scale information systems using ADLs – An industrial experience report
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2014.09.018
Keywords: Architecture description language
Software architecture discovery
Industrial experience report
Abstract: An organisation that had developed a large information system wanted to embark on a programme that would involve large-scale evolution of it. As a precursor to this, it was decided to create a comprehensive architectural description to capture and understand the system's design. This undertaking faced a number of challenges, including a low general awareness of software modelling and software architecture practices. The approach taken by the software architects tasked with this project included the definition of a simple, very specific, architecture description language. This paper reports our experience of the project and a simple ADL that we created as part of it.
URL: https://www.sciencedirect.com/science/article/pii/S0164121214002052


Reference Type:  Conference Proceedings
Record Number: 8974
Author: Alali, A. and Sillito, J.
Year of Conference: 2013
Title: Motivations for collaboration in software design decision making
Conference Name: 2013 6th International Workshop on Cooperative and Human Aspects of Software Engineering (CHASE)
Pages: 129-132
Date: 25-25 May 2013
Short Title: Motivations for collaboration in software design decision making
DOI: 10.1109/CHASE.2013.6614748
Keywords: decision making
groupware
software engineering
collaborative process
development process
organizational work context
social work context
software design decision making
Collaboration
Context
Interviews
Organizations
Software design
Abstract: Software design is a result of software design decisions made at different stages of the development process and these decisions are often made collaboratively. As part of an ongoing research project to understand and improve this collaborative process we have interviewed 13 designers about their design processes. In this paper we report on a preliminary analysis of our interview data focusing on why people collaborate around design decisions. We found that designers collaborate to improve their design decisions, save or share decision making effort, and in response to social or organizational work contexts.
'File' Atttachments: internal-pdf://1143860543/Motivations for collaboration in software desi.pdf


Reference Type:  Conference Proceedings
Record Number: 9305
Author: Brothers, K.
Year of Conference: 1994
Title: Moving upstream in the design process: new frontiers for technical communicators
Conference Name: IPCC 94 Proceedings. Scaling New Heights in Technical Communication
Pages: 280-284
Date: 28 Sep-1 Oct 1994
Short Title: Moving upstream in the design process: new frontiers for technical communicators
DOI: 10.1109/IPCC.1994.347517
Keywords: human factors
system documentation
technical presentation
design teams
peripheral user documentation
product design
product design teams
software design
technical communicators
usable products
Documentation
Job design
Process design
Software prototyping
Software testing
System testing
Usability
Abstract: Early involvement with product design teams forces technical communicators to reflect on their roles in the design of usable products and requires a new perspective about peripheral user documentation. The paper addresses the link between software design and documentation and considers these questions: what new roles are available to technical communicators? How can technical communicators be more effective on design teams? How are product design and documentation affected by human factors?


Reference Type:  Conference Proceedings
Record Number: 9162
Author: Kharchenko, A., Halay, I. and Bodnarchuk, I.
Year of Conference: 2016
Title: Multicriteria architecture choice of software system under design and reengineering
Conference Name: 2016 XIth International Scientific and Technical Conference Computer Sciences and Information Technologies (CSIT)
Pages: 4-8
Date: 6-10 Sept. 2016
Short Title: Multicriteria architecture choice of software system under design and reengineering
DOI: 10.1109/STC-CSIT.2016.7589855
Keywords: decision making
optimisation
software architecture
systems re-engineering
criteria values limitations
criterial function structure
criterion weight
multicriteria architecture choice
optimization model replacement-compensation
software design
software system architecture
software system reengineering
universal scalar convolution
value proximity
Computer architecture
Convolution
Linear programming
Optimization
Software systems
multicriteria choice
quality of software architecture
trade-off
Abstract: The problems of multi-criteria choice of software system architecture are discussed, connected with definition of criterial function structure and formalization of trade-offs definition procedure for decision making. Universal scalar convolution is offered for taking into account requirements of subject area and criteria values limitations. The criterion weight in this convolution depends on its value proximity to the limitation. Optimization model &#x201C;replacement-compensation&#x201D; is used for software system reengineering problems or for directed choice of software architecture.


Reference Type:  Conference Proceedings
Record Number: 9487
Author: Martini, A. and Bosch, J.
Year of Conference: 2016
Title: A Multiple Case Study of Continuous Architecting in Large Agile Companies: Current Gaps and the CAFFEA Framework
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 1-10
Date: 5-8 April 2016
Short Title: A Multiple Case Study of Continuous Architecting in Large Agile Companies: Current Gaps and the CAFFEA Framework
DOI: 10.1109/WICSA.2016.31
Keywords: software architecture
software management
software process improvement
software prototyping
CAFFEA organizational framework
Scrum setting
agile software development
grounded theory
large agile software companies
software architecture management
structured deductive analysis
structured inductive analysis
Companies
Computer architecture
Conferences
Interviews
Software
Agile Architecture
Architect Roles
Development Teams
Organizational Framework
Software Product Lines
Abstract: In order to continuously support the value delivery both in short-term and long-term, a key goal for large software companies is to continuously develop and manage software architecture. In order to understand how architecture management is employed in large Agile software companies, we have conducted interviews involving several roles at 5 firms. Through a combination of structured inductive and deductive analysis proper of Grounded Theory, we have identified current architect roles and gaps in the architecture practices in the studied organizations. From such investigation, we have developed an organizational framework, CAFFEA, for Agile architecting, including roles, (virtual) teams and practices. The framework has been evaluated through a cross-company workshop including participants from 5 large software companies, discussion groups and a final survey. Finally, we have evaluated the framework in practice after one year of its application at one of the companies. We found that some necessary architectural practices are overlooked in Large Agile Software Development. The evaluation of CAFFEA framework showed that the included roles and teams are needed in order to mitigate the gaps in the architectural practices. The responsibilities and the activities have been mapped to key architect roles compatible with the Scrum setting employed at the companies. The evaluation of CAFFEA shows key benefits.
'File' Atttachments: internal-pdf://0447239119/A Multiple Case Study of Continuous Architecti.pdf


Reference Type:  Journal Article
Record Number: 9388
Author: Caric, A. and Toivo, K.
Year: 2000
Title: New generation network architecture and software design
Journal: IEEE Communications Magazine
Volume: 38
Issue: 2
Pages: 108-114
Short Title: New generation network architecture and software design
ISSN: 0163-6804
DOI: 10.1109/35.819903
Keywords: software engineering
telecommunication computing
telecommunication networks
ATM
IP
access telephony applications
circuit switching
legacy telephony applications
network architecture
network evolution
software design
software development
software research
telecommunications networks
Application software
Computer architecture
Intelligent networks
Investments
Microelectronics
Power generation
Research and development
Telecommunication switching
Wireless networks
Abstract: This article deals with new telecommunications networks, the reasons for changes, and the options telecommunications are facing today. The new generation of network architecture is discussed, and two network evolution case studies are presented as well as the new role of powerful applications in the future development of networks. Special emphasis is on software research and development supporting this &ldquo;new telecom world&rdquo;
Notes: Telecommunication networks


Reference Type:  Journal Article
Record Number: 8850
Author: Fraser, S. and Mancl, D.
Year: 2008
Title: No Silver Bullet: Software Engineering Reloaded
Journal: IEEE Software
Volume: 25
Issue: 1
Pages: 91-94
Short Title: No Silver Bullet: Software Engineering Reloaded
ISSN: 0740-7459
DOI: 10.1109/MS.2008.14
Keywords: decision making
object-oriented programming
software engineering
decision-making tool
silver bullet
Application software
Books
Leg
Object oriented programming
Operating systems
Project management
Silver
Software design
Software tools
Frederick Brooks
complexity
computing
information technology and systems
organizational impact
Abstract: A celebratory panel took place at the 22nd International Conference on object-oriented programming, systems, languages, and applications in Montreal. The occasion was the 20th anniversary of Fred Brooks' paper "no silver bullet: essence and accidents of software engineering." Fred suggested that useful solutions must address inherent complexity observing that object-oriented techniques have come closest to achieving this goal. David described a "silver bullet" as a technique that requires no training or experience to apply a silver bullet should find its mark without aim. Software engineering as a discipline has expanded significantly, both in terms of system complexity and the community's global extent. "no silver bullet" continues to be both an enjoyable must-read and an influential reference. People use languages without the ideas, so the object community still has much to do. It is nice to know that, when all else fails us, we have an innate decision-making tool to fall back on.
Notes: just book review


Reference Type:  Conference Paper
Record Number: 8300
Author: Chu, Yaohan, Peters, Larry and Scott, Leighton
Year: 1978
Title: Notations For Software Specification And Design (Panel Discussion)
Conference Name: Proceedings of the 1978 annual conference
Conference Location: Washington, D.C., USA
Publisher: ACM
Pages: 460
DOI: 10.1145/800127.804147
Place Published: 804147
Notes: Chairman - Leonard Tripp


Reference Type:  Conference Proceedings
Record Number: 7873
Author: Galster, Matthias and Avgeriou, Paris
Year of Conference: 2011
Title: The notion of variability in software architecture: results from a preliminary exploratory study
Conference Name: Proceedings of the 5th Workshop on Variability Modeling of Software-Intensive Systems
Conference Location: Namur, Belgium
Publisher: ACM
Pages: 59-67
Short Title: The notion of variability in software architecture: results from a preliminary exploratory study
DOI: 10.1145/1944892.1944899
Place Published: 1944899
Abstract: Context: In the software product line domain, the concept of variability is well recognized. However, variability in the context of software architecture still seems to be poorly understood. Objective: In this paper, we aim at contributing to the development of a basic understanding of the notion of variability in the software architecture domain, beyond the idea of product lines. Method: We perform a preliminary exploratory study which consists of two parts: an expert survey among 11 subjects, and a mini focus group with 4 participants. For both parts, we collect and analyze mostly qualitative data. Results: Our observations indicate that there seems to be no common understanding of "variability" in the context of software architecture. On the other hand, some challenges related to variability in software architecture are similar to challenges identified in the product line domain. Conclusions: Variability in software architecture might require more theoretical foundations in order to establish "variability" as an architectural key concept and first-class quality attribute.
'File' Atttachments: internal-pdf://3983383324/The notion of variability in software architec.pdf


Reference Type:  Journal Article
Record Number: 8612
Author: Heliades, G. P. and Edmonds, E. A.
Year: 1999
Title: On facilitating knowledge transfer in software design
Journal: Knowledge-Based Systems
Volume: 12
Issue: 7
Pages: 391-395
Date: 11//
Short Title: On facilitating knowledge transfer in software design
ISSN: 0950-7051
DOI: https://doi.org/10.1016/S0950-7051(99)00039-8
Keywords: Software design
Design rationale
Expertise transfer systems
Abstract: This paper presents a discussion of the facilitation of expertise sharing among software design stakeholders. LOUIS, a prototype research tool, helps to capture much of the contextual information and knowledge in early design meetings that are very often lost soon after the meetings are over. Using LOUIS as a basis, we consider knowledge and skill transfer effects in software design tasks. Results from trials indicate that, although not entirely sufficient, process-related knowledge, in the form of argumentation, is useful to software designers who have reason to re-use that knowledge. A list of recommendations on how those knowledge transfer effects can be further facilitated is provided.
URL: https://www.sciencedirect.com/science/article/pii/S0950705199000398


Reference Type:  Conference Paper
Record Number: 8104
Author: Downey, Jack and Babar, Muhammad Ali
Year: 2008
Title: On identifying the skills needed for software architects
Conference Name: Proceedings of the first international workshop on Leadership and management in software architecture
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 1-6
DOI: 10.1145/1373307.1373309
Place Published: 1373309
Abstract: This position paper claims that software architects need a unique set of skills that may be difficult to gain solely from academic qualifications and/or training courses. We believe that socio-cognitive factors and artifacts with which software engineers work have a vital role in identifying the skill-set for software architects. Based on social cognitive theory and an artifact-centric framework, we have designed an instrument to investigate the skills needed by software architects. We believe that such an instrument will enable researchers and practitioners to gather the skill-set information by considering the personal traits of software architects, their behaviors, and the organization they work in together with the artifacts they use. This paper explains how the different concepts of social cognitive theory and an artifact-centric framework can stimulate discussion with software architects in order to gather information about their skills. We also briefly describe our experience of using this instrument in a pilot study.


Reference Type:  Conference Paper
Record Number: 8139
Author: Medvidovic, Nenad
Year: 2002
Title: On the role of middleware in architecture-based software development
Conference Name: Proceedings of the 14th international conference on Software engineering and knowledge engineering
Conference Location: Ischia, Italy
Publisher: ACM
Pages: 299-306
DOI: 10.1145/568760.568814
Place Published: 568814
Abstract: Software architectures promote development focused on modular functional building blocks (components), their interconnections (configurations), and their interactions (connectors). Since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will be complex as well. Middleware technologies such as CORBA, COM, and RMI, provide a set of predefined services for enabling component composition and interaction. However, the potential role of such services in the implementations of software architectures is not well understood. Furthermore, components adhering to one middleware standard cannot readily interact with those adhering to another. In order to understand the role and tradeoffs among middleware technologies in implementing architectures and enable component interoperability across middleware platforms, we have investigated a set of techniques and conducted preliminary case studies involving a particular architectural style, C2, and its implementation infrastructure. In particular, by encapsulating middleware functionality within C2's explicit software connectors, we have been able to couple C2's existing benefits such as component interchangeability, substrate independence, and structural guidance with new capabilities of multi-lingual, multi-process, and distributed application development in a manner that is transparent to architects. Furthermore, we have demonstrated the utility of our connector-based approach in enabling components implemented on top of different middleware platforms to interoperate. Though several details of our approach derive from the characteristics of the C2 style, we believe that a number of lessons learned are more generally applicable. We argue that these lessons can help form a broader research agenda for coupling the modeling power of software architectures with the implementation support provided by middleware.
Notes: architecture and middleware


Reference Type:  Conference Paper
Record Number: 8058
Author: Pettersson, Oskar, Svensson, Martin, Gil, Didac, Andersson, Jesper and Milrad, Marcelo
Year: 2010
Title: On the role of software process modeling in software ecosystem design
Conference Name: Proceedings of the Fourth European Conference on Software Architecture: Companion Volume
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 103-110
DOI: 10.1145/1842752.1842778
Place Published: 1842778
Abstract: Software Ecosystems (SECOs) have in recent years emerged as a promising approach for improved inter and intra organizational reuse and for reusability involving end-users in the software development process. Understanding the software's role in a larger perspective and how it interconnects with stakeholders is key for progress in those directions. However, for SECOs, several theoretical and methodological gaps remain to be charted. This paper identifies one such gap, the need for precise process modeling. It elaborates on experiences gained from the analysis of a SECO for mobile learning and brings up several aspects and insights for this particular domain. The main contributions are an initial reference model for the mobile learning domain and an outline for an analysis method for domain specific SECOs.
Notes: specific solution for one problem


Reference Type:  Conference Proceedings
Record Number: 7767
Author: Graaf, K. A. de, Tang, A., Liang, P. and Vliet, H. van
Year of Conference: 2012
Title: Ontology-based Software Architecture Documentation
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 121-130
Date: 20-24 Aug. 2012
Short Title: Ontology-based Software Architecture Documentation
DOI: 10.1109/WICSA-ECSA.212.20
Keywords: document handling
file organisation
information retrieval
ontologies (artificial intelligence)
software architecture
architectural knowledge
file based documents
industry projects
knowledge retrieval
ontology based software architecture documentation
semantic wiki
software ontology
Computer architecture
Documentation
Electronic publishing
Information services
Ontologies
Semantics
Software
architectural knowledge retrieval
software architecture documentation
software architecture knowledge
software ontologies
Abstract: A common approach to software architecture documentation in industry projects is the use of file-based documents. This approach offers a single-dimensional perspective on the architectural knowledge contained. Knowledge retrieval from file-based architecture documentation is efficient if the perspective chosen fits the needs of the readers, it is less so if the perspective does not match the needs of the readers. In this paper we describe an approach aimed at addressing architecture documentation retrieval issues. We have employed a software ontology in a semantic wiki optimized for architecture documentation. We have evaluated this ontology-based approach in a controlled industry experiment involving software professionals. The efficiency and effectiveness of the proposed approach is found to be better than that of the file-based approach.
Notes: documentation of ADDs


Reference Type:  Conference Proceedings
Record Number: 9085
Author: Chai, J. and Liu, J. N. K.
Year of Conference: 2010
Title: An ontology-driven framework for supporting complex decision process
Conference Name: 2010 World Automation Congress
Pages: 1-6
Date: 19-23 Sept. 2010
Short Title: An ontology-driven framework for supporting complex decision process
ISBN: 2154-4824
Keywords: computational complexity
decision making
group decision support systems
ontologies (artificial intelligence)
software architecture
Web environment
complex decision process
complex structure
decision analysis
decision path
embedded ontology structure
formal description
group decision making
group decision support system
ontology driven framework
selection method
Decision support systems
Problem-solving
Semantics
GDSS
Ontology
decision process
group decision-making
workshop system
Abstract: The study proposes a framework of ONTOlogy-based Group Decision Support System (ONTOGDSS) for decision process which exhibits the complex structure of decision-problem and decision-group. It is capable of reducing the complexity of problem structure and group relations. The system allows decision makers to participate in group decision-making through the web environment, via the ontology relation. It facilitates the management of decision process as a whole, from criteria generation, alternative evaluation, and opinion interaction to decision aggregation. The embedded ontology structure in ONTOGDSS provides the important formal description features to facilitate decision analysis and verification. It examines the software architecture, the selection methods, the decision path, etc. Finally, the ontology application of this system is illustrated with specific real case to demonstrate its potentials towards decision-making development.
Notes: system development


Reference Type:  Conference Paper
Record Number: 7871
Author: Erfanian, Aida and Aliee, Fereidoun Shams
Year: 2008
Title: An ontology-driven software architecture evaluation method
Conference Name: Proceedings of the 3rd international workshop on Sharing and reusing architectural knowledge
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 79-86
DOI: 10.1145/1370062.1370081
Place Published: 1370081
Abstract: Software architecture evaluation has a crucial role in the life cycle of software intensive systems. In this paper we propose an approach to empower a software architecture evaluation method called the Architecture tradeoff Analysis Method (ATAM). Our approach is highly focused on the effective reusability of software architecture knowledge. We propose two ontologies focusing on the role of Attribute-Based Architectural styles (ABAS) in software architecture development and analysis. We show the effectiveness of our approach by presenting three case studies.
Notes: evaluation method


Reference Type:  Conference Paper
Record Number: 8162
Author: Sullivan, Kevin
Year: 2010
Title: Opportunity-centered software development
Conference Name: Proceedings of the FSE/SDP workshop on Future of software engineering research
Conference Location: Santa Fe, New Mexico, USA
Publisher: ACM
Pages: 369-374
DOI: 10.1145/1882362.1882437
Place Published: 1882437
Abstract: The position of this paper is that it is worthwhile to invest now in use-inspired fundamental research and development leading to a new class of software development environments and methods, in which software investment opportunities (in addition to software capabilities) are modeled and analyzed explicitly, in support of a dynamic investment management approach to software development decision making. Theoretical work in this area has progressed far enough, and at the same time the cost of converting theory to practice has been radically reduced by advances in software development environment technology. The potential payoff on such an investment is a significantly improved capability for both engineers and executives to see, value, and exploit flexibility in software products, projects and processes, leading to significant improvements in decision making and thus in software design productivity.


Reference Type:  Conference Paper
Record Number: 8008
Author: Berenbach, Brian
Year: 2008
Title: The other skills of the software architect
Conference Name: Proceedings of the first international workshop on Leadership and management in software architecture
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 7-12
DOI: 10.1145/1373307.1373310
Place Published: 1373310
Abstract: The skills that are taught to the software architect in academic programs often leave him or her completely unprepared to assume the role of solution architect on a project with more than four or five developers. Furthermore, the globalization of software development has created a need for architects that can effectively manage multiple teams at multiple locations. Additionally, the lack of qualified architects has resulted in serious difficulties for industry. This position paper provides insight into the 'real' role of the architect on a large project, and examines the gap between what is taught at the university and what skills are needed for success.


Reference Type:  Journal Article
Record Number: 8726
Author: Tofan, Dan, Galster, Matthias, Avgeriou, Paris and Schuitema, Wes
Year: 2014
Title: Past and future of software architectural decisions – A systematic mapping study
Journal: Information and Software Technology
Volume: 56
Issue: 8
Pages: 850-872
Date: 8//
Short Title: Past and future of software architectural decisions – A systematic mapping study
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2014.03.009
Keywords: Software architecture
Architectural decisions
Systematic mapping study
Abstract: AbstractContext The software architecture of a system is the result of a set of architectural decisions. The topic of architectural decisions in software engineering has received significant attention in recent years. However, no systematic overview exists on the state of research on architectural decisions. Objective The goal of this study is to provide a systematic overview of the state of research on architectural decisions. Such an overview helps researchers reflect on previous research and plan future research. Furthermore, such an overview helps practitioners understand the state of research, and how research results can help practitioners in their architectural decision-making. Method We conducted a systematic mapping study, covering studies published between January 2002 and January 2012. We defined six research questions. We queried six reference databases and obtained an initial result set of 28,895 papers. We followed a search and filtering process that resulted in 144 relevant papers. Results After classifying the 144 relevant papers for each research question, we found that current research focuses on documenting architectural decisions. We found that only several studies describe architectural decisions from the industry. We identified potential future research topics: domain-specific architectural decisions (such as mobile), achieving specific quality attributes (such as reliability or scalability), uncertainty in decision-making, and group architectural decisions. Regarding empirical evaluations of the papers, around half of the papers use systematic empirical evaluation approaches (such as surveys, or case studies). Still, few papers on architectural decisions use experiments. Conclusion Our study confirms the increasing interest in the topic of architectural decisions. This study helps the community reflect on the past ten years of research on architectural decisions. Researchers are offered a number of promising future research directions, while practitioners learn what existing papers offer.
Notes: literature review
URL: https://www.sciencedirect.com/science/article/pii/S0950584914000706


Reference Type:  Conference Paper
Record Number: 7915
Author: Nadschl, Stefan, #228, ger, K, Josef, #252 and ng
Year: 2016
Title: A pattern collection for knowledge processing system architecture
Conference Name: Proceedings of the 21st European Conference on Pattern Languages of Programs
Conference Location: Kaufbeuren, Germany
Publisher: ACM
Pages: 1-23
DOI: 10.1145/3011784.3011796
Place Published: 3011796
Abstract: Many architecture and design patterns exist for enterprise software development. Nowadays interest of knowledge processing systems has been heightened, as these technologies can provide a valuable benefit for a company (e.g., supporting decision making). Nevertheless, the algorithms and technologies used in this domain can be complex and difficult to implement. Some parts can even outreach standard software development. This paper tries to identify similarities to enterprise systems and present a selection of existing design patterns that can be used to solve knowledge processing difficulties. The aim is to provide a pattern collection to allow also software designers and developers not familiar with knowledge processing principles, to easily design, implement and integrate such systems.
Notes: system development


Reference Type:  Conference Proceedings
Record Number: 8851
Author: Gokhale, S. S. and Yacoub, S.
Year of Conference: 2005
Title: Performability analysis of a pipeline software architecture
Conference Name: 29th Annual International Computer Software and Applications Conference (COMPSAC'05)
Volume: 1
Pages: 77-82 Vol. 2
Date: 26-28 July 2005
Short Title: Performability analysis of a pipeline software architecture
ISBN: 0730-3157
DOI: 10.1109/COMPSAC.2005.120
Keywords: document handling
object-oriented programming
pipeline processing
software architecture
software metrics
software performance evaluation
component failure
component structural organization
connector structural organization
document analysis system
nonfunctional attribute
performability analysis
pipeline software architecture
qualitative assessment
software pattern
software performance
unreliable components
Application software
Computer architecture
Computer industry
Connectors
Filters
Performance analysis
Pipelines
Software systems
Text analysis
Abstract: An architecture style defines a commonly occurring pattern of the structural organization of components and connectors such that the impact of the pattern on the different non functional attributes is known. It is possible to make a qualitative assessment of whether a specific style is conducive to the nonfunctional attribute of performance based on the knowledge and experience in the use of the style. It is necessary however, that such a qualitative judgment be substantiated by a quantitative estimate obtained using a systematic performance analysis approach, since architecture styles are likely to be used in domains where application performance will play a critical role in ensuring its widespread use. Recognizing this need, several research efforts have focused on the development of quantitative performance analysis approaches for general purpose software architectures as well as for architecture styles. A notable drawback of the existing approaches is that they do not consider failures of components and connectors and hence provide optimistic performance estimates. In this paper we present a performability analysis approach for a pipeline architecture style which accounts for unreliable components. The performance estimate provided by the proposed approach is more realistic than what can be provided by the prevalent approaches. We illustrate the potential of the approach with an industrial case study of a document analysis system.
Notes: analysis of tool


Reference Type:  Conference Paper
Record Number: 8355
Author: Fritz, Jane M.
Year: 1987
Title: A pragmatic approach to systems analysis and design
Conference Name: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education
Conference Location: St. Louis, Missouri, USA
Publisher: ACM
Pages: 127-131
DOI: 10.1145/31820.31746
Place Published: 31746
Abstract: The University of New Brunswick offers a wide selection of upper year Computer Science electives. Systems analysis and design, consisting of the study and use of the system life cycle for developing business information systems together with associated techniques and issues, has been offered for about 14 years. Considered to be a “soft” subject in a sea of hard-core technical courses, for many years this course was elected by a manageable maximum of 15-25 students per year. In recent years, particularly due to reinforcement by an active group of employers in our expanding co-op program, the value of such a course has been more widely recognized by our students. This paper examines methods used to handle substantial enrollment increases (40-60 students) in a subject which is especially sensitive to class size. Efforts made to improve the effectiveness of teaching this non-technical but vital material to technically oriented students are discussed. As well, the differences between software engineering and systems analysis and design are outlined. A case is made for a change in the ACM Curriculum '78 Software Design course CS14 to relect the very important role of the analysis phase in software development.
Notes: students in focus


Reference Type:  Journal Article
Record Number: 9646
Author: Wirfs-Brock, R. J.
Year: 2009
Title: Principles in Practice
Journal: IEEE Software
Volume: 26
Issue: 4
Pages: 11-12
Short Title: Principles in Practice
ISSN: 0740-7459
DOI: 10.1109/MS.2009.99
Keywords: object-oriented programming
systems analysis
abstraction-interface definition
design flexibility preservation
implementation detail hiding
object behavior distribution
software design principle
Astronomy
Digital audio broadcasting
Electronics packaging
Physics
Software design
Thumb
Uncertainty
Writing
Robert Martin
design principles
software
Abstract: This paper deals with good software design principle. On what do you base your design decisions-established conventions, past experience, or principles? The author discusses about three principles that seemed to underlie many of those experts decisions: 1) distribute behavior among objects (rather than concentrate it into a single controlling object). 2) preserve design flexibility by hiding implementation details.3) define abstractions and interfaces first (before focusing on data and coding details).


Reference Type:  Conference Proceedings
Record Number: 9115
Author: Pareto, L., Sandberg, A., Eriksson, P. and Ehnebom, S.
Year of Conference: 2011
Title: Prioritizing Architectural Concerns
Conference Name: 2011 Ninth Working IEEE/IFIP Conference on Software Architecture
Pages: 22-31
Date: 20-24 June 2011
Short Title: Prioritizing Architectural Concerns
DOI: 10.1109/WICSA.2011.13
Keywords: groupware
software architecture
system documentation
analytical techniques
architectural concern prioritization
architectural documentation
collaborative techniques
heterogeneous stakeholder groups
Conferences
Documentation
Interviews
Organizations
Planning
Reflection
Taxonomy
analytic-deliberative decision making
architectural concern
concern prioritization
software architecture design
Abstract: Efficient architecture work involves balancing the degree of architectural documentation with attention to needs, costs, agility and other factors. This paper presents a method for prioritizing architectural concerns in the presence of heterogeneous stakeholder groups in large organizations that need to evolve existing architecture. The method involves enquiry, analysis, and deliberation using collaborative and analytical techniques. Method outcomes are action principles directed to managers and improvement advice directed to architects along with evidence for recommendations made. The method results from 3 years of action research at Ericsson AB with the purpose of adding missing views to architectural documentation and removing superfluous ones. It is illustrated on a case where 29 senior engineers and managers within Ericsson prioritized 37 architectural concerns areas to arrive at 8 action principles, 5 prioritized improvement areas, and 24 improvement suggestions. Feedback from the organization is that the method has been effective in prioritizing architectural concerns, that data collection and analysis is more extensive compared to traditional prioritization practices, but that extensive analysis seems inevitable in architecture improvement work.
'File' Atttachments: internal-pdf://0815143596/Prioritizing Architectural Concerns.pdf


Reference Type:  Conference Paper
Record Number: 7938
Author: Riebisch, Matthias, Bode, Stephan and Brcina, Robert
Year: 2011
Title: Problem-solution mapping for forward and reengineering on architectural level
Conference Name: Proceedings of the 12th International Workshop on Principles of Software Evolution and the 7th annual ERCIM Workshop on Software Evolution
Conference Location: Szeged, Hungary
Publisher: ACM
Pages: 106-115
DOI: 10.1145/2024445.2024466
Place Published: 2024466
Abstract: Software architectures play a key role for the development and evolution of software systems because they have to enable their quality properties such as scalability, flexibility, and security. Software architectural decisions represent a transition from problem space with quality goals and requirements on one side to solution space with technical solutions on the other side. Technical solutions are reusable elements for the work of the architect as for example patterns, styles, frameworks and building blocks. For long-term evolution of the systems, an explicit mapping between goals and solutions is helpful for expressing design knowledge and fundamental decisions. Such a mapping has to bridge between the fields of requirements engineering, software architectural design, and software quality thus enabling reuse. In this paper the Goal Solution Scheme is discussed, which maps quality goals and goal refinements to architectural principles and solutions. The paper extends the approach from the previously discussed forward engineering to re-engineering activities thus covering evolutionary development processes. The evaluation of the approach has been performed in several case studies and projects including a large industrial one.


Reference Type:  Conference Paper
Record Number: 8152
Author: Zannier, Carmen and Maurer, Frank
Year: 2005
Title: A qualitative empirical evaluation of design decisions
Conference Name: Proceedings of the 2005 workshop on Human and social factors of software engineering
Conference Location: St. Louis, Missouri
Publisher: ACM
Pages: 1-7
DOI: 10.1145/1082983.1083124
Place Published: 1083124
Abstract: In this paper, we motivate examining software design decision making and provide the process by which the examination will occur. The objective is to provide qualitative results indicative of rational or naturalistic software design decision making. In a rational decision a decision maker evaluates decision alternatives and potential outcomes for each alternative using a utility function and probabilities of the outcome of each alternative. The utility function assigns a value to each possible alternative based on its outcome. The goal of rational decision making is selecting the optimal alternative. A naturalistic decision manifests itself in dynamic and continually changing conditions, embodies real-time reactions to these changes, embraces ill-defined tasks, and has a goal of selecting a satisfactory alternative. The proposed empirical qualitative study consists of inductive and deductive interviewing and deductive observations.


Reference Type:  Conference Proceedings
Record Number: 8949
Author: Golden, E., John, B. E. and Bass, L.
Year of Conference: 2005
Title: Quality vs. quantity: comparing evaluation methods in a usability-focused software architecture modification task
Conference Name: 2005 International Symposium on Empirical Software Engineering, 2005.
Pages: 10 pp.
Date: 17-18 Nov. 2005
Short Title: Quality vs. quantity: comparing evaluation methods in a usability-focused software architecture modification task
DOI: 10.1109/ISESE.2005.1541823
Keywords: software architecture
software quality
software reusability
empirical software engineering
software architecture design
software development
usability-supporting architectural pattern
Computer architecture
Particle measurements
Programming
Software design
Software engineering
Software measurement
Time measurement
Usability
User interfaces
Abstract: A controlled experiment was performed to assess the usefulness of portions of a usability-supporting architectural pattern (USAP) in modifying the design of software architectures to support a specific usability concern. Results showed that participants using a complete USAP produced modified designs of significantly higher quality than participants using only a usability scenario. Comparison of solution quality ratings with a quantitative measure of responsibilities considered in the solution showed positive correlation between the measures. Implications for software development are that usability concerns can be included at architecture design time, and that USAPs can significantly help software architects to produce better designs to address usability concerns. Implications for empirical software engineering are that validated quantitative measures of software architecture quality may potentially be substituted for costly and often elusive expert assessment.


Reference Type:  Journal Article
Record Number: 8404
Author: Kim, Suntae, Kim, Dae-Kyoo, Lu, Lunjin and Park, Sooyong
Year: 2009
Title: Quality-driven architecture development using architectural tactics
Journal: Journal of Systems and Software
Volume: 82
Issue: 8
Pages: 1211-1231
Date: 8//
Short Title: Quality-driven architecture development using architectural tactics
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2009.03.102
Keywords: Architectural tactics
Feature composition
Feature modeling
Quality-driven
Role-based metamodeling language
Software architecture, UML
Abstract: This paper presents a quality-driven approach to embodying non-functional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for common issues pertaining to quality attributes. In this approach, architectural tactics are represented as feature models, and their semantics is defined using the Role-Based Metamodeling Language (RBML) which is a UML-based pattern specification notation. Given a set of NFRs, architectural tactics are selected and composed, and the composed tactic is used to instantiate an initial architecture for the application. The proposed approach addresses both the structural and behavioral aspects of architecture. We describe the approach using tactics for performance, availability and security to develop an architecture for a stock trading system. We demonstrate tool support for instantiating a composed tactic to generate an initial architecture of the stock trading system.
URL: https://www.sciencedirect.com/science/article/pii/S0164121209000909


Reference Type:  Conference Proceedings
Record Number: 9622
Author: Reza, H. and Grant, E.
Year of Conference: 2005
Title: Quality-oriented software architecture
Conference Name: International Conference on Information Technology: Coding and Computing (ITCC'05) - Volume II
Volume: 1
Pages: 140-145 Vol. 1
Date: 4-6 April 2005
Short Title: Quality-oriented software architecture
DOI: 10.1109/ITCC.2005.237
Keywords: formal specification
software architecture
software quality
optimal architectural style
quality requirements
quality-oriented software architecture
systematic correlation
user requirements
Bridges
Computational modeling
Computer architecture
Concurrent computing
Message passing
Security
Software systems
Spatial databases
Transaction databases
Abstract: This paper proposes a method to select the software architecture for a family of systems that meets user requirements. The method is based on a set of universally accepted design principles and tactics that aims to establish a systematic correlation between the quality requirements of a system and an architectural style that best implements it. The proposed method can also be a valuable assistant to a novice software engineer in selecting an optimal architectural style because the selection of an appropriate architectural style plays an important role in success or failure of a system.


Reference Type:  Conference Proceedings
Record Number: 9010
Author: Bouwers, E., Correia, J. P., Deursen, A. v. and Visser, J.
Year of Conference: 2011
Title: Quantifying the Analyzability of Software Architectures
Conference Name: 2011 Ninth Working IEEE/IFIP Conference on Software Architecture
Pages: 83-92
Date: 20-24 June 2011
Short Title: Quantifying the Analyzability of Software Architectures
DOI: 10.1109/WICSA.2011.20
Keywords: public domain software
software architecture
software metrics
software quality
systems analysis
component balance
distributed system
open source software systems
software architecture analyzability
software metric
software quality aspects
software system decomposition
Computer architecture
Electric breakdown
Size measurement
Software systems
Abstract: The decomposition of a software system into components is a major decision in any software architecture, having a strong influence on many of its quality aspects. A system's analyzability, in particular, is influenced by its decomposition into components. But into how many components should a system be decomposed to achieve optimal analyzability? And how should the elements of the system be distributed over those components? In this paper, we set out to find answers to these questions with the support of a large repository of industrial and open source software systems. Based on our findings, we designed a metric which we call Component Balance. In a case study we show that the metric provides pertinent results in various evaluation scenarios. In addition, we report on an empirical study that demonstrates that the metric is strongly correlated with ratings for analyzability as given by experts.
Notes: framework/model


Reference Type:  Conference Paper
Record Number: 8128
Author: Kazman, Rick, Asundi, Jai and Klein, Mark
Year: 2001
Title: Quantifying the costs and benefits of architectural decisions
Conference Name: Proceedings of the 23rd International Conference on Software Engineering
Conference Location: Toronto, Ontario, Canada
Publisher: IEEE Computer Society
Pages: 297-306
Place Published: 381504
Abstract: The benefits of a software system are assessable only relative to the business goals the system has been developed to serve. In turn, these benefits result from interactions between the system's functionality and its quality attributes (such as performance, reliabilty and security). Its quality attributes are, in most cases, dictated by its architectural design decisions. Therefore, we argue in this paper that the software architecture is the crucial artifact to study in making design tradeoffs and in performing cost-benefit analyses. A substantial part of such an analysis is in determining the level of uncertainty with which we estimate both costs and benefits. In this paper we offer an architecture-centric approach to the economic modeling of software design decision making called CBAM (Cost Benefit Analysis Method), in which costs and benefits are traded off with system quality attributes. We present the CBAM, the early results from applying this method in a large-scale case study, and discuss the application of more sophisticated economic models to software decision making.
Notes: framework


Reference Type:  Conference Proceedings
Record Number: 8016
Author: Zhang, Cheng, Wang, Futian, Xu, Rongbin, Li, Xuejun and Yang, Yun
Year of Conference: 2014
Title: A quantitative analysis of survey data for software design patterns
Conference Name: Proceedings of the 2014 3rd International Workshop on Evidential Assessment of Software Technologies
Conference Location: Nanjing, China
Publisher: ACM
Pages: 48-55
Short Title: A quantitative analysis of survey data for software design patterns
DOI: 10.1145/2627508.2627516
Place Published: 2627516
Abstract: Software design patterns are largely concerned with improving the practices and products of software development. However, there has been no systematic analysis how users' profiles influence the effectiveness of design patterns. The aim of this paper is to investigate the links between the respondents' demographic data from our previous online survey and the design patterns. In this paper we employ a statistical approach to analyse the quantitative data collected from the respondents of our previous online survey. Through analysing the demographic data from the 206 responses of the questionnaire, we find that the positive assessment percentage of using patterns increases with greater experience with design patterns. The results show that the functions of design patterns are influenced by users' experiences rather than users' roles. 
'File' Atttachments: internal-pdf://3813218541/A quantitative analysis of survey data for sof.pdf


Reference Type:  Conference Paper
Record Number: 8050
Author: Sureka, Ashish, Mirajkar, Pranav Prabhakar and Varma, Kishore Indukuri
Year: 2009
Title: A rapid application development framework for rule-based named-entity extraction
Conference Name: Proceedings of the 2nd Bangalore Annual Compute Conference
Conference Location: Bangalore, India
Publisher: ACM
Pages: 1-4
DOI: 10.1145/1517303.1517330
Place Published: 1517330
Abstract: Named Entity Recognition and Classification (NERC) consist of identifying and labeling specific pieces of information like proper names from free-form textual data. There are primarily three approaches to named-entity extraction: hand-crafted rule based, machine-learning based and hybrid. Rule-based approaches consist of defining heuristics in the form of regular expressions or linguistic pattern and making use of dictionaries and lexicons for extracting named-entities. Rule-based approaches have proven to be quite successful but one of their limitations is that it requires a domain expert to manually define and encode the rules. The process of hand-engineering rules is a time consuming and tedious process. It also requires a domain expert, cannot be easily ported to other domains and languages and becomes hard to maintain. Machine learning based approaches tries to overcome these limitations by automatically learning rules or inducing a model rather than defining the rules by a human expert. In this work, we present our research on overcoming the limitations of rule-based approach by building a rapid application development framework that can expedite the process of rule-building and making it easy to maintain and apply it to other domains. We describe a framework that can enable a business user to easily define and maintain rules and lexicons.
Notes: Approach for NLP


Reference Type:  Conference Proceedings
Record Number: 9145
Author: Gaubatz, W. A.
Year of Conference: 1996
Title: Rapid prototyping
Conference Name: 1996 IEEE Aerospace Applications Conference. Proceedings
Volume: 3
Pages: 303-311 vol.3
Date: 3-10 Feb 1996
Short Title: Rapid prototyping
DOI: 10.1109/AERO.1996.496070
Keywords: aerospace industry
economics
management
military systems
missiles
product development
DC-X System
Delta Clipper Programs
Delta Clipper-Experimental system
Integrated Product Development
McDonnell Douglas
competitive strengths
compressed schedule
concurrent release
costs
drawings
explicitly defined budget
first time quality
flight testing
hardware and software design
international marketplace
procurements
rapid decision making authority
rapid prototyping
software design
team-wide communications
total management
Design engineering
Engineering management
Environmental management
Job shop scheduling
Life testing
Manufacturing processes
Prototypes
Software prototyping
Abstract: Competitiveness in today's market will be determined by the ability to be first to market with high-quality products at the lowest price. This product agility will be a key to competitive strengths in the international marketplace. To do this, first time quality with lower costs must be a way of life, not just a slogan. Rapid Prototyping, an Integrated Product Development (IPD) process creates the total management, operations, engineering, manufacturing, test and business environment that enables this to happen, Rapid prototyping has been a way of life on the Delta Clipper Programs since their inception, growing from a heritage of successful, fast paced programs carried out at McDonnell Douglas. The Rapid Prototyping Approach incorporates the basic tenets of Total Quality Management: empower the work force; build teams and commitment; and, build in quality from the beginning. The Delta Clipper Programs involve development efforts with a high degree of technical complexity, multi-discipline interactions, and schedule criticality. This requires managing a large number of activities simultaneously within a compressed schedule and an explicitly defined (and tight) budget. Schedule requirements demand concurrent release of drawings and procurements along with hardware and software design and development. The rapid prototyping environment facilitates these actions through team-wide communications, short management lines, and delegated, rapid decision making authority. This paper discusses the processes and results of rapid prototyping as applied to the development and flight testing of the Delta Clipper-Experimental, DC-X System
Notes: Not research...


Reference Type:  Conference Proceedings
Record Number: 8837
Author: Mustapic, G., Wall, A., Norstrom, C., Crnkovic, I., Sandstrom, K., Froberg, J. and Andersson, J.
Year of Conference: 2004
Title: Real world influences on software architecture - interviews with industrial system experts
Conference Name: Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004)
Pages: 101-111
Date: 12-15 June 2004
Short Title: Real world influences on software architecture - interviews with industrial system experts
DOI: 10.1109/WICSA.2004.1310694
Keywords: research and development
software architecture
software development management
architecture-determining decisions
industrial system experts
industrial systems
system architecture evolution
Computer architecture
Computer industry
Control systems
Hardware
Radio control
Robot control
Robotics and automation
Software systems
Telecommunication control
Abstract: Industrial systems are examples of complex and often long-lived systems in which software is playing an increasingly important role. Their architectures play a crucial role in maintaining the properties of such systems during their entire life cycle. In this paper, we present the results of a case study based on a series of interviews and a workshop with key personnel from research and development groups of successful international companies in their Swedish locations. The main goal of the investigation was to find the significant factors which influence system and software architectures and to find similarities and differences between the architecture-determining decisions and the architectures of these systems. The role of the architect was an important subject of the investigation. Our findings result in recommendations relating to the design and evolution of system architectures and suggestions regarding areas in which future research would be beneficial.
'File' Atttachments: internal-pdf://0325623180/Real world influences on software architecture.pdf


Reference Type:  Journal Article
Record Number: 8561
Author: Roeller, Ronny, Lago, Patricia and van Vliet, Hans
Year: 2006
Title: Recovering architectural assumptions
Journal: Journal of Systems and Software
Volume: 79
Issue: 4
Pages: 552-573
Date: 4//
Short Title: Recovering architectural assumptions
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2005.10.017
Keywords: Software architecture
Architectural knowledge
Assumptions
Architecture recovery
Abstract: During the creation of a software architecture, the architects and stakeholders take a lot of decisions. Many of these decisions can be directly related to functional or quality requirements. Some design decisions, though, are more or less arbitrarily made on the fly because of personal experience, domain knowledge, budget constraints, available expertise, and the like. These decisions, as well as the reasons for those decisions, are often not explicit upfront. They are implicit, and usually remain undocumented. We call them assumptions. There is no accepted way to document assumptions, and the relation between the software architecture and these assumptions easily gets lost, becomes hidden in the girders of the architecture. They are rediscovered at a later stage, when the software evolves and assumptions become invalid or new assumptions contradict earlier ones. In this paper, we develop a method to recover such assumptions from an existing software product. We illustrate the method by applying it to a commercial software product, and show how the results can help assess the evolutionary capabilities of its architecture.
URL: https://www.sciencedirect.com/science/article/pii/S0164121205001615


Reference Type:  Journal Article
Record Number: 8713
Author: Ikeya, Nozomi, Luck, Rachael and Randall, Dave
Year: 2012
Title: Recovering the emergent logic in a software design exercise
Journal: Design Studies
Volume: 33
Issue: 6
Pages: 611-629
Date: 11//
Short Title: Recovering the emergent logic in a software design exercise
ISSN: 0142-694X
DOI: https://doi.org/10.1016/j.destud.2012.06.004
Keywords: ethnomethodology
software design
design practice
reasoning
problem solving
Abstract: This paper develops a deeper understanding of professional software design by examining the emergent logic of a software design exercise. Decision-making is evident as a ‘product’ of activity, including coordinated attention to primarily two artefacts, the brief and the whiteboard. Thus, we pay attention to the ‘situatedness’ of decision-making, which is not one person’s accomplishment, but is interactively carried out through treating what is known to the participants such as requirements written in the brief as ‘documentary’ of what is to be understood. The paper examines how each pair resolved the requirements uncertainties, by treating different ‘users’ differently. Our examination reveals how different approaches to the design exercise were actually organised to shed new light on software design practices.
URL: https://www.sciencedirect.com/science/article/pii/S0142694X12000415
'File' Attachments: internal-pdf://4113978989/Recovering the emergent logic in a software de.pdf


Reference Type:  Journal Article
Record Number: 9043
Author: Avgeriou, P., Kruchten, P., Nord, R. L., Ozkaya, I. and Seaman, C.
Year: 2016
Title: Reducing Friction in Software Development
Journal: IEEE Software
Volume: 33
Issue: 1
Pages: 66-73
Short Title: Reducing Friction in Software Development
ISSN: 0740-7459
DOI: 10.1109/MS.2016.13
Keywords: data analysis
decision making
software maintenance
software quality
data science
economic theory
innovation curve
internal software quality
investment activity
software development
software engineering life cycle
software engineering progress
software evolution
software reengineering
Economics
Maintenance engineering
Software engineering
Stakeholders
Sustainability
education
maintenance and evolution
software architecture
software economics
software management
technical debt
Abstract: Software is being produced so fast that its growth hinders its sustainability. Technical debt, which encompasses internal software quality, evolution and maintenance, reengineering, and economics, is growing such that its management is becoming the dominant driver of software engineering progress. It spans the software engineering life cycle, and its management capitalizes on recent advances in fields such as source code analysis, quality measurement, and project management. Managing technical debt will become an investment activity applying economic theories. It will effectively address the architecture level and will offer specific processes and tools employing data science and analytics to support decision making. It will also be an essential part of the software engineering curriculum. Getting ahead of the software quality and innovation curve will inevitably involve establishing technical-debt management as a core software engineering practice. This article is part of a special issue on the Future of Software Engineering.
Notes: Not research, instead article


Reference Type:  Journal Article
Record Number: 8439
Author: Chauhan, Muhammad Aufeef, Babar, Muhammad Ali and Sheng, Quan Z.
Year: 2017
Title: A Reference Architecture for provisioning of Tools as a Service: Meta-model, Ontologies and Design Elements
Journal: Future Generation Computer Systems
Volume: 69
Pages: 41-65
Date: 4//
Short Title: A Reference Architecture for provisioning of Tools as a Service: Meta-model, Ontologies and Design Elements
ISSN: 0167-739X
DOI: https://doi.org/10.1016/j.future.2016.12.002
Keywords: Cloud computing
Software reference architecture
Tools as a Service (TaaS)
Meta-model
Ontologies
Abstract: Software Architecture (SA) plays a critical role in designing, developing and evolving cloud-based platforms that can be used to provision different types of services for consumers on demand. In this paper, we present a Reference Architecture (RA) for designing cloud-based Tools as a service SPACE (TSPACE), which can provision a bundled suite of tools following the Software as a Service (SaaS) model. The reference architecture has been designed by leveraging information structuring approaches and by using well-known architecture design principles and patterns. The RA has been documented using view-based approach and has been presented in terms of its context, goals, the RA meta-model, information structuring and relationship models using ontologies and components of the RA. We have demonstrated the feasibility and applicability of the RA with the help of a prototype and have used the prototype to provision software architecting tools. We have also evaluated the RA in terms of effectiveness of the design decisions and the RA’s completeness and feasibility using scenario-based architecture evaluation method. The proposed TSPACE RA can provide valuable insights to information structure approaches and guidelines for designing and implementing TSPACE for various domains.
Notes: design of specific software
URL: https://www.sciencedirect.com/science/article/pii/S0167739X16307221


Reference Type:  Conference Paper
Record Number: 8239
Author: Nakagawa, Elisa Yumi, Jos, #233 and Maldonado, Carlos
Year: 2008
Title: Reference architecture knowledge representation: an experience
Conference Name: Proceedings of the 3rd international workshop on Sharing and reusing architectural knowledge
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 51-54
DOI: 10.1145/1370062.1370077
Place Published: 1370077
Abstract: Software architectures have played a significant role in determining the success of software systems. In spite of impact of the architectures to the software development and, as a consequence, to the software quality, there is not yet a consensus about which mechanisms work better to describe these architectures. In addition, despite the relevance of reference architectures as an artifact that comprises knowledge of a given domain and supports development of systems for that domain, issues related to their representation have not also had enough attention. In this perspective, this work intends to contribute with an experience of representing reference architectures aiming at easily sharing and reusing knowledge in order to develop software systems. A case study on software testing is presented illustrating our experience.


Reference Type:  Conference Paper
Record Number: 8250
Author: Nakagawa, Elisa Yumi
Year: 2012
Title: Reference architectures and variability: current status and future perspectives
Conference Name: Proceedings of the WICSA/ECSA 2012 Companion Volume
Conference Location: Helsinki, Finland
Publisher: ACM
Pages: 159-162
DOI: 10.1145/2361999.2362032
Place Published: 2362032
Abstract: Reference architectures refer to a special type of software architecture that achieves well-recognized understanding of specific domains, promoting reuse of design expertise and facilitating the development, standardization, and evolution of software systems. Designed for various domains and purpose, they have increasingly impacted important aspects of system development, such as productivity and quality of such systems. In another perspective, variability has been considered in several research topics as a mechanism that facilitates software development and evolution. In this context, the main contribution of this paper is to present the current status regarding variability in the reference architecture engineering. It is also presented future research perspectives that could be conducted, providing new directions to the reference architecture engineering in order to become existing and new reference architectures more effective elements to the development and evolution of software-intensive systems.
Notes: focus on reference architecture


Reference Type:  Conference Paper
Record Number: 8028
Author: Hagen, Penny and MacFarlane, John
Year: 2008
Title: Reflections on the role of seeding in social design
Conference Name: Proceedings of the 20th Australasian Conference on Computer-Human Interaction: Designing for Habitus and Habitat
Conference Location: Cairns, Australia
Publisher: ACM
Pages: 279-282
DOI: 10.1145/1517744.1517780
Place Published: 1517780
Abstract: In strategies that make use of social software participation not only defines success but also defines the design. This foregrounds particular considerations during the planning and design process about participation, and how we bridge the gap between the client vision, the project and the potential community of contributors or users. This paper introduces and reflects on the notion of seeding as a construct useful for emphasising and exploring ways to promote or increase the likelihood of successful engagement. In systems that are determined by participation, it is our position that part of our role as designers is to facilitate or seed that participation and that the act of seeding (participation) becomes a core design activity. In this paper we reflect through case studies on the significance and potential for seeding content, connection and community through our design work, and on the way this has affected our approach to and understanding of the design process.
Notes: not empirical


Reference Type:  Conference Proceedings
Record Number: 9230
Author: Razavian, M., Tang, A., Capilla, R. and Lago, P.
Year of Conference: 2016
Title: Reflective Approach for Software Design Decision Making
Conference Name: 2016 Qualitative Reasoning about Software Architectures (QRASA)
Pages: 19-26
Date: 5-8 April 2016
Short Title: Reflective Approach for Software Design Decision Making
DOI: 10.1109/QRASA.2016.8
Keywords: decision making
software engineering
problem-generic reflective questions
software design decision making
two-minds model
Cognition
Context
Object oriented modeling
Problem-solving
Software design
Abstract: Good software design practice is difficult to define and teach. Despite the many software design methods and processes that are available, the quality of software design relies on human factors. We notice from literature and our own experiments that some of these factors concern design reasoning and reflection. In this paper, we propose a reflective approach to software design decision making. The approach is built upon Two-Minds model and is enabled by a set of problem-generic reflective questions. We illustrate its usefulness in design sessions with an example taken from preliminary experimentation.


Reference Type:  Conference Paper
Record Number: 7959
Author: Inverardi, Paola and Yankelevich, Daniel
Year: 1996
Title: Relating CHAM Descriptions of Software Architectures
Conference Name: Proceedings of the 8th International Workshop on Software Specification and Design
Publisher: IEEE Computer Society
Pages: 66
Place Published: 858268
Abstract: We propose an approach to compare descriptions of software architectures based on the CHAM formalism. The need to compare descriptions of the same system at different level of abstraction often arises typically when the software practice uses a stepwise refinement approach. Differently from other approaches presented in the literature, our framework allows for expressing correct refinement both of the static structure and of the dynamic behaviour of an architecture. Statically we rely on a suitable definition of partial morphism between the signatures of the two architectures. Dynamically we propose a notion of structure preserving simulation which allows the behaviours of the two CHAM descriptions to be (pre orderly) related. In both definitions an important role is played by the membrane construct which allows for expressing non functional constraints on the architecture to be refined. The main idea is to use the membranes to denote basic software components of the architecture that can be further decomposed during a refinement process but that cannot be destroyed even if the behaviour of the overall system is preserved. One point in favour of our approach is that we do not constrain too much the further development since we only require the membrane structure to be preserved.
Notes: compare architectures


Reference Type:  Conference Paper
Record Number: 8345
Author: Marasovi, Kristina, #263 and Lutz, Michael
Year: 2015
Title: Remote development and distance delivery of innovative courses: challenges and opportunities
Conference Name: Proceedings of the 37th International Conference on Software Engineering - Volume 2
Conference Location: Florence, Italy
Publisher: IEEE Press
Pages: 299-302
Place Published: 2819055
Abstract: The Rochester Institute of Technology (RIT) offers programs of study at several of RIT's international campuses: Dubrovnik and Zagreb (Croatia), Dubai (United Arab Emirates) and Priatina (Kosovo). At RIT Croatia, some courses are delivered as distance education courses using Polycom, a video conferencing system, supported by other online education tools. Although distance learning methods and tools provide an effective way to offer instructions remotely, delivering a course that emphasizes team-based software development, with laboratory exercises and in-class team activities, creates new challenges that need to be addressed. This paper discusses the authors' experiences with the remote development and delivery of one of those courses - the SWEN-383 Software Design Principles and Patterns course in the Information Technology program at RIT Croatia. The paper first explains the role and need for offering this particular course. It then discusses how the collaborative development of this new course was conducted between the U.S. And the Croatian campuses, including remote delivery from Zagreb to Dubrovnik. The paper concludes with observations and suggestions for those who may engage in such a project in the future.
Notes: students


Reference Type:  Conference Proceedings
Record Number: 9577
Author: Lytra, I., Engelbrecht, G., Schall, D. and Zdun, U.
Year of Conference: 2015
Title: Reusable Architectural Decision Models for Quality-Driven Decision Support: A Case Study from a Smart Cities Software Ecosystem
Conference Name: 2015 IEEE/ACM 3rd International Workshop on Software Engineering for Systems-of-Systems
Pages: 37-43
Date: 17-17 May 2015
Short Title: Reusable Architectural Decision Models for Quality-Driven Decision Support: A Case Study from a Smart Cities Software Ecosystem
DOI: 10.1109/SESoS.2015.14
Keywords: decision making
knowledge based systems
smart cities
software architecture
software quality
software reusability
architectural decision making
architectural design
architectural knowledge
document quality
quality attributes
quality-driven decision support
reusable architectural decision models
software ecosystem
software systems
system-of-systems domain
Biological system modeling
Computer architecture
Data mining
Ecosystems
Software
architectural decision support
architectural design decision
quality attribute
smart city
Abstract: Architectural design decisions and architectural knowledge are becoming relevant in the current practice of software architecture. In addition, reusable architectural knowledge has gained much importance in the industrial practice. In the process of architectural decision making, quality attributes constitute key drivers for designing software systems, therefore, it is important to document quality attributes along with the decisions captured. However, most of the current tools for management of architectural decisions focus mainly on capturing or sharing of design decisions. We propose to enrich a reusable architectural decision meta-model with quality attributes and introduce a corresponding tool. Our goal is to support software architects during decision making based on reusable decisions driven by quality attributes. Our approach was motivated by and applied in an industrial case study on a large-scale software ecosystem for smart cities, that constitute a complex and challenging system-of-systems domain. We applied our proposal in a few scenarios in the smart cities domain, in which the consideration of quality attributes is required to model reusable architectural knowledge adequately.
Notes: document decisions


Reference Type:  Conference Paper
Record Number: 8335
Author: Shidende, Nima Herman, M, Christina, #246 and rtberg
Year: 2014
Title: Re-visiting design-after-design: reflecting implementation mediators connectedness in distributed participatory design activities
Conference Name: Proceedings of the 13th Participatory Design Conference: Research Papers - Volume 1
Conference Location: Windhoek, Namibia
Publisher: ACM
Pages: 61-70
DOI: 10.1145/2661435.2661437
Place Published: 2661437
Abstract: This paper aims at an extended understanding of the design facilitators' role, here implementation mediators, in participatory design practices. In reflecting connectedness between use and design in a distributed open source software design practice, a particular focus is devoted to the implementation mediator's interaction between local users, global software developers, and local designers who are geographically distributed, possess different technological skills, and different work experiences. The implementation mediators' insights are useful in the design of large information systems that involve distributed actors. A maternal and child health setting in Tanzania was the case in this study. An ethnographic study involving interactions with global developers and participative activities in local health practices were conducted. In addition, mediators connected local and global designers to configure a computer system for a particular context; configured participation, involving health workers in designing practices. We present the role of the implementation mediators and its related participatory activities by using the notion of design-after-design. We also highlight the challenges which could face implementation mediators in distributed participatory design activities.
Notes: Thematically not fitting...
'File' Attachments: internal-pdf://2008152556/Re-visiting design-after-design reflecting imp.pdf


Reference Type:  Conference Proceedings
Record Number: 9108
Author: Boasson, M.
Year of Conference: 1996
Title: The role of architecture in the development of software systems
Conference Name: Computer Software and Applications Conference, 1996. COMPSAC '96., Proceedings of 20th International
Pages: 350-351
Date: 21-23 Aug 1996
Short Title: The role of architecture in the development of software systems
ISBN: 0730-3157
DOI: 10.1109/CMPSAC.1996.544589
Keywords: software cost estimation
software metrics
software performance evaluation
fast hardware
software architecture
software complexity
software development cost
software development process
system functionality
systems sophistication
Availability
Chaotic communication
Computer architecture
Cost function
Explosions
Hardware
Safety
Software systems
Virtual machining
Abstract: Systems increasingly rely on software as the main technology for implementing the desired behaviour. There is a clear trend of steadily growing sophistication in the behaviour of these systems. The availability of cheap and fast hardware suggests that successive generations of systems should exhibit greatly enhanced behaviour, but this increase in functionality is not observed to an extent that can be related to the progress made in hardware. To the contrary, systems grow in complexity very rapidly (as exemplified by their cost and the required sophistication of the development process), without providing much in terms of added functionality. This complexity, and resulting cost, limits the achievable level of sophistication in systems, unless techniques are found that allow the software complexity to be reduced very significantly. The imbalance between cost and functionality is discussed and arguments are presented suggesting it to be avoidable through a sound software architecture
Notes: cost focus


Reference Type:  Journal Article
Record Number: 9642
Author: Shaw, M.
Year: 2012
Title: The Role of Design Spaces
Journal: IEEE Software
Volume: 29
Issue: 1
Pages: 46-50
Short Title: The Role of Design Spaces
ISSN: 0740-7459
DOI: 10.1109/MS.2011.121
Keywords: software engineering
Studying Professional Software Design workshop
design space
traffic signal simulator
Object oriented modeling
Product development
Software architecture
Software design
design
Abstract: A central task in design is deciding what artifact will best satisfy the client's needs, whether that requires creating an artifact or choosing from existing alternatives. A design space identifies and organizes the decisions that must be made, together with the alternatives for those decisions, thereby providing guidance for creating artifacts or a framework for comparing them. The Studying Professional Software Design workshop studied three pairs of professional software designers sketching designs for a traffic signal simulator. A discussion of the design space for the simulation task shows how this design space enables comparison of the designs. It also illustrates the benefits of explicitly considering the design space during design and the risks of failing to do so.
'File' Attachments: internal-pdf://3790582486/The Role of Design Spaces.pdf


Reference Type:  Journal Article
Record Number: 9283
Author: Adelson, B. and Soloway, E.
Year: 1985
Title: The Role of Domain Experience in Software Design
Journal: IEEE Transactions on Software Engineering
Volume: SE-11
Issue: 11
Pages: 1351-1360
Short Title: The Role of Domain Experience in Software Design
ISSN: 0098-5589
DOI: 10.1109/TSE.1985.231883
Keywords: Artificial intelligence
cognitive models
cognitive science
software design
Computer science
Information science
Problem-solving
Protocols
Abstract: A designer's expertise rests on the knowledge and skills which develop with experience in a domain. As a result, when a designer is designing an object in an unfamiliar domain he will not have the same knowledge and skills available to him as when he is designing an object in a familiar domain. In this paper we look at the software designer's underlying constellation of knowledge and skills, and at the way in which this constellation is dependent upon experience in a domain. What skills drop out, what skills, or interactions of skills come forward as experience with the domain changes? To answer the above question, we studied expert designers in experimentally created design contexts with which they were differentially familiar. In this paper we describe the knowledge and skills we found were central to each of the above contexts and discuss the functional utility of each. In addition to discussing the knowledge and skills we observed in expert designers, we will also compare novice and expert behavior.
'File' Attachments: internal-pdf://4088361484/The Role of Domain Experience in Software Desi.pdf


Reference Type:  Journal Article
Record Number: 9512
Author: Sharp, H., Dittrich, Y. and Souza, C. R. B. de
Year: 2016
Title: The Role of Ethnographic Studies in Empirical Software Engineering
Journal: IEEE Transactions on Software Engineering
Volume: 42
Issue: 8
Pages: 786-804
Short Title: The Role of Ethnographic Studies in Empirical Software Engineering
ISSN: 0098-5589
DOI: 10.1109/TSE.2016.2519887
Keywords: cultural aspects
human factors
software process improvement
empirical software engineering
ethnography
human aspects
social aspects
sociotechnological realities
software development practice
software engineering tools
software process development
Computer science
Context
Electronic mail
Guidelines
Sociology
Software
Software engineering
Design tools and techniques
computer-supported collaborative work
human factors in software design
software engineering process
Abstract: Ethnography is a qualitative research method used to study people and cultures. It is largely adopted in disciplines outside software engineering, including different areas of computer science. Ethnography can provide an in-depth understanding of the socio-technological realities surrounding everyday software development practice, i.e., it can help to uncover not only what practitioners do, but also why they do it. Despite its potential, ethnography has not been widely adopted by empirical software engineering researchers, and receives little attention in the related literature. The main goal of this paper is to explain how empirical software engineering researchers would benefit from adopting ethnography. This is achieved by explicating four roles that ethnography can play in furthering the goals of empirical software engineering: to strengthen investigations into the social and human aspects of software engineering; to inform the design of software engineering tools; to improve method and process development; and to inform research programmes. This article introduces ethnography, explains its origin, context, strengths and weaknesses, and presents a set of dimensions that position ethnography as a useful and usable approach to empirical software engineering research. Throughout the paper, relevant examples of ethnographic studies of software practice are used to illustrate the points being made.
Notes: interesting but about ethnography as technique to identify possible research


Reference Type:  Journal Article
Record Number: 9434
Author: Sen, A.
Year: 1997
Title: The role of opportunism in the software design reuse process
Journal: IEEE Transactions on Software Engineering
Volume: 23
Issue: 7
Pages: 418-436
Short Title: The role of opportunism in the software design reuse process
ISSN: 0098-5589
DOI: 10.1109/32.605760
Keywords: blackboard architecture
software libraries
software reusability
software tools
blackboard technology
cognitive model
collaborative design knowledge
demand-side software reuse
design schema
opportunism
protocol analysis
reuse library management system
software design reuse process
software development life cycle
structured description
task requirements
Collaborative software
Computer aided software engineering
Humans
Investments
Process design
Programming
Software design
Abstract: Software design involves translating a set of task requirements into a structured description of a computer program that will perform the task. A software designer can use design schema, collaborative design knowledge, or can reuse design artifacts. Very little has been done to include reuse of design artifacts in the software development life cycle, despite tremendous promises of reuse. As a result, this technique has not seen widespread use, possibly due to a lack of cognitive understanding of the reuse process. This research explores the role of a specific cognitive aspect, opportunism, in demand-side software reuse. We propose a cognitive model based on opportunism that describes the software design process with reuse. Protocol analysis verifies that the software design with reuse is indeed opportunistic and reveals that some software designers employ certain tasks of the reuse process frequently. Based on these findings, we propose a reuse support system that incorporates blackboard technology and existing reuse library management system


Reference Type:  Conference Paper
Record Number: 8184
Author: Passier, Harrie
Year: 2017
Title: The role of Procedural Guidance in Software Engineering Education
Conference Name: Companion to the first International Conference on the Art, Science and Engineering of Programming
Conference Location: Brussels, Belgium
Publisher: ACM
Pages: 1-2
DOI: 10.1145/3079368.3079398
Place Published: 3079398
Abstract: Designing and programming require several types of knowledge. Beside conceptual knowledge, procedural knowledge is of importance. Procedural knowledge, however, is often missed in courses about software design and implementation. As a consequence, students can easily be stuck and do not know how to proceed.

Considering software engineering as a complex task, the didactic approach 4C/ID is applicable. This approach prescribes that besides mental models, cognitive strategies should be learned, consisting of overall steps and rules and procedures per step. As an example, a procedure for designing and programming a concurrent program is briefly described. This procedure will scaffffold studentfis learning of concurrency concepts and their application.
Notes: students


Reference Type:  Conference Proceedings
Record Number: 9000
Author: Akhtar, A., Motla, Y. H., Aslam, H. and Jamal, M.
Year of Conference: 2014
Title: Role of requirement change in software architecture using Twin Peaks Model
Conference Name: 2014 IEEE 5th International Conference on Software Engineering and Service Science
Pages: 174-177
Date: 27-29 June 2014
Short Title: Role of requirement change in software architecture using Twin Peaks Model
ISBN: 2327-0586
DOI: 10.1109/ICSESS.2014.6933539
Keywords: formal specification
software architecture
Twin Peaks Model
requirement change management
software development
Analytical models
Computer architecture
Decision making
Object oriented modeling
Software
Unified modeling language
Requirement management
Abstract: Requirement change management is an important activity in software development. When we change our requirements it affects the other requirements of the system as well as the architecture of the system. It needs a proper approach which improves the requirement change management and its impact on architecture in a better way. In this paper a framework has been introduced which integrates the impact of requirement change in the software system by using Twin Peak Model. The expert review method is used to evaluate our research. This framework gives a better approach to measure the impact of a requirement change in the architecture of the system. Our research outcome is, to develop a framework by using Twin Peaks Model to analyze the changing requirement and gives the impact of these changes in requirements on software architecture designing. It will be helpful to manage changes in the software architecture.
Notes: process/framework


Reference Type:  Conference Proceedings
Record Number: 9478
Author: Shekaran, C., Garlan, D., Jackson, M., Mead, N. R., Potts, C. and Reubenstein, H. B.
Year of Conference: 1994
Title: The role of software architecture in requirements engineering
Conference Name: Proceedings of IEEE International Conference on Requirements Engineering
Pages: 239-245
Date: 18-22 Apr 1994
Short Title: The role of software architecture in requirements engineering
DOI: 10.1109/ICRE.1994.292379
Keywords: formal specification
professional aspects
systems analysis
application domain specialist
application-specific high-level design
high-level implementation constraints
problem definition
requirements engineer
requirements engineering
software architect
software architecture
software development process
solution structure
Computer architecture
Computer industry
Laboratories
Performance analysis
Programming
Reliability engineering
Shape
Software engineering
Software systems
Abstract: The role of software architecture (which reflects high-level implementation constraints) in requirements engineering is clarified by providing perspectives on relevant issues, including the following: is requirements engineering merely a front end to the software development process that is concerned only with problem definition? Is software architecture an application-specific, high-level design of a system (for example, &ldquo;an object-oriented system with a specified object hierarchy&rdquo;)? What is the relationship between the problem definition and the solution structure? What is the relationship between the roles of requirements engineer, software architect, and application domain specialist?


Reference Type:  Conference Proceedings
Record Number: 9494
Author: Laine, P. K.
Year of Conference: 2001
Title: The role of SW architecture in solving fundamental problems in object-oriented development of large embedded SW systems
Conference Name: Proceedings Working IEEE/IFIP Conference on Software Architecture
Pages: 14-23
Date: 2001
Short Title: The role of SW architecture in solving fundamental problems in object-oriented development of large embedded SW systems
DOI: 10.1109/WICSA.2001.948400
Keywords: embedded systems
object-oriented programming
software architecture
OO SW development
OO approach
SW architecture
conceptual problems
large embedded SW systems
methodological implications
object oriented SW development
Computer architecture
Embedded software
Embedded system
Failure analysis
Filling
Hardware
Laboratories
Large-scale systems
Performance analysis
Power system modeling
Abstract: The article approaches SW (software) architecture through the needs and problems of object oriented SW development. It is widely perceived that the OO approach, despite its generally acknowledged strengths, has so far failed to fully deliver its promises. Based on experiences from the development of several large embedded SW systems, an analysis of common practical and conceptual problems in OO SW development is performed and a solution is suggested The analysis indicates a need for SW architecture as a separate concept. The discussion of the solution concentrates on the nature of SW architecture in this context, on the methodological implications of combining SW architecture work with OO approach and on the role of the architecture task in the entirety of SW construction


Reference Type:  Conference Proceedings
Record Number: 9279
Author: Reece, M. J.
Year of Conference: 1985
Title: The Role of the Software Engineer in the System Design Process
Conference Name: MILCOM 1985 - IEEE Military Communications Conference
Volume: 2
Pages: 346-349
Date: 20-23 Oct. 1985
Short Title: The Role of the Software Engineer in the System Design Process
DOI: 10.1109/MILCOM.1985.4795049
Keywords: Communication system control
Control systems
Design engineering
Embedded computing
Embedded software
Embedded system
Hardware
Microprocessors
Power engineering and energy
Systems engineering and theory
Abstract: There presently exists a large and growing body of embedded computer systems, computers that perform some controlling function in a larger system such as a communications system. These embedded systems are often developed by project teams that do not contain the expertise of the software engineer in the beginning phases. This approach was appropriate when the technical nature of the embedded system development had a relatively small software component. Now, however, the availability of cheap, powerful, general-purpose microprocessors has moved software into a more critical role in the system design process. As a result, the engineering that used to be conducted in a hardware design atmosphere is now being conducted in a software design and programming environment and the skills and experience of the software engineer are needed in the beginning phases of the design process. This paper discusses some of the differences between software engineering and other branches of engineering, presents an approach for integrating software and firmware into the overall system design process and suggests possible risk reduction measures to use during the development process.
Notes: process oriented


Reference Type:  Conference Paper
Record Number: 7869
Author: Spichkova, Maria, Schmidt, Heinz and Trubiani, Catia
Year: 2017
Title: Role of women in software architecture: an attempt at a systematic literature review
Conference Name: Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings
Conference Location: Canterbury, United Kingdom
Publisher: ACM
Pages: 31-34
DOI: 10.1145/3129790.3129826
Place Published: 3129826
Notes: literature review


Reference Type:  Journal Article
Record Number: 8405
Author: El-Hassan, Osama and Fiadeiro, José Luiz
Year: 2007
Title: Role-based Architectural Modelling of Socio-Technical Systems
Journal: Electronic Notes in Theoretical Computer Science
Volume: 181
Pages: 5-17
Date: 6/27/
Short Title: Role-based Architectural Modelling of Socio-Technical Systems
ISSN: 1571-0661
DOI: https://doi.org/10.1016/j.entcs.2007.01.050
Keywords: Role-based Modelling
Software Architecture
Coordination
Abstract: The focus of this paper is on how a role-based architectural approach can contribute to building normative models for evolvable and adaptable socio-technical systems, i.e. systems in which both software components and people play well-defined roles and need to interact to ensure that required global properties emerge. We propose a method that is associated with a set of new modelling primitives anchored on organisational roles and governed by social laws that handle the situations that may arise when the people involved deviate from prescribed behaviour and fail to play the role that they have been assigned as entities of the system.
URL: https://www.sciencedirect.com/science/article/pii/S1571066107003659


Reference Type:  Conference Proceedings
Record Number: 9485
Author: Paulisch, F. and Zimmerer, P.
Year of Conference: 2010
Title: A role-based qualification and certification program for software architects: an experience report from Siemens
Conference Name: 2010 ACM/IEEE 32nd International Conference on Software Engineering
Volume: 2
Pages: 21-27
Date: 2-8 May 2010
Short Title: A role-based qualification and certification program for software architects: an experience report from Siemens
ISBN: 0270-5257
DOI: 10.1145/1810295.1810300
Keywords: certification
computer science education
educational courses
knowledge based systems
software architecture
Siemens report
business unit
international company
knowledge- experience-based certification
role-based certification program
role-based qualification
software architect
software engineering curriculum
Business
Computer architecture
Conferences
Qualifications
Software
Testing
curriculum
education
software engineering
training
Abstract: In this experience report, we describe the motivation, experience, lessons learned, and future directions of a software engineering curriculum used at a large international company. The "Curriculum for Software Engineers" project, which developed the content and a role-based qualification and certification program, was started at Siemens in 2006. This paper includes an overview of various kinds of certification in the software engineering area and why we chose the knowledge- and experience-based type of certification. The experience report part focuses mainly on the "certified senior software architect" role, as this role has the longest history and participants from many different business units and countries.


Reference Type:  Conference Proceedings
Record Number: 8809
Author: Gurp, J. van and Bosch, J.
Year of Conference: 2000
Title: SAABNet: Managing qualitative knowledge in software architecture assessment
Conference Name: Proceedings Seventh IEEE International Conference and Workshop on the Engineering of Computer-Based Systems (ECBS 2000)
Pages: 45-53
Date: 2000
Short Title: SAABNet: Managing qualitative knowledge in software architecture assessment
DOI: 10.1109/ECBS.2000.839860
Keywords: belief networks
software architecture
software performance evaluation
Belief Network
SAABNet
qualitative assessments
qualitative knowledge
software architecture assessment
software architectures
Bayesian methods
Computer architecture
Computer languages
Feedback
Feeds
Knowledge management
Probability
Q factor
Quality management
Abstract: Quantitative techniques have traditionally been used to assess software architectures. We have found that early in development process there is often insufficient quantitative information to perform such assessments. So far the only way to make qualitative assessments about an architecture, is to use qualitative assessment techniques such as peer reviews. The problem with this type of assessment is that they depend on the techniques knowledge of the expert designers who use them. In this paper we introduce a technique, SAABNet (Software Architecture Assessment Belief Network), that provides support to make qualitative assessments of software architectures
Notes: assess software architecture


Reference Type:  Journal Article
Record Number: 8552
Author: Upadhyay, Nitin
Year: 2016
Title: SDMF: Systematic Decision-making Framework for Evaluation of Software Architecture
Journal: Procedia Computer Science
Volume: 91
Pages: 599-608
Date: //
Short Title: SDMF: Systematic Decision-making Framework for Evaluation of Software Architecture
ISSN: 1877-0509
DOI: https://doi.org/10.1016/j.procs.2016.07.151
Keywords: Decision-making
software architecture
design decisions
pattern
software quality
TOPSIS
Abstract: The software architectural decisions are crucial and critical to the success of a software project life cycle. The set of relevant design decisions affects the quality of the software architecture. In this paper, a systematic decision-making framework is proposed by considering management and organizational factors and design goals/parameters that affect software architecture (SA) and integrating it with the technique for order preference by similarity to ideal solution (TOPSIS) to evaluate and select the quality software architecture. An illustrative case study is also mentioned to show the applicability of the proposed framework. The framework suggested in the paper should enable an architect and other key stakeholders of the software architecture to efficiently identify, evaluate and select the software architecture.
URL: https://www.sciencedirect.com/science/article/pii/S1877050916313448


Reference Type:  Conference Proceedings
Record Number: 9266
Author: Telschig, K., Schöffel, N., Schultis, K. B., Elsner, C. and Knapp, A.
Year of Conference: 2016
Title: SECO Patterns: Architectural Decision Support in Software Ecosystems
Conference Name: 2016 1st International Workshop on Decision Making in Software ARCHitecture (MARCH)
Pages: 38-44
Date: 5-5 April 2016
Short Title: SECO Patterns: Architectural Decision Support in Software Ecosystems
DOI: 10.1109/MARCH.2016.10
Keywords: decision making
decision support systems
ecology
environmental science computing
feature selection
software architecture
CoCoADvISE
SECO patterns
architectural decision support
high-level architecture
software design
software ecosystems
two-step decision support system
Biological system modeling
Computer architecture
Ecosystems
Organizations
Software
architectural decision
decision support system
seco pattern
Abstract: A software ecosystem challenges the architect through additional considerations, because multiple partners with different interests are involved. Therefore, the perspectives business, organization and high-level architecture need to be taken into account before deriving a detailed software design. In this paper, we present our vision and first results of SECO patterns, which capture solutions for recurring high-level problems in software ecosystems. They can be used standalone, but our vision also includes a two-step decision support system to aid the architect in two complex decisions: At first, it can propose relevant SECO patterns to support feature selection. The proposals are based on the specific characteristics of the software ecosystem of interest, which have to be provided by the architect. In a second step, the decision support system can aid the architect in applying a selected SECO pattern. For this step, we reuse the method and knowledge base of CoCoADvISE to provide guidance on decision making regarding the detailed software architecture.
Notes: decision support system


Reference Type:  Conference Proceedings
Record Number: 9586
Author: Liang, P., Jansen, A. and Avgeriou, P.
Year of Conference: 2008
Title: Selecting a High-Quality Central Model for Sharing Architectural Knowledge
Conference Name: 2008 The Eighth International Conference on Quality Software
Pages: 357-365
Date: 12-13 Aug. 2008
Short Title: Selecting a High-Quality Central Model for Sharing Architectural Knowledge
ISBN: 1550-6002
DOI: 10.1109/QSIC.2008.20
Keywords: software architecture
software quality
system documentation
architectural knowledge documentation
concept mapping relationships
design decisions
high-quality central model
indirect mapping approach
semantic distance
Astronomy
Computer architecture
Context modeling
Employment
Mathematical model
Mathematics
Programming
Quality management
architectural knowledge sharing
ontology matching
Abstract: In the field of software architecture, there has been a paradigm shift from describing the outcome of architecting process to documenting architectural knowledge (AK), such as design decisions and rationale. To this end, a series of domain models have been proposed for defining the concepts and their relationships in the field of AK. To a large extent, the merit of this new paradigm is derived by sharing and reusing AK across organizations, especially in geographically distributed contexts. However, the employment of different AK domain models by different parties makes effective AK sharing challenging, as it needs to be mapped either from one domain model to another directly, or indirectly through a central model for simplicity when the number of AK models increases. The indirect mapping approach has proved to be a cost-effective way by sacrificing acceptable sharing quality compared with direct mapping approach. However, there exist no criteria for the selection of a high quality central model besides the intuitive judgment by domain experts. In this paper, we propose to tackle this issue by using the concept of semantic distance between AK models, which is calculated using rules based on the concept mapping relationships between the models. A high quality central model is therefore the one with the shortest semantic distance to all potential AK models.
Notes: ADD tool


Reference Type:  Conference Proceedings
Record Number: 9144
Author: Poirot, P. e., Ren, S., Nogiec, J. and Tsai, J.
Year of Conference: 2006
Title: Separating Functional and Non-functional Concerns through Coordination: An Application to Reliability
Conference Name: 30th Annual International Computer Software and Applications Conference (COMPSAC'06)
Volume: 2
Pages: 63-66
Date: 17-21 Sept. 2006
Short Title: Separating Functional and Non-functional Concerns through Coordination: An Application to Reliability
ISBN: 0730-3157
DOI: 10.1109/COMPSAC.2006.163
Keywords: middleware
object-oriented programming
software architecture
software reliability
Actor Architecture
Actor model
component dynamicity
component-based coordination
computational components
computational coordinators
distributed system
functional concerns
nonfunctional concerns
nonfunctional requirements
reliability constraints
role-based coordination
system dependability
Application software
Computer architecture
Computer science
Control systems
Laboratories
Monitoring
Power system reliability
Software maintenance
System testing
Vehicle detection
Abstract: This paper presents a software architecture that ensures system dependability through external coordination. Under this architecture, a distributed system is decomposed into two types of entities, i.e., computational components and coordinators. The system's computational functionalities are carried out by computational components, whereas coordinators are to coordinate these computational components to respect the system's non-functional requirements, such as reliability constraints. Coordination in the system is done implicitly through intercepting, rerouting and suppressing communications between components. Additionally, roles are introduced into the system to bridge the connection between components and coordinators. Roles abstract the non-functional behaviors shared by computational components. Thus role-based coordination is more scalable than individual component-based coordination. Additionally, the dynamicity of components is concealed from the coordinators by the roles. A proof of concept implementation is built on top of the Actor Architecture, a middleware for distributed systems based on the Actor model by G. Aghal et al. (1997), The results show that not only such separation is feasible, but also that the architecture allows us to better control the dependability of the system. Finally, the application developed based on the proposed model is more modularized and consequently more reusable
Notes: System structure


Reference Type:  Conference Proceedings
Record Number: 9362
Author: Crowley, J. L.
Year of Conference: 2005
Title: Situated Observation of Human Activity
Conference Name: Computer Vision for Interactive and Intelligent Environment (CVIIE'05)
Pages: 97-108
Date: 17-18 Nov. 2005
Short Title: Situated Observation of Human Activity
DOI: 10.1109/CVIIE.2005.18
Keywords: Communications technology
Computer vision
Encoding
Humans
Information technology
Production
Real time systems
Software architecture
Streaming media
Video recording
Abstract: Many human activities follow a loosely defined script in which individuals assume roles. Encoding such scripts in a formal representation makes it possible to build systems that observe and understand human activity. In this paper, we first present a conceptual framework in which scripts for human activity are described as scenarios composed of actors and objects within a network of situations. We provide formal definitions for the underlying concepts for situation models, and then propose a layered, component-based, software architecture model for constructings systems to observe human activity. Both the conceptual framework and architectural model are illustrated with a system for real-time composition of a synchronized audio-video streams for recording activity within a meeting or lecture.
Notes: Systems to observe human behavior


Reference Type:  Conference Paper
Record Number: 8085
Author: Wirfs-Brock, Rebecca Jordan
Year: 2010
Title: Skills for the agile designer: seeing, shaping and discussing design ideas
Conference Name: Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion
Conference Location: Reno/Tahoe, Nevada, USA
Publisher: ACM
Pages: 323-326
DOI: 10.1145/1869542.1869630
Place Published: 1869630
Abstract: Agile teams incrementally develop solutions. So the pace of design work can be more intense and episodic. Agile designers need to be able to quickly see the essence of a problem and shape reasonable solutions. And when ideas don't pan out or require-ments shift, they must be comfortable revising their designs. This SPLASH tutorial introduces several techniques and some vocabu-lary for sharing design ideas, characterizing (and then designing to accommodate) variability, responding to design advice, and track-ing design work and technical debt.
Notes: tutorial


Reference Type:  Conference Paper
Record Number: 8161
Author: Zannier, Carmen and Maurer, Frank
Year: 2007
Title: Social Factors Relevant to Capturing Design Decisions
Conference Name: Proceedings of the Second Workshop on SHAring and Reusing architectural Knowledge Architecture, Rationale, and Design Intent
Publisher: IEEE Computer Society
Pages: 1
DOI: 10.1109/shark-adi.2007.12
Place Published: 1269071
Abstract: We present results from a qualitative study of design decision making that used interviews, observations and participatory observations to describe inherent traits of software design decision makers. We find that designers do not always strive for optimal design solutions, that designers do not always consider alternatives when making design decisions, and that alternatives are considered more often in groups of people having a casual conversation. We highlight that tool support for capturing design rationale and intent should first recognize the way decisions are inherently made in software environments and we provide a summary of our results as an indicator of requirements for such tools.


Reference Type:  Conference Paper
Record Number: 8084
Author: Bondi, Andre B.
Year: 2009
Title: The software architect as the guardian of system performance and scalability
Conference Name: Proceedings of the 2009 ICSE Workshop on Leadership and Management in Software Architecture
Publisher: IEEE Computer Society
Pages: 28-31
DOI: 10.1109/lmsa.2009.5074861
Place Published: 1564685
Abstract: System performance and scalability issues often have their roots in architectural and design choices that are made early in the software life cycle. Because he must communicate with developers, designers, product managers, business stake holders, application domain experts, testers, and requirements engineers, the software architect is uniquely placed to play a leadership role in linking performance requirements to business and engineering needs. Ideally, the architectural, technology, and design choices that are made should take performance requirements and artifacts into account. This means that the architect should be equipped with at least a rudimentary understanding of performance engineering concepts. Ideally, an architect should be directly involved in performance concerns. Failing that, he should overtly give a mandate to and remain in close contact with a performance engineer to do this instead, because close architectural involvement with performance concerns is key to the success of the project.


Reference Type:  Conference Paper
Record Number: 7900
Author: McBride, Matthew R.
Year: 2004
Title: The software architect: essence, intuition, and guiding principles
Conference Name: Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Conference Location: Vancouver, BC, CANADA
Publisher: ACM
Pages: 230-235
DOI: 10.1145/1028664.1028764
Place Published: 1028764
Abstract: Software architecture is a distinct and developing discipline in the software profession. Many practitioners have apparently entered the field with little effort; adding the word "architect" to a title is easy to do. However, beneath the surface appearance, distinct approaches and toolsets are required to succeed. Reports of IT overspending and project failures emphasize the fact that these skills must be leveraged and developed. The practical application of this growing body of knowledge will continue to play an important role in the maturing of our profession, and its ability to deliver effective solutions. The software architect possesses a unique perspective and mental framework that guides the development of software systems. Additionally, strong interpersonal skills are vital to the software architect's success. In this paper, I explore the unique approaches and characteristics of the successful software architect.


Reference Type:  Journal Article
Record Number: 9210
Author: Mateosian, R.
Year: 2009
Title: Software Architects [review of 97 Things Every Software Architect Should Know: Collective Wisdom from the Experts (Monson-Haefel, R., Ed.; 2009)]
Journal: IEEE Micro
Volume: 29
Issue: 3
Pages: 62-64
Short Title: Software Architects [review of 97 Things Every Software Architect Should Know: Collective Wisdom from the Experts (Monson-Haefel, R., Ed.; 2009)]
ISSN: 0272-1732
DOI: 10.1109/MM.2009.47
Keywords: Auditory system
Biographies
Books
Documentation
Java
Message service
Project management
Risk management
Rivers
Stress
development tools
software architecture
software design
Abstract: Richard Mateosian reviews this book that offers nuggets of information to anyone who designs software. Nearly 50 people contribute their ideas. Each entry fills two facing pages and includes a contributor photo and brief biography. Most of the ideas fall into the following themes: communication; requirements; pitfalls; design and development approaches; performance and maintenance; tools and techniques; and the necessary quality or skills of software architects.
Notes: Book review...


Reference Type:  Journal Article
Record Number: 9391
Author: Hohpe, G., Ozkaya, I., Zdun, U. and Zimmermann, O.
Year: 2016
Title: The Software Architect's Role in the Digital Age
Journal: IEEE Software
Volume: 33
Issue: 6
Pages: 30-39
Short Title: The Software Architect's Role in the Digital Age
ISSN: 0740-7459
DOI: 10.1109/MS.2016.137
Keywords: Ericsson
architecture as a service
connected vehicles
decision making
embedded software
software architect
software architecture
software development
software engineering
software engineering education
Abstract: Internet scale, the increasing rate of technology evolution, and the broad adoption of lean and agile methods have triggered a profound change in not only application and infrastructure architectures but also the software architect's roles and responsibilities. This article reviews the field's state of the art, identifies the skills of the connected architect, and gives an overview of related education programs and knowledge sources.


Reference Type:  Conference Proceedings
Record Number: 9416
Author: Wolff, E.
Year of Conference: 2012
Title: Software architecture &#x2014; What does it mean in industry? (Invited industrial talk)
Conference Name: 2012 34th International Conference on Software Engineering (ICSE)
Pages: 999-999
Date: 2-9 June 2012
Short Title: Software architecture &#x2014; What does it mean in industry? (Invited industrial talk)
ISBN: 0270-5257
DOI: 10.1109/ICSE.2012.6227250
Abstract: Summary form only given. As communications get embedded in any objects we will see more and more instances of services and information seamlessly coupled to objects. Kindle has been the forerunner and we are going to see many more kind of objects being connected to the Internet. This will create a new slate of opportunities for many companies and Telecom Operators will be able to have a significant and economically relevant role in this space. The talk will address the technologies enabling this transformation and the evolution in value chains that may result emphasizing the role of Telecom Operators in this transformation. A concrete example of a territorial transformation taking place in Trento, Italy, will be given. This example may be discussed to evaluate the extent to which it can be applied in different context.
Notes: talk...


Reference Type:  Journal Article
Record Number: 8430
Author: Vishnyakov, Andrei and Orlov, Sergey
Year: 2015
Title: Software Architecture and Detailed Design Evaluation
Journal: Procedia Computer Science
Volume: 43
Pages: 41-52
Date: //
Short Title: Software Architecture and Detailed Design Evaluation
ISSN: 1877-0509
DOI: https://doi.org/10.1016/j.procs.2014.12.007
Keywords: Architectural patterns
Architecture efficiency
Metric suite selection
Functional points
Coupling and cohesion
Abstract: Software design and estimation play the key role for software development process. Different methods are used for architecture design and detailed design evaluation. For architectural design stage a technique that allows selecting and evaluating suite of architectural patterns is proposed. It allows us to consistently evaluate the impact of specific patterns to software characteristics with a given functionality. Also the criterion of efficiency metric is proposed which helps us to evaluate architectural patterns for specified software. During detailed design stage we are interested in the selection of the optimal metric suits which takes into account the characteristics of required system. The proposed technique contains a number a steps where at each step a specific criterion should be used to make a selection from the available metric suites. In the end we can perform the selected metric suite improvement.
URL: https://www.sciencedirect.com/science/article/pii/S1877050914015750


Reference Type:  Conference Paper
Record Number: 8080
Author: Kruchten, Phillippe
Year: 1995
Title: Software architecture and iterative development process
Conference Name: Tutorial proceedings on TRI-Ada '91: Ada's role in global markets: solutions for a changing complex world
Conference Location: Anaheim, California, USA
Publisher: ACM
Pages: 491-539
DOI: 10.1145/216591.216609
Place Published: 216609
Abstract: This tutorial has two parts.

Part 1 deals with the "why" and "what". We introduce the concept of software architecture, its boundaries, and its motivation. We propose a model to represent the architecture of software-intensive systems, using multiple views or blueprints. For each view: conceptual, dynamic, static, physical, we detail the elements involved, a view-specific notation, and its relations with other views.

Part 2 deals with the "how" and "who". An iterative process is described to develop and validate a software architecture. We then examine the organizational aspects related to software architecture and in particular the role of an architect or an architecture team.

The tutorial is based on practical experience in the development of large, software intensive systems in the areas of aerospace, defense, command and control, and telecommunications over the last fifteen years, and the examples are derived from telecommunication and air traffic control systems. 
Notes: tutorial..


Reference Type:  Conference Proceedings
Record Number: 9645
Author: Kang, M. H. and Froscher, J. N.
Year of Conference: 2000
Title: Software architecture and logic for secure applications
Conference Name: DARPA Information Survivability Conference and Exposition, 2000. DISCEX '00. Proceedings
Volume: 1
Pages: 391-405 vol.1
Date: 2000
Short Title: Software architecture and logic for secure applications
DOI: 10.1109/DISCEX.2000.825042
Keywords: military computing
security of data
software architecture
software reliability
workflow management software
classification domains
coalition partners
distributed program monitoring
emergency response organizations
enterprise application
globally distributed user coordination
local law enforcement
military missions
mission critical operations
multilevel mission logic programming
multilevel secure systems
survivability
workflow application
Access control
Application software
Business
Information technology
Laboratories
Logic
Mission critical systems
Monitoring
Multilevel systems
Abstract: Today's military supports many different missions as well as the traditional role of national defense. This diversity means that these systems must be easily configurable to accommodate integration with coalition partners all over the world and with local law enforcement and emergency response organizations, and secure and survivable to ensure the success of the military mission. Commercial workflow and enterprise application integration products provide solutions to similar problems in the commercial world. However these products cannot satisfy the military because they lack security and survivability features. DoD needs multilevel secure (MLS) and survivable systems and tools that allow users to program multilevel mission logic, securely coordinate globally distributed users and existing applications, and monitor the progress of the distributed program across classification domains. This paper summarizes an effort to provide a methodology and tools to support mission critical operations
Notes: mission criticla tools for military


Reference Type:  Conference Paper
Record Number: 7936
Author: Medvidovic, Nenad
Year: 2008
Title: Software architecture and mobility: a perfect marriage or an uneasy alliance?
Conference Name: Proceedings of the 1st international workshop on Software architectures and mobility
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 1-1
DOI: 10.1145/1370888.1370889
Place Published: 1370889
Abstract: Developments in the area of software architecture over the past decade have pushed it to the forefront of a number of critical software engineering activities: modeling, design, analysis, simulation, implementation, deployment, and evolution. Architecture is advocated as an effective conceptual tool for addressing the many challenges of developing large, complex, distributed systems. Largely in parallel to these developments, significant advances have also been made in the domain of mobile computing. Many mobile systems are also large, complex, and distributed, yet a majority of the advances in this domain appear not to have resulted from an explicit software architectural focus. Despite this, architecture appears to offer clear benefits in this domain, as evidenced by some recent approaches. In this talk, I will overview the state-of-the-art in the area of mobile computing, with a specific focus on the role software architecture should and does play in this domain. I will highlight the characteristics of software architectures as well as specific architecture-based approaches that make them particularly suitable to developing mobile systems. I will also highlight several impediments, both real and perceived, to the wholesale adoption of architectural principles in this area.
Notes: specific architecture in mobile


Reference Type:  Conference Proceedings
Record Number: 9398
Author: Krishnamurthy, B.
Year of Conference: 1994
Title: Software architecture and reuse-an inherent conflict?
Conference Name: Proceedings of 1994 3rd International Conference on Software Reuse
Pages: 215
Date: 1-4 Nov. 1994
Short Title: Software architecture and reuse-an inherent conflict?
DOI: 10.1109/ICSR.1994.365798
Keywords: software engineering
software reusability
application system
architectural styles
design
documents
experience
reusable assets
scripts
software architecture
software reuse
specification
Assembly
Asset management
Computer architecture
Packaging
Software libraries
Software packages
Stability
Abstract: Summary form only. Software architecture is loosely defined as the packaging of functions and objects, together with their interface, and control to implement applications in a domain. An accepted model of software reuse consists of taking a library of reusable assets, instituting a reuse process that permits augmentation of the assets in a supportive environment and providing deliverables via a streamlined development process. Classification of reusable libraries aids in packaging of objects/functions. Given the proper consideration at an earlier (architectural) level it is possible to attain large scale reuse. Without well understood constraints there is little possibility of a high degree of reuse. Role separation and constraints provide the needed stability for reuse. One way to view architecture is as a collection of architectural styles and services. An architectural style helps in arranging the components. The services support the non-functional requirements of the architectural styles. Thus to increase reuse the key is to identify a set of styles and services and combine them appropriately. Besides code, other reusable entities include scripts, documents, design, experience, specification, and application system. Reusability of specification often leads to reusable software components. Architectural constraints may dictate what components may be reused and availability of reused entities may enhance the stability of the architecture.<<ETX>>
Notes: architecture focus


Reference Type:  Conference Paper
Record Number: 7967
Author: Medvidovi, Nenad and #263
Year: 2012
Title: Software architecture challenges and opportunities for the 21st century: dynamism, mobility, autonomy, services, grids, and clouds
Conference Name: Proceedings of the 5th India Software Engineering Conference
Conference Location: Kanpur, India
Publisher: ACM
Pages: 1-1
DOI: 10.1145/2134254.2134255
Place Published: 2134255
Abstract: Developments in the area of software architecture over the past two decades have pushed architecture to the forefront of a number of critical software engineering activities: modeling, design, analysis, simulation, implementation, deployment, maintenance, and evolution. Architecture is advocated as an effective conceptual tool for addressing the many challenges of developing large, complex, distributed systems. Largely in parallel to these developments, significant advances have also been made in the domains of mobile, autonomic, service-oriented, grid-based, and most recently, cloud-based computing. The systems in these domains are also large, complex, and distributed; they are frequently expected to dynamically adapt to failures as well as changing requirements and execution contexts. At first blush, a number of the advances in these domains appear not to have resulted from an explicit software architectural focus. However, I posit that architecture offers clear, and often critical, benefits in these domains. In support of this argument, I will overview the state-of-the-art in the areas of mobile, autonomic, service-oriented, grid-based, and cloud-based computing; with a specific focus on the role software architecture should and actually does play in these domains. I will highlight the characteristics of software architectures as well as specific architecture-based approaches that make them particularly suitable to developing these systems.


Reference Type:  Conference Proceedings
Record Number: 9307
Author: Dasanayake, S., Markkula, J., Aaramaa, S. and Oivo, M.
Year of Conference: 2015
Title: Software Architecture Decision-Making Practices and Challenges: An Industrial Case Study
Conference Name: 2015 24th Australasian Software Engineering Conference
Pages: 88-97
Date: Sept. 28 2015-Oct. 1 2015
Short Title: Software Architecture Decision-Making Practices and Challenges: An Industrial Case Study
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2015.20
Keywords: decision making
knowledge management
software architecture
Europe
software architecture decision-making
software system
system life cycle
systematic software development method
Computer architecture
Context
Software
Systematics
architecture decision making
architecture knowledge management
case study
Abstract: Software architecture decision-making is critical to the success of a software system as software architecture sets the structure of the system, determines its qualities, and has far-reaching consequences throughout the system life cycle. The complex nature of the software development context and the importance of the problem has led the research community to develop several techniques, tools, and processes to assist software architects in making better decisions. Despite these effort, the adoption of such systematic approaches appears to be quite limited in practice. In addition, the practitioners are also facing new challenges as different software development methods suggest different approaches for architecture design. In this paper, we study the current software architecture decision-making practices in the industry using a case study conducted among professional software architects in three different companies in Europe. As a result, we identified different software architecture decision-making practices followed by the software teams as well as their reasons for following them, the challenges associated with them, and the possible improvements from the software architects' point of view. Based on that, we recognized that improving software architecture knowledge management can address most of the identified challenges and would result in better software architecture decision-making.
'File' Atttachments: internal-pdf://3495049590/Software Architecture Decision-Making Practice.pdf


Reference Type:  Conference Proceedings
Record Number: 7724
Author: Knodel, J. and Naab, M.
Year of Conference: 2014
Title: Software Architecture Evaluation in Practice: Retrospective on More Than 50 Architecture Evaluations in Industry
Conference Name: 2014 IEEE/IFIP Conference on Software Architecture
Pages: 115-124
Date: 7-11 April 2014
Short Title: Software Architecture Evaluation in Practice: Retrospective on More Than 50 Architecture Evaluations in Industry
DOI: 10.1109/WICSA.2014.37
Keywords: software architecture
architecture work
industrial customers
industrial perspective
practical perspective
scientific community
software architecture evaluation
Companies
Computer architecture
Concrete
Context
Documentation
architecture evaluation
empirical evidences
experience report
Abstract: Architecture evaluation has become a mature sub-discipline in architecting with high-quality practical and scientific literature available. However, publications on industrial applications and concrete experiences are rare. We want to fill this gap and share our experiences - having performed more than 50 architecture evaluations for industrial customers in the last decade. We compiled facts and consolidated our findings about architecture evaluations in industry. In this paper, we provide a critical retrospective on more than 50 projects and share our lessons learned. This industrial and practical perspective allows practitioners to benefit from our experience in their daily architecture work and scientific community to focus their research work on the generalizability of our findings.
Notes: Literature review


Reference Type:  Conference Proceedings
Record Number: 9019
Author: Krishna, V. and Basu, A.
Year of Conference: 2012
Title: Software Architecture for large/critical applications
Conference Name: 2012 CSI Sixth International Conference on Software Engineering (CONSEG)
Pages: 1-4
Date: 5-7 Sept. 2012
Short Title: Software Architecture for large/critical applications
DOI: 10.1109/CONSEG.2012.6349514
Keywords: formal specification
project management
software architecture
software management
software quality
business requirement
critical application
large application
project failure rate
quality related aspect
software requirements
software system
system development
technology evolution
Business
Complexity theory
Computer architecture
Noise
Scalability
Software
Agility
Large critical applications
Plan driven
Abstract: Software Architecture provides a blue print for developing a system and plays a vital role in addressing quality related aspects such as performance, security, scalability etc. [1]. Architecture of a software system has to ensure that design is able to support all requirements as well as able to incorporate any changes requested by the customer. This paper discusses the role of architecture and design on project failure rate and also suggests the steps that need to be added in architecture and design in order to cope up with changes in business requirements and evolution of technology to avoid such failures.


Reference Type:  Journal Article
Record Number: 8625
Author: Manavazhi, Mohan R.
Year: 2001
Title: A software architecture for the virtual construction of structures
Journal: Advances in Engineering Software
Volume: 32
Issue: 7
Pages: 545-554
Date: 7//
Short Title: A software architecture for the virtual construction of structures
ISSN: 0965-9978
DOI: https://doi.org/10.1016/S0965-9978(01)00005-9
Keywords: Structural construction simulation
Object-oriented simulation
Object-oriented architecture
Automated model generation
Structural construction analysis
Abstract: In addition to being a tedious procedure, the complexity of structural construction makes the task of manually generating simulation models quite complicated. The paucity of simulation expertise in the construction industry exacerbates the problem. This research addresses the issue through the development of a generic system architecture that would facilitate the creation of automated model generators for structural construction. The architecture is based on the object-oriented programming paradigm, which supports the use of modularity and hierarchy in the software development process. The generic system architecture developed in this research was used to create an automated model generator for automatically generating and executing a simulation model for the construction of an earth-filled embankment. The simulation results obtained were compared with those obtained through the execution of a manually generated simulation model. A trace obtained from the execution of the automatically generated simulation model was also studied. Both the comparison and the trace tests conducted demonstrated the satisfactory functioning of the automated model generator.
Notes: automated model generation
URL: https://www.sciencedirect.com/science/article/pii/S0965997801000059


Reference Type:  Conference Proceedings
Record Number: 8780
Author: Soni, D., Nord, R. L. and Hofmeister, C.
Year of Conference: 1995
Title: Software Architecture in Industrial Applications
Conference Name: 1995 17th International Conference on Software Engineering
Pages: 196-196
Date: 23-30 April 1995
Short Title: Software Architecture in Industrial Applications
ISBN: 0270-5257
DOI: 10.1145/225014.225033
Keywords: Application software
Computer industry
Software architecture
Software engineering
Abstract: To help us identify and focus on pragmatic and concrete issues related to the role of software architecture in large systems, we conducted a survey of a variety of software systems used in industrial applications. Our premise, which guided the examination of these systems, was that software architecture is concerned with capturing the structures of a system and the relationships among the elements both within and between structures. The structures we found fell into several broad categories: conceptual architecture, module interconnection architecture, code architecture, and execution architecture. These categories address different engineering concerns. The separation of such concerns, combined with specialized implementation techniques, decreased the complexity of implementation, and improved reuse and reconfiguration.


Reference Type:  Conference Proceedings
Record Number: 9439
Author: Vliet, H. v.
Year of Conference: 2008
Title: Software Architecture Knowledge Management
Conference Name: 19th Australian Conference on Software Engineering (aswec 2008)
Pages: 24-31
Date: 26-28 March 2008
Short Title: Software Architecture Knowledge Management
ISBN: 1530-0803
DOI: 10.1109/ASWEC.2008.4483186
Keywords: knowledge management
software architecture
architectural knowledge
system development
system evolution
Computer architecture
Computer industry
Computer science
Connectors
Finance
Road transportation
Software engineering
Wiring
Abstract: Software architecture is a recognized and indispensable part of system development. Software architecture is often defined in terms of components and connectors, or the "high-level conception of a system". In recent years, there has been an awareness that not only the design itself is important to capture, but also the knowledge that has led to this design. This so-called architectural knowledge concerns the set of design decisions and their rationale. Capturing architectural knowledge is difficult. Part of it is tacit and difficult to verbalize. Like developers, software architects are not inclined to document their solutions. Establishing ways to effectively manage and organize architectural knowledge is one of the key challenges of the field of software architecture. This architectural knowledge plays a role during development, when architects, developers, and other stakeholders must communicate about the system to be developed, possibly in a global setting. It also plays a role during the evolution of a system, when changes are constrained by decisions made earlier.


Reference Type:  Conference Proceedings
Record Number: 9457
Author: Mirakhorli, M.
Year of Conference: 2015
Title: Software architecture reconstruction: Why? What? How?
Conference Name: 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER)
Pages: 595-595
Date: 2-6 March 2015
Short Title: Software architecture reconstruction: Why? What? How?
ISBN: 1534-5351
DOI: 10.1109/SANER.2015.7081885
Keywords: software architecture
software maintenance
system recovery
legacy system
software architecture reconstruction
software architecture recovery
software engineering
software system implementation-level artifact
Companies
Computational modeling
Computer architecture
Software
Tutorials
Abstract: Software architecture reconstruction plays an increasingly essential role in software engineering tasks such as architecture renovation, program comprehension, and change impact analysis. Various methods have been developed which use a software system's implementation-level artifacts to recover the architecture of the software. This tutorial will answer three fundamental questions about software architecture recovery: Why? What? and How? Through several examples it articulates and synthesizes technical forces and financial motivations that make software companies to invest in software architecture recovery. It discusses what are the pieces of design knowledge that can be recovered and lastly demonstrates a methodology as well as required tools for answering how to reconstruct architecture from implementation artifacts.
Notes: Tutorial


Reference Type:  Journal Article
Record Number: 8712
Author: Tang, Antony and Lau, Man F.
Year: 2014
Title: Software architecture review by association
Journal: Journal of Systems and Software
Volume: 88
Pages: 87-101
Date: 2//
Short Title: Software architecture review by association
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2013.09.044
Keywords: Software architecture review
Design reasoning
Verification of software architecture
Abstract: During the process of software design, software architects have their reasons to choose certain software components to address particular software requirements and constraints. However, existing software architecture review techniques often rely on the design reviewers’ knowledge and experience, and perhaps using some checklists, to identify design gaps and issues, without questioning the reasoning behind the decisions made by the architects. In this paper, we approach design reviews from a design reasoning perspective. We propose to use an association-based review procedure to identify design issues by first associating all the relevant design concerns, problems and solutions systematically; and then verifying if the causal relationships between these design elements are valid. Using this procedure, we discovered new design issues in all three industrial cases, despite their internal architecture reviews and one of the three systems being operational. With the newly found design issues, we derive eight general design reasoning failure scenarios.
URL: https://www.sciencedirect.com/science/article/pii/S0164121213002409


Reference Type:  Conference Proceedings
Record Number: 9033
Author: Zayaraz, G. and Thambidurai, P.
Year of Conference: 2005
Title: Software Architecture Selection Framework Based on Quality Attributes
Conference Name: 2005 Annual IEEE India Conference - Indicon
Pages: 167-170
Date: 11-13 Dec. 2005
Short Title: Software Architecture Selection Framework Based on Quality Attributes
ISBN: 2325-940X
DOI: 10.1109/INDCON.2005.1590147
Keywords: Decision Making
Quality Attributes
Requirements
Software Architecture
Computer architecture
Decision support systems
Educational institutions
Failure analysis
Security
Software quality
Software systems
Abstract: Software Architectures are generally designed with particular functional and nonfunctional requirements. Organizations often need to choose Software Architecture for future development from several competing candidate architectures. The various Stakeholders' quality requirements need to be considered collectively to describe the quality requirements of the envisioned system and therefore build the basis for the comparison and selection criteria. Choosing Software Architecture for any system still remains a difficult task as many different stake holders are involved in the selection process. Stakeholders view on quality requirements is different and at times they can also be conflicting in nature. Existing software architecture selection methods [1, 2, 3, 4] have been analyzed to identify their limitations. To overcome the limitations and challenges, a selection framework has been proposed and validated based on multiattribute decision making using Hypothetical Equivalents [7]. The proposed framework provides the rationale for an architecture selection process by comparing the fitness of competing candidate architectures for the envisioned system based on the quality requirements of different Stakeholders.


Reference Type:  Conference Proceedings
Record Number: 8925
Author: Majidi, E., Alemi, M. and Rashidi, H.
Year of Conference: 2010
Title: Software Architecture: A Survey and Classification
Conference Name: 2010 Second International Conference on Communication Software and Networks
Pages: 454-460
Date: 26-28 Feb. 2010
Short Title: Software Architecture: A Survey and Classification
DOI: 10.1109/ICCSN.2010.94
Keywords: software architecture
software complexity
software management
Communication system software
Computer architecture
Conference management
Connectors
Control systems
Qualifications
Software design
Software quality
Software systems
Quality properties
Styles software
Abstract: As software systems enlarges, software complexity increases and controlling of the software management will be highly important. Systems are decomposed into many components, of which their organization shows new problems in software architecture. Selecting appropriate components for system architecture plays an important role in success or failure of software. This paper reviews the old and present styles of software architecture and presents a survey on classification of the styles. In this survey, advantages and disadvantages of three kinds of classifications are analyzed, and some criterions for choosing a suitable style in different applications are also presented.
Notes: focus on software architecture


Reference Type:  Conference Proceedings
Record Number: 9247
Author: Abolhassani, H., Hui, Chen, Far, B. H. and Koono, Z.
Year of Conference: 1999
Title: Software creation: detail of human design knowledge and it's application to automatic software design
Conference Name: Software Engineering Conference, 1999. (APSEC '99) Proceedings. Sixth Asia Pacific
Pages: 412-419
Date: 1999
Short Title: Software creation: detail of human design knowledge and it's application to automatic software design
DOI: 10.1109/APSEC.1999.809631
Keywords: automatic programming
computer aided software engineering
knowledge based systems
learning (artificial intelligence)
user modelling
automatic design learning human designer
automatic software design
design rule
design rules
dictionary type definitions
hierarchical detailing
hierarchical work process
human concept
human design knowledge
human mental operations
knowledge model
lower level structure
micro design rules
software creation
software organization
Application software
Artificial intelligence
Dictionaries
Humans
Intelligent structures
Intelligent systems
Knowledge engineering
Process design
Software design
Software engineering
Abstract: The paper reports on results of a study aiming at establishing a fundamental basis for automating design of any kind of software. Considering the final object, an automatic design learning human designer has been taken. An excellent software organization with high maturity has been taken as the expert, and the hierarchical work process is the knowledge model. For detailing, the major operations are made by hierarchical detailing. Namely, a software design may be reduced hierarchically to various design rules, which are parent and children relationship of a human concept created during expansion of a piece of design to more detailed form. To know the inside of human mental operations generating a design rule, a more detailed study was made and it was found that a design rule may be further reduced hierarchically to some fundamental human mental operations, called micro design rules. They represent basic operations during a design. After reporting them, a discussion on further lower level structure used during them, which are dictionary type definitions is made
Notes: automatic design


Reference Type:  Conference Paper
Record Number: 8176
Author: Medvidovic, Nenad and Malek, Sam
Year: 2007
Title: Software deployment architecture and quality-of-service in pervasive environments
Conference Name: International workshop on Engineering of software services for pervasive environments: in conjunction with the 6th ESEC/FSE joint meeting
Conference Location: Dubrovnik, Croatia
Publisher: ACM
Pages: 47-51
DOI: 10.1145/1294904.1294911
Place Published: 1294911
Abstract: Over the past several years we have investigated two problems related to the domain of highly distributed, mobile, resource constrained, embedded, and pervasive environments: software deployment and quality of service (QoS). We have done so with the explicit focus on the role played by software architecture in deployment, and on its relationship to QoS. In the process, we have amassed a body of knowledge and experience, and assembled a suite of solutions for targeting different facets of the interplay among software architecture, deployment, and QoS. At the same time, the area we are addressing has proven to be multi-faceted and very complex, constantly presenting new challenges. In this paper we outline the contours of the problem of QoS in architecture-based deployment, our strategy for addressing it, and the challenges that remain. We view this as an important (and fruitful) area of research.
Notes: Focus on specific architecture


Reference Type:  Journal Article
Record Number: 8960
Author: Budgen, D.
Year: 1999
Title: Software design methods: life belt or leg iron?
Journal: IEEE Software
Volume: 16
Issue: 5
Pages: 136, 133-135
Short Title: Software design methods: life belt or leg iron?
ISSN: 0740-7459
DOI: 10.1109/52.795114
Keywords: software engineering
technological forecasting
future
risk
software design methods
software development process
software process deterioration
software process improvement
suboptimum solutions
Belts
Design methodology
Hazards
Humans
Iron
Leg
Problem-solving
Process design
Programming
Software design
Abstract: Do software design methods have a future? The issue I explore in this article is concerned with the problems that the use of design methods can present. It can be expressed as a question: &ldquo;Will the adoption of a design method help the software development process (the `life belt' role), or is there significant risk that its use will lead to suboptimum solutions (the `leg iron' role)?&rdquo; (I use &ldquo;method&rdquo; to mean &ldquo;a way of doing something&rdquo;, rather than using the more pretentious-sounding &ldquo;methodology&rdquo;, which more correctly means &ldquo;study of methods&rdquo;). To address, but not necessarily answer, this question, I first consider what designing involves in a wider context, and then compare this with what we do, and finally consider what this might imply for the future


Reference Type:  Journal Article
Record Number: 9517
Author: Kuhn, S.
Year: 1998
Title: The software design studio: an exploration
Journal: IEEE Software
Volume: 15
Issue: 2
Pages: 65-71
Short Title: The software design studio: an exploration
ISSN: 0740-7459
DOI: 10.1109/52.663788
Keywords: computer science education
continuing education
professional aspects
software engineering
teaching
building design
design media
design patterns
design solutions
development practices
heterogeneous issues
informal critique
nontechnical aspects
open ended problems
project based work
software design studio
software designers
software implications
software practice
software practitioners
software professionals
studio course
usability
user needs
very rapid iteration
work practices
Computer architecture
Control engineering education
Engineering education
Fellows
Proposals
Prototypes
Psychology
Reflection
Software design
Time factors
Abstract: Some software designers have recently turned for inspiration to the process of building design to improve development practices and increase software's usefulness and effectiveness. Architects' education revolves around the studio course, which promotes: project based work on complex and open ended problems; very rapid iteration of design solutions; frequent formal and informal critique; consideration of heterogeneous issues; the use of precedent and thinking about the whole; the creative use of constraints; and the central importance of design media. M. Kapor (1991) suggested that software practitioners needed to &ldquo;rethink the fundamentals of how software is made&rdquo; and proposed the architect's role in building design as a fruitful analogy for software professionals seeking to reform software practice. This analogy helps us focus on usefulness, usability, user needs and practices, and other technical and nontechnical aspects of good software design. It highlights concerns about people's lives and work practices and how people &ldquo;inhabit&rdquo; systems. Several authors have explored similarities and differences between software design and building design, including some who have pursued the software implications of architect Christopher Alexander's design patterns
Notes: tool


Reference Type:  Conference Paper
Record Number: 8017
Author: Shani, Uri and Sela, Aviad
Year: 2008
Title: Software design using UML for empowering end-users with an external domain specific language
Conference Name: Proceedings of the 4th international workshop on End-user software engineering
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 52-55
DOI: 10.1145/1370847.1370859
Place Published: 1370859
Abstract: Domain Specific Languages (DSL) also known as "small languages" lack the power of a general purpose language (GPL), but are very productive for the purpose they are designed. While "internal" DSLs require and rely on the use of a hosting GPL, "external" DSLs are independent of a GPL and are thus more suitable for the non-programmer - but domain expert - end-user. Empowering this end-user via DSLs is our prime goal as software designers and architects. Our product will be stronger since much of the final tuning of the application can be done by the end-user and will reduce the number of software revisions that require stringent GPL software testing and validations. As software engineers, the design of a DSL as part of our product should fit into the tools of the trade of software development. We adopt UML for this purpose and propose that the design of DSL can be embedded as an extension of the traditional software modeling and design tools. In this paper we present firstly a view of software development process in which DSLs are an integral part, and than how we use UML to design a DSL which, via empowering a domain expert end-user, achieves challenging software delivery requirements with good stability and excellent performance.
Notes: tool development


Reference Type:  Conference Paper
Record Number: 7970
Author: Dickover, Melvin E., McGowan, Clement L. and Ross, Douglas T.
Year: 1977
Title: Software design using: SADT
Conference Name: Proceedings of the 1977 annual conference
Conference Location: Seattle, Washington
Publisher: ACM
Pages: 125-133
DOI: 10.1145/800179.810192
Place Published: 810192
Abstract: SADT TM, Structured Analysis and Design Technique, is a graphical language for describing systems. In this paper we indicate the role of SADT in software design. The graphical language provides a powerful design vocabulary in which a designer can concisely and unambiguously express his design. SADT is compatible with widely used contemporary design methodologies including Structured Design and the Jackson method.
Notes: Design technique


Reference Type:  Conference Paper
Record Number: 8189
Author: Kashyap, Divya and Misra, A. K.
Year: 2013
Title: Software development cost estimation using similarity difference between software attributes
Conference Name: Proceedings of the 2013 International Conference on Information Systems and Design of Communication
Conference Location: Lisboa, Portugal
Publisher: ACM
Pages: 1-6
DOI: 10.1145/2503859.2503860
Place Published: 2503860
Abstract: Although software industry has seen a tremendous growth and expansion since its birth, it is continuously facing problems in its evolution. The major challenge for this industry is to produce quality software which is timely designed and build with proper cost estimates. Thus the techniques for controlling the quality and predicting cost of software are in the center of attention for many software firms. In this paper, we have tried to propose a cost estimation model based on Multiobjective Particle Swarm Optimization (MPSO) to tune the parameters of the famous COstructive COst MOdel (COCOMO). This cost estimation model is integrated with Quality Function Deployment (QFD) methodology to assist decision making in software designing and development processes for improving the quality. This unique combination will help the project managers to efficiently plan the overall software development life cycle of the software product.
Notes: Cost estimation technique


Reference Type:  Journal Article
Record Number: 9222
Author: Faber, D. J.
Year: 1975
Title: Software Development for Distributed Systems
Journal: Computer
Volume: 8
Issue: 6
Pages: 68-69
Short Title: Software Development for Distributed Systems
ISSN: 0018-9162
DOI: 10.1109/C-M.1975.218997
Keywords: Communication industry
Computer industry
Constraint optimization
Distributed control
Programming
Runtime
Software tools
System testing
Systems engineering and theory
Abstract: My prime interest in participating in this session is to project the applicability of SP to the development of software for Distributed Computer Systems (such as the UC Irvine Distributed Computer System and the CMU C.MMP). The difficulties common to all software design and development efforts are made even more acute when writing software for a DCS. Setting up experiments that involve widely separated, loosely coupled computers is not an easy or straightforward task. Error situations may develop fortuitously and then evade most efforts to cause them to occur again. In this predicament, structured modular top-down programming techniques appear likely to play an important role since they offer an opportunity to bring significant software reliability improvements.
Notes: focus on distributed systems


Reference Type:  Journal Article
Record Number: 9409
Author: Francioni, J. M. and Kandel, A.
Year: 1988
Title: A software engineering tool for expert system design
Journal: IEEE Expert
Volume: 3
Issue: 1
Pages: 33-41
Short Title: A software engineering tool for expert system design
ISSN: 0885-9000
DOI: 10.1109/64.2093
Keywords: decision tables
expert systems
software tools
design tool
expert system design
production-type knowledge bases
software engineering tool
Control systems
Design methodology
Humans
Phase detection
Production systems
Software design
Software engineering
Springs
Abstract: The properties of design tools for expert systems are identified. A design tool is presented for constructing production-type knowledge bases that provides a straightforward methodology and adheres to these properties. The use of decision tables in software design is discussed, and a modified table that can be used for the present application is presented.<<ETX>>
Notes: tool


Reference Type:  Journal Article
Record Number: 8565
Author: Ahmed, Faheem and Capretz, Luiz Fernando
Year: 2008
Title: The software product line architecture: An empirical investigation of key process activities
Journal: Information and Software Technology
Volume: 50
Issue: 11
Pages: 1098-1113
Date: 10//
Short Title: The software product line architecture: An empirical investigation of key process activities
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2007.10.013
Keywords: Software product line
Software architecture
Empirical study
Software engineering
Domain engineering
Abstract: Software architecture has been a key area of concern in software industry due to its profound impact on the productivity and quality of software products. This is even more crucial in case of software product line, because it deals with the development of a line of products sharing common architecture and having controlled variability. The main contributions of this paper is to increase the understanding of the influence of key software product line architecture process activities on the overall performance of software product line by conducting a comprehensive empirical investigation covering a broad range of organizations currently involved in the business of software product lines. This is the first study to empirically investigate and demonstrate the relationships between some of the software product line architecture process activities and the overall software product line performance of an organization at the best of our knowledge. The results of this investigation provide empirical evidence that software product line architecture process activities play a significant role in successfully developing and managing a software product line.
Notes: Focus on software product line architecture
URL: https://www.sciencedirect.com/science/article/pii/S0950584907001243
'File' Attachments: internal-pdf://4231218876/The software product line architecture An empi.pdf


Reference Type:  Conference Paper
Record Number: 7909
Author: Bosch, Jan
Year: 2012
Title: Speed and innovation through architecture
Conference Name: Proceedings of the 15th ACM SIGSOFT symposium on Component Based Software Engineering
Conference Location: Bertinoro, Italy
Publisher: ACM
Pages: 1-2
DOI: 10.1145/2304736.2304738
Place Published: 2304738
Abstract: The nature of software system development is changing. Rather than building systems according to specification, innovation processes and customer intimacy are at the heart of software development, requiring unprecedented levels of agility and speed. In addition, software is increasingly built in the context of a software ecosystem where other companies and independent developers add value as well. As these trends require small teams to work efficiently and rapidly in the context of large complex systems, the role of software architecture (and that of a software architect in particular) is more important in this new world, but there is significant evolution in its implementation. This keynote starts by characterizing the new approach to software engineering and the role of compositionality. It then explores the implications for software architecture and the role of the software architect. The talk will present examples from several industries to illustrate specific focus areas.
Notes: Talk...


Reference Type:  Conference Paper
Record Number: 7994
Author: Nakagawa, Elisa Y., Gon, Marcelo, #231, alves, Guessi, Milena, Oliveira, Lucas B. R. and Oquendo, Flavio
Year: 2013
Title: The state of the art and future perspectives in systems of systems software architectures
Conference Name: Proceedings of the First International Workshop on Software Engineering for Systems-of-Systems
Conference Location: Montpellier, France
Publisher: ACM
Pages: 13-20
DOI: 10.1145/2489850.2489853
Place Published: 2489853
Abstract: Currently, software systems have become increasingly large and complex, often resulted by the integration of several operationally independent systems, resulting in a new class of systems: the Systems of Systems (SoS). In another perspective, software architectures play a major role in determining system quality, since they form the backbone of any successful software-intensive system. Attention given to the software architectures of SoS is also certainly fundamental to the success of such systems. However, it is observed that there is a lack of works that present a wide and, at the same time, a detailed panorama about how SoS architectures have been treated. In this scenario, the main contribution of this paper is to present the state of the art on software architectures of SoS, mainly regarding their development, representation, evaluation, and evolution. This work also contributes with future research topics on SoS architectures that should be still investigated. Besides that, we intend this paper opens new perspectives of research in the software architecture area, intending to contribute to the success of SoS.
Notes: System of systems as focus


Reference Type:  Conference Paper
Record Number: 8244
Author: Eide, Eric, Reid, Alastair, Regehr, John and Lepreau, Jay
Year: 2002
Title: Static and dynamic structure in design patterns
Conference Name: Proceedings of the 24th International Conference on Software Engineering
Conference Location: Orlando, Florida
Publisher: ACM
Pages: 208-218
DOI: 10.1145/581339.581367
Place Published: 581367
Abstract: Design patterns are a valuable mechanism for emphasizing structure, capturing design expertise, and facilitating restructuring of software systems. Patterns are typically applied in the context of an object-oriented language and are implemented so that the pattern participants correspond to object instances that are created and connected at run-time. The paper describes a complementary realization of design patterns, in which many pattern participants correspond to statically instantiated and connected components. Our approach separates the static parts of the software design from the dynamic parts of the system behavior. This separation makes the software design more amenable to analysis, thus enabling more effective and domain-specific detection of system design errors, prediction of run-time behavior, and more effective optimization. This technique is applicable to imperative, functional, and object-oriented languages: we have extended C, Scheme, and Java with our component model. We illustrate our approach in the context of the OSKit, a collection of operating system components written in C.
Notes: Analysis of patterns


Reference Type:  Conference Proceedings
Record Number: 9523
Author: Knodel, J., Lindvall, M., Muthig, D. and Naab, M.
Year of Conference: 2006
Title: Static evaluation of software architectures
Conference Name: Conference on Software Maintenance and Reengineering (CSMR'06)
Pages: 10 pp.-294
Date: 22-24 March 2006
Short Title: Static evaluation of software architectures
ISBN: 1534-5351
DOI: 10.1109/CSMR.2006.53
Keywords: reverse engineering
software architecture
software performance evaluation
software architecture development
software architecture static evaluation
Acoustical engineering
Computer architecture
Computer industry
Educational institutions
Instruments
Programming
Software engineering
Software systems
ADORE
PuLSE-DSSA
architecture
architecture evaluation
product line
reverse engineering.
Abstract: The software architecture is one of the most crucial artifacts within the lifecycle of a software system. Decisions made at the architectural level directly enable, facilitate, hamper, or interfere with the achievement of business goals, functional and quality requirements. Architecture evaluations play an important role in the development and evolution of software systems since they determine how adequate the architecture is for its intended usage. This paper summarizes our practical experience with using architecture evaluations and gives an overview on when and how static architecture evaluations contribute to architecture development. We identify ten distinct purposes and needs for static architecture evaluations and illustrate them using a set of industrial and academic case studies. In particular, we show how subsequent steps in architecture development are influenced by the results from architecture evaluations
Notes: evaluation of architecture


Reference Type:  Conference Proceedings
Record Number: 7769
Author: Su, M. T., Tempero, E., Hosking, J. and Grundy, J.
Year of Conference: 2012
Title: A Study of Architectural Information Foraging in Software Architecture Documents
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 141-150
Date: 20-24 Aug. 2012
Short Title: A Study of Architectural Information Foraging in Software Architecture Documents
DOI: 10.1109/WICSA-ECSA.212.22
Keywords: document handling
software architecture
SA
academic AD users
critical responsibility
forages type
foraging sequences
industry practitioner
physical view
process view
quality requirements
software architecture documents
task-based architectural information foraging
use cases
Computer architecture
Documentation
Electronic mail
Industries
Navigation
Software
exploration
foraging
software architecture document
understanding
Abstract: When using Software Architecture documents (ADs), users typically &#x201C;forage&#x201D; for information. However, it is little understood how they do this foraging or how to structure architecture documentation to assist them. We conducted a survey of two different groups of foragers, industry practitioner and academic AD users, to investigate issues - types of forages, foraging sequences and styles - related to task-based architectural information foraging in software architecture documents. Our results show that there were different pre-conceived ideas of what to forage for prior to the search, but during foraging there was commonly foraged information. The different groups of foragers place different emphasis on information related to quality requirements, purpose of the system, use cases, physical view and process view. Foraging sequences starting with certain information were suggested to better support understanding of the described SA. These sequences typically followed the written order of the information as dictated by the AD producers. This reinforces the critical responsibility of AD producers to structure the architectural information for understanding. Diagrams, views and design decisions were most frequently cited as supporting understanding of the SA. The main hindrance was too much text and a lack of diagrams.
'File' Atttachments: internal-pdf://2490619577/A Study of Architectural Information Foraging.pdf


Reference Type:  Conference Proceedings
Record Number: 7675
Author: Groher, I. and Weinreich, R.
Year of Conference: 2015
Title: A Study on Architectural Decision-Making in Context
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 11-20
Date: 4-8 May 2015
Short Title: A Study on Architectural Decision-Making in Context
DOI: 10.1109/WICSA.2015.27
Keywords: decision making
software architecture
architectural decision-making process
business factors
cultural factors
individual factors
organizational contexts
organizational factors
project factors
software system
Companies
Context
Interviews
Standards organizations
architectural design process
decision-making process
expert survey
influence factors
Abstract: Design decisions are made throughout the design process of a new software system or the evolution of an existing system. The context in which a system is developed influences these decisions themselves and the way they are made. There are only a few empirical studies regarding architectural decision-making or concerning how the decision-making process is executed. In this paper, we report an analysis of expert interviews regarding architectural decision-making to gain insight into how decision-making is organized in different organizational contexts. We base our analysis on interviews conducted in a previous study, where we talked to 25 software architects, team leads, and senior developers from 22 different companies in ten different countries about architectural decision-making and documentation. In this paper, we specifically analyze the interview transcripts with regard to the decision-making process. We identified eight different categories of main factors influencing how, when, and by whom decisions are made. We also present decision-making scenarios and relate them to the discovered influence factors. Results show that, apart from organizational factors, individual factors and cultural factors seem to have about the same influence as business and project factors. Company size and domain do not influence the decision-making process as much as one might expect.
'File' Atttachments: internal-pdf://3585303818/A Study on Architectural Decision-Making in Co.pdf


Reference Type:  Conference Proceedings
Record Number: 9571
Author: Rekhav, V. S. and Muccini, H.
Year of Conference: 2014
Title: A Study on Group Decision-Making in Software Architecture
Conference Name: 2014 IEEE/IFIP Conference on Software Architecture
Pages: 185-194
Date: 7-11 April 2014
Short Title: A Study on Group Decision-Making in Software Architecture
DOI: 10.1109/WICSA.2014.15
Keywords: decision making
software architecture
software development management
architectural design decisions
architecture-related group decisions
component selection
connectors selection
decision making enhancement
decisions rationale
design alternatives
design decisions
group decision making techniques
stakeholder concerns
Companies
Computer architecture
Industries
Software systems
Group Design Decisions
Study
state of the practice
Abstract: When architecting software systems, architects (with the contribution of other stakeholders) make several design decisions. These decisions could be related to the selection of the right components and connectors, the architectural style to be used, the distribution of various components, the deployment of software components into hardware devices, etc. Many methods have been proposed by the research community to help documenting several aspects of architectural design decisions including design alternatives, stakeholder concerns, decisions and the rationale for making such decisions and enhancing the decision-making process. Still, very little has been done to truly understand how architectural design decisions are made by group of practitioners, what information is documented, the tools used for helping documenting and how conflicts are managed. This study, by looking at principles and techniques for group decision making coming from other disciplines, aims to understand: a) how practitioners make group decisions in architecting software systems, b) how practiced group decision-making techniques relate to state-of-the-art techniques, and c) challenges companies face when making architecture-related group decisions. The study is conducted by using a questionnaire distributed to practitioners and researchers involved in group design decisions in industry. The results are used to drive some recommendations to improve the current group design decision process.
'File' Atttachments: internal-pdf://3165903344/A Study on Group Decision-Making in Software A.pdf


Reference Type:  Conference Proceedings
Record Number: 9158
Author: Kouroshfar, E., Mirakhorli, M., Bagheri, H., Xiao, L., Malek, S. and Cai, Y.
Year of Conference: 2015
Title: A Study on the Role of Software Architecture in the Evolution and Quality of Software
Conference Name: 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories
Pages: 246-257
Date: 16-17 May 2015
Short Title: A Study on the Role of Software Architecture in the Evolution and Quality of Software
ISBN: 2160-1852
DOI: 10.1109/MSR.2015.30
Keywords: public domain software
software architecture
software quality
architecture recovery techniques
cross architectural module boundaries
open-source software systems
software evolution
Computer architecture
Couplings
Data mining
History
Measurement
Software systems
Defects
Software Repositories
Abstract: Conventional wisdom suggests that a software system's architecture has a significant impact on its evolution. Prior research has studied the evolution of software using the information of how its files have changed together in their revision history. No prior study, however, has investigated the impact of architecture on the evolution of software from its change history. This is mainly because most open-source software systems do not document their architectures. We have overcome this challenge using several architecture recovery techniques. We used the recovered models to examine if co-changes spanning multiple architecture modules are more likely to introduce bugs than co-changes that are within modules. The results show that the co-changes that cross architectural module boundaries are more correlated with defects than co-changes within modules, implying that, to improve accuracy, bug predictors should also take the software architecture of the system into consideration.
Notes: Connection of changes


Reference Type:  Conference Paper
Record Number: 8029
Author: Curtis, Bill, Walz, Diane and Elam, Joyce
Year: 1990
Title: Studying the process of software design teams
Conference Name: Proceedings of the 5th international software process workshop on Experience with software process models
Conference Location: Kennebunkport, Maine, USA
Publisher: IEEE Computer Society Press
Pages: 52-53
Place Published: 317698
Abstract: In the 1990s we will begin to see software development environments that embed models of the software process in the control of their tools. These process models will too often be based on traditional life cycle models, models of individual activity, or idealized models of team processes. If these environments are to benefit software development they must support team activity rather than hinder it. The crucial issue in developing technology to aid teams is how well the model implemented by the software coincides with a team's most effective behaviors in performing a task. In order to get a broad perspective on how software design teams solved problems, Herb Krasner and Jeff Conklin videotaped 37 team meetings over five months of an MCC team designing an object-oriented database. In a doctoral dissertation using these data, Diane Walz (1988) devised a method for scoring the verbal protocols of design teams into categories tailored to the design process. Her analysis emphasized the team's information requirements and their effect on the group process, especially information sharing. She began by assuming that the conflicts within a software design team were not solely the result of incompatible goals and/or opinions, but also represented the natural dialectic through which knowledge was exchanged and terminology was clarified (Walz, Elam, Krasner, & Curtis, 1988). Analyses of the protocols and follow-up questions to team members indicated that design meetings were generally dominated by a few individuals to whom fellow participants attributed the greatest breadth of expertise. These individuals appeared to form a coalition that controlled the direction of the team. A fundamental problem in building large systems is the development of a common understanding of the requirements and design across the project team. Of the few studies of multiple agents performing complex design activities, none have investigated the integration of knowledge across experts in different domains or the communication processes required to develop a common model of the application and the system design across the entire design team. As a result, design in team situations is typically treated as an outgrowth of individual design activities, avoiding the multi-agent problem-solving and communication issues. The transcripts of team meetings reveal the large amounts of time designers spend trying to develop a shared model of the design. For instance, many design meetings may be devoted to filling knowledge gaps, such as lectures about the application (e.g., talks by outside experts on object-oriented programming or the requirements for object repositories). Next, the team must come to a common understanding of the semantics of the symbol or diagrammatic system they are using to represent design information. The longer they go without establishing this consensus, the more communication breakdowns will occur. Next they must try to comprehend the differences in their initial model of the application and the design solution. Without understanding these individualized starting points, the team is unable to detect when a breakdown in establishing consensus is likely to have occurred. Finally, they must come to negotiate a common understanding of the architecture. This common model allows them to work on different components of the system without violating interfaces or architectural constraints. Problems of this nature usually do not show up until integration test, and are much more expensive to remove than they would have been in the design phase. The existing research on team problem-solving led us to expect monotonically increasing consensus among design team members on design issues. A simplistic model assuming that cooperative design activity requires agreement among team members lead us to expect this monotonic increase. However, an interesting pattern in the verbal acts representing agreement within the team was observed across the 17 meetings that constituted the design phase of this project. As the data in Figure 1 demonstrate, Walz observed a surprising inverted U-shaped curve (verified through logistic regression) that characterized verbal acts of agreement. The level of agreement increased until meetings 7-10, when the design team released a document presenting its functional specification in response to customer requirements. In subsequent meetings the level of agreement began to decrease. There are several possible explanations for the observed pattern. First, there may be an inflection point in the middle of a group process where the team is forced to come together and agree on their technical plan and operating procedures. Gersick (1988) observed such a point in a study of project teams. Rather than the standard group process of form-storm-norm-perform, Gersick suggested there came a point halfway through a group project where the team faced its lack of progress during its early stage, and came to a consensus about how it would attack the objective. Often this critical point involved an insight into the problem's structure. Group process was relatively stable and productive until the delivery of the final product. Although this model suggests that significant changes occur in a group's process midway through its history, it does not explain the downturn (the drop in consensus) of the inverted U-shaped curve. Gersick's model may be more descriptive of temporary teams that are asked to perform tasks out of their area of expertise. A second hypothesis is that this curve results from the integration of two processes occurring in teams. There is a intellectual process of integrating technical ideas and resolving inconsistencies. Overlaid on this process is a project process of meeting scheduled milestones. Meeting the milestone forced a contrived consensus that did not resolve underlying technical disagreements, but allowed production of a document. However, the existence of this document disguised the lack of intellectual integration that remained in the design. These disagreements began to dominate design meetings immediately after document delivery. Having completed their obligations the team was free to reopen the conflicts that were temporarily suspended to meet the milestone. Thus, we would expect this inverted-U phenomenon of agreement to recur whenever the team must achieve a shared (rather than individual) milestone. Since we only looked at the design phase, Walz could only observe one such curve. Had we studied behavior across the entire development phase Walz might have uncovered an oscillating curve representing the level of agreement with the upper inflections occurring at deadlines for milestones. However, the magnitude of these oscillations should decrease over time as the team resolved more of their underlying technical disagreements. A third explanation is not unlike the second, but emerges more from modeling the stepwise refinement (decomposition) of the artifact. In this model the team struggles to resolve technical conflicts at the initial level of refinement required of them (e.g., functional specification, system architecture, detailed design, etc.). After the artifact at this level is produced, the next level of refinement presents many new technical issues over which the team must struggle toward consensus. Thus, we would again expect to see an oscillating curve of agreement as succeeding stages of refinement present new sets of problems for the team to resolve. These continuing issues would not be surprising since the development team shifts its attention from the early concern with application structure to a later concern with how to optimize the software on the available hardware architecture. This model might differ from the second by not requiring a decreasing magnitude for the oscillations, since each oscillation represents a new wave of problems, rather than the continuing struggle to resolve disagreements that have existed from the project's start. Of these three explanations we prefer the second because we believe that on many, perhaps most, real projects there are people present who recognize early some of the fundamental problems that must be resolved. Their understanding of these problems cuts across several levels of abstraction or refinement and they are able to articulate the implications of these issues for several levels of refinement early in the design process. The levels of refinement argument may be relevant in that the problems attended to early are those that must be resolved to produce the artifact. Thus, levels of refinement provides a model for selecting among problems in order to make progress toward a milestone. Much research lies ahead before we can feel comfortable selecting among these speculations or other explanations of these data. We have concluded that the team design process should be modeled as a multi-agent cognitive process, on which the social processes of role development, coalition formation, communication, etc. are superimposed. In order to explain the team design process, we model group dynamics by their effect on team cognitive processes.
Notes: More a summary


Reference Type:  Conference Paper
Record Number: 7943
Author: Berenbach, Brian and Bass, Len
Year: 2008
Title: Summary for leadership and management in software architecture (lMSA 2008)
Conference Name: Companion of the 30th international conference on Software engineering
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 1043-1044
DOI: 10.1145/1370175.1370238
Place Published: 1370238
Abstract: Software architecture, in education and practice, is primarily concerned with technical issues associated with the quality of software architecture and design. However, as project size increases, leadership, management skills, and the organizational context of the architect become more important, to the point where the non-technical duties of the project architect can "make or break" a project. This workshop is focused on understanding these non-technical duties.
Notes: workshop


Reference Type:  Conference Proceedings
Record Number: 9588
Author: Harandi, M. T. and Hing-Yan, Lee
Year of Conference: 1992
Title: A support environment for knowledge-based software design
Conference Name: Proceedings Fourth International Conference on Software Engineering and Knowledge Engineering
Pages: 71-78
Date: 15-20 Jun 1992
Short Title: A support environment for knowledge-based software design
DOI: 10.1109/SEKE.1992.227945
Keywords: diagrams
entity-relationship modelling
knowledge based systems
software reusability
systems analysis
dataflow diagrams
dataflow-oriented software design
design environment
entity-relationship based data models
interactive system
knowledge-based software design
structured analysis
system design reuse
Data analysis
Data models
Process design
Software design
Abstract: Most of the important aspects of the design process can be effectively supported if such expertise can be identified, acquired, and reused. This paper presents a design environment that supports this knowledge-based approach to software design. The design approach may be viewed as knowledge-driven refinement of abstract/specific design models. The design environment consists of a design subsystem, an acquisition and refinement subsystem, and a retrieval mechanism for the retrieval of abstract/specific design models. This paper also describes the interactive aspects required in such an environment. The design representation used in the environment consists of leveled dataflow diagrams and entity-relationship based data models supporting structured analysis and dataflow-oriented software design
Notes: techniques to describe architecture


Reference Type:  Conference Proceedings
Record Number: 7677
Author: Cavalcante, E., Batista, T. and Oquendo, F.
Year of Conference: 2015
Title: Supporting Dynamic Software Architectures: From Architectural Description to Implementation
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 31-40
Date: 4-8 May 2015
Short Title: Supporting Dynamic Software Architectures: From Architectural Description to Implementation
DOI: 10.1109/WICSA.2015.21
Keywords: programming languages
software architecture
&#x03C0
-ADL
Go programming language
architectural-level primitives
architecture description languages
dynamic software architectures
programmed dynamic reconfiguration specification
real-world flood monitoring system
source code
Computer architecture
Connectors
Logic gates
Monitoring
Runtime
Sensors
Go
architecture description language
dynamic reconfiguration
p-ADL
software architectures
Abstract: Dynamic software architectures are those that describe how components and connectors can be created, interconnected, and/or removed during system execution. Most existing architecture description languages (ADLs) provide a limited support to expressively describe these architectures and entail architectural mismatches and inconsistencies between architecture and implementation due to their decoupling from implementation. In this paper, we introduce the dynamic reconfiguration support provided by &#x03C0;-ADL, a formal, well-founded theoretically language for describing dynamic software architectures under structural and behavioral viewpoints. &#x03C0;-ADL provides architectural-level primitives for specifying programmed dynamic reconfigurations, i.e., Foreseen changes described at design time and triggered at runtime. In addition, &#x03C0;-ADL allows enacting dynamic reconfiguration by means of: (i) an exogenous approach, in which it is possible to control all elements of the software architectures and to apply the changes on the whole structure, and (ii) an endogenous approach, in which the architectural elements can manage dynamic reconfiguration actions. Furthermore, &#x03C0;-ADL is integrated with the Go programming language, thus enabling to automatically generate implementation code from architectural descriptions, thus tackling the existing gap between them. We hereby use a real-world flood monitoring system as an illustrative example of how to describe dynamic software architectures in &#x03C0;-ADL and automatically generate source code in Go.
Notes: automatic source code generation


Reference Type:  Conference Proceedings
Record Number: 8779
Author: Brien, L. O', Smith, D. and Lewis, G.
Year of Conference: 2005
Title: Supporting Migration to Services using Software Architecture Reconstruction
Conference Name: 13th IEEE International Workshop on Software Technology and Engineering Practice (STEP'05)
Pages: 81-91
Date: 0-0 0
Short Title: Supporting Migration to Services using Software Architecture Reconstruction
DOI: 10.1109/STEP.2005.29
Keywords: software architecture
software maintenance
software reusability
systems re-engineering
legacy component identification
legacy component reuse
product streamlining
service-oriented architecture
software architecture reconstruction
system modernization
Computer architecture
Conferences
Decision making
Scalability
Service oriented architecture
Simple object access protocol
Software engineering
Software measurement
Web services
Architecture
Architecture Reconstruction
Migration to Services
Oriented Architecture
Service
System Modernization.
Abstract: There are many good reasons why organizations should perform software architecture reconstructions. However, few organizations are willing to pay for the effort. Software architecture reconstruction must be viewed not as an effort on its own but as a contribution in a broader technical context, such as the streamlining of products into a product line or the modernization of systems that hit their architectural borders, that is require major restructuring. In this paper we propose the use of architecture reconstruction to support system modernization through the identification and reuse of legacy components as services in a service-oriented architecture (SOA). A case study showing how architecture reconstruction was used on a system to support an organization's decision-making process is presented
Notes: tool to reconstruct software architecture


Reference Type:  Conference Paper
Record Number: 8059
Author: Stevanetic, Srdjan, Plakidas, Konstantinos, Ionescu, Tudor B., Schall, Daniel and Zdun, Uwe
Year: 2016
Title: Supporting quality-driven architectural design decisions in software ecosystems
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-4
DOI: 10.1145/2993412.3003383
Place Published: 3003383
Abstract: System quality attributes (QAs) are often considered as the most important decision drivers. In this paper, motivated by the decision making in a smart-city software ecosystem, we extend our previous approach that integrates reusable architectural design decisions (ADDs) with the QAs, by integrating tactics that support quality-driven decision making. In addition, we present an approach that enables system evolution, based on controlled and adaptable decision making and utilizing real data obtained during system monitoring. The approach integrates the previous approach that uses tactics with the existing model-driven development paradigm and the corresponding tools.


Reference Type:  Conference Paper
Record Number: 7920
Author: Alebrahim, Azadeh and Heisel, Maritta
Year: 2012
Title: Supporting quality-driven design decisions by modeling variability
Conference Name: Proceedings of the 8th international ACM SIGSOFT conference on Quality of Software Architectures
Conference Location: Bertinoro, Italy
Publisher: ACM
Pages: 43-48
DOI: 10.1145/2304696.2304705
Place Published: 2304705
Abstract: Design decisions should take quality characteristics into account. To support such decisions, we capture various solution artifacts with different levels of satisfying quality requirements as variabilities in the solution space and provide them with rationales for selecting suitable variants. We present a UML-based approach to modeling variability in the problem and the solution space by adopting the notion of feature modeling. It provides a mapping of requirements variability to design solution variability to be used as a part of a general process for generating design alternatives. Our approach supports the software engineer in the process of decision-making for selecting suitable solution variants, reflecting quality concerns, and reasoning about it.


Reference Type:  Journal Article
Record Number: 8604
Author: Tang, Antony, Babar, Muhammad Ali, Gorton, Ian and Han, Jun
Year: 2006
Title: A survey of architecture design rationale
Journal: Journal of Systems and Software
Volume: 79
Issue: 12
Pages: 1792-1804
Date: 12//
Short Title: A survey of architecture design rationale
ISSN: 0164-1212
DOI: https://doi.org/10.1016/j.jss.2006.04.029
Keywords: Design rationale
Software architecture
Survey
Abstract: Many claims have been made about the consequences of not documenting design rationale. The general perception is that designers and architects usually do not fully understand the critical role of systematic use and capture of design rationale. However, there is to date little empirical evidence available on what design rationale mean to practitioners, how valuable they consider it, and how they use and document it during the design process. This paper reports a survey of practitioners to probe their perception of the value of design rationale and how they use and document the background knowledge related to their design decisions. Based on 81 valid responses, this study has discovered that practitioners recognize the importance of documenting design rationale and frequently use them to reason about their design choices. However, they have indicated barriers to the use and documentation of design rationale. Based on the findings, we conclude that further research is needed to develop methodology and tool support for design rationale capture and usage. Furthermore, we put forward some specific research questions about design rationale that could be further investigated to benefit industry practice.
URL: https://www.sciencedirect.com/science/article/pii/S0164121206001415
'File' Attachments: internal-pdf://1820063103/A survey of architecture design rationale.pdf


Reference Type:  Journal Article
Record Number: 9083
Author: Dobrica, L. and Niemela, E.
Year: 2002
Title: A survey on software architecture analysis methods
Journal: IEEE Transactions on Software Engineering
Volume: 28
Issue: 7
Pages: 638-653
Short Title: A survey on software architecture analysis methods
ISSN: 0098-5589
DOI: 10.1109/TSE.2002.1019479
Keywords: reviews
software architecture
software quality
appropriateness studies
classifications
objective reflections
potential risk identification
scenarios
software architecture analysis methods
software architecture assessment process
software quality attributes
software quality requirements
survey
Computer Society
Computer architecture
Computer industry
Guidelines
Reflection
Risk analysis
Software metrics
Software systems
Abstract: The purpose of the architecture evaluation of a software system is to analyze the architecture to identify potential risks and to verify that the quality requirements have been addressed in the design. This survey shows the state of the research at this moment, in this domain, by presenting and discussing eight of the most representative architecture analysis methods. The selection of the studied methods tries to cover as many particular views of objective reflections as possible to be derived from the general goal. The role of the discussion is to offer guidelines related to the use of the most suitable method for an architecture assessment process. We will concentrate on discovering similarities and differences between these eight available methods by making classifications, comparisons and appropriateness studies.


Reference Type:  Conference Paper
Record Number: 7868
Author: Robillard, Martin P.
Year: 2016
Title: Sustainable software design
Conference Name: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering
Conference Location: Seattle, WA, USA
Publisher: ACM
Pages: 920-923
DOI: 10.1145/2950290.2983983
Place Published: 2983983
Abstract: Although design plays a central role in software development, the information produced in this activity is often left to progressively evaporate as the result of software evolution, loss of artifacts, or the fading of related knowledge held by the development team. This paper introduces the concept of sustainability for software design, and calls for its integration into the existing catalog of design quality attributes. Applied to software design, sustainability conveys the idea that a particular set of design decisions and their rationale can be succinctly reflected in the host technology and/or described in documentation in a way that is checkable for conformance with the code and generally resistant to evaporation. The paper discusses the relation between sustainability and existing research areas in software engineering, and highlights future research challenges related to sustainable software design. 


Reference Type:  Journal Article
Record Number: 8509
Author: Breivold, Hongyu Pei, Crnkovic, Ivica and Larsson, Magnus
Year: 2012
Title: A systematic review of software architecture evolution research
Journal: Information and Software Technology
Volume: 54
Issue: 1
Pages: 16-40
Date: 1//
Short Title: A systematic review of software architecture evolution research
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2011.06.002
Keywords: Software evolvability
Systematic review
Software architecture
Architecture evolution
Architecture analysis
Evolvability analysis
Abstract: Context Software evolvability describes a software system’s ability to easily accommodate future changes. It is a fundamental characteristic for making strategic decisions, and increasing economic value of software. For long-lived systems, there is a need to address evolvability explicitly during the entire software lifecycle in order to prolong the productive lifetime of software systems. For this reason, many research studies have been proposed in this area both by researchers and industry practitioners. These studies comprise a spectrum of particular techniques and practices, covering various activities in software lifecycle. However, no systematic review has been conducted previously to provide an extensive overview of software architecture evolvability research. Objective In this work, we present such a systematic review of architecting for software evolvability. The objective of this review is to obtain an overview of the existing approaches in analyzing and improving software evolvability at architectural level, and investigate impacts on research and practice. Method The identification of the primary studies in this review was based on a pre-defined search strategy and a multi-step selection process. Results Based on research topics in these studies, we have identified five main categories of themes: (i) techniques supporting quality consideration during software architecture design, (ii) architectural quality evaluation, (iii) economic valuation, (iv) architectural knowledge management, and (v) modeling techniques. A comprehensive overview of these categories and related studies is presented. Conclusion The findings of this review also reveal suggestions for further research and practice, such as (i) it is necessary to establish a theoretical foundation for software evolution research due to the fact that the expertise in this area is still built on the basis of case studies instead of generalized knowledge; (ii) it is necessary to combine appropriate techniques to address the multifaceted perspectives of software evolvability due to the fact that each technique has its specific focus and context for which it is appropriate in the entire software lifecycle.
Notes: literature review
URL: https://www.sciencedirect.com/science/article/pii/S0950584911001376


Reference Type:  Conference Proceedings
Record Number: 8926
Author: Dabhade, M., Suryawanshi, S. and Manjula, R.
Year of Conference: 2016
Title: A systematic review of software reuse using domain engineering paradigms
Conference Name: 2016 Online International Conference on Green Engineering and Technologies (IC-GET)
Pages: 1-6
Date: 19-19 Nov. 2016
Short Title: A systematic review of software reuse using domain engineering paradigms
DOI: 10.1109/GET.2016.7916646
Keywords: object-oriented methods
software architecture
software quality
software reusability
software reviews
SDLC
architecture definition languages
domain engineering paradigms
object oriented design
software components
software development life cycle
software reuse research
systematic review
Analytical models
Computer architecture
Libraries
Productivity
Systematics
AOSD
CBSD
COTS
Domain Engineering
Software Reuse
Abstract: Software reuse is the use of already existing concepts, objects or software components to build new software. The goal of software reuse research is to explore systematic procedures for developing new systems from existing ones. The systematic software reuse is the most effective way to improve software development. Domain engineering plays crucial role in Software Reuse research, which makes the use of approaches based on object oriented design, software architecture and architecture definition languages. These approaches can be significantly used at initial stages of Software Development Life Cycle (SDLC). It helps us to reduce the rework by enhancing the productivity and quality of reuse. Thus the goal is to identify barriers of software reusability that must be overcome for successful reuse. This paper presents a detailed literature survey on software reuse processes, current research and challenges which encounters while software reusing.
Research Notes: literature review


Reference Type:  Journal Article
Record Number: 9174
Author: Galster, M., Eberlein, A. and Moussavi, M.
Year: 2010
Title: Systematic selection of software architecture styles
Journal: IET Software
Volume: 4
Issue: 5
Pages: 349-360
Short Title: Systematic selection of software architecture styles
ISSN: 1751-8806
DOI: 10.1049/iet-sen.2009.0004
Keywords: software architecture
SYSAS method
software architecture styles
systematic architecture style selection
Abstract: Selecting appropriate styles for software architectures is important as styles impact characteristics of software (e.g. reliability). Moreover, styles influence how software is built as they determine architectural elements (e.g. components, connectors) and rules on how these elements are integrated in the architecture. Therefore this study presents a method, called SYSAS, for the systematic selection of architecture styles. In SYSAS, style selection is based on (a) characteristics of basic architectural elements that are relevant for the developer, and (b) characteristics of the target system that are visible to the end user. The selection procedure requires ratings about the importance of characteristics of architectural elements and results in a ranking of styles. SYSAS can be applied at system level as well as for choosing styles for individual subsystems. A case study is presented to illustrate SYSAS and its applicability and added benefit. Additional case studies are performed to compare results of SYSAS with judgements of experts.
Research Notes: Tool for decisions


Reference Type:  Journal Article
Record Number: 9320
Author: Weiss, D. M.
Year: 1987
Title: Teaching a Software Design Methodology
Journal: IEEE Transactions on Software Engineering
Volume: SE-13
Issue: 11
Pages: 1156-1163
Short Title: Teaching a Software Design Methodology
ISSN: 0098-5589
DOI: 10.1109/TSE.1987.232864
Keywords: Software design
software engineering education
teaching software design
Application software
Design methodology
Education
Job design
Laboratories
Monitoring
Productivity
Programming
Software engineering
Abstract: This paper describes an approach to teaching a software design methodology used at The Wang Institute of Graduate Studies. The approach is general enough to be used with any of the currently popular design methodologies. Students are first taught the principles underlying the methodology, and the standards used with it. This phase is done in a series of lectures. In the second phase, students are presented with a real design problem, and asked to solve it using the methodology. They are monitored in this process by an expert in the methodology whose job is to assure that the students adhere to the methodology, but who makes no design decisions.
Research Notes: students


Reference Type:  Journal Article
Record Number: 9541
Author: Ergen, S. C., Sangiovanni-Vincentelli, A., Sun, X., Tebano, R., Alalusi, S., Audisio, G. and Sabatini, M.
Year: 2009
Title: The Tire as an Intelligent Sensor
Journal: IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
Volume: 28
Issue: 7
Pages: 941-955
Short Title: The Tire as an Intelligent Sensor
ISSN: 0278-0070
DOI: 10.1109/TCAD.2009.2022879
Keywords: automotive engineering
data acquisition
intelligent sensors
road safety
safety systems
tyres
vehicle dynamics
wireless sensor networks
automotive safety
data-acquisition system
distributed architecture
intelligent sensor
load transfer
safety system
tire-road friction
wireless sensor network
energy efficiency
energy scavenging
heterogeneous systems
intelligent systems
platform-based design
tires
ultrawideband
wireless sensors
Abstract: Active safety systems are based upon the accurate and fast estimation of the value of important dynamical variables such as forces, load transfer, actual tire-road friction (kinetic friction) mu<i>k</i>, and maximum tire-road friction available (potential friction) mu<i>p</i>. Measuring these parameters directly from tires offers the potential for improving significantly the performance of active safety systems. We present a distributed architecture for a data-acquisition system that is based on a number of complex intelligent sensors <i>inside</i> <i>the</i> <i>tire</i> that form a wireless sensor network with coordination nodes placed on the body of the car. The design of this system has been extremely challenging due to the very limited available energy combined with strict application requirements for data rate, delay, size, weight, and reliability in a highly dynamical environment. Moreover, it required expertise in multiple engineering disciplines, including control-system design, signal processing, integrated-circuit design, communications, real-time software design, antenna design, energy scavenging, and system assembly.
Research Notes: Specific solution


Reference Type:  Conference Paper
Record Number: 7933
Author: Stevanetic, Srdjan, Plakidas, Konstantinos, Ionescu, Tudor B., Li, Fei, Schall, Daniel and Zdun, Uwe
Year: 2015
Title: Tool Support for the Architectural Design Decisions in Software Ecosystems
Conference Name: Proceedings of the 2015 European Conference on Software Architecture Workshops
Conference Location: Dubrovnik, Cavtat, Croatia
Publisher: ACM
Pages: 1-6
DOI: 10.1145/2797433.2797480
Place Published: 2797480
Abstract: Software architecture entails the making of architectural decisions based on a set of both functional and quality requirements, as well as trade-offs between them, which have to be considered to achieve design goals. Access to accumulated and documented architectural knowledge facilitates this process. In this paper, we present a set of tools that support creative decision making in the different stages an architecture specification goes through. These tools are structured around a central repository, where acquired knowledge is stored for reuse. The approach is motivated by the challenges arising from the particular needs of the software ecosystem environment, where the software design process is characterized by the participation of multiple and diverse stakeholders and the existence of multiple software applications built on a common platform. Our aim is to provide tool support for making quality-driven design decisions in a flexible and reusable manner, facilitating the system's evolvability, as well as enhancing its understandability to the stakeholders involved.
Notes: tools for ADDs


Reference Type:  Conference Proceedings
Record Number: 9413
Author: Sherman, S. and Hadar, I.
Year of Conference: 2015
Title: Toward Defining the Role of the Software Architect
Conference Name: 2015 IEEE/ACM 8th International Workshop on Cooperative and Human Aspects of Software Engineering
Pages: 71-76
Date: 18-18 May 2015
Short Title: Toward Defining the Role of the Software Architect
DOI: 10.1109/CHASE.2015.17
Keywords: software architecture
agile development methods
human-centered activities
software development
Computer architecture
Project management
Software
Software architect
communication
leadership
mentoring
soft skills
Abstract: Software architecture is integral part of the software development; however, its integration in the development process has become more challenging with the transition from traditional to agile development methods, and with the architects becoming much more than technological experts responsible for high-level design. Some attention has been paid in recent years to the role of the architect, seeking a contemporary and comprehensive definition of this role. This paper reports on the results of an online survey, with the participation of 104 software architects, aimed at defining the soft aspects of the software architect's role. The results reveal that architects perform a variety of human-centered activities such as mentoring, leadership, reviewing and management,. Moreover, in the contexts of mentoring and leadership, software architects strive to do more than they currently do.
'File' Atttachments: internal-pdf://0200452626/Toward Defining the Role of the Software Archi.pdf


Reference Type:  Conference Paper
Record Number: 8129
Author: Sherman, Sofia and Hadar, Irit
Year: 2015
Title: Toward defining the role of the software architect: an examination of the soft aspects of this role
Conference Name: Proceedings of the Eighth International Workshop on Cooperative and Human Aspects of Software Engineering
Conference Location: Florence, Italy
Publisher: IEEE Press
Pages: 71-76
Place Published: 2819333
Abstract: Software architecture is integral part of the software development; however, its integration in the development process has become more challenging with the transition from traditional to agile development methods, and with the architects becoming much more than technological experts responsible for high-level design. Some attention has been paid in recent years to the role of the architect, seeking a contemporary and comprehensive definition of this role. This paper reports on the results of an online survey, with the participation of 104 software architects, aimed at defining the soft aspects of the software architect's role. The results reveal that architects perform a variety of human-centered activities such as mentoring, leadership, reviewing and management, Moreover, in the contexts of mentoring and leadership, software architects strive to do more than they currently do.


Reference Type:  Conference Paper
Record Number: 7872
Author: Bhat, Manoj, Shumaiev, Klym and Matthes, Florian
Year: 2017
Title: Towards a framework for managing architectural design decisions
Conference Name: Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings
Conference Location: Canterbury, United Kingdom
Publisher: ACM
Pages: 48-51
DOI: 10.1145/3129790.3129799
Place Published: 3129799
Abstract: Software architecture is considered as a set of architectural design decisions. The recent trends, both in research and industry, call for improved tool support for software architects and developers to manage architectural design decisions and its associated concepts. As part of our ongoing work, we propose a framework for managing architectural design decisions in large software-intensive projects. Each component within this framework addresses specific use cases including (a) extraction and classification of design decisions from issue management systems, (b) annotation of architectural elements, (c) recommendation of alternative decision options, (d) reasoning about decisions' rationale, and (e) recommendation of experts for addressing design decisions. These components are planned to be iteratively realized and evaluated using the design science research approach. We believe that the realization of such a framework will allow an architectural knowledge management system to integrate with the design, development, and maintenance phases to support stakeholders not only to document design decisions but also to learn from decisions made in the past projects.
Notes: Tool


Reference Type:  Conference Proceedings
Record Number: 9368
Author: Rabinia, Z., Moaven, S. and Habibi, J.
Year of Conference: 2016
Title: Towards a knowledge-based approach for creating software architecture patterns ontology
Conference Name: 2016 International Conference on Engineering & MIS (ICEMIS)
Pages: 1-9
Date: 22-24 Sept. 2016
Short Title: Towards a knowledge-based approach for creating software architecture patterns ontology
DOI: 10.1109/ICEMIS.2016.7745299
Keywords: document handling
knowledge acquisition
learning (artificial intelligence)
ontologies (artificial intelligence)
software architecture
storage management
document architectural design decisions
knowledge extraction
knowledge representation
knowledge retrieval
knowledge storage
knowledge-based approach
learning process
ontology engineer
ontology learning resource
pattern complexity
pattern variability
software architecture pattern ontology
software architecture problems
software architecture stakeholders
Complexity theory
Computer architecture
Databases
Documentation
OWL
Ontologies
Knowledge Management
Ontology
Semantic Web Technologies
Software Architecture Patterns
Abstract: Software architecture patterns present solutions for software architecture problems and help to document architectural design decisions. Complexity and variability of patterns, and the required expertise for selecting an appropriate pattern, would cause some difficulties in utilizing architectural patterns. Using an ontology for registering architectural patterns is an efficient step in solving those problems. However, the mentioned difficulties make the process of constructing the architectural patterns ontology even more complicated. This paper proposes an approach that considers the construction of the architectural patterns ontology from four perspectives in order to overcome this complexity. Each of these perspectives has certain functionality. The ontology engineer deals with large volumes of patterns that would complicate registration of them in the ontology. Thus, the using of a relational database as an ontology learning resource is considered in this approach and the learning process is explained in knowledge extraction perspective. Sometimes, all knowledge of patterns (the possible interactions of patterns and the architect decisions) is not explicitly stored. Knowledge storage and representation perspective is placed in this approach in order to describe knowledge of patterns and to infer further knowledge. How retrieving an appropriate pattern is discussed in knowledge retrieval perspective. Knowledge sharing is another perspective that discusses how making the patterns ontology available for software architecture stakeholders.


Reference Type:  Conference Paper
Record Number: 8126
Author: Yskout, Koen, Landuyt, Dimitri Van and Joosen, Wouter
Year: 2017
Title: Towards a platform for empirical software design studies
Conference Name: Proceedings of the 1st International Workshop on Establishing the Community-Wide Infrastructure for Architecture-Based Software Engineering
Conference Location: Buenos Aires, Argentina
Publisher: IEEE Press
Pages: 3-7
DOI: 10.1109/ecase.2017..3
Place Published: 3101284
Abstract: The process of empirical research is founded on careful study design, sound instantiation and planning of the study, and the systematic collection and processing of data. These activities require extensive expertise and know-how, are repetitive, laborious and error-prone, and adequate tool support is currently lacking, particularly in support of empirical software engineering research. In this paper, we outline our vision of an integrated end-to-end tool platform that supports these activities and we elaborate on what it would take for such a platform to become a (re)usable platform for the research community.
Notes: platform idea


Reference Type:  Conference Proceedings
Record Number: 9009
Author: Yskout, K., Landuyt, D. Van and Joosen, W.
Year of Conference: 2017
Title: Towards a Platform for Empirical Software Design Studies
Conference Name: 2017 IEEE/ACM 1st International Workshop on Establishing the Community-Wide Infrastructure for Architecture-Based Software Engineering (ECASE)
Pages: 3-7
Date: 22-22 May 2017
Short Title: Towards a Platform for Empirical Software Design Studies
DOI: 10.1109/ECASE.2017.3
Keywords: software reusability
software tools
empirical software design
empirical software engineering research
integrated end-to-end tool platform
reusable platform
Atmospheric measurements
Particle measurements
Planning
Software design
Software engineering
Tools
empirical software engineering
experimental research
platform
Abstract: The process of empirical research is founded on careful study design, sound instantiation and planning of the study, and the systematic collection and processing of data. These activities require extensive expertise and know-how, are repetitive, laborious and error-prone, and adequate tool support is currently lacking, particularly in support of empirical software engineering research. In this paper, we outline our vision of an integrated end-to-end tool platform that supports these activities and we elaborate on what it would take for such a platform to become a (re)usable platform for the research community.
Notes: platform idea


Reference Type:  Conference Paper
Record Number: 8090
Author: Knodel, Jens and Manikas, Konstantinos
Year: 2016
Title: Towards reference architectures as an enabler for software ecosystems
Conference Name: Proccedings of the 10th European Conference on Software Architecture Workshops
Conference Location: Copenhagen, Denmark
Publisher: ACM
Pages: 1-4
DOI: 10.1145/2993412.3003387
Place Published: 3003387
Abstract: Software ecosystems - a topic with increasingly growing interest in academia and industry in the past decade - arguably revolutionized many aspects of industrial software engineering (business models, architectures, platforms, project executions, collaboration models, distribution of assets, to name a few). Software ecosystems enable the contribution of external actors with distinct center a common technology and the potential distribution of the actor contributions to an existing user set.

Reference architectures have been proven successful and beneficial for software product lines and traditional software development within distinct domains. They arguably come with a set of benefits that severely counterweights the additional effort of design and implementation. But what is the role of reference architectures in an ecosystem setting?

In this position paper, we argue for the use of reference architecture as a means of facilitating the operation of software ecosystems, supporting not only the technical aspects but also business and organizational. Thus, we propose that reference architectures can be used as a tool to facilitate software ecosystem orchestration and promote the ecosystem health. In this work, we identify a set of challenges and propose a research agenda for the further development of the field towards efficiently improving the existing means of ecosystem orchestration.
Notes: Reference architecture


Reference Type:  Conference Proceedings
Record Number: 8931
Author: Cicchetti, A., Borg, M., Sentilles, S., Wnuk, K., Carlson, J. and Papatheocharous, E.
Year of Conference: 2016
Title: Towards Software Assets Origin Selection Supported by a Knowledge Repository
Conference Name: 2016 1st International Workshop on Decision Making in Software ARCHitecture (MARCH)
Pages: 22-29
Date: 5-5 April 2016
Short Title: Towards Software Assets Origin Selection Supported by a Knowledge Repository
DOI: 10.1109/MARCH.2016.11
Keywords: Context
Decision making
History
Ontologies
Software
Software architecture
architectural knowledge
decision support
knowledge repository
Abstract: Software architecture is no more a mere system specification as resulting from the design phase, but it includes the process by which its specification was carried out. In this respect, design decisions in component-based software engineering play an important role: they are used to enhance the quality of the system, keep the current market level, keep partnership relationships, reduce costs, and so forth. For non trivial systems, a recurring situation is the selection of an asset origin, that is if going for in-house, outsourcing, open-source, or COTS, when in the need of a certain missing functionality. Usually, the decision making process follows a case-by-case approach, in which historical information is largely neglected: hence, it is avoided the overhead of keeping detailed documentation about past decisions, but it is hampered consistency among multiple, possibly related, decisions.The ORION project aims at developing a decision support framework in which historical decision information plays a pivotal role: it is used to analyse current decision scenarios, take well-founded decisions, and store the collected data for future exploitation. In this paper, we outline the potentials of such a knowledge repository, including the information it is intended to be stored in it, and when and how to retrieve it within a decision case.
Notes: tool framework


Reference Type:  Conference Paper
Record Number: 7910
Author: Xu, Lihua, Hendrickson, Scott A., Hettwer, Eric, Ziv, Hadar, Andr, #233, Hoek, van der and Richardson, Debra J.
Year: 2006
Title: Towards supporting the architecture design process through evaluation of design alternatives
Conference Name: Proceedings of the ISSTA 2006 workshop on Role of software architecture for testing and analysis
Conference Location: Portland, Maine
Publisher: ACM
Pages: 81-87
DOI: 10.1145/1147249.1147260
Place Published: 1147260
Abstract: This paper addresses issues involved when an architect explore alternative designs including non-functional requirements; in our approach, non-functional requirements are expressed as state-charts. Non-functional requirements greatly impact the resulting design of a system because they naturally conflict with each other, crosscut the system at multiple points, and may be satisfied in a number of different ways. This makes correctly designing them early in the software lifecycle critical, since correcting them later can be extremely costly. Our approach supports an architect generating and evaluating many different design alternatives. This explorative process is not well supported by current techniques, which focus on documenting the result of this process, but not on assisting the designer during this process. We present an architecture-based approach that supports exploration of non-functional requirements expressed as statecharts. Our approach captures design alternatives of non-functional requirements separately, composes different system designs from these alternatives using a novel weaving technique, and analyzes the resulting design for specific qualities using simulation.


Reference Type:  Conference Paper
Record Number: 8173
Author: Alebrahim, Azadeh, Fassbender, Stephan, Filipczyk, Martin, Goedicke, Michael and Heisel, Maritta
Year: 2015
Title: Towards systematic selection of architectural patterns with respect to quality requirements
Conference Name: Proceedings of the 20th European Conference on Pattern Languages of Programs
Conference Location: Kaufbeuren, Germany
Publisher: ACM
Pages: 1-20
DOI: 10.1145/2855321.2855362
Place Published: 2855362
Abstract: The design of software architecture for a system-to-be is a challenge, since required functionality as well as the desired quality requirements have to be considered. Building upon common knowledge and best practices captured in architectural patterns has shown to be valuable in this context. However, existing solutions for deriving architectures from requirements mostly rely on experienced architects. Beside the required experience, it is often a problem that the decision is not properly reasoned and documented. In this paper, we propose a process to select appropriate architectural patterns with regards to given (quality) requirements for the system-to-be. The process uses problem frames for modeling requirements and relates requirements to architectural patterns by means of a question catalog. The answers to the questions indicate suitable architectural pattern candidates. The final decision making about the pattern to be used is supported with several steps and also takes tactics and their applicability for a pattern into account. This way, our proposed process connects requirements and architecture, guides even less experienced software engineers through the pattern selection process, provides support for decision making, and makes the decision rationale transparent. The expected target audience for this paper consists of both experienced and less-experienced software architects.


Reference Type:  Conference Proceedings
Record Number: 9164
Author: Ruscio, D. Di, Muccini, H., Pierantonio, A. and Pelliccione, P.
Year of Conference: 2006
Title: Towards weaving software architecture models
Conference Name: Fourth Workshop on Model-Based Development of Computer-Based Systems and Third International Workshop on Model-Based Methodologies for Pervasive and Embedded Software (MBD-MOMPES'06)
Pages: 10 pp.-112
Date: 30-30 March 2006
Short Title: Towards weaving software architecture models
DOI: 10.1109/MBD-MOMPES.2006.24
Keywords: Unified Modeling Language
software architecture
UML metamodels
directed weaving operations
model-driven architecture
software architecture models
software development
Architecture description languages
Computer architecture
Conferences
Connectors
Performance analysis
Programming
System recovery
Weaving
Abstract: Increasingly, UML metamodels and profiles are adopted to specify software architectures from different angles in order to cope with analysis specific modeling needs. In particular, whenever two or more analysis techniques are required over the same architectural model, different modeling tools and notations are required, and feedback from one model to the other is not propagated since integration is not universally established. Model-driven architecture offers a conceptual framework for defining a set of standards in support of model-driven development, where models are first class entities and play a central role in software development. In this paper, the coexistence and integration of different analysis techniques at the architectural level is reduced to the problem of enriching multi-view descriptions with proper UML elements by means of directed weaving operations
Notes: UML as technique


Reference Type:  Conference Proceedings
Record Number: 9423
Author: Fraga, A. and Llorens, J.
Year of Conference: 2007
Title: Training Initiative for New Software/Enterprise Architects: An Ontological Approach
Conference Name: 2007 Working IEEE/IFIP Conference on Software Architecture (WICSA'07)
Pages: 19-19
Date: 6-9 Jan. 2007
Short Title: Training Initiative for New Software/Enterprise Architects: An Ontological Approach
DOI: 10.1109/WICSA.2007.48
Keywords: computer science education
learning (artificial intelligence)
ontologies (artificial intelligence)
software architecture
training
ontological approach
reinforcement learning
software-enterprise architects
training courses
university studies
Certification
Computer architecture
Engineering profession
History
Learning
Ontologies
Seminars
Software engineering
Education
Methodology.
Software/Enterprise Architecture
Abstract: In this paper, we describe the importance of new software/enterprise architects in the discipline of software architecture and enterprise architecture. Both are often idealized as super heroes with a lot of qualities that are very infrequent in contemporary people. The enterprise/software architect role could be assumed by a group of people able to manage the qualities for the role. In any case, even a group or a single person must be educated in the discipline by training courses, new methodologies of learning, or traditional university studies. In order to improve the process of becoming a new architect we propose a methodology based on ontological structures and reinforcement learning.
Notes: learning approach


Reference Type:  Conference Proceedings
Record Number: 7646
Author: Kazman, R., Cervantes, H., Haziyev, S. and Hrytsay, O.
Year of Conference: 2016
Title: Tutorial Summary for Designing Software Architectures Using ADD 3.0
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 253-253
Date: 5-8 April 2016
Short Title: Tutorial Summary for Designing Software Architectures Using ADD 3.0
DOI: 10.1109/WICSA.2016.20
Keywords: object-oriented methods
software architecture
ADD 3.0
attribute driven design
Big data
Computer architecture
Context
Design methodology
Tutorials
Abstract: Attribute Driven Design (ADD)--a method for designing software architectures--was originally developed by the Software Engineering Institute in 2000.ADD 2.0, was published in 2006. Recently we have made some significant changes to ADD to make it easier to enact, to make it better aligned with the way that software is developed today, and hence to improve its adoption by the software architecture practitioner community.In this tutorial we will introduce ADD 3.0 and explain the key changes that we made to its previous versions. We will also present a detailed real-world case study, in the domain of big data, and walk the participants through a few iterations of the method showing how the steps are performed in practice. Then the participants will have the opportunity to enact several iterations of the method on their own. We will place particular emphasis on the design decisions that are made in the different design iterations: how different concepts are used in different iterations, and how these decisions are made more confidently through the use of a reusable catalog of design concepts, how these are documented, and how these can be analyzed within the design process.
Notes: Reuse of architecture patterns


Reference Type:  Conference Proceedings
Record Number: 7647
Author: Bosch, J.
Year of Conference: 2016
Title: Tutorial summary for speed, data and ecosystems: The future of software engineering
Conference Name: 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA)
Pages: 254-254
Date: 5-8 April 2016
Short Title: Tutorial summary for speed, data and ecosystems: The future of software engineering
DOI: 10.1109/WICSA.2016.18
Keywords: organisational aspects
software architecture
software prototyping
agile development practices
architecture dimension
architecture technical debt management
business dimension
continuous integration visualization
ecosystems
evidence-based development
organization dimension
process dimension
software engineering
Computer architecture
Tutorials
Abstract: The tutorial first discusses the trends that lead to our conclusion that the aforementioned factors are central for future software engineering. Based on this, we then discuss the implications that organizations will experience. These implications are concerned with the business, architecture, process and organization dimensions. For each dimension, we discuss specific methods and techniques. Examples include architecture technical debt management, visualization of continuous integration, techniques for evidence-based development as well as organizational models for combining architecture with agile development practices.
Notes: tutorial


Reference Type:  Journal Article
Record Number: 8699
Author: Lytra, Ioanna, Gaubatz, Patrick and Zdun, Uwe
Year: 2015
Title: Two controlled experiments on model-based architectural decision making
Journal: Information and Software Technology
Volume: 63
Pages: 58-75
Date: 7//
Short Title: Two controlled experiments on model-based architectural decision making
ISSN: 0950-5849
DOI: https://doi.org/10.1016/j.infsof.2015.03.006
Keywords: Architectural design decision
Architectural decision model
Architectural knowledge
Controlled experiment
Abstract: AbstractContext In recent years, architectural design decisions are becoming more and more common for documenting software architectures. Rather than describing the structure of software systems, architectural decisions capture the design rationale and – often reusable – architectural knowledge. Many approaches and tools have been proposed in the literature to support architectural decision making and documentation (for instance, based on models, ontologies, or templates). In this context, the capturing, organization, and effective reuse of architectural knowledge has gained a lot of attention. Objective However, there is little empirical evidence about the supportive effect of reusable architectural knowledge on the effectiveness and efficiency of architectural decision making. Method To investigate these aspects, we conducted two separate controlled experiments with software architecture students in which we tested the supportive effect of reusable decision models in decision making and documentation. Results Our results show that the use of reusable decision models can significantly increase both the efficiency and the effectiveness of novice architects. Conclusion We can report, that our findings are in line with similar studies and support the claims regarding reusable architectural design decisions in principle.
URL: https://www.sciencedirect.com/science/article/pii/S0950584915000634


Reference Type:  Conference Paper
Record Number: 7861
Author: Volpato, Tiago, Oliveira, Brauner R. N., Garc, Lina, #233, Capilla, Rafael and Nakagawa, Elisa Yumi
Year: 2017
Title: Two perspectives on reference architecture sustainability
Conference Name: Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings
Conference Location: Canterbury, United Kingdom
Publisher: ACM
Pages: 188-194
DOI: 10.1145/3129790.3129815
Place Published: 3129815
Abstract: In the context of software architectures, sustainability has been investigated as an important quality property to assess how well these architectures support changes over time. Several initiatives to achieve sustainable software architectures/systems can be already found. In parallel, reference architectures have served as an effective support to facilitate and standardize the development and evolution of software systems, including in complex, critical application domains. By encompassing valuable knowledge of specific domains, the reference architectures survival is considered of utmost importance, however, the most of such architectures have not been updated since their first version. Furthermore, there is a lack of works investigating how a reference architectures, by itself, can become sustainable and/or can contribute to develop sustainable systems in a domain. The main contribution of this paper is to provide a first view about sustainability on reference architectures. Resulting from our expertise on reference architectures, we bring out the two perspectives on their sustainability: (i) sustainability IN reference architectures; and (ii) sustainability OF reference architectures. In particular, for the perspective OF, we analyzed 20 existing reference architectures to assess their sustainability, and we found most of them were not updated over time. Hence, we also provide an initial set of aspects that could contribute to address sustainability of those architectures.
Notes: Reference architectures


Reference Type:  Conference Proceedings
Record Number: 9574
Author: Krikhaar, R., Postma, A., Sellink, A., Stroucken, M. and Verhoef, C.
Year of Conference: 1999
Title: A two-phase process for software architecture improvement
Conference Name: Software Maintenance, 1999. (ICSM '99) Proceedings. IEEE International Conference on
Pages: 371-380
Date: 1999
Short Title: A two-phase process for software architecture improvement
ISBN: 1063-6773
DOI: 10.1109/ICSM.1999.792635
Keywords: algebra
formal specification
program visualisation
software architecture
software metrics
software process improvement
Relation Partition Algebra
abstract syntax trees
architecture visualisation
changing system requirements
complexity control
fast feedback loop
formal transformation techniques
large systems
normal development process
product lines
quality aspects
renovation factories area
software architecture improvement
software architecture improvement process
software architecture transformation
transformation engines
two-phase process
Computer architecture
Consumer electronics
Control systems
Engines
Feedback loop
Laboratories
Production facilities
Software maintenance
Visualization
Abstract: Software architecture is important for large systems in which it is the main means for among other things, controlling complexity. Current ideas on software architectures were not available more than ten years ago. Software developed at that time has been deteriorating from an architectural point of view over the years, as a result of adaptations made in the software because of changing system requirements. Parts of the old software are nevertheless still being used in new product lines. To make changes in that software, like adding features, it is imperative to first adapt the software to accommodate those changes. Architecture improvement of existing software is therefore becoming more and more important. The paper describes a two-phase process for software architecture improvement, which is the synthesis of two research areas: the architecture visualisation and analysis area of Philips Research, and the transformation engines and renovation factories area of the University of Amsterdam. Software architecture transformation plays an important role, and is to our knowledge a new research topic. Phase one of the process is based on Relation Partition Algebra (RPA). By lifting the information to higher levels of abstraction and calculating metrics over the system, all kinds of quality aspects can be investigated. Phase two is based on formal transformation techniques on abstract syntax trees. The software architecture improvement process allows for a fast feedback loop on results, without the need to deal with the complete software and without any interference with the normal development process
Notes: extract information about architecture


Reference Type:  Conference Proceedings
Record Number: 9073
Author: Weitzel, B.
Year of Conference: 2012
Title: Understanding deployment costs of enterprise systems: Towards architecture support in deployment decisions
Conference Name: 2012 28th IEEE International Conference on Software Maintenance (ICSM)
Pages: 677-680
Date: 23-28 Sept. 2012
Short Title: Understanding deployment costs of enterprise systems: Towards architecture support in deployment decisions
ISBN: 1063-6773
DOI: 10.1109/ICSM.2012.6405352
Keywords: decision making
information systems
investment
reverse engineering
software architecture
software cost estimation
architecture support
conceptual deployment model
deployment decisions
deployment descriptors
downtime penalties
enterprise environment
enterprise system deployment costs
hardware infrastructure
large scale information systems
runtime traces
software deployment optimization
software license costs
usage profiles
Computer architecture
Hardware
Runtime
Servers
Software
Unified modeling language
Deployment
Software Maintenance
Abstract: The operation of large scale information systems requires investment into hardware infrastructure and causes running cost for keeping it in a productive state. This especially applies in an enterprise environment where also expenses for software licenses costs or penalties for downtime occur. The deployment of software influences these costs both in their amount and their composition. In order to optimize them a transparent view on these costs and the deployment is mandatory. In this paper, we present an approach for making deployment explicit on an architectural level. A conceptual model of deployment is defined that can be populated by reverse engineering of deployment descriptors, runtime traces and usage profiles. We envision fostering a comprehensive decision making and optimization of software deployment.
Notes: extract information about architecture


Reference Type:  Conference Proceedings
Record Number: 7792
Author: Bass, L. and Nord, R. L.
Year of Conference: 2012
Title: Understanding the Context of Architecture Evaluation Methods
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 277-281
Date: 20-24 Aug. 2012
Short Title: Understanding the Context of Architecture Evaluation Methods
DOI: 10.1109/WICSA-ECSA.212.45
Keywords: software architecture
architecture evaluation methods
contextual elements
industrial software architecture evaluation methods
technical personnel
Computer architecture
Context
Face
Industries
Organizations
comparison of architecture evaluation methods
contextual factors
software architecture evaluation methods
Abstract: This paper analyzes several industrial software architecture evaluation methods from the perspective of their contextual elements. Contextual elements include the time available for the evaluation, the personnel available, the openness of the results, the involvement of stakeholders, and so forth. The goal of this analysis is to inform managers and technical personnel about the possibilities for an architecture evaluation method given their particular context.


Reference Type:  Conference Paper
Record Number: 7956
Author: Egorova, Inga and Itsykson, Vladimir
Year: 2015
Title: Usage of design patterns as a kind of components of software architecture
Conference Name: Proceedings of the 11th Central &#38; Eastern European Software Engineering Conference in Russia
Conference Location: Moscow, Russia
Publisher: ACM
Pages: 1-9
DOI: 10.1145/2855667.2855679
Place Published: 2855679
Abstract: This survey is dedicated to the research and comparison of the key technologies, supporting systematic usage of design patterns. The approach to use the design patterns as an exclusive kind of components of software architecture based on the most modern patterns modeling concepts is suggested. The possible CAD program realization is described and the results obtained with it are demonstrated.
Notes: tool support for design patterns


Reference Type:  Conference Proceedings
Record Number: 7775
Author: That, M. T. T., Sadou, S. and Oquendo, F.
Year of Conference: 2012
Title: Using Architectural Patterns to Define Architectural Decisions
Conference Name: 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture
Pages: 196-200
Date: 20-24 Aug. 2012
Short Title: Using Architectural Patterns to Define Architectural Decisions
DOI: 10.1109/WICSA-ECSA.212.28
Keywords: conformance testing
program verification
software architecture
architectural decision conformance checking
architectural design decision
architectural model
architectural pattern
architecture development process
document architectural decision
nonfunctional property
pattern formalization technique
Computer architecture
Documentation
Object oriented modeling
Semantics
Semiconductor optical amplifiers
Unified modeling language
MDA
architectural decision
pattern
Abstract: During the architecture development process, architectural design decisions play an important role in maintaining non-functional properties of the system. Instead of supposing that architectural decisions are implicitly recognizable, existing works propose to give them first-class status. However, little focus is paid on the automation of architectural decision checking. This paper proposes to leverage pattern formalization techniques to document architectural decisions. The approach consists of a way to describe architectural patterns that hold the architectural decision definition, show how to integrate architectural decisions (patterns) into an architectural model and finally automate the architectural decision conformance checking.
Notes: tool for ADDs


Reference Type:  Conference Proceedings
Record Number: 8794
Author: Morveli-Espinoza, M., Possebom, A. T., Mendes, G. F. and Tacla, C. A.
Year of Conference: 2015
Title: Using argumentation for cooperative decision making process
Conference Name: 2015 IEEE 19th International Conference on Computer Supported Cooperative Work in Design (CSCWD)
Pages: 431-436
Date: 6-8 May 2015
Short Title: Using argumentation for cooperative decision making process
DOI: 10.1109/CSCWD.2015.7230998
Keywords: decision making
groupware
software agents
software architecture
argumentation model
cooperative decision making process
cooperative design work
intelligent agent architecture
software architecture design
Guidelines
Lead
Abstract: Decision making process is an important topic in cooperative design work, but it also can be a complex and long-running task, especially when many aspects must be decided, several parties are involved and there are conflicting points of view. One form of dealing with this complexity is automating all or part of the process. With the aim of giving a partial support, we propose a based-argumentation model for the decision making process. In our model, intelligent agents act on behalf of the human participants and after a decision making process a suggested decision is given. We also propose an agent architecture in which the knowledge is divided into data and beliefs, depending on a credibility value of the information. Finally, we give an example of the performance of our model in a scenario of software architecture design.


Reference Type:  Journal Article
Record Number: 8815
Author: Kerth, N. L. and Cunningham, W.
Year: 1997
Title: Using patterns to improve our architectural vision
Journal: IEEE Software
Volume: 14
Issue: 1
Pages: 53-59
Short Title: Using patterns to improve our architectural vision
ISSN: 0740-7459
DOI: 10.1109/52.566428
Keywords: object-oriented methods
object-oriented programming
software engineering
specification languages
objects
pattern languages
software architecture
software design
Art
Assembly
Computer architecture
Concrete
Design methodology
Glass
Programming
Prototypes
Abstract: Pattern languages can play an important role in furthering the use of architecture and objects in software design, but first we must understand what these terms mean. The authors use the work of Christopher Alexander (1975, 1979, 1981, 1985) to illuminate the problems and shed light on future directions in our use of pattern languages in design
Notes: pattern visualization


Reference Type:  Conference Paper
Record Number: 8167
Author: Wang, Wei and Burge, Janet E.
Year: 2010
Title: Using rationale to support pattern-based architectural design
Conference Name: Proceedings of the 2010 ICSE Workshop on Sharing and Reusing Architectural Knowledge
Conference Location: Cape Town, South Africa
Publisher: ACM
Pages: 1-8
DOI: 10.1145/1833335.1833336
Place Published: 1833336
Abstract: Architectural design rationale describes the decisions made, alternatives considered, and reasons for and against each alternative considered when defining a software architecture. At least some of these reasons should reference the non-functional requirements (NFRs) for the system. The SEURAT_Architecture system uses a pre-defined pattern library and the NFRs for a software system to guide the selection of architectural patterns. Each pattern recommended by the system serves as an alternative to the architectural decision made and comes with rationale for why this pattern is considered useful. This system serves several purposes---to guide the architect through the decision-making process, to ensure that NFRs are considered when making these critical early decisions, and to capture the rationale for the architecture as a byproduct of the tool-supported selection process.


Reference Type:  Conference Proceedings
Record Number: 9218
Author: Nord, R. L. and Cheng, B. C.
Year of Conference: 1994
Title: Using RMA for evaluating design decisions
Conference Name: Proceedings of 2nd IEEE Workshop on Real-Time Applications
Pages: 76-80
Date: 21-22 Jul 1994
Short Title: Using RMA for evaluating design decisions
DOI: 10.1109/RTA.1994.316146
Keywords: formal specification
real-time systems
software engineering
systems analysis
RMA
architectural integrity
communication behavior
dependency analysis
design decision evaluation
large complex software
nonfunctional properties
performance
real-time
safety-critical
schedulability analysis
software architecture
specification
synchronization
system structure
Communication system control
Computer architecture
Control system analysis
Control systems
Design methodology
Feedback
Performance analysis
Real time systems
Software systems
Abstract: Software architecture plays a central role in large, complex software systems with real-time or safety-critical requirements. We are investigating design methods based on software architecture, and techniques to specify, represent, and analyze them. As a practical matter we have decided to focus our architectural research on system structure, communication behavior and specific non-functional properties such as performance, synchronization, architectural integrity, dependency analysis and control. In this paper we show how software architecture can provide support for early performance and schedulability analysis, and how the resulting analysis can also provide feedback to evaluate the design decisions made at the architecture level


Reference Type:  Conference Paper
Record Number: 7867
Author: Nakagawa, Elisa Yumi, Feitosa, Daniel and Felizardo, Katia Romero
Year: 2010
Title: Using systematic mapping to explore software architecture knowledge
Conference Name: Proceedings of the 2010 ICSE Workshop on Sharing and Reusing Architectural Knowledge
Conference Location: Cape Town, South Africa
Publisher: ACM
Pages: 29-36
DOI: 10.1145/1833335.1833340
Place Published: 1833340
Abstract: Software architectures have played a significant role in determining the success of software systems. In this perspective, a lot of work have been conducted and considerable knowledge in the software architecture area has been accumulated. In another perspective, systematic mapping is a technique that provides an overview of a research area to assess the quantity of evidence existing on a topic of interest. Thus, the main objective of this paper is to introduce systematic mapping in order to explore, understand, organize and summarize software architecture knowledge, aiming at contributing to software architecture area. A simple example of use of this technique is presented and results point out to its viability also in the software architecture research area.
Notes: Kind of review


Reference Type:  Conference Paper
Record Number: 7984
Author: Wang, Shangzhu, Avrunin, George S. and Clarke, Lori A.
Year: 2006
Title: Verification support for plug-and-play architectural design
Conference Name: Proceedings of the ISSTA 2006 workshop on Role of software architecture for testing and analysis
Conference Location: Portland, Maine
Publisher: ACM
Pages: 49-50
DOI: 10.1145/1147249.1147255
Place Published: 1147255
Abstract: In software architecture, connectors are intended to represent the specific semantics of how components interact with each other, capturing some of the most important yet subtle aspects of a system. In practice, choosing the appropriate interaction semantics for the connectors in a system tends to be very difficult. The typical design process often involves not only a choice from commonly used interaction mechanisms, such as remote procedure call, message passing, and publish/subscribe, but also decisions about such details as the particular type and size of a message buffer or whether a communication should be synchronous or asynchronous. Given such a large design space, it is important that designers be able to get feedback about the appropriateness of their design decisions on interaction semantics, based on the correctness of the overall system behavior. In particular, one would like to be able to propose a design, and then use design-time verification to determine whether important properties of the system are satisfied. This practice may repeat until a desired design of the system is achieved.
Notes: tool


Reference Type:  Conference Proceedings
Record Number: 9017
Author: Brondum, J. and Zhu, L.
Year of Conference: 2012
Title: Visualising architectural dependencies
Conference Name: 2012 Third International Workshop on Managing Technical Debt (MTD)
Pages: 7-14
Date: 5-5 June 2012
Short Title: Visualising architectural dependencies
DOI: 10.1109/MTD.2012.6226003
Keywords: decision making
industrial property
software architecture
software metrics
COTS
architectural dependency visualization
architectural knowledge
architecture related debt
behavioural dependency
code level violations
complex dependency
dependency analysis
dependency relationship visualization
heterogeneous environments
implicit dependency
intellectual property rights
legal contracts
limiting factors
multidimensional property
programming languages
software dependency complexity
structural dependency
sufficient code visibility
system level decision-making processes
technical debt visibility
Architectural Debt
Architectural Dependency Analysis
Abstract: Visibility of technical debt is critical. A lack thereof can lead to significant problems without adequate visibility as part of the system level decision-making processes [2]. Current approaches for analysing and monitoring architecture related debt are based on dependency analysis to detect code level violations of the software architecture [2,3,6]. However, heterogeneous environments with several systems constructed using OTS, and/or several programming languages may not offer sufficient code visibility. Other limiting factors include legal contracts, Intellectual Property Rights, and just very large systems. Secondly, the complexity of a software dependency is often greater than simple structural dependencies, including; multi-dimensional properties (as argued by [10]); behavioural dependencies [5,9]; and `implicit' dependencies (i.e., dependency inter-relatedness [11]). This paper proposes a simple modelling approach for visualising dependency relationships as an extension of the current approaches, while supporting complex dependencies. The model can be built using existing dependency analysis and general architectural knowledge; thus is better suited for heterogeneous environments. We demonstrate the proposed modelling using an exemplar, and two field case studies.


Reference Type:  Journal Article
Record Number: 9552
Author: Zhang, C. and Budgen, D.
Year: 2012
Title: What Do We Know about the Effectiveness of Software Design Patterns?
Journal: IEEE Transactions on Software Engineering
Volume: 38
Issue: 5
Pages: 1213-1231
Short Title: What Do We Know about the Effectiveness of Software Design Patterns?
ISSN: 0098-5589
DOI: 10.1109/TSE.2011.79
Keywords: object-oriented programming
software maintenance
Gang-of-Four
design structures
knowledge transfer
object-oriented design patterns
software design patterns
software development
software engineering
Maintenance engineering
Search engines
Software design
Systematics
Terminology
Design patterns
empirical software engineering
systematic literature review
Abstract: Context. Although research in software engineering largely seeks to improve the practices and products of software development, many practices are based upon codification of expert knowledge, often with little or no underpinning from objective empirical evidence. Software design patterns seek to codify expert knowledge to share experience about successful design structures. Objectives. To investigate how extensively the use of software design patterns has been subjected to empirical study and what evidence is available about how and when their use can provide an effective mechanism for knowledge transfer about design. Method. We conducted a systematic literature review in the form of a mapping study, searching the literature up to the end of 2009 to identify relevant primary studies about the use of the 23 patterns catalogued in the widely referenced book by the &#x201C;Gang of Four.&#x201D; These studies were then categorized according to the forms of study employed, the patterns that were studied, as well as the context within which the study took place. Results. Our searches identified 611 candidate papers. Applying our inclusion/exclusion criteria resulted in a final set of 10 papers that described 11 instances of &#x201C;formal&#x201D; experimental studies of object-oriented design patterns. We augmented our analysis by including seven &#x201C;experience&#x201D; reports that described application of patterns using less rigorous observational forms. We report and review the profiles of the empirical evidence for those patterns for which multiple studies exist. Conclusions. We could not identify firm support for any of the claims made for patterns in general, although there was some support for the usefulness of patterns in providing a framework for maintenance, and some qualitative indication that they do not help novices learn about design. For future studies we recommend that researchers use case studies that focus upon some key patterns, and seek to id- ntify the impact that their use can have upon maintenance.
Notes: Literature review


Reference Type:  Conference Proceedings
Record Number: 9120
Author: Breivold, H. P., Sundmark, D., Wallin, P. and Larsson, S.
Year of Conference: 2010
Title: What Does Research Say about Agile and Architecture?
Conference Name: 2010 Fifth International Conference on Software Engineering Advances
Pages: 32-37
Date: 22-27 Aug. 2010
Short Title: What Does Research Say about Agile and Architecture?
DOI: 10.1109/ICSEA.2010.12
Keywords: software architecture
software prototyping
agile development
flexible development
rapid development
software development
Computer architecture
Conferences
Data mining
Programming
Software
Agile
Agile methodology
Architecture
Abstract: Agile has been used to refer to a software development paradigm that emphasizes rapid and flexible development. In the meanwhile, we have through our practical experiences in scaling up agile methods, noticed that architecture plays an important role. Due to the inter-relationship between agile methods and architecture, as well as divergent perceptions on their correlation stated in numerous sources, we are motivated to find out how these perceptions are supported by findings in the research community in general and in empirical studies in particular. To fully benefit from agile practices and architectural disciplines, we need empirical data on the perceived and experienced impacts of introducing agile methods to existing software development process, as well as correlations between agile and architecture. In this paper, we survey the research literature for statements made regarding the relationship between agile development and software architecture. The main findings are that there is a lack of scientific support for many of the claims that are concerned with agile and architecture, and more empirical studies are needed to fully reveal the benefits and drawbacks implied by an agile software development method.
Notes: literature review


Reference Type:  Journal Article
Record Number: 8773
Author: Voas, J. and Kuhn, R.
Year: 2017
Title: What Happened to Software Metrics?
Journal: Computer
Volume: 50
Issue: 5
Pages: 88-98
Short Title: What Happened to Software Metrics?
ISSN: 0018-9162
DOI: 10.1109/MC.2017.144
Keywords: Context
Organizations
Software
Software engineering
Software metrics
Tools
Virtual Roundtable
history of computing
software architecture
software quality
software testing
Abstract: A panel of seven experts discuss the past 40 years of software metrics, with a focus on evidence-based methods.
Notes: Panel discussion


Reference Type:  Journal Article
Record Number: 8417
Author: Tang, Antony, Aleti, Aldeida, Burge, Janet and van Vliet, Hans
Year: 2010
Title: What makes software design effective?
Journal: Design Studies
Volume: 31
Issue: 6
Pages: 614-640
Date: 11//
Short Title: What makes software design effective?
ISSN: 0142-694X
DOI: https://doi.org/10.1016/j.destud.2010.09.004
Keywords: software design
decision making
design reasoning
design effectiveness
Abstract: Software design is a complex cognitive process in which decision making plays a major role, but our understanding of how decisions are made is limited, especially with regards to reasoning with design problems and formulation of design solutions. In this research, we have observed software designers at work and have analysed how they make decisions during design. We report on how factors such as design planning, design context switching, problem-solution co-evolution and the application of reasoning techniques influence software design effectiveness.
URL: https://www.sciencedirect.com/science/article/pii/S0142694X10000669
'File' Attachments: internal-pdf://0072961136/What makes software design effective.pdf


Reference Type:  Journal Article
Record Number: 8863
Author: Erder, M. and Pureur, P.
Year: 2017
Title: What Type of People Are Software Architects?
Journal: IEEE Software
Volume: 34
Issue: 4
Pages: 20-22
Short Title: What Type of People Are Software Architects?
ISSN: 0740-7459
DOI: 10.1109/MS.2017.103
Keywords: psychometric testing
software architecture
software architect
Computer architecture
Monitoring
Pragmatics
Psychology
Sociology
Software engineering
Statistics
Belbin Team Roles
HBDI
Herrmann Brain Dominance Instrument
MBTI
Myers-Briggs Type Indicator
personality testing
psychometrics
software development
Abstract: Psychometrics measures mental traits, abilities, and processes. This article presents popular industry approaches to psychometric testing and how to apply them to the role of the software architect.


Reference Type:  Journal Article
Record Number: 9639
Author: Erder, M. and Pureur, P.
Year: 2016
Title: What's the Architect's Role in an Agile, Cloud-Centric World?
Journal: IEEE Software
Volume: 33
Issue: 5
Pages: 30-33
Short Title: What's the Architect's Role in an Agile, Cloud-Centric World?
ISSN: 0740-7459
DOI: 10.1109/MS.2016.119
Keywords: software architecture
software prototyping
agile architecture
agile cloud-centric world
architectural decisions
continuous architecture
Computer architecture
Microarchitecture
Pragmatics
Software engineering
Stakeholders
agile
cloud
software architect
software development
Abstract: The software architecture pendulum is swinging away from traditional practices and toward agile and continuous practices. To be successful in this new world, architects should emphasize products over projects, drive architectural decisions, understand code, and communicate and collaborate effectively with delivery teams.


Reference Type:  Conference Paper
Record Number: 8340
Author: Kowalski, Luke, Ashley, Jeremy and Vaughan, Misha W.
Year: 2006
Title: When design is not the problem: better usability through non-design means
Conference Name: CHI '06 Extended Abstracts on Human Factors in Computing Systems
Conference Location: Montr&#233;al, Qu&#233;bec, Canada
Publisher: ACM
Pages: 165-170
DOI: 10.1145/1125451.1125488
Place Published: 1125488
Abstract: When it comes to shipping quality software, design is not the hard part. Methods and techniques to study users, best practices for creating iterative designs, and tools to validate them are all very well documented. Unfortunately, in chaotic and complex ecosystems very few of the designs actually end up making it through the user-centered design (UCD) process. Interaction designers' input is either ignored or interpreted through a development/business lens and considerable fidelity is lost. As a result, designers too often throw up their hands and blame the technology or the organizations. These barriers can be overcome if designers broaden their roles and better understand other stakeholders' charters. Successful collaboration with other disciplines that make up the software development lifecycle is the key to success. Practical case studies will be discussed where usability, attractiveness, and good design were achieved through non-design means. Poor information architecture, screen layout, and task flows were not the barriers to usability. Design impact was made instead through overcoming barriers in technology, organizational structure, legal, marketing, documentation / quality assurance (QA), and development tools.


Reference Type:  Conference Proceedings
Record Number: 7680
Author: Tamburri, D. A. and Nitto, E. D.
Year of Conference: 2015
Title: When Software Architecture Leads to Social Debt
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 61-64
Date: 4-8 May 2015
Short Title: When Software Architecture Leads to Social Debt
DOI: 10.1109/WICSA.2015.16
Keywords: social sciences computing
software architecture
DAHLIA
connected debt
debt-aimed architecture-level incommunicability analysis
development artefacts
industrial case-study
social debt
sociotechnical interactions
software development organizations
technical debt
Computer architecture
Interviews
Measurement
Organizational aspects
Osmosis
Software
Abstract: Social and technical debt both represent the state of software development organizations as a result of accumulated decisions. In the case of social debt, decisions (and connected debt) weigh on people and their socio-technical interactions/characteristics. Digging deeper into social debt with an industrial case-study, we found that software architecture, the prince of development artefacts, plays a major role in causing social debt. This paper discusses a key circumstance wherefore social debt is connected to software architectures and what can be done and measured in response, as observed in our case-study. Also, we introduce DAHLIA, that is "Debt-Aimed Architecture-Level Incommunicability Analysis" - a framework to elicit some of the causes behind social debt for further analysis.


Reference Type:  Conference Paper
Record Number: 7921
Author: Creighton, Oliver and Singer, Matthias
Year: 2008
Title: Who leads our future leaders?: on the rising relevance of social competence in software development
Conference Name: Proceedings of the first international workshop on Leadership and management in software architecture
Conference Location: Leipzig, Germany
Publisher: ACM
Pages: 23-26
DOI: 10.1145/1373307.1373315
Place Published: 1373315
Abstract: Siemens is currently developing a curriculum for several software engineering roles. Our first step was the role of Senior Software Architect. As social competence becomes increasingly important for all software professionals, we argue that reflection is the key to improve a person's skill profile. We believe that a standard component of software development education should be the ability to realistically self-assess one's own effectiveness.


Reference Type:  Conference Proceedings
Record Number: 7682
Author: Naab, M., Braun, S., Lenhart, T., Hess, S., Eitel, A., Magin, D., Carbon, R. and Kiefer, F.
Year of Conference: 2015
Title: Why Data Needs more Attention in Architecture Design - Experiences from Prototyping a Large-Scale Mobile App Ecosystem
Conference Name: 2015 12th Working IEEE/IFIP Conference on Software Architecture
Pages: 75-84
Date: 4-8 May 2015
Short Title: Why Data Needs more Attention in Architecture Design - Experiences from Prototyping a Large-Scale Mobile App Ecosystem
DOI: 10.1109/WICSA.2015.13
Keywords: mobile computing
software architecture
software prototyping
software quality
agricultural domain
architectural drivers
architecture decision management
architecture design
computer science
data modeling
information systems
large-scale mobile app ecosystem prototyping
system quality attributes
Computer architecture
Context
Data models
Databases
Ecosystems
Mobile communication
Synchronization
app ecosystem
data
mobile
practical experiences
Abstract: Data is of great importance in computer science and in particular in information systems and how data is treated has major impact on a system's quality attributes. Nevertheless, software architecture research, literature, and practice often neglect data and focus instead on other architectural topics like components and connectors or the management of architecture decisions in general. This paper contributes experiences from the prototyping of a large-scale mobile app ecosystem for the agricultural domain. Architectural drivers like multi-tenancy, different technical platforms and offline capability led to deep reasoning about data. In this paper, we describe the architectural decisions made around data in the app ecosystem and we present our lessons learned on technical aspects regarding data, but also on data modeling and general methodical aspects how to treat data in architecting. We want to share these experiences with the research community to stimulate more research on data in software architecture and we want to give practitioners usable hints for their daily work around data in constructing large information systems and ecosystems.


Reference Type:  Conference Proceedings
Record Number: 9414
Author: Lockhart, S. and Mehrotra, R.
Year of Conference: 2000
Title: Writing as software development: making meaning before, after, and of the code
Conference Name: 18th Annual Conference on Computer Documentation. ipcc sigdoc 2000. Technology and Teamwork. Proceedings. IEEE Professional Communication Society International Professional Communication Conference an
Pages: 205-219
Date: 2000
Short Title: Writing as software development: making meaning before, after, and of the code
DOI: 10.1109/IPCC.2000.887492
Keywords: software architecture
system documentation
technical presentation
user interfaces
human computer interaction
product development
software development
software product life cycle
technical writing
Collaboration
Collaborative software
Computer architecture
Documentation
Programming
Refining
Software tools
Solid modeling
Writing
Abstract: This paper presents some thoughts on redefining a technical writer's role in the software development process. It outlines ways in which writers can use their writing skills to collaborate with and add value to the HCI (human computer interaction) and software architecture functions. It also points to areas that writers need to explore further to discover the ways in which they can contribute meaningfully to information, and therefore product development throughout the life cycle of the software product. It uses real-life examples to illustrate ways in which writers can transform documentation from an item on the laundry list of deliverables into an effective design and development tool