1 Introduction

Software architecture is a significant topic in Software Engineering curricula, as evidenced by many academic publications (Zhang et al., 2020; Van Deursen et al., 2017). Architectural design is frequently integrated into other software engineering courses in most computer science and related programs (Li, 2020). However, teaching software architecture design is challenging due to its multi-view definition, practical requirements such as coding, and the use of complex problems (Galster & Angelov, 2016). The architect’s role is multifaceted, demanding experience in designing and developing real systems, the ability to analyze and quickly solve problems while detecting the root cause and making critical decisions for the project based on context and communication skills (Van Deursen et al., 2017).

Teaching software architecture is complex, requiring a genuine context, teamwork, projects with sufficient complexity, and ongoing student support and guidance (Angelov & de Beer, 2017). It is particularly challenging for teachers to instruct undergraduate students on abstract concepts such as principles, heuristics, and patterns crucial to software architecture design, particularly since they lack experience in the software industry (Lieh & Irawan, 2018). Teaching architecture concepts goes beyond conventional courses where the teacher guides an area of knowledge from books, lectures, and exercises. The abstract and extensive nature of software architecture design (Li, 2020; Zhang et al., 2020) presents a challenge in teaching software architecture because abstract concepts are difficult to comprehend. Practical learning involves complex projects, real clients, and diverse software quality attributes that compete with each other.

Perceptions differ between colleges and companies regarding software architecture practices and the responsibilities and skills required of architects. Trainers need to balance numerous factors, such as quality, scope, depth, applicability, soft and technical skills, and individual and collaborative learning to ensure effective teaching in the classroom (Palacin-Silva et al., 2017; Abad et al., 2019; Angelov & de Beer, 2017; Wei et al., 2020). It is necessary to analyze past experiences with teaching and learning software architecture activities to understand the gap between academic insight and industrial needs.

This paper presents a systematic mapping study aimed at resolving issues related to the teaching of software architecture. We consider course experiences and teaching strategies that allow us to align teaching practices with the competencies expected of software architects in the industry. These strategies can bring architecture courses closer to the needs and conditions of the software industry, improving graduate students’ employability, facilitating their transition from academic institutes to industry, and achieving better learning outcomes. Without such strategies, fresh graduates may need to undergo re-training, resulting in training costs and delays in hiring new graduates by prospective employers.

Our work makes a significant contribution to the field of research by identifying the teaching strategies employed in various experiences reported in the literature. We explore how these strategies intersect with the competencies achieved by students, the course contents studied, the challenges encountered during the training process, and the methods used to confirm each experience. By analyzing and cross-referencing this information, we gain valuable insights into existing research gaps.

2 Frequent software architecture concepts from the industry

This section explores various architectural concepts that are used in industrial practices and software architecture courses. These concepts include the definition of software architecture, quality attributes, architecture patterns, and architectural tactics. These ideas have been identified and defined based on their frequent appearance in the literature. Recognizing and understanding these concepts is crucial when designing software architecture training programs.

2.1 Definition of software architecture

The concept of software architecture is continually evolving, and it is essential to understand the various definitions of software architecture reported in the literature. A modern definition of software architecture might involve a set of fundamental decisions concerning the structure of the software system, which guides the design and construction of the system (Jansen & Bosch, 2005; Fowler, 2003; De Boer & Van Vliet, 2009). This structure includes the organization of the components, the way they communicate, and the distribution of responsibilities among them (Bass et al., 2012). Software architecture also addresses issues related to the quality of non-functional attributes, such as the system’s performance, scalability, security, usability, and maintainability (Richards & Ford, 2020).

2.2 Quality attributes

Quality attributes refer to the specific traits a software product satisfies, with each attribute being associated with specific metrics that define the quality levels for a software product (Sabry, 2015). Quality attributes include security, reliability, performance, and interoperability, which arise from complex business rules and quality concerns (Dobrica & Niemela, 2002). Managing these quality attributes appropriately is crucial since inappropriate handling poses a significant business risk. The architect needs to consider the potential conflicts between quality attributes and solve them through trade-offs.

2.3 Architecture patterns

Architecture patterns refer to common solution structures to similar design problems (Harrison & Avgeriou, 2010). Each pattern describes a general software system structure or high-level behavior that should satisfy a product’s functionalities, qualities, and constraints. These patterns are chosen based on early design decisions, such as the satisfaction of functional requirements, non-functional requirements, and system constraints (Harrison & Avgeriou, 2010).

2.4 Architectural tactics

Architectural tactics refer to high-level abstractions that capture decisions made to achieve quality goals in software architecture. These tactics can be design-time, such as hiding information to improve modifiability, or runtime, such as managing concurrency to improve performance (Harrison & Avgeriou, 2010). Architectural tactics have varying impacts on software design, and a developer can initiate a tactic through a particular architectural pattern.

The role of the software architect involves a range of technical skills, including software design and development, as well as a deep understanding of systems and network concepts. The architect needs analytical skills to understand the problem and diagnose potential root causes quickly. Additionally, leadership skills are crucial to making decisions crucial to the project based on the context and environment (Lieh & Irawan, 2019).

3 Related work

While there have been secondary studies on the alignment of software engineering education and the software industry, the focus on software architecture education has been limited. However, a few studies have addressed this topic in detail. These studies are discussed below.

  1. 1.

    Garousi et al. (2020) conducted a review of studies investigating the challenges faced by software engineering graduates in their early careers due to a misalignment between the skills developed in college education and the needs of the software industry. The authors found that graduates often struggle to apply their knowledge to practical situations and lack essential skills required by the industry, such as communication, teamwork, and critical thinking skills.

  2. 2.

    da Cunha et al. (2018) conducted a systematic mapping study of Brazilian literature on studies related to games, tools, teaching methodologies, and the integration between disciplines to support education in software engineering. The study aimed to assess the status of advancements within the teaching-learning process of software engineering. The findings of this study provide valuable insights into the current state of software engineering education.

  3. 3.

    Brito et al. (2018) conducted an updated systematic mapping study on free projects in software engineering education to bridge the gap between academia and the software industry. The study aimed to identify the current state of the pedagogical use of open-source software projects for teaching software engineering. The authors found a growing trend in the use of open-source software projects for teaching software engineering, but they also noted that this area of research has yet to reach maturity.

  4. 4.

    Groeneveld et al. (2019) conducted a literature review focusing on the importance of soft skills as a fundamental component to help students become good software developers. The study aimed to identify the primary soft skills essential for success in software development. The authors identified four primary soft skills: self-reflection, conflict resolution, communication, and teamwork. This study makes a valuable contribution to enhancing software engineering curricula by offering fresh perspectives on the connections between noncognitive abilities and teaching elements.

  5. 5.

    Qadir and Usman (2011) conducted a systematic mapping study to synthesize software engineering programs and curricula from various colleges worldwide. The study aimed to provide a broad overview of the software engineering education landscape. This systematic mapping study facilitated a comprehensive overview of the field by consolidating documented endeavors about the software engineering curriculum.

Two relevant studies focus on software architecture education reviews. The first study, proposed by Rodrigues and Werner (2009), aims to identify initiatives used in software architecture education. The study examines examples, techniques, software development tools and editors, books, and methodologies related to software architecture teaching. The study’s findings highlight the prevalent use of design patterns across multiple educational initiatives.

Similarly, Oliveira et al. (2022) explore concepts associated with software architecture and integrate real-world project requirements, such as agile and continuous delivery, into software architecture education. While these studies share similarities with ours, our study reveals findings regarding strategies to align software architecture between educational and industry contexts.

These contributions offer researchers and educators guidance to improve their software architecture courses by incorporating strategies reported by the literature review. These strategies can bring architecture courses closer to the needs and conditions of the software industry.

4 Literature review process

4.1 Method

This study follows the mapping study method proposed by Petersen et al. (2008), which describes how to conduct a systematic mapping study in software engineering and provides guidelines. The method systematically organizes current knowledge into categories, classification, or taxonomy formats and summarizes its results related to the research questions. This approach requires less effort while providing a more coarse-grained overview of the field.

The essential process steps of the systematic mapping study are as follows (see Fig. 1): (1) defining the research questions, (2) searching for primary studies, (3) reviewing full-text articles based on inclusion criteria/exclusion, (4) classifying documents, and (5) extracting and mapping collected data. Each stage produces a result used as input for the following steps.

The following subsections present the process for preparing the mapping study. By following these steps, we can systematically organize and analyze the current knowledge in software engineering education and identify strategies to align software architecture education with industry needs.

Fig. 1
figure 1

Systematic mapping process proposed by Petersen et al. (2008)

Full size image

4.2 Research questions

The research questions in this study aim to identify gaps in software architecture training research, including the training process followed by colleges, their learning strategies, and content. The research questions are as follows:

  1. 1.

    RQ1: How do software architecture courses incorporate training techniques and teaching methodologies to meet the needs of the software industry?

  2. 2.

    RQ2: What software architecture content is included in college courses?

  3. 3.

    RQ3: What are the key skills that a student in software architecture should develop during their training?

  4. 4.

    RQ4: What are the challenges that students encounter during software architecture training?

  5. 5.

    RQ5: What methods were used to validate the training experiences and achieve the proposed objectives?

Table 1 presents the questions and their motivation. By addressing these research questions, we can select, analyze, and categorize the information found in the study area. This approach allows us to identify areas where improvements can be made in software architecture education to better prepare students for success in the software industry.

Table 1 Research questions used for systematic mapping
Full size table

4.3 Search strategy

A fundamental aspect of conducting a systematic literature mapping study is ensuring that research questions are well-constructed. The PICOC method helps describe the five elements of a searchable question and stands for Population, Intervention, Comparison, Outcome, and Context.

To collect data from bibliographic databases systematically, we used the following search string based on the PICOC criteria (Souza et al., 2018):

(“educational needs” OR “knowledge needs” OR “desired skills” OR “essential competencies” OR “knowledge requirements” OR “skill requirements” OR “training” OR “teaching”) AND (“software architectures” OR “Software Architecture” OR “software design”) AND (“industrial software” OR “software industry”) AND “course”

We applied this query to the title, abstract, and keywords of six bibliographic databases: ACM Digital Library, EBSCO Services, IEEE Digital Library, Scopus, ScienceDirect, and Google Scholar (Ronchieri & Canaparo, 2019). Although EBSCO is not a technology-related database, we included it to incorporate relevant articles from reliable sources. We adjusted the query to the syntax of each search engine and applied it to studies published from January 2011 to March 2021.

4.4 Selection criteria for primary studies

Following the guidelines proposed by Petersen et al. (2008), we employed the subsequent inclusion and exclusion criteria to identify the most relevant studies for our research and answer the research questions.

Inclusion criteria: The inclusion criteria employed to identify relevant studies for our research and answer the research questions were as follows:

  1. 1.

    The papers are written in English, concentrating on software architects’ education to meet the industry’s requirements.

  2. 2.

    The papers are full-text publications in peer-reviewed journals, conferences, or symposiums.

  3. 3.

    The papers are based on empirical data and not solely on the authors’ opinions.

  4. 4.

    The full text of the paper is accessible to readers from a reliable source.

Exclusion criteria:

  1. 1.

    The primary study does not present a solution that contributes to software architects training that aligns with the needs of the industry.

  2. 2.

    Studies not available in full text.

  3. 3.

    Papers that display non-peer-reviewed material.

  4. 4.

    Secondary or tertiary studies that report and analyze the results of other investigations.

  5. 5.

    Duplicate publications by the same author.

We considered a study if it met each inclusion criterion and did not meet any of the exclusion criteria.

4.5 Execution stage

In phase 1 of our study, we applied the search string to five bibliographic databases and obtained 673 results. We then applied the inclusion and exclusion criteria to the abstracts, keywords, and titles of the articles, resulting in 78 “candidate primary studies” after eliminating duplicates. In phase 2, we further applied the selection criteria and identified 56 primary articles. In phase 3, we extracted data, characterized the studies, and answered the proposed research questions. We did not consider secondary studies in our information extraction, and a researcher expert in architecture issues used a second criterion in cases of doubt during the selection process.

Between 2011 and 2021, 56 experiences with software architecture training were reported. These experiences aimed to bridge the gap between college education and the needs of the software industry. We categorized these experiences into three groups: (i) experiences focused solely on software architecture training (37%); (ii) experiences focused on software engineering training that included software architectures in a global theme and the software development cycle, including analysis, design, implementation, testing, and deployment (57%); and (iii) complementary experiences that used strategies to support software patterns and architecture training (9%). Figure 2 depicts the number of experiences in each of these three groups.

Appendix A shows the primary articles.

The study identified four levels of software architecture training: undergraduate, postgraduate, continuing education, and industry training. Undergraduate training refers to college programs in computer science, software engineering, and related fields. Postgraduate training refers to master’s programs while continuing education refers to university-based teaching that aims to link with the environment through training and educational programs. The goal is to educate individuals who wish to deepen their knowledge and skills and keep up to date with the latest developments in their field. Industry training refers to training provided by companies to their employees through private courses aimed at improving their skills. Figure 3 depicts the distribution of experiences across each level of training, with most incidents reported in the literature corresponding to undergraduate courses (39 experiences, 70%).

Fig. 2
figure 2

Experiences supporting issues of software architecture training

Full size image
Fig. 3
figure 3

Report of experiences at each level of training

Full size image

5 Results and analysis of results

Fig. 4 presents the annual distribution of publications about software architecture training in line with the needs of the software industry. In recent years, there has been a significant increase in publications, with the highest number occurring between 2018 and 2020 (8 per year, totaling 25, representing 44.4%). This trend indicates that teaching software architecture is an area of interest to the research community. 2014 had the smallest number of publications, with only one paper published. 2021, there is only one publication because the data collection was conducted until March.

Overall, our intention is to answer the research questions posed earlier.

Fig. 4
figure 4

Article publications per year focusing on the training of software architects

Full size image

5.1 RQ1: How do software architecture courses incorporate training techniques and teaching methodologies to meet the needs of the software industry?

The literature review reveals various teaching strategies to align software architecture training courses with the needs of the software industry. These techniques can be classified into two categories: those used for training software architects and those used for teaching and learning methodologies. The former refers to strategies for recreating the industry’s working environment in the classroom, while the latter refers to strategies teachers use to teach software architecture courses. Tables 2 and 3 provide a synthesis of these strategies.

Table 2 Techniques in training software architects aligned with the needs of the software industry
Full size table
Table 3 Teaching methodologies in training software architects in line with the needs of the software industry
Full size table

In terms of training techniques, several strategies have been identified.

One approach to software architecture training is small project-based training. This approach involves developing one- or two-week-long projects focusing on a specific quality attribute, such as improving user interface usability, enhancing system performance, or strengthening security. This approach emphasizes practical exercises using modern web services and software frameworks rather than attempting to make superficial improvements on junior projects (Rupakheti & Chenoweth, 2015). Some experiences have demonstrated educational strategies that use lightweight projects with public and free resources for collaborative and experimental learning.

These courses are designed using an iterative approach that involves planning, executing, evaluating, and improving. Projects are available on cloud-based platforms such as GoogleAppEngine, IBM Cloud Lite, and Dropbox. From a faculty perspective, public access platforms make it easier to evaluate student projects by allowing users to examine the runtime of project systems or components online [36]. The course progresses from designing a large system with its requirements and discussing design choices to a set of smaller weekly coding exercises that involve adding new features to the system using a specific design pattern. This approach provides students with a practical and hands-on learning experience (Chatley & Field, 2017).

In certain experiences, students were provided with the source code to analyze and evaluate the architectural design (Li, 2019). In other instances, projects utilized a simulated or actual client with a genuine need (Mohan et al., 2012). Some courses incorporated Design Thinking methods and agile practices into the project life cycle (Palacin-Silva et al., 2017).

Large project-based training

involves involves medium and high-complexity projects with multiple requirements that focus on software architecture. This approach allows students to learn software architecture through a complete project, enabling them to see the results of their architectural design in a final product [68]. Software architecture and engineering courses are usually built on project-based learning and collaborative paradigms that simulate industrial environments.

Some studies incorporate agile team development practices (Luukkainen et al., 2012), while others combine Global Software Engineering with Open-Source Development Projects (Hjelsvold & Mishra, 2019). These projects enable students to apply theoretical knowledge of software architecture to real-world systems (Zhang et al., 2020). Students learn to design software systems that meet stakeholder needs and provide a positive user experience by working on actual challenges (Sun et al., 2011; Péraire, 2019; Khakurel & Porras, 2020). This approach requires students to communicate and collaborate effectively within teams. Some courses even provide junior research assistants who serve as tutors in team meetings, offering advice and support (Matthies et al., 2018). Students also learn about creating architecture, the architect’s role, and the documentation that should be used to support software architecture (Angelov & de Beer, 2017).

Open-source projects training enables students to interact with existing systems, factual issues, and actual software development teams to build high-quality working software. This approach provides students with a unique opportunity to gain experience only present in real-world scenarios, which can increase their abilities and self-confidence (Pinto et al., 2019). By working on open-source projects, students can make extensions, correct bugs, or analyze the architecture of existing systems. Listed below, we provide different alternatives to work with open-source projects.

  • Experiences in teaching object-oriented modeling with UML (Unified Modeling Language) using open-source projects are reported by Silva et al. (2019).

  • Students work with Moodle mobile and Moodle plug-in issues (Hjelsvold & Mishra, 2019).

  • Students analyze open-source systems and learn from analyses conducted by other teams. Additionally, students create book chapters based on the architecture documentation of their system (Van Deursen et al., 2017).

  • Open-source projects provide students with the opportunity to gain experience from common mistakes made by beginner developers, such as poor naming of variables and methods, comments between lines, lengthy methods, switch structures instead of polymorphism, no unit tests, and duplicated code (Hu et al., 2018).

  • Some proposals suggest the creation of public code repositories containing actual projects from popular industry sectors. These repositories would serve as a reference for instructors to enhance the software architecture learning experience (Wei et al., 2020).

  • Other initiatives propose that students develop a component, extension, or application within or on top of an existing open-source software project (Weerawarana et al., 2012).

Some software architecture courses involve real clients or industry experts who participate by providing requirements and evaluating demonstrations. The college may request candidate clients from companies, with most candidates being graduates from the same educational institutions (Rupakheti & Chenoweth, 2015). In other instances, each group of students has a mentor who acts as a client (Abdool & Pooransingh, 2014). Furthermore, some courses use industry software experts to assess class projects through demonstrations. In addition to assisting with the assessment workload, industry experts provide students with practical feedback based on current industry best practices (Weerawarana et al., 2012).

Conferences featuring guests from the software industry sector are valuable in software architecture education. Experienced software architects who have worked on large-scale system designs share their experiences in software architecture issues (Wang, 2011; Zhang et al., 2020; Van Deursen et al., 2017; Li, 2019). Collaborative efforts between academia and industry are essential, with many colleges having agreements with software development companies (de Beer & Angelov, 2015). Some courses offer seminars during the semester with guests from the industry on innovative topics [29]. The conferences often involve student feedback to plan future events (Collins, 2020).

Field visits to software development companies also provide students with valuable insights into the world of work. Through these visits, students can interact with developers, architects, and businesspeople and see how companies organize their projects, work teams, and time. This approach enables students to have early contact with the industry (Collins, 2020).

Instructors and guest contributors in software engineering from the industry sector can also provide valuable practical software engineering skills. They are often more qualified to teach practical skills than pure scholars and can give their teaching material a greater sense of significanc (Hu et al., 2018).

In some cases, each team of students is assigned a mentor with industry and project experience who plays the role of the company’s project manager (Johns-Boast & Flint, 2013).

Students in software architecture education learn the software development process by developing software under conditions faced in the industry. The development process is essential for organizing all team members ’ roles and activities (Mohan et al., 2012).

Global software development is another approach, where students form teams of diverse nationalities to develop software projects. They use Scrum and are familiar with Jira, Git, and Moodle applications. Global Software Engineering is combined with open-source projects to provide students with an experience of the software industry (Hjelsvold & Mishra, 2019).

Through projects, students can apply knowledge and skills demanded in the industry and develop the essential skills required for successful careers. The skills acquired in the courses are compared with the soft skills of the industry reported in the literature (Sun et al., 2011). Some experiences involve role-playing software projects and building industry skills as analysts, architects, designers, testers, and integrators (Joy & Renumol, 2018).

Some experiences in designing study plans for software architecture education use job advertisements to align curricula with industry needs. Job adverts publish required professional skills, enabling curricula that align with the industry’s needs (Ward et al., 2015).

Other experiences focus on using industry-applied tools such as bug tracking, continuous integration, Heroku, and Vagrant (Paez, 2017). The use of virtual machines simplifies the installation and configuration of these tools. For software architecture, students should become familiar with modeling and DevOps tools.

To stay up to date with current software architecture practices, students learn using papers and other materials from the current state-of-the-art software architecture (Zhang et al., 2020). There are many tasks that students can work on Zhang et al. (2020). First, the teacher assigns a student to read a paper in software architecture. Each student reads and answers a set of questions, including the problem, the solution, contributions, results, and lessons learned, then the student makes a report, using slides.

Another task requires students to read articles in pairs and cooperate to create reading notes to avoid individual biases. The students select articles from recognized journals and conferences. In a third assignment, students conduct research in both academia and industry. They search for research groups and industrial companies in software architecture, rank the top ten teams or organizations, and explain the reasons for the ranking in the report..

Design thinking is an approach to solving complex problems by using creative methods. It emphasizes the importance of empathy between designers and users and encourages shared exploration of issues and solutions. During the ideation phase, software architects assess the feasibility of the solution considered, eliminating fruitless prototyping of solutions according to the current state of technologies (Palacin-Silva et al., 2017).

Appendix B shows techniques in training software architects versus primary studies. The most used strategies are large project-based training (12 citations), open-source projects training (8 citations), and small project-based training (7 citations).

The following are the strategies related to teaching methodologies.

Professors teach traditional classes in software architecture education

Professors explain and share their knowledge with students in person (Wang, 2011; Lieh Ouh et al., 2020). These classes focus on teaching students how to design software systems that solve real-world problems, meet the requirements of stakeholders, and provide a positive user experience (Péraire, 2019).

The flipped classroom approach in software architecture education involves educators offering lectures or showing videos to students before the face-to-face session. During the face-to-face meeting, students organize discussions and exercises, study the source code, and understand how to implement concepts such as concurrency, security, principles, modifiability, persistence, event management, and error handling (Palacin-Silva et al., 2017).

In some experiences, students have found the flipped classroom approach to be much more effective and engaging than the traditional approach because it focuses on problem-solving (Joy & Renumol, 2018). The flipped classroom favors immersive, collaborative, and active learning experiences (Paez, 2017). Some courses have a blended approach that combines flipped classroom classes with traditional instruction (Péraire, 2019).

Problem-based learning is a strategy used in software architecture education where teams of students address architectural problems, and instructors play a minimal role without interfering in the discussion. As students explore issues, instructors function as facilitators and guide questions to bring them back to the main learning goal. For example, one subgroup explains a particular design solution, while the other subgroup understands another group’s design solution and prepares questions for the actual presentation. Each student listens to the experiences and thinking of various students applied in a real-life scenario (Lieh & Irawan, 2019).

Using projects and problem-based learning encourages collaborative work (Kiwelekar, 2021) that examines the effect of the problem/project-based approach on students’ skill gains (Khakurel & Porras, 2020).

Case-based learning is another approach where case studies are “real-life scenarios that allow students to analyze, apply taught concepts, and mitigate potential trade-offs within a realistic context” (Lieh Ouh et al., 2020). It focuses on the design and analysis of actual software projects for companies.

Under this approach, students work in teams within real-life scenarios. The instructors play a minimal role and do not interfere in the discussion. When students explore doubts, instructors function as facilitators and use guiding questions to bring them back to the main learning goal (Lieh & Irawan, 2019).

Teachers conduct case-based teaching in a flipped classroom setting. The cases include a client–server style ATM system, a service-oriented online vending system, an emergency monitoring system, a web-based automated management system, and software architecture design in real-time. Each student analyzes the case and completes the design tasks required for the [35] assignment within one week (Li, 2019).

Students work in teams of 5 or 6 members with specific roles assigned to each member. Two senior architects make the architectural design decisions, identify design problems, and capture architectural design decisions. Two cognitive architects challenge senior architects’ decisions and raise concerns when risks or incomplete information are present. One or two junior architects oversee understanding and modeling the captured decisions and provide a solution architecture (Capilla et al., 2020).

Online learning in software architecture education is delivered through two fundamental modalities: MOOCs (Massive Open Online Courses) and SPOCs (Small Private Online Courses).

Wendt et al. (2016) offer a Small Private Online Course (SPOC) on software design, and after completing the course, they apply a survey where participants value the course content. The industry will receive SPOC courses for staff training.

Schmidt and McCormick (2013) describe the experiences of producing and delivering a MOOC entitled “Pattern-Oriented Software Architecture for Concurrent and Networked Software.” They also discuss “the broader implications of MOOCs on lifelong learning and their role in improving the quality and productivity of software professionals in academia and industry” (Schmidt & McCormick, 2013).

Another approach to online learning in software architecture education is the Intelligent Tutorial System, which provides personalized learning pathways by tracking each student’s progress. In Thevathayan and Hamilton (2017), students interact with an Intelligent Tutorial System (ITS) that meets varied needs by enabling different learning modes. An ITS works with multiple-choice questionnaires that pose UML and design problems. Crafting questions to show specific concepts or patterns is a challenging task. One advantage of cloud-based ITS is that the developed courseware can be shared with other institutions across the globe.

Appendix C shows teaching methodologies versus primary studies. The most used strategies are case-based learning (6 citations) and flipped classrooms (4 citations).

The literature review presents courses to train software architects with the necessary skills to enter the job market. Each experience explores one or more teaching strategies from a pedagogical and technological perspective. However, the review also highlights ineffective teaching strategies in training software architects. Table 4 provides a summary of these ineffective strategies.

Table 4 Strategies that are not effective for training software architects
Full size table

5.2 RQ2: What software architecture content is typically included in college courses?

This question involves two perspectives: identifying the topics covered in the literature and aligning them with the learning goals of the courses. Table 5 displays the learning goals identified through systematic mapping. Although all these courses focus on software architecture, they have different approaches. Courses can be either basic or advanced and may be based on existing projects or project formulations.

Table 5 Learning Goals of the courses reported by the literature review
Full size table
Table 6 Content of the courses reported by the literature review
Full size table
Table 7 Soft skills of the software architect
Full size table
Table 8 Technical skills of the software architect
Full size table

Table 6 presents the topics covered in the literature. As with the learning goals, the content varies from one course to another. However, the literature does not provide specific information, such as topics and subtopics, which makes it challenging to conduct a more comprehensive examination of the content. Nevertheless, the reported experiences share common content, including software architecture fundamentals, architecture patterns, quality attributes, design principles, design patterns, analysis, design, and architecture evaluation.

In Appendix D, we can see that the most cited topics include architecture patterns (6 citations), quality attributes (3 citations), design principles (3 citations), analysis, design, and evaluation of software architecture (3 citations), and design patterns (3 citations).

5.3 RQ3: What are the key skills that a student in software architecture should develop during their training?

Tables 7 and 8 provide a summary of the technical and soft skills that software architects need to develop, as reported in the literature. In this section, we will discuss the soft skills of software architects.

One of the key skills that software architects need is effective communication. This includes the ability to speak, write, and present ideas in a clear and concise manner, especially when dealing with complex problems that require a straightforward design solution. Various sources in the literature emphasize the importance of communication skills for architects (Rupakheti & Chenoweth, 2015; Silva et al., 2019; Hjelsvold & Mishra, 2019; Johns-Boast & Flint, 2013; Sun et al., 2011; Péraire, 2019; Pratheesh & Devi, 2013; Desai et al., 2012; Weerawarana et al., 2012; Lee et al., 2015; Jarzabek, 2013; Hu et al., 2018; Mohan et al., 2012; Backert et al., 2020).

Moreover, communication skills are crucial for students pursuing a career in software architecture (Hu et al., 2018). It is vital to ensure that students develop fundamental communication skills, such as reading, writing, listening, speaking, and comprehension (Mohan et al., 2012).

Software architects engage and communicate with experts in various disciplines to effectively conduct their role. Understanding the terminology, common problems, needs, and diverse cultural approaches (including ways of working and thinking) within these disciplines is important for them (Backert et al., 2020).

Effective communication is crucial for architects, both externally (with clients) and internally (with team members) (Khakurel & Porras, 2020). Architects need to have skills in communicating with stakeholders and achieving consensus on decisions (Van Deursen et al., 2017). Leadership skills are essential for architects to lead, present, negotiate, and justify their designs and decisions (Lieh & Irawan, 2019). They need to listen to and solve problems with design implementers (Wei et al., 2020).

Teamwork is another critical skill for software architects. They collaborate closely with other members of the development team, such as programmers (May et al., 2018; Mohan et al., 2012; Hjelsvold & Mishra, 2019; Zhang et al., 2020; Johns-Boast & Flint, 2013; Palacin-Silva et al., 2017; Khakurel & Porras, 2020; Sun et al., 2011; Péraire, 2019; Desai et al., 2012; Joy & Renumol, 2018; Li, 2019; Giraldo et al., 2011; Lee et al., 2015; Jarzabek, 2013). Learning about architecture involves intensive teamwork (Li, 2020), and the team should analyze and make architectural decisions together (Angelov & de Beer, 2017).

Leadership and negotiation skills are crucial for software architects to lead, present, negotiate, and justify their architectural designs and decisions (Abad et al., 2019; Lieh & Irawan, 2019; Rupakheti & Chenoweth, 2015). These skills include making independent decisions, taking the initiative, demonstrating independent judgment, being influential, and commanding respect (Bass et al., 2012).

Artistic skills are also necessary for software architects to create simple designs that are easy to understand and solve complex problems (Rupakheti & Chenoweth, 2015; Wei et al., 2020). Artistic skills involve knowledge of unique design techniques and tools, how to design complex multi-product systems, object-oriented analysis and design, UML diagrams, and UML analysis modeling (Bass et al., 2012).

In addition to soft skills, software architects possess a range of technical skills. These are explained below.

Being familiar with multiple technologies allows them to choose the appropriate technology for the project. While software architects do not have to be technology experts, keeping up to date with the latest technology trends is important (Rupakheti & Chenoweth, 2015; Palacin-Silva et al., 2017; Wei et al., 2020).

As a software architect, it is crucial to understand the domain in which a system will operate. The domain means comprehending the business environment in which the software will function to design and develop an appropriate solution. It involves understanding the specific business processes, rules, and operations and the needs and requirements of users and stakeholders. This knowledge is essential in designing an architecture that aligns with the business goals and objectives (Rupakheti & Chenoweth, 2015; Wei et al., 2020).

Analytical skills are crucial for software architects to understand the problem, identify potential root causes, and make informed decisions for the project (Rupakheti & Chenoweth, 2015; Lieh Ouh et al., 2020; Joy & Renumol, 2018; Angelov & de Beer, 2017; Li, 2020). Architects need to identify the root causes of high-level problems in existing designs, such as system performance issues or security vulnerabilities (Wei et al., 2020).

Another critical skill for software architects is the ability to design, model, analyze, and evaluate software architectures (Van Deursen et al., 2017; Lopes et al., 2019; Silva et al., 2018; Zhang et al., 2020; Lieh & Irawan, 2018; Desai et al., 2012; Jarzabek, 2013). Architects need to be adept at applying patterns and frameworks to build high-quality applications (Schmidt & McCormick, 2013).

Designing the architecture of complex, large-scale software systems with numerous requirements and millions of lines of code requires exceptional modeling and abstraction skills (Ciancarini et al., 2016).

In addition to technical skills, software architects need solid research abilities to manage and coordinate all elements of a successful application project. Research skills enable architects to understand complex situations and solve problems (Li, 2020). Before designing any software solution, architects conduct research to understand the business requirements and needs. This includes conducting interviews, discussions, and analyses with users and stakeholders to understand what is expected from the system. Research enables architects to capture requirements accurately and define an architecture that meets business needs (Zhang et al., 2020).

Although software architects do not need to be programming experts, they should possess minimum programming skills. Architectural roles typically require software design and programming experience. Architects need to know enough about programming to communicate effectively with developers (Lieh & Irawan, 2018; Li, 2020).

Effective architectural decision-making requires a software architect to gather and analyze relevant information to make informed decisions. This involves understanding system requirements, technical constraints, business needs, and other relevant factors. By analyzing this information, architects can evaluate different options and make decisions based on sound data. In situations with uncertainty, time pressure, or limited exploration of alternatives, the ability to make informed design decisions is critical to success (Lieh Ouh et al., 2020).

Systemic thinking is a way of understanding and analyzing interactions between variables within a system or multiple subsystems, expressed in terms of feedback. This approach seeks to analyze these interactions in an orderly and comprehensive manner, considering all interrelated elements. Software architects need to possess systemic and holistic thinking abilities to approach problems from multiple perspectives (Wei et al., 2020).

Appendix E, Appendix E illustrates that common soft skills for software architects are communication (18 citations) and teamwork (15 citations). These skills are essential for effective collaboration and communication with team members and stakeholders.

In Appendix F, the common technical skills for software architects are building and assessing architectures (9 citations), analytical skills (5 citations), and knowledge of multiple technologies (4 citations).

5.4 RQ4: What are the challenges that students encounter during software architecture training?

This question aims to identify the challenges that arise during the software architecture training process, as reported in the literature. Table 9 presents the findings of this research. Below, we outline each difficulty.

  1. 1.

    Lack of real-world experience among instructors. To be effective, instructors should possess a diverse range of real-world experience. However, many instructors have academic backgrounds and may have limited experience designing large-scale projects (Rupakheti & Chenoweth, 2015).

  2. 2.

    The abstract and ambiguous nature of software architecture poses a significant challenge for students. Concepts such as design principles, offsets, architectural patterns, and product lines can be difficult to grasp (Zhang et al., 2020; Li, 2020; Sun et al., 2011; Van Deursen et al., 2017). Unlike programming, there are no clear-cut right or wrong solutions in software architecture. One of the main challenges of teaching software architecture is making these abstract concepts more accessible to students. For beginners, this requires a shift in mindset from concrete software programming to abstract architectural design. Architects used to write code and achieving deterministic results adapt to structuring components in a diagram and justifying their decisions based on trade-offs since perfect solutions do not exist. Furthermore, environmental aspects and principles may vary based on students’ experiences and backgrounds, making software architecture solutions abstract and challenging to understand (Lieh & Irawan, 2019).

    Table 9 Challenges to training software architects aligned with the software industry
    Full size table
  3. 3.

    Difficulty involving clients and industry experts is a common challenge in academic environments (de Beer & Angelov, 2015). These individuals often have busy schedules, making it challenging to involve them in software architecture training. (de Beer & Angelov, 2015).

  4. 4.

    Teaching software architecture requires going beyond traditional teaching methods to account for the complexity of social interactions and collaborative software development in a real-world environment (Pinto et al., 2019). Unlike traditional college education, which focuses on imparting knowledge, software architecture requires the ability to apply knowledge effectively to deliver results (Pillutla & Alladi, 2013; Pratheesh & Devi, 2013; Van Deursen et al., 2017). Traditional lectures are not motivating for software architecture students (Paez, 2017).

  5. 5.

    Small and simple projects are insufficient for providing students with practical experience. To teach software architecture effectively, complex problems with multiple quality attributes and an appropriate context are necessary (Galster & Angelov, 2016). Class projects are often “toy projects” that lack the scope and maturity necessary for actual software development (Pinto et al., 2019). Academics and researchers do not typically work on projects in industrial settings, making it challenging to use industry-developed projects in the classroom or interact with companies in the educational context (Silva et al., 2019).

  6. 6.

    Lack of involvement in open-source projects. Open-source repositories offer benefits for learning software architectures. However, instructors need to gain experience in this type of project (Silva et al., 2019). Working on open-source projects is challenging for teachers and their students, as they require in-depth knowledge and experience in technology. A learning stage is necessary before the implementation of tasks (Hjelsvold & Mishra, 2019).

  7. 7.

    Personalized monitoring is necessary for each student. Like a piano student, software architecture students require personalized attention from their teachers. However, this can be challenging for large teams (Thevathayan & Hamilton, 2017).

  8. 8.

    Modern methods developed in the industry may take time to reach academia, resulting in classroom teachings that may soon become outdated (Thevathayan & Hamilton, 2017).

  9. 9.

    Teaching software architectures is a challenging task that requires educators to balance quality, scope, depth, applicability, soft and technical skills, and individual and collaborative learning (Palacin-Silva et al., 2017). Learning requires a realistic context, teamwork, adequate complexity, and practical training (Angelov & de Beer, 2017). Educators need to find the right balance between “realism” and classroom control for software architecture students (Abad et al., 2019). Most architecture courses focus on theoretical concepts or cannot immerse students in complex industrial-level projects unless instructors come from the industry sector (Wei et al., 2020).

  10. 10.

    The need for courses to adapt to changes is crucial in providing students with the best possible education. Universities should strive to improve the course learning experience and update course contents to meet changing requirements (Matthies et al., 2018). Software architecture classes should be adjustable and regularly adjust to fluctuations in the business, technological breakthroughs, and student needs so that students can get the most precise and current instruction conceivable.

  11. 11.

    Completed project scenarios are helpful in training software architecture, but they can also intimidate students who may feel compelled to make changes. Instead, students prefer new projects that are more accessible and enable them to understand the requirements and have complete control over the software’s architecture, design, and structure (Weerawarana et al., 2012).

  12. 12.

    There is a significant gap between students’ skills and the expectations of industry managers or hiring personnel. This gap prevents students from getting job offers or meeting the expectation level of the software industry. There is a knowledge gap between the theory learned in the classroom and the actual requirements demanded by the industry (Joy & Renumol, 2018).

  13. 13.

    There is a need to clarify how to work with software architecture in agile methodologies. In agile methods, it is not always clear when to create the architecture, the architect’s role, how the architecture documentation should be, the methods and activities involved, and the value and costs associated with them (Angelov & de Beer, 2017).

  14. 14.

    Activities in the software architecture stages require students to apply knowledge from previous courses, such as networking, databases, operating systems, distributed systems, and software engineering. Careful consideration and application of this knowledge are necessary (Li, 2019).

Appendix G reveals that the most reported difficulties in the literature are the abstract and ambiguous nature of software architecture (8 citations), lack of real practical experience in small and simple projects (4 citations), the need to go beyond traditional teaching methods when teaching software architecture (5 citations), and the challenging nature of teaching software architectures (4 citations). The abstract and ambiguous nature of software architecture is the most discussed obstacle, making the teaching of this subject a considerable undertaking.

Table 10 Validation methods of the proposed courses and their usage percentages
Full size table
Fig. 5
figure 5

Validation methods of the courses reported in the literature

Full size image

5.5 RQ5: What methods were used to validate the training experiences and achieve the proposed objectives?

Each experience presented in the literature details a specific approach to training students in software architectures through the application of teaching strategies. Each approach requires a course design and subsequent implementation. After these experiences have been conducted, it is essential to understand the effectiveness of the teaching strategies employed.

Various methods have been proposed to determine the effectiveness of the teaching-learning processes. Table 10 summarizes the validation methods used for courses. Surveys are often administered to students at the end of the course to measure satisfaction using the Technology Acceptance Model (TAM). Another technique involves comparing satisfaction with the proposed course to that of a traditional course (with studies using the Kruskal-Wallis test for data verification). A third technique measures the quality of the artifacts produced, such as requirements specifications, analysis models, design models, and tests. Fourth, evaluations of the students during the course are analyzed to understand the learning process and objectives. Finally, a fifth technique involves analyzing and comparing the skills achieved in the course with those reported in the literature.

Appendix H illustrates the validation techniques used for software architecture courses compared to primary studies. The most used techniques were student surveys (20 citations), metrics to analyze student evaluations (4 citations), and metrics to assess the quality of artifacts produced (3 citations). Most experiences utilized the survey technique (69%, as seen in Fig. 5) because it allows for the collection of students’ perceptions and analysis of their comments. However, we recognize that this technique may reduce objectivity in validation, as students may not be able to assess the quality of the course.

We have analyzed the validation techniques in conjunction with teaching strategies from RQ1, and the results are shown in Fig. 6, which presents a bubble diagram with three dimensions. The Y-axis represents teaching strategies, the X-axis represents course validation techniques, and the width of the bubble corresponds to the number of experiences that use the intersected strategy and validation. The diagram reveals that the most used technique is crossing short projects with validation through surveys (six experiences). Additionally, certain strategies have no associated validation techniques, such as current state-of-the-art software architecture.

Fig. 6
figure 6

Teaching Strategies Vs. validations techniques

Full size image

6 Discussion

This systematic mapping analyzed the strategies, contents, skills, challenges, and course validation methods for training students in software architecture from selected studies. The papers were reviewed across six databases, and documents on teaching software architecture from January 2011 to March 2021 were examined. From this analysis, 56 primary studies were selected for further data extraction and analysis, providing a comprehensive understanding of how the training process for software architecture is being implemented in colleges, considering the needs of the industry. The main highlights of this systematic mapping are summarized as follows:

  1. 1.

    Teaching software architecture in computer science and software engineering programs is a pertinent topic in the scientific community, with a consistent number of publications over the last decade. The most publications were recorded between 2018 and 2020, with an average of eight publications per year. The countries most interested in this topic are the USA, India, China, and Brazil, which accounted for 44% of total publications over the last ten years.

  2. 2.

    Teaching software architectures presents many challenges for educators. The most reported difficulties in the literature include the abstract and ambiguous nature of software architecture (8 citations), the lack of real practical experience in small and simple projects (4 citations), the need to go beyond traditional teaching methods when teaching software architecture (5 citations), and the challenging nature of training software architectures (4 citations).

  3. 3.

    Despite the fact that the most significant challenge reported is the abstract and ambiguous nature of software architectures, no training strategies have been developed to address this challenge.

  4. 4.

    The literature review presents various teaching strategies to align software architecture training courses with the needs of the software industry. These techniques have been classified into two categories: training software architects and teaching methodologies. The most used strategies for training software architects are large project-based training (12 citations), Open-Source Projects training (8 citations), and small project-based training (7 citations). Case-based learning (6 citations) and flipped classrooms (4 citations) are the most used strategies related to teaching methodologies. Despite these strategies, no complete solution addresses the challenges of training software architects. Educators still struggle to train software architects and rely on their experience or trial-and-error testing. New educators require guidelines or patterns for designing software architecture curricula.

  5. 5.

    While the teaching experiences use diverse training strategies, there is a gap in integrating multiple strategies to enhance the teaching process.

  6. 6.

    Table 3 shows two experiences related to online learning, whereas only one reference pertains to intelligent tutorial systems. Exploring these two distinct lines of inquiry could present an intriguing research context for software architecture training.

  7. 7.

    Software architecture students need to develop their abilities gradually over time, and it is necessary to agree on the relevant skill sets. While the range of technical and soft abilities is wide, the two most often mentioned soft skills are communication (cited 18 times) and collaboration (cited 15 times).

  8. 8.

    Tables 7 and 8 present the soft and technical skills of the software architect. However, it is essential to investigate and study the teaching strategies that facilitate the development of these skills.

  9. 9.

    The reported experiences cover fundamental topics such as software architectures, architecture patterns, design patterns, quality attributes, design principles, analysis, design, and evaluation of architectures.

  10. 10.

    The most used validation techniques for software architecture courses are student surveys (20 citations), metrics to analyze student evaluations (4 citations), and metrics to measure the quality of artifacts produced (3 citations).

  11. 11.

    Figure 6 shows that surveys are the most utilized validation techniques, but when using surveys, it is necessary to consider students may not offer an objective analysis of the quality of the course. Validations should reflect industry-relevant skills from real-world needs.

  12. 12.

    Teaching software architectures is a current research topic that aligns with the needs of the industry. While researchers have made noteworthy contributions, the complexity of architecture, the industry’s expectations, the transformation of the architecture concept, the emergence of recent technologies, and the quality criteria mean that many facets of this topic still need to be explored. Some studies provide insight into topics such as the architect’s role, lessons learned, and details on what and how to teach a software architecture course.

The results of this systematic mapping can help researchers and educators understand the challenges of teaching software architecture, propose new courses that build skills in architecture aligned with the needs of the industry, and improve existing courses by incorporating and combining strategies reported in the literature that have been effective under certain conditions.

7 Conclusions

In this study, we conducted a systematic mapping to investigate teaching experiences in software architectures. We selected 56 primary studies published from January 2011 to March 2021 and classified the experiences into three groups: (i) experiences focused on teaching software architectures, (ii) experiences focused on teaching software engineering, and (iii) other experiences with interesting strategies that support the teaching of software patterns and architectures.

We discovered that teaching strategies focus on aligning and providing feedback on software architecture training courses to meet the needs of the software industry, the software architecture course contents offered by colleges, and the skills associated with the software architect role.

Despite two decades of teaching software architecture, challenges remain, making this area a challenging research topic. Software architecture education requires more maturity due to the complexity and knowledge required. The findings of this study will be beneficial for researchers and educators who aim to overcome the challenges of teaching software architectures.