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: 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:  Book Section
Record Number: 7503
Author: Zalewski, Andrzej and Kijas, Szymon
Year: 2010
Title: Architecture Decision-Making in Support of Complexity Control
Editor: Babar, Muhammad Ali and Gorton, Ian
Book Title: Software Architecture: 4th European Conference, ECSA 2010, Copenhagen, Denmark, August 23-26, 2010. Proceedings
Place Published: Berlin, Heidelberg
Publisher: Springer Berlin Heidelberg
Pages: 501-504
Short Title: Architecture Decision-Making in Support of Complexity Control
ISBN: 978-3-642-15114-9
DOI: 10.1007/978-3-642-15114-9_50
Label: Zalewski2010
Abstract: The main challenge of software engineering has always been to bring software complexity under control. Different kinds of abstractions have been devised and applied for that purpose at different levels of software design. Some of them have proven successful, such as function hierarchies, layers, API’s, abstract classes, encapsulation, interfaces etc. and are widely used in practice. Concepts from the genre of software architecture should also help to manage software complexity. We argue that, before architecture decisions and architecture decision-making become a common industrial practice, they have to support software complexity management much more efficiently than at present. Despite the substantial progress already made, it is still a major challenge both in theory (architecture decisions representation and architecture decision-making methods) and practice (tool support).
URL: https://doi.org/10.1007/978-3-642-15114-9_50


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 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:  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: 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: 8826
Author: Jingqiu, Shao and Far, B. H.
Year of Conference: 2004
Title: Development of an intelligent system for architecture design and analysis [software architecture]
Conference Name: Canadian Conference on Electrical and Computer Engineering 2004 (IEEE Cat. No.04CH37513)
Volume: 1
Pages: 539-542 Vol.1
Date: 2-5 May 2004
Short Title: Development of an intelligent system for architecture design and analysis [software architecture]
ISBN: 0840-7789
DOI: 10.1109/CCECE.2004.1345092
Keywords: inference mechanisms
knowledge representation
software architecture
software quality
software tools
ADD
architectural alternatives exploration
architectural information
attribute driven design method
design process support tools
intelligent software architecture design system
knowledge base
quality attributes
reasoning mechanisms
software architecture analysis
user requirements
Business communication
Computer architecture
Design engineering
Information analysis
Intelligent systems
Knowledge engineering
Maintenance engineering
Software design
Software maintenance
Abstract: Software architecture plays a pivotal role in allowing an organization to meet its business goals, in terms of the early insights it provides into the system, the communication it enables among stakeholders, and the value it provides as a re-usable asset. Unfortunately, designing and analyzing architecture for a certain system is recognized as a hard task for most software engineers, because the process of collecting, maintaining, and validating architectural information is complex, knowledge-intensive, iterative, and error prone. The needs of software architectural design and analysis have led to a desire to create tools to support the process. This paper introduces an intelligent system, which serves the following purposes: to obtain meaningful nonfunctional requirements from users; to aid in exploring architectural alternatives; and to facilitate architectural analysis.


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 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:  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:  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 “right”. 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 “right” 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:  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: 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:  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 “replacement-compensation” is used for software system reengineering problems or for directed choice of software architecture.


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 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 Proceedings
Record Number: 9441
Author: Li, L., Xu, Y., Li, X., Liu, L. and Fang, X.
Year of Conference: 2008
Title: Research on Software Architecture for Expert System in Practice
Conference Name: 2008 Third International Conference on Pervasive Computing and Applications
Volume: 1
Pages: 17-21
Date: 6-8 Oct. 2008
Short Title: Research on Software Architecture for Expert System in Practice
DOI: 10.1109/ICPCA.2008.4783569
Keywords: expert systems
software architecture
agro-meteorology
database technology
expert system
machine learning
quotient space
real-time process control
Application software
Databases
Knowledge management
Problem-solving
Process control
Real time systems
Space technology
intelligence software
software component
Abstract: Advanced applications in fields such as expert system, real-time process control problem solving, machine learning require the construction, efficient access and management of large, shared knowledge bases. Such knowledge bases cannot be built using existed tools such as expert system shells, because these do not scale up, nor can be built in terms of existing database technology, because such technology does not support the rich representational structure and inference mechanisms required for knowledge-based systems. This paper proposes a generic architecture for a knowledge base management system intended for such applications. The software architecture assumes quotient space structure which analyses identic problem in different granularity space. A new software architecture model for knowledge base system based on quotient space is given. The atomic component, quotient component connector and configuration are defined As an example, a knowledge base system framework for agro-meteorology is described Some components and a configuration about agro-meteorology are given. All above work sets up basic theory of software architecture for knowledge base system based on quotient space and provides new way for further research.


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:  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 “rethink the fundamentals of how software is made” 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 “inhabit” 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:  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:  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 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: 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 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