Relevant bibliographies by topics / Software architecture / Journal articles
To see the other types of publications on this topic, follow the link: Software architecture.

Journal articles on the topic 'Software architecture'

Author: Grafiati
Published: 4 June 2021
Last updated: 31 July 2024

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Software architecture.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Sahlabadi, Mahdi, Ravie Chandren Muniyandi, Zarina Shukur, and Faizan Qamar. "Lightweight Software Architecture Evaluation for Industry: A Comprehensive Review." Sensors 22, no. 3 (February 7, 2022): 1252. http://dx.doi.org/10.3390/s22031252.

Full text
Abstract:
Processes for evaluating software architecture (SA) help to investigate problems and potential risks in SA. It is derived from many studies that proposed a plethora of systematic SA evaluation methods, while industrial practitioners currently refrain from applying them since they are heavyweight. Nowadays, heterogeneous software architectures are organized based on the new infrastructure. Hardware and associated software allow different systems, such as embedded, sensor-based, modern AI, and cloud-based systems, to cooperate efficiently. It brings more complexities to SA evaluation. Alternatively, lightweight architectural evaluation methods have been proposed to satisfy the practitioner’s concerns, but practitioners still do not adopt these methods. This study employs a systematic literature review with a text analysis of SA’s definitions to propose a comparison framework for SA. It identifies lightweight features and factors to improve the architectural evaluation methods among industrial practitioners. The features are determined based on the practitioner’s concerns by analyzing the architecture’s definitions from stakeholders and reviewing architectural evaluation methods. The lightweight factors are acquired by studying the five most commonly used lightweight methods and the Architecture-based Tradeoff Analysis Method (ATAM), the most well-known heavyweight method. Subsequently, the research addresses these features and factors.
APA, Harvard, Vancouver, ISO, and other styles
2

WOODSIDE, C. M. "SOFTWARE RESOURCE ARCHITECTURE." International Journal of Software Engineering and Knowledge Engineering 11, no. 04 (August 2001): 407–29. http://dx.doi.org/10.1142/s0218194001000608.

Full text
Abstract:
Performance is determined by a system's resources and its workload. Some of the resources are software resources which are an aspect of the software architecture; some of them are even created by the software behaviour. This paper describes software resources and resource architecture, and shows how resource architecture can be determined from software architecture and behaviour. The resource architecture is distinct from views of software architecture which describe software components, but it is related to the so-called "execution view" of architecture. The paper considers how resource architecture emerges during design, the relationship of software and hardware resources, some classes of resource architecture, and what they can tell us about system performance. Other uses of resource architecture are, to analyze deadlocks, to understand special software architectures developed for demanding situations, and to analyze how subsystems fit together when they share resources. Resource architecture can be described using description languages (ADLs) developed for software architecture.
APA, Harvard, Vancouver, ISO, and other styles
3

Medvidovic, Nenad, Eric M. Dashofy, and Richard N. Taylor. "The Role of Middleware in Architecture-Based Software Development." International Journal of Software Engineering and Knowledge Engineering 13, no. 04 (August 2003): 367–93. http://dx.doi.org/10.1142/s0218194003001330.

Full text
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. In practice, middleware can resolve various types of component heterogeneity — across platform and language boundaries, for instance — but also can induce unwanted architectural constraints on application development. We present an approach in which components communicate through architecture-level software connectors that are implemented using middleware. This approach preserves the properties of the architecture-level connectors while leveraging the beneficial capabilities of the underlying middleware. We have implemented this approach in the context of a component- and message-based architectural style called C2 and demonstrated its utility in the context of several diverse applications. We argue that our approach provides a systematic and reasonable way to bridge the gap between architecture-level connectors and implementation-level middleware packages.
APA, Harvard, Vancouver, ISO, and other styles
4

Ponnala Gangadhar Adepu, Ramesh. "Modeling Software Architecture with UML." International Journal of Science and Research (IJSR) 1, no. 3 (March 5, 2012): 21–26. http://dx.doi.org/10.21275/ijsr12120316.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

McGregor, John D. "Software Architecture." Journal of Object Technology 3, no. 5 (2004): 65. http://dx.doi.org/10.5381/jot.2004.3.5.c7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Anderson, Bruce, Mary Shaw, Larry Best, and Kent Beck. "Software architecture." ACM SIGPLAN Notices 28, no. 10 (October 1993): 356–59. http://dx.doi.org/10.1145/167962.165922.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Roško, Zdravko. "Business Applications Architecture Model Based on Software Product Line Approach." Research Papers Faculty of Materials Science and Technology Slovak University of Technology 21, Special-Issue (June 1, 2013): 90–97. http://dx.doi.org/10.2478/rput-2013-0015.

Full text
Abstract:
Abstract Software product line architecture is one of the most important artifacts defined at the early stage of a product line development process. Since the rest of the products are developed based on the initial product line architecture, it is of high importance to ensure the architecture stability by enabling the software’s evolution possibilities. Industrial evidence shows that companies spend more resources on maintaining and evolving their architecture and products than on the initial development of them. Hence, there is a need for flexible software architecture that stays stable as the requirements evolve. In this paper we propose a structural model, some architecture quality metrics, case-based reasoning methodology to predict the architectural stability and a feature model for business applications. The goal of the proposed architecture model is to develop a framework for business applications development and evaluating the stability of product line architectures in the face of changes in requirements.
APA, Harvard, Vancouver, ISO, and other styles
8

Sarma, U. V. R., Neelakantam Pavani Pavani, and P. Premchand. "Building Software Architecture using Architectural Design Patterns." International Journal of Science and Engineering Applications 2, no. 4 (April 1, 2013): 71–77. http://dx.doi.org/10.7753/ijsea0204.1004.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Donins, Uldis, and Janis Osis. "Reconciling software requirements and architectures within MDA." Scientific Journal of Riga Technical University. Computer Sciences 38, no. 38 (January 1, 2009): 84–95. http://dx.doi.org/10.2478/v10143-009-0007-9.

Full text
Abstract:
Reconciling software requirements and architectures within MDAIn the software development world little guidance and few methods are available for reconciling software requirements and architecture which satisfies those requirements. In fact none of these methods use formal basis for the reconciling process. The main goal of this paper is to define an approach by which it is possible to reconcile software requirements and architectures within model driven architecture. Model driven architecture considers system from three viewpoints. Each viewpoint has its own model by which the viewpoint is modelled. It is possible to use topological functioning model of system to reconcile software requirements and architectures and to make formal transformation from computation independent model into platform independent model. The use of topological functioning model provides possibility for traceability between software artefacts, e.g. between requirements and architecture elements. By using case study we have proven that it is possible to reconcile requirements and architectures by using topological functioning model. The software architecture in this case is modelled by using topological class diagrams. At the end of the case study we have shown how we can introduce more formalism into UML diagrams by transforming topology from topological functioning model to class diagrams.
APA, Harvard, Vancouver, ISO, and other styles
10

Sarma, A. D. N. "A Generic Functional Architecture for Operational BI System." International Journal of Business Intelligence Research 9, no. 1 (January 2018): 64–77. http://dx.doi.org/10.4018/ijbir.2018010105.

Full text
Abstract:
In recent years, Operational Business Intelligence has emerged as an important trend in the Business Intelligence (BI) market. Majority of BI application architectures are bespoke in nature which have several architectural limitations like tightly coupled, static, historic, subjective, no performance measurement of business processes, limited user access, limited analytical processing, querying and reporting features. In this article, a generic functional architecture for Operational BI systems based on software architecture principles is presented. All functional modules of the system are derived from the key features of the system and by using top down approach of software design principles. The similar functional modules are grouped into sub-systems and a set of these sub-systems constitutes overall functional architecture. The proposed architecture overcomes the limitations of traditional BI architectures.
APA, Harvard, Vancouver, ISO, and other styles
11

Rocha, Fábio Gomes, Sanjay Misra, and Michel S. Soares. "Guidelines for Future Agile Methodologies and Architecture Reconciliation for Software-Intensive Systems." Electronics 12, no. 7 (March 28, 2023): 1582. http://dx.doi.org/10.3390/electronics12071582.

Full text
Abstract:
Background: Several methodologies have been proposed since the first days of software development, from what is now named traditional/heavy methodologies, and later their counterpart, the agile methodologies. The whole idea behind agile methodologies is to produce software at a faster pace than what was considered with plan-based methodologies, which had a greater focus on documenting all tasks and activities before starting the proper software development. Problem: One issue here is that strict agilists are often against fully documenting the software architecture in the first phases of a software process development. However, architectural documentation cannot be neglected, given the well-known importance of software architecture to the success of a software project. Proposed Solution: In this article, we describe the past and current situation of agile methodologies and their relation to architecture description, as well as guidelines for future Agile Methodologies and Architecture Reconciliation. Method: We propose a literature review to understand how agile methodologies and architecture reconciliation can help in providing trends towards the success of a software project and supporting software development at a faster pace. This work was grounded in General Systems Theory as we describe the past, present, and future trends for rapid systems development through the integration of organizations, stakeholders, processes, and systems for software development. Summary of results: As extensively discussed in the literature, we found that there is a false dichotomy between agility and software architecture, and then we describe guidelines for future trends in agile methodologies and reconciliation of architecture to document agile architectures with both architectural decisions and agile processes for any system, as well as future trends to support organizations, stakeholders, processes, and systems.
APA, Harvard, Vancouver, ISO, and other styles
12

ZHANG, Li. "Software Architecture Evaluation." Journal of Software 19, no. 6 (October 21, 2008): 1328–39. http://dx.doi.org/10.3724/sp.j.1001.2008.01328.

Full text
APA, Harvard, Vancouver, ISO, and other styles
13

Anderson, Bruce, Mary Shaw, Larry Best, and Kent Beck. "Software architecture (panel)." ACM SIGPLAN OOPS Messenger 5, no. 2 (April 1994): 63–66. http://dx.doi.org/10.1145/260304.260321.

Full text
APA, Harvard, Vancouver, ISO, and other styles
14

Garlan, David. "Software architecture (panel)." ACM SIGSOFT Software Engineering Notes 20, no. 4 (October 1995): 5. http://dx.doi.org/10.1145/222132.222134.

Full text
APA, Harvard, Vancouver, ISO, and other styles
15

Barber, K. S., and J. Holt. "Software architecture correctness." IEEE Software 18, no. 6 (2001): 64–65. http://dx.doi.org/10.1109/52.965805.

Full text
APA, Harvard, Vancouver, ISO, and other styles
16

Del Ra, William. "Software systems architecture." ACM SIGSOFT Software Engineering Notes 37, no. 2 (April 3, 2012): 36. http://dx.doi.org/10.1145/2108144.2108171.

Full text
APA, Harvard, Vancouver, ISO, and other styles
17

Miyachi, Christine. "Agile software architecture." ACM SIGSOFT Software Engineering Notes 36, no. 2 (March 14, 2011): 1–3. http://dx.doi.org/10.1145/1943371.1943388.

Full text
APA, Harvard, Vancouver, ISO, and other styles
18

Innocente, V., L. Silvestris, and D. Stickland. "CMS software architecture." Computer Physics Communications 140, no. 1-2 (October 2001): 31–44. http://dx.doi.org/10.1016/s0010-4655(01)00253-3.

Full text
APA, Harvard, Vancouver, ISO, and other styles
19

Davis, Margaret J., and Roger B. Williams. "Software architecture characterization." ACM SIGSOFT Software Engineering Notes 22, no. 3 (May 1997): 30–38. http://dx.doi.org/10.1145/258368.258380.

Full text
APA, Harvard, Vancouver, ISO, and other styles
20

Xu, Hongzhen, Wenlin Song, and Zhiqiang Liu. "A Specification and Detection Approach for Parallel Evolution Conflicts of Software Architectures." International Journal of Software Engineering and Knowledge Engineering 27, no. 03 (April 2017): 373–98. http://dx.doi.org/10.1142/s0218194017500139.

Full text
Abstract:
Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.
APA, Harvard, Vancouver, ISO, and other styles
21

BROWN, ALAN W., and JOHN A. McDERMID. "THE ART AND SCIENCE OF SOFTWARE ARCHITECTURE." International Journal of Cooperative Information Systems 16, no. 03n04 (September 2007): 439–66. http://dx.doi.org/10.1142/s0218843007001718.

Full text
Abstract:
Experience in all aspects of software engineering has confirmed the pivotal role of focusing on architectural concerns in the development of complex software-intensive systems. Consequently, the past 20 years has seen significant investments in the theory and practice of software architecture. However, architectural deficiencies are frequently cited as a key factor in the shortcomings and failures that lead to unpredictable delivery of complex operational systems. Here, we consider the art and science of software architecture: we explore the current state of software architecture, identify key architectural trends, and directions in academia and industry, and highlight some of the architectural research challenges which need to be addressed. The paper proposes a detailed agenda of research activities to be carried out by a partnership between academia and industry. While challenges exist in many domains, for this paper we draw examples from one area of particular concern: safety-critical systems.
APA, Harvard, Vancouver, ISO, and other styles
22

Ruiz Nepomuceno, Aldair, Eduardo López Domínguez, Saúl Domínguez Isidro, María Auxilio Medina Nieto, Amilcar Meneses-Viveros, and Jorge de la Calleja. "Software Architectures for Adaptive Mobile Learning Systems: A Systematic Literature Review." Applied Sciences 14, no. 11 (May 25, 2024): 4540. http://dx.doi.org/10.3390/app14114540.

Full text
Abstract:
Adaptive Mobile Learning Systems (AMLSs) are technological tools that incorporate adaptive learning to generate an individual teaching–learning process for each student. Despite the proliferation of AMLS, their development is often hindered by a lack of standardization and the poor quality of existing software architectures in terms of requirements correctness and coverage. This paper presents a systematic literature review (SLR) of software architectures oriented to developing AMLS reported in the state of the art. For this SLR, we searched the ACM Digital Library, IEEE Xplore, Science Direct, Springer, and SCOPUS. Studies published in English that describe and evaluate a software architecture to develop AMLS were included. Twenty-two primary works were relevant to the present study. Based on the obtained results, we have identified key aspects that must be considered in a software architecture proposed for developing an AMLS in terms of requirements, quality attributes, stakeholders, services provided to users, views and architectural styles, components, and implementation technologies. The main finding of this work is the lack of a reference software architecture that considers all the requirements and quality attributes needed for developing AMLS. This gap hinders the effective development and standardization of quality AMLSs, suggesting a critical need for a comprehensive reference software architecture.
APA, Harvard, Vancouver, ISO, and other styles
23

Goel, Amit. "The Philosophy of Software Architecture." International Journal of Web Portals 2, no. 4 (October 2010): 28–39. http://dx.doi.org/10.4018/jwp.2010100103.

Full text
Abstract:
Computer Software Intensive systems have become ingrained in our daily life. Apart from obvious scientific and business applications, various embedded devices are empowered with computer software. Such a diverse application of Computer Software has led to inherent complexity in building such systems. As civilizations moved forward, the concept of architectural thinking and practice was introduced to grapple with the complexity and other challenges of creating buildings, skyscrapers, townships, and cities. The Practice of Software Architecture is an attempt to understand and handle similar challenges in Software Intensive Systems. This paper introduces software architecture and the underlying philosophy thereof. This paper provokes a discussion around the present and future of Software Architecture. The authors discuss skills and roles of Software Architect.
APA, Harvard, Vancouver, ISO, and other styles
24

Papapostolu, A., and D. Birov. "Architecture Evolution through Dynamic Reconfiguration in jADL." Information Technologies and Control 15, no. 1 (March 1, 2017): 23–32. http://dx.doi.org/10.1515/itc-2017-0019.

Full text
Abstract:
Abstract In software architecture the dynamic structure of a software system can be described in terms of components and connectors and expressed through the use of Architectural Description Languages (ADLs). We present jADL, a new ADL, designed for the creation and validation of dynamic and mobile architectures. It, also, aims to help towards the process of “unifying” the definition and implementation of an architecture in a way that the final result is consistent with the architecture in terms of both functional requirements and quality attributes. In this paper, we examine into details the definition and expression of jADL’s architectural elements; components, connectors, ports, roles and behaviour describing statements – attach, detach, config, bind. The attributes of synchronicity and multiplicity concerning the connections between architectural elements are presented. A special case of connections is presented – the bind statement and the construction of composite architectural elements. Also, a case study of the client-server dynamic model in jADL is presented and the possibilities of jADL for dynamic reconfiguration are explored.
APA, Harvard, Vancouver, ISO, and other styles
25

Ananthavijayan, Ramesh, Prabhakar Karthikeyan Shanmugam, Sanjeevikumar Padmanaban, Jens Holm-Nielsen, Frede Blaabjerg, and Viliam Fedak. "Software Architectures for Smart Grid System—A Bibliographical Survey." Energies 12, no. 6 (March 26, 2019): 1183. http://dx.doi.org/10.3390/en12061183.

Full text
Abstract:
Smart grid software interconnects multiple Engineering disciplines (power systems, communication, software and hardware technology, instrumentation, big data, etc.). The software architecture is an evolving concept in smart grid systems, in which system architecture development is a challenging process. The architecture has to realize the complex legacy power grid systems and cope with current Information and Communication Technologies (ICT). The distributed generation in a smart grid environment expects the software architecture to be distributed and to enable local control. Smart grid architecture should also be modular, flexible, and adaptable to technology upgrades. In this paper, the authors have made a comprehensive review of architectures for smart grids. An in depth analysis of layered and agent-based architectures based on the National Institute of Standards and Technology (NIST) conceptual model is presented. Also presented is a set of smart grid Reference Architectures dealing with cross domain technology.
APA, Harvard, Vancouver, ISO, and other styles
26

Hexmoor, Henry, and David Kortenkamp. "Issues on building software for hardware agents." Knowledge Engineering Review 10, no. 3 (September 1995): 301–4. http://dx.doi.org/10.1017/s0269888900007499.

Full text
Abstract:
James Albus states that “an architecture is a description of how a system is constructed from basic components and how those components fit together to form the whole” (Albus, 1995). A software architecture for physical agents reflects the organising principles that its designers have learned from many prior experiences in building such agents. Architectures that have been proposed for physical agents have differed greatly—from subsumption (Brooks, 1986) to Soar (Laird et al., 1987). However, a surprising consensus about architectures is beginning to emerge within the small community of researchers applying artificial intelligence to robotics. The consensus is that a multi- layer, hierarchical architecture is necessary. In particular, the community is moving towards a three-layered architecture. The lowest layer is a reactive control system inspired by subsumption (Brooks, 1986). The top layer is a traditional symbolic planning and modelling system. The middle layer is the key; it serves as a “differential” between the short-range reaction and long-range reasoning.
APA, Harvard, Vancouver, ISO, and other styles
27

Nivethitha, V., and P. M Abhinaya. "Combinatorics based problem specific software architecture formulation using multi-objective genetic algorithm." International Journal of Engineering & Technology 7, no. 1.7 (February 5, 2018): 79. http://dx.doi.org/10.14419/ijet.v7i1.7.9579.

Full text
Abstract:
In Software Development Process, the design of complex systems is an important phase where software architects have to deal with abstract artefacts, procedures and ideas to discover the most suitable underlying architecture. Due to uncontrolled modifications of the design and frequent change of requirements, many of the working systems do not have a proper architecture. Most of the approaches recover the architectural blocks at the end of the development process which are not appropriate to the system considered. In order to structure these systems software components compositions and interactions should be properly adjusted which is a tedious work. Search-based Software Engineering (SBSE) is an emerging area which can support the decision making process of formulating the software architecture from initial analysis models. Thus component-based architectures is articulated as a multiple optimisation problem using evolutionary algorithms. Totally different metrics is applied looking on the design needs and also the specific domain. Thus during this analysis work, an effort has been created to propose a multi objective evolutionary approach for the invention of the underlying software system architectures beside a versatile encoding structure, correct style metrics for the fitness operate to enhance the standard and accuracy of the software system design.
APA, Harvard, Vancouver, ISO, and other styles
28

Tsybulnyk, Serhii, Viktoriia Nakoryk, and Diana Pivtorak. "DESIGN OF THE ARCHITECTURE OF THE AUTOMATED SYSTEM FOR CREATING THE ACCOMPANYING DOCUMENTATION OF THE EDUCATIONAL PROCESS." Bulletin of Kyiv Polytechnic Institute. Series Instrument Making, no. 67(1) (June 30, 2024): 77–83. http://dx.doi.org/10.20535/1970.67(1).2024.306737.

Full text
Abstract:
Background. The architecture of the automated system is the main source of quality of software and software-hardware systems. It determines how quickly and efficiently a developer is able to analyze, understand, test, extend, and maintain an automated system. Changes in the system architecture have a high cost due to its complexity and the possibility of destruction during expansion. At present, most of the knowledge and information about the design decisions on which the architecture is based are implicitly embedded in it, which leads to problems during the development process, in particular, during the programmatic implementation of its structural elements. It is determined that, despite the long way that the evolution of systems architecture has passed, today there are very few objective, repeatable and empirically based methodologies and tools for the design and analysis of architecture. As a rule, software architects are programmers who have decades of experience in software development practice. Given their experience, they clearly understand that errors in the architecture design are the root causes of lower-level problems that manifest in the software code. Most often, a programmer feels when the architecture of his project is of low quality, because there are a large number of technical flaws, the number of which only increases with time. But most projects continue to be implemented, which leads to a decrease in the quality of the finished automated system. Objective. The purpose of this work is to design and document the software architecture of the automated system for creating the accompanying documentation of the educational process in order to take the first step towards understanding the relationships and the impact of the adopted project decisions on the code base. Conclusions. To achieve the goal, a class of multi-level architectures was chosen, among which the three-level architecture is the most common. Features of implementation of open and closed three-level architectures are considered. On the basis of the MVC architectural template, an architectural project of an automated system for creating accompanying documentation of the educational process has been developed. The main subsystems and data elements are documented.
APA, Harvard, Vancouver, ISO, and other styles
29

Bahrami, Mehdi, and Mohammad Bahrami. "A Review of Software Architecture for Collaborative Software’s." Advanced Materials Research 433-440 (January 2012): 2372–76. http://dx.doi.org/10.4028/www.scientific.net/amr.433-440.2372.

Full text
Abstract:
Software architecture has emerged as an important sub-discipline of software engineering; particularly in the realm of large system development. Collaboration software applications are inherently cooperative, requiring many software applications to coordinate their efforts to produce a software system application. Integral to this effort is developing shared understanding surrounding multiple artifacts, each artifact embodying its own model, over the entire development process. This focus on model collaboration embedded within a larger process is what distinguishes collaboration research in software engineering from broader collaboration research. This article first review a list of goals for software architecture, then collaboration software application, several possible future directions for collaboration in software engineering is presented. The article concludes by noting a problem in performing research on collaborative systems.
APA, Harvard, Vancouver, ISO, and other styles
30

Bilokon, O. S. "Software Architecture of Navigation Systems for Control Modules of Robotics." Èlektronnoe modelirovanie 45, no. 5 (October 10, 2023): 103–12. http://dx.doi.org/10.15407/emodel.45.05.103.

Full text
Abstract:
The peculiarities of the software architecture of navigation systems of robotic control modules are considered. Particular attention is focused on the reproduced classifications of the characteristics of architectural solutions. The three-functional architecture of the Shakey robot, the architecture of R. Brooks (Subsumption), and Boltzmann's intellectual model were studied in detail. Three-level architectural system LAAS, multi-level architecture CLARAty, intelligent real-time control system CIRCA are also considered.
APA, Harvard, Vancouver, ISO, and other styles
31

Schmidt, Frederick, Stephen MacDonell, and Andy M. Connor. "Multi-Objective Reconstruction of Software Architecture." International Journal of Software Engineering and Knowledge Engineering 28, no. 06 (June 2018): 869–92. http://dx.doi.org/10.1142/s0218194018500262.

Full text
Abstract:
Design erosion is a persistent problem within the software engineering discipline. Software designs tend to deteriorate over time and there is a need for tools and techniques that support software architects when dealing with legacy systems. This paper presents an evaluation of a search-based software engineering (SBSE) approach intended to recover high-level architecture designs of software systems by structuring low-level artifacts into high-level architecture artifact configurations. In particular, this paper describes the performance evaluation of a number of metaheuristic search algorithms applied to architecture reconstruction problems with high dimensionality in terms of objectives. These problems have been selected as representative of the typical challenges faced by software architects dealing with legacy systems and the results inform the ongoing development of a software tool that supports the analysis of trade-offs between different reconstructed architectures.
APA, Harvard, Vancouver, ISO, and other styles
32

Dong, Xia, Shou Quan Wang, Xin Zhang, and Xiao Jia Ji. "Software Radar Hardware Architecture Based on General Computer." Advanced Materials Research 846-847 (November 2013): 207–10. http://dx.doi.org/10.4028/www.scientific.net/amr.846-847.207.

Full text
Abstract:
For software radar, different functions are realized by software running on standard hardware platform, which brings to great predominance over traditional radar. In this paper, realizable structure of software radar was analyzed, and hardware platform based on computer was studied. Two hardware architectures, one-computer architecture as well as computer cluster architecture were raised based on computer. The one-computer architecture is available to radars that cubage is restricted, while computer cluster architecture is applied in huge radar with complex computation.
APA, Harvard, Vancouver, ISO, and other styles
33

ORLANDIC, RATKO, and JOHN L. PFALTZ. "PREVENTING MISMATCH OF HOMOGENEOUS COMPONENTS IN THE DESIGN OF SOFTWARE ARCHITECTURE." International Journal of Software Engineering and Knowledge Engineering 11, no. 06 (December 2001): 731–59. http://dx.doi.org/10.1142/s0218194001000761.

Full text
Abstract:
The objective of this work is to examine the feasibility of, as well as to learn about, a process of developing software architecture that prevents the possibility of mismatch between homogeneous components implemented according to the architectural specification. This paper shows how the architecture can be organized, which restrictions it can use and, provided that they are used, how elaborate it should be in order to ensure that independently-developed artifacts are structurally compatible. Two components are deemed structurally compatible as long as they have appropriate code to avoid mismatch. Since the focus of the paper is on the structural forms of mismatch, the results are derived under the assumption that no run-time environment can prevent a component from executing any path in its code. The paper develops a formal model of architecture that provides a minimal set of concepts in terms of which the designers can reason about incompatibility of components. The model is used to identify the causes of structural mismatch and examine alternative ways of eliminating these causes. Following that, the paper adopts a set of architectural restrictions and shows how these restrictions can be applied in the design of software architectures to prevent the possibility of structural mismatch.
APA, Harvard, Vancouver, ISO, and other styles
34

Yang, Shuo, Xinjun Mao, Sen Yang, and Zhe Liu. "Towards a hybrid software architecture and multi-agent approach for autonomous robot software." International Journal of Advanced Robotic Systems 14, no. 4 (July 1, 2017): 172988141771608. http://dx.doi.org/10.1177/1729881417716088.

Full text
Abstract:
To support robust plan execution of autonomous robots in dynamic environments, autonomous robot software should include adaptive and reactive capabilities to cope with the dynamics and uncertainties of the evolving states of real-world environments. However, conventional software architectures such as sense-model-plan-act and behaviour-based paradigms are inadequate for meeting the requirements. A lack of sensing during acting in the sense-model-plan-act paradigm makes the software slow to react to run-time contingencies, whereas the behaviour-based architectures typically fall short in planning of long-range steps and making optimized plan adaptations. This article proposes a hybrid software architecture that maintains both adaptivity and reactivity of robot behaviours in dynamic environments. To implement this architecture, we further present the multi-agent development framework known as AutoRobot, which views the robot software as a multi-agent system in which diverse agent roles collaborate to achieve software functionalities. To demonstrate the applicability and validity of our concrete framework and software architecture, we conduct an experiment to implement a typical case, for example, a robot that autonomously picks up and drops off dishes for remote guests, which requires the robot to plan and navigate in a highly dynamic environment and can adapt its behaviours to unexpected situations.
APA, Harvard, Vancouver, ISO, and other styles
35

Alshudukhi, Jalawi Sulaiman. "Pattern-based solution for architecting cloud-enabled software." International Journal of ADVANCED AND APPLIED SCIENCES 8, no. 8 (August 2021): 9–19. http://dx.doi.org/10.21833/ijaas.2021.08.002.

Full text
Abstract:
Cloud computing exploits the software as a service model with distributed and interoperable services for the composition of software systems. Cloud-enabled systems that demand elasticity, scalability, and composition of services, etc., there is a need to capitalize on reusable solutions exploiting patterns and styles to architect cloud-based software. The objective of this research is to build and exploit a catalog of patterns that support reusable design knowledge to develop cloud-based architectures. We propose a three-step process with (i) pattern discovery, (ii) pattern documentation (building the catalog), and finally, (iii) pattern application (exploiting the catalog) to enable pattern-based architecting of cloud systems. We discovered seven patterns as generic and reusable solutions and demonstrate the pattern-driven architecture of the ECMC case study. Results suggest that pattern-based architecting enables the reuse of generic design decisions but lacks fine-grained architectural design. The solution is the first attempt towards establishing the catalog as a repository of patterns for architecture-based development of cloud systems.
APA, Harvard, Vancouver, ISO, and other styles
36

GRUNDY, JOHN, and JOHN HOSKING. "SOFTARCH: TOOL SUPPORT FOR INTEGRATED SOFTWARE ARCHITECTURE DEVELOPMENT." International Journal of Software Engineering and Knowledge Engineering 13, no. 02 (April 2003): 125–51. http://dx.doi.org/10.1142/s0218194003001238.

Full text
Abstract:
A good software architecture design is crucial in successfully realising an object-oriented analysis (OOA) specification with an object-oriented design (OOD) model that meets the specification's functional and non-functional requirements. Most CASE tools and software architecture design notations do not adequately support software architecture modelling and analysis, integration with OOA and OOD methods and tools, and high-level, dynamic architectural visualisations of running systems. We describe SoftArch, an environment that provides flexible software architecture modelling using a concept of successive refinement and an extensible architecture meta-model. SoftArch provides extensible analysis tools enabling developers to analyse their architecture model properties. Run-time visualisation of systems uses dynamic annotation and animation of high-level architectural modelling views. SoftArch is integrated with a component-based CASE tool and run-time monitoring tool, and has facilities for 3rd party tool integration through a common exchange format. This paper discusses the motivation for SoftArch, its modelling, analysis and dynamic visualisation capabilities, and its integration with various analysis, design and implementation tools.
APA, Harvard, Vancouver, ISO, and other styles
37

Li, Qiuying, and Fuping Zeng. "Enhancing Software Architecture Adaptability: A Comprehensive Evaluation Method." Symmetry 16, no. 7 (July 13, 2024): 894. http://dx.doi.org/10.3390/sym16070894.

Full text
Abstract:
The field of self-adaptive software is becoming increasingly crucial because software has to adapt its behavior at runtime to keep up with dynamic and constantly evolving environments. The ability of software to modify and adjust itself is known as adaptability, which has been acknowledged as an important quality attribute. As software architecture development represents the initial stage of the design process, architectural design has emerged as a critical development activity. The degree to which the architecture can adapt to changes will be the key factor in determining the adaptability of the software ultimately released to users. Existing metrics for software architectural adaptability typically view adaptability as a positive attribute, meaning that any possibility of change in architectural elements is perceived as an improvement in adaptability. However, the application of adaptability that leads to increased costs or complexity can only be seen as a negative attribute. In other words, the side effects brought about solely for the purpose of achieving adaptability are greatly overlooked; that is, the impacts caused by adaptability exhibit both symmetry and asymmetry for software architectural adaptability. On the other hand, the existing measures of adaptability only define it from the perspective of whether a module will change, without considering changes beyond the topological structure under multiple strategies. In this paper, we propose a comprehensive assessment approach to measure software architecture adaptability. Multiple factors are considered, including the number and types of strategies employed, the cost of completing the adaptation, the extent of changes made to the architectural elements, and the overall impact of the adaptation on the architecture. An extended UML (e-UML) component diagram is presented to model software architectural changes under various types of strategies. Finally, an experiment on the znn.com software is conducted to validate the practical feasibility of our proposed method. Our approach can assist software architects in making informed decisions regarding software architecture design options to improve the adaptability and longevity of their software systems.
APA, Harvard, Vancouver, ISO, and other styles
38

LUNG, CHUNG-HORNG, and KALAI KALAICHELVAN. "AN APPROACH TO QUANTITATIVE SOFTWARE ARCHITECTURE SENSITIVITY ANALYSIS." International Journal of Software Engineering and Knowledge Engineering 10, no. 01 (February 2000): 97–114. http://dx.doi.org/10.1142/s0218194000000079.

Full text
Abstract:
Software architectures are often claimed to be robust. However, there is no explicit and concrete definition of software architecture robustness. This paper gives a definition of software architecture robustness and presents a set of architecture metrics that were applied to real-time telecommunications software for the evaluation of robustness. The purpose of this study is to provide a structured method to support software architecture evaluations and downstream software implementations. The study also expands the software architecture research to quantitative and measurable evaluations as opposed to qualitative assessments. In addition, this paper presents an empirical case study of applying the metrics. The approach and the metrics data provide insights into software architecture sensitivity analysis on system qualities and trade-off analysis among a set of design alternatives to support product evolution.
APA, Harvard, Vancouver, ISO, and other styles
39

Xiang, Liang, Yang Hua, Jia Si Wang, Zhong Wei Chen, and Song Yang Du. "Software Information Management-Oriented Software Architecture Analysis." Applied Mechanics and Materials 263-266 (December 2012): 1745–49. http://dx.doi.org/10.4028/www.scientific.net/amm.263-266.1745.

Full text
Abstract:
This paper is to study the common architecture of the software development and compare the software system architecture-selection criteria. Meanwhile, this paper offers appropriate software architecture solution according to the features of data information management of the software testing organization.
APA, Harvard, Vancouver, ISO, and other styles
40

Niepostyn, Stanislaw Jerzy, and Wiktor Bohdan Daszczuk. "Entropy as a Measure of Consistency in Software Architecture." Entropy 25, no. 2 (February 10, 2023): 328. http://dx.doi.org/10.3390/e25020328.

Full text
Abstract:
In building software architectures, the relations between elements in different diagrams are often overlooked. The first stage of building IT systems is the use of ontology terminology, not software terminology, in the requirements engineering process. Then, when constructing software architecture, IT architects more or less consciously however introduce elements that represent the same classifier on different diagrams with similar names. These connections are called consistency rules and are usually not attached in any way in a modeling tool, and only a significant number of them in the models increase the quality of the software architecture. It is mathematically proved that the application of consistency rules increases the information content of software architecture. Authors show that increasing readability and ordering of software architecture by means of consistency rules have their mathematical rationale. In this article, we found proof of decreasing Shannon entropy while applying consistency rules in the construction of software architecture of IT systems. Therefore, it has been shown that marking selected elements in different diagrams with these same names is, therefore, an implicit way to increase the information content of software architecture while simultaneously improving its orderliness and readability. Moreover, this increase in the quality of the software architecture can be measured by entropy, which allows for checking whether the number of consistency rules is sufficient to compare different architectures, even of different sizes, thanks to entropy normalization, and checking during the development of the software architecture, what is the improvement in its orderliness and readability.
APA, Harvard, Vancouver, ISO, and other styles
41

Imam Ya’u, Badamasi, and Muhammed Nura Yusuf. "Building Software Component Architecture Directly from User Requirements." International Journal Of Engineering And Computer Science 7, no. 02 (February 16, 2018): 23557–66. http://dx.doi.org/10.18535/ijecs/v7i2.07.

Full text
Abstract:
Building software architectures from a set of requirements has been an area of research where programmers, architects and software engineers spend a lot of time using their expertise in resolving peculiar problems of mapping requirements to architectures. Some of these problems are directly associated with the ambiguity, incompleteness and inconsistency of requirements which draw a wide gap between the informal and formal specification of these requirements. The main objective here is to reconcile the mismatch in-between these domains by providing a systematic mapping technique. This paper presents a tool from which requirements are read from user in natural language or file and generated into words whereby the user makes some selections and maps the selected words directly to components architecture. Based on the design of this tool, human heuristic is used in the selection of the words. Unlike components, connectors are set as static. Partial architecture of requirements is drawn incrementally until complete system architecture is constructed
APA, Harvard, Vancouver, ISO, and other styles
42

Wang, Alf Inge, and Bian Wu. "Using Game Development to Teach Software Architecture." International Journal of Computer Games Technology 2011 (2011): 1–12. http://dx.doi.org/10.1155/2011/920873.

Full text
Abstract:
This paper describes a case study of how a game project using the XNA Game Studio from Microsoft was implemented in a software architecture course. In this project, university students have to construct and design a type of software architecture, evaluate the architecture, implement an application based on the architecture, and test this implementation. In previous years, the domain of the software architecture project has been a robot controller for navigating a maze.Robot controllerwas chosen as the domain for the project, as there exist several papers and descriptions on reference architectures for managing mobile robots. This paper describes the changes we had to make to introduce an XNA game development project to the software architecture course, and our experiences from running a software architecture project focusing on game development and XNA. The experiences described in this paper are based on feedback from the course staff, the project reports of the students, and a mandatory course evaluation. The evaluation shows among other things that the majority of the students preferred the game project to the robot project, that XNA was considered to be suitable platform for a software architecture project, that the students found it useful to learn XNA and C#, and that some students were carried away when developing the game in the software architecture project.
APA, Harvard, Vancouver, ISO, and other styles
43

Qing, Liu, Cao Kai, and Lai Ying-yong. "FPGA Software Architecture for Software Defined Radio." Procedia Engineering 29 (2012): 2133–39. http://dx.doi.org/10.1016/j.proeng.2012.01.275.

Full text
APA, Harvard, Vancouver, ISO, and other styles
44

Tummers, J., A. Kassahun, and B. Tekinerdogan. "Reference architecture design for farm management information systems: a multi-case study approach." Precision Agriculture 22, no. 1 (June 1, 2020): 22–50. http://dx.doi.org/10.1007/s11119-020-09728-0.

Full text
Abstract:
AbstractOne of the key elements of precision agriculture is the farm management information system (FMIS) that is responsible for data management, analytics and subsequent decision support. Various FMISs have been developed to support the management of farm businesses. A key artefact in the development of FMISs is the software architecture that defines the gross level structure of the system. The software architecture is important for understanding the system, analysing the design decisions and guiding the further development of the system based on the architecture. To assist in the design of the FMIS architecture, several reference architectures have been provided in the literature. Unfortunately, in practice, it is less trivial to derive the application architecture from these reference architectures. Two underlying reasons for this were identified. First of all, it appears that the proposed reference architectures do not specifically focus on FMIS but have a rather broad scope of the agricultural domain in general. Secondly, the proposed reference architectures do not seem to have followed the proper architecture documentation guidelines as defined in the software architecture community, lack precision, and thus impeding the design of the required application architectures. Presented in this article is a novel reference architecture that is dedicated to the specific FMIS domain, and which is documented using the software architecture documentation guidelines. In addition, the systematic approach for deriving application architectures from the proposed reference architecture is provided. To illustrate the approach, the results of multi-case study research are shown in which the presented reference architecture is used for deriving different FMIS application architectures.
APA, Harvard, Vancouver, ISO, and other styles
45

El Murabet, Amina, and Anouar Abtoy. "Methodologies of the Validation of Software Architectures." Journal of Computing Theories and Applications 1, no. 2 (November 1, 2023): 29–36. http://dx.doi.org/10.33633/jcta.v1i2.9332.

Full text
Abstract:
Software architecture validation is the process of assessing whether a software architecture meets its intended requirements and goals. It is an important step in the software development process, as it can help to identify and address potential problems early on before they become more costly and difficult to fix. There are a variety of different methodologies that can be used to validate software architecture. Some of the most common methodologies include Architectural evaluation methods, Architecture tests and reviews, and Model-based validation. This paper will provide an overview of the different methodologies that can be used to validate software architecture. Apart from that, it also analyzes and summarizes the strengths and weaknesses of each method so that it can guide determining the most appropriate methodology for a particular case.
APA, Harvard, Vancouver, ISO, and other styles
46

PUDOV, Pavel Nailevich. "Software in landscape architecture." Russian Electronic Scientific Journal, no. 1 (2022): 38–52. http://dx.doi.org/10.31563/2308-9644-2022-43-1-38-52.

Full text
APA, Harvard, Vancouver, ISO, and other styles
47

Stiller, L. B. "RETROGRADE ANALYSIS: SOFTWARE ARCHITECTURE." ICGA Journal 24, no. 2 (June 1, 2001): 86–87. http://dx.doi.org/10.3233/icg-2001-24208.

Full text
APA, Harvard, Vancouver, ISO, and other styles
48

Gardner, Tracy, and Renato Iannella. "Architecture and software solutions." Online Information Review 24, no. 1 (February 2000): 35–40. http://dx.doi.org/10.1108/14684520010320059.

Full text
APA, Harvard, Vancouver, ISO, and other styles
49

Johann, Sven. "Software Architecture for Developers." IEEE Software 32, no. 5 (September 2015): 93–96. http://dx.doi.org/10.1109/ms.2015.125.

Full text
APA, Harvard, Vancouver, ISO, and other styles
50

Helm, Richard. "Patterns, architecture and software." ACM SIGPLAN Notices 31, no. 1 (January 1996): 2–3. http://dx.doi.org/10.1145/249094.249099.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the bibliographies on the topic 'Software architecture' for other source types:
Dissertations / Theses Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography