Software Craftsmanship is about professionalism in software development. The “craftsmanship” metaphor is based on the notion of professional craftsmen who take responsibility for their work and aim to achieve mastery –not only as individuals but also as part of a community. Especially in the context of developing and extending high-quality systems with long lifecycles, it is important that we nurture a strong culture of professionalism in software development. This includes both technical aspects such as automated tests, addressing technical debt, and refactoring as well as cultural aspects such as responsibility, failure culture, embracing change, and continuous learning. This paper describes what we, as industrial practitioners, mean by professionalism and describes our global training program that sets the foundation for this way of working. This is accompanied by a software craftsmanship program that enables software engineers to continuously learn, further increase their mastery of craftsmanship and apply what they learned on their current and future projects.

This paper was published in IEEE Software, vol. 40, no. 6, pp. 55-62, Nov.-Dec. 2023, DOI Bookmark: 10.1109/MS.2023.3311267 Full article at: http://ieeexplore.ieee.org/iel7/52/10339104/10242135.pdf

Siemens established a company-wide role-based qualification and certification curriculum, focusing on the topic of “architecture”. Architects play a central role in the product lifecycle of the complex systems that Siemens offers. Since the curriculum's start in 2006 with the “senior software architect” program, we have added programs for software, system, and test architects. This curriculum is meanwhile broadly established throughout Siemens and Siemens Healthineers and other associated Siemens companies. We meanwhile have almost 700 certified architects in almost 20 countries. This industrial experience report describes the curriculum briefly but will focus on how the “architecture” of the training program for architects enabled us to evolve and extend the curriculum over time. The evolution covers not only additional roles, but also keeps the technical content up to date and adapts to modern learning formats as we strive to achieve the most impact in the available time. Our experience may be a blueprint for other key role curricula.

The ever-increasing complexity of software and rapidly changing development environments continues to drive the evolution of new technologies, techniques, and tools. This special issue, Software Engineering in Practice, provides the software engineering community with a valuable collection of current, high-quality research articles that explore topics driven by real problems in the industry. The inspiration for this special issue has drawn upon the ICSE Software Engineering in Practice (ICSE SEIP 2018) Track, 1 part of the Industry Program at the 40th International Conference on Software Engineering. 2 The ICSE SEIP Track provides a premier venue for researchers and practitioners to discuss innovations and solutions to concrete software engineering problems. The Guest Co-editor team for this special issue is an international collaboration involving the co-organizers of the ICSE SEIP 2018 Track, Frances Paulisch and Jan Bosch, and an editor of the Journal of Software: Practice and Experience 3 (JSPE), Kendra M. L. Cooper. Methodology The Call for Papers was designed to encourage submissions that presented novel and innovative ideas that broadly spanned the software engineering discipline—ideas that provided rigorously validated solutions for real problems encountered by practitioners. In order to promote an inclusive environment, the call was broadly disseminated as an open call; it was advertised on the JSPE and the ICSE SEIP 2018 websites, established software engineering newsgroups (eg, SE World), and conference announcement sites (eg, WikiCFP), in addition to numerous professional and social media platforms. The call required submissions be original manuscripts that had not been previously published and were also not under consideration for publication elsewhere. Submissions of research article, survey papers, short communication, and extended conference papers were welcome; extended conference papers were required to include at least 30% additional novel contributions. The response from the software engineering community was enthusiastic: the special issue received 41 submissions. Submissions featured international collaborations from researchers in academia and industry, case studies from industry, and the use of open source data sets and systems provided by the broader community. The submissions were reviewed according to the JSPE standards, with a goal of publishing the online version of the articles in a timely fashion. Ultimately, nine articles were selected for the special issue. Overviews of these accepted manuscripts are presented below, organized into three groups. Overview of the collection Novel contributions in the area of data analytics are explored in some of the papers in the special issue. Astekin et al present a framework for automated analysis of large system logs to detect anomalies. Karna et al employ data mining methods on the software engineering process itself and use these techniques for effort estimation. Marijan et al introduce a novel learning algorithm to optimize the continuous integration and testing practice. In addition, Martens et al investigate the problem of data migration between legacy and newly developed IT systems. Research problems centered on mobile application code are the focus of two papers in the special issue. Ochoa et al apply static analysis techniques on Android applications to detect context leaks in the code. Wang et al also study mobile applications; these authors report on approaches to obfuscate mobile application code with the intent of impeding efforts to reverse engineering applications. Techniques based on the model-driven development paradigm are presented in several of the papers in the special issue. Nooraei and Ajoudanian present a framework to ensure the on-going integrity of the transformation between the platform-independent model (PIM) and the corresponding platform-specific model (PSM) of a system via regression testing. Markthaler et al present a model-driven method for the automotive domain that spans multiple layers of software engineering artifacts; on-going consistency checking between the layers is supported in addition to the generation and re-generation of test cases. O'Shea et al present a three-layer design model for a virtualized test automation framework; a key feature of this model is the virtualized infrastructure layer. We would like to extend our warmest thanks to all the authors who submitted their manuscripts, the anonymous reviewers who provided timely and high-quality review comments in their generous service to the community, and the editorial board and personnel of the Journal of Software: Practice and Experience.

In this experience report, we describe the motivation, experience, lessons learned, and future directions of a software engineering curriculum used at a large international company. The "Curriculum for Software Engineers" project, which developed the content and a role-based qualification and certification program, was started at Siemens in 2006. This paper includes an overview of various kinds of certification in the software engineering area and why we chose the knowledge- and experience-based type of certification. The experience report part focuses mainly on the "certified senior software architect" role, as this role has the longest history and participants from many different business units and countries.

In this workshop, we invite practitioners and researchers interested in the application of iterative, adaptive, and agile processes. And we expect to learn from each other. We include those favoring detailed or large-scale process descriptions (such as the Rational UP) to those favoring minimalist descriptions (such as Serum), from process evangelists to process agnostics, from expert developers to business managers, from domains where speed is the top priority to domains where quality or verifiability are the top priority.

The paper reports on Siemens' extensive experience with process assessments and improvements in a wide variety products and systems, be they software, hardware, or some combination thereof. The Siemens Process Assessments are based on the Capability Maturity Model (CMM) and the BOOTSTRAP approach together with Siemens-specific refinements and extensions, especially for the engineering disciplines. They are significantly more detailed as well as being move focused than other assessment approaches on the business needs of the assessed organization. The authors summarize the lessons learned. In particular they focus on how improvement projects are identified and initiated on the basis of Siemens Process Assessments, and how improvement projects are established as projects within the operating divisions. They describe the challenges that arise and how they can be met.

Software architecture focuses on the overall structure of a software system. The structure is defined by its components (subsystems) and the relationships between them and is often described in shorthand by such terms as model-view-controller, client-server, pipe and filter, etc. We focus not only on the reusability components themselves, but on the reusability of their interconnections as well. The interconnections could take on various forms e.g. aggregation, inheritance, frameworks, etc. Software architecture goes beyond the scope of classical software design in which the structure of a software system is mainly defined by a functional decomposition of its primary subject matter. Software architecture explicitly considers not only the functional but also the non-functional aspects of software systems, such as reusability, changeability, maintainability, portability, interoperability, testability, efficiency, fault-tolerance etc. Desirable non-functional properties have a strong influence on the architecture of the software system. Careful consideration should be given to the relative importance of the multiple nonfunctional requirements at an early stage in the software development lifecycle because their objectives are often contradictory. We focus on how the non-functional property reusability relates to the software architecture of a system.>

Automatic layout algorithms are commonly used when displaying graphs on the screen because they provide a “nice” drawing of the graph without user intervention. There are, however, a couple of disadvantages to automatic layout. Without user intervention, an automatic layout algorithm is only capable of producing an aesthetically pleasing drawing of the graph. User- or application-specified layout constraints (often concerning the semantics of a graph) are difficult or impossible to specify. A second problem is that automatic layout algorithms seldom make use of information in the current layout when calculating the new layout. This can also be frustrating to the user because whenever a new layout is done, the user's orientation in the graph is lost.