Software Due Diligence
SERVICES _
Trainings for Software Development
In practical training sessions, we provide best practices and suggestions on how to pragmatically improve software development at the interfaces between requirements capture, architecture, coding and testing in order to increase software quality and achieve insightful monitoring and better project planning.
- Software architecture - introduction to the concept and its creation
- Principles of quality assurance with issue tracker and version control (esp. Git) and their application (developed by developers for developers)
- Introduction to "Design for testability" principles and patterns
- Requirements engineering - what software developers and architects should and must know about it
TRAINING _
Software Architecture
Introduction to the concept and creation
The architecture of a software system has a decisive influence on its success. It determines whether the system can be used productively and developed effectively and cost-effectively. It is essential to learn how to create and shape software architecture. It has to be done in a way so that the software architecture has a positive impact on whether the system can be improved, expanded and adapted to changing technologies, application scenarios and customer-specific requirements over the course of its life cycle.
Content
- A systematic introduction to the topics of software architecture and its creation
- Group exercises based on a challenging end-to-end case study to learn what challenges software architects face and what tasks architects take on in development projects.
- Insight into techniques, practices and tips that help when interacting with stakeholders such as product owners, managers and testers.
- Support to identify individual gaps in your software architecture and creation process that could pose a risk in your current project and practical advice on how to address them
Duration: 5 days
We recommend holding this training on site for a group of at least eight participants. However, a purely online-based version or a combination of online and on-site components is also possible.
Goals
After completing this training you will know:
- how architects identify and evaluate architecturally-significant requirements,
- how to systematically create an architectural design and how to proceed in doing so,
- which architectural aspects and best practices make life easier for the architect,
- what a step-by-step process for creating an architecture looks like and when architecture refactoring activities should be carried out,
- how non-technical aspects (e.g. business goals, domain modeling and soft skills) influence the architect's work,
- how architects ensure the quality of the product and software,
- how architects deal with technical and infrastructural issues, and how decisions are made,
- how architectures are documented and presented,
- what problems arise in practice when creating software architectures and how they can be solved,
- how architects can evaluate architectures and implementation processes,
- how architects are embedded in the development process and the resulting dependencies.
After the training, you will be able to start applying and implementing these methods and techniques on your own in your software projects. This training will help you start your career as a hands-on software architect.
Prerequisites
Basic knowledge and experience in software engineering
Target audience
- Software developers who want to acquire knowledge about the creation of software architectures
- Future software architects
- Key/lead developers
KNOWLEDGE _
KNOWLEDGE AREA
Want to quench your thirst for knowledge quickly? Take a look at our knowledge area.
DOWNLOADS _
DOWNLOADS
In our download area you will find valuable resources that you can download fir free.
TRAINING _
Development Methodology
Using issue trackers and code repositories with added value - pragmatic guidelines and advanced Git techniques
This seminar will provide you with best practices and recommendations on how to pragmatically improve the technical development process in order to increase software quality, speed up debugging and achieve insightful project monitoring. For this, we focus on the correct handling of the issue tracker, the version control system (especially Git) and in particular on their shared use.
Content
- Basics of how and why to introduce a reasonable set of issue types in an issue tracker according to the principle of "as few as possible and as many as necessary".
- Writing meaningful and structured issue descriptions and commit messages
- Break down code changes into individual commits in a sensible way.
- Advanced Git techniques: interactive staging & interactive rebasing
- Branching workflows
- Exercises for each section
Duration: 1 day
Goals
After completing this seminar you will know:
- how to write and specify requirements (as issues) concisely and well,
- how to pragmatically use an issue tracker for this purpose,
- how to apply advanced best practices (e.g. interactive staging & rebasing) in Git,
- how to link commits to issues,
- how to become more productive in debugging using Git and an issue tracker,
- how to use Git and an issue tracker to build a project history that is useful and traceable for development, in order to avoid a lot of extra work later on in debugging and understanding the code,
- how to start with a simple branching workflow and later grow with the requirements and apply further workflows.
After the seminar, you will be able to implement these techniques independently in your projects and convince colleagues & employees of the added value of corresponding procedures.
Prerequisites
Prerequisites are basic knowledge of Git and of an issue tracker and an installed Git tool on your computer.
Target audience
Software developers, software architects, quality managers, product owners
EVENTS _
EVENTS
You can see where you can meet us at these events
CAPE OF GOOD CODE _
ABOUT CAPE OF GOOD CODE
Find out more about our history here
Design for Testability
Increasing software testability with the right design patterns
In this practical seminar, we teach design techniques for creating software to increase design quality. The focus will be on design patterns that contribute to decoupling AND easier testability of the code. Easier testability of the code automatically favours the creation of more tests. Thus, not only the external system quality is improved, but also the comprehensibility of the code for the entire development team.
Content
- Design patterns that you can apply when creating new code to aim for a good and testable design in the code.
- Obstacles that exist when introducing tests for existing code parts.
- Design techniques to overcome these obstacles step by step in order to perform successive refactoring steps to introduce unit tests or integration tests.
- Exercises for each learning section including application to your own code base.
Duration: 1 day
Goals
After completing this seminar you will know
- which design patterns lead to better code decoupling and testability,
- which design techniques can be used to subsequently modify existing code by means of step-by-step refactoring steps in order to introduce unit tests or integration tests,
- how to continue applying appropriate approaches to your code base after the seminar.
Prerequisites
Prerequisites are basic knowledge in writing tests using a unit test framework, an installed unit test framework on your computer. Ideally, you will bring some code examples from your work to apply what you have learned.
Our suggestions and methods are independent of programming languages and can be used in your project regardless of a specific test framework.
Target audience
Software developers, testers, software architects
Egon Wuchner, CEO
Knowledge is for sharing.
We can't wait to share our secrets with you!
Requirements Engineering
What software developers and architects should know about it
This training aims at creating awareness and understanding of requirements-engineering as far as software architects and developers are involved in their interaction with product owners, product managers and testers. As an outcome, you will comprehend, recognize and even apply good requirement engineering practices. You will be able to distinguish good from bad requirements engineering and well from badly written requirements.
Content
- Differences between functional and non-functional requirements and their further categorisation
- Organisation and concrete design of requirements (epics, features, user stories/acceptance criteria, tasks) using examples
- Techniques for specifying epics, features (via use cases or domain storytelling) using examples
- Techniques for specifying non-functional requirements
- Embedding into the SAFe framework
- Introduction to the topic of domain modelling and its relation to requirements and software engineering
- Knowledge of other techniques such as event storming
- Exercises in groups using a challenging end-to-end case study to learn how to specify functional and non-functional requirements with added value for development
Duration: 3 days
We recommend holding this course on site for a group of at least eight participants. However, a purely online-based version is also possible.
Goals
After completing this training you will know
- the concepts, terms, relations with respect to requirements and learn how to specify, write and organize requirements.
- what good requirements (epics, features, user stories) look like,
- how to achieve testability of requirements by good acceptance criteria (e.g. by using Given-When-Then (GWT) statements),
- how requirements differ from the vision and the business goals and what good vision statements and business goal formulations look like (since not fitting or not even knowing the business goals makes you spend some effort in vain),
- how to deal with non-functional requirements in a testable way (based on scenarios),
- how to benefit from requirements traceability (which you need for any medium- to big-sized project),
- how use case descriptions, domain storytelling (and event storming) help in eliciting and distinguishing epics, features and user stories,
- why and how domain modeling is at the intersection of requirements and software engineering
After the training, you will be able to point your product owner/manager to badly specified requirements and insist on their refinement before starting any implementation in code.
Finally, you will have the knowledge to assist product owners and managers in specifying requirements, especially with respect to non-functional ones.
Prerequisites
Basic knowledge and experience in software engineering
Target audience
- Software developers, software architects
- Product Owner, Product Managers
More than dry theory
We know that good arguments alone are often not enough. Therefore, we will convince you of our approaches by showing examples, taking apart concrete cases and doing exercises with subsequent discussions. We want you to experience "aha moments" and not just adopt our views.
We are aware that developers often consider extra work that is not directly related to the process of programming as overhead. We are aware that it is often not easy to convince teams to consistently put in this extra effort, and that team leaders often do not feel justified in demanding this kind of discipline. We are also aware that guidelines are not accepted and implemented if they are only decided and imposed by superiors. We offer solutions and strategies for how to motivate your team and get them to even become advocates of such approaches.
KNOWLEDGE _
Our Latest Knowledge Articles
In our knowledge blog you will constantly find new articles on various topics from software development.
Software Due Diligence
Software Due Diligence: The Key To Successful M&A Deals
Egon Wuchner
Dec 11, 2024
Egon Wuchner
Mar 26, 2024
You can find more articles in our knowledge area
No one-size-fits-all solution
Following training, we are happy to accompany you in the implementation of the adopted measures. The scope of our engagement can be agreed individually. It can be regular reviews (e.g. weekly, monthly) or a one-off review after a certain period of time (e.g. quarterly) or even technical support (e.g. setup & configuration of tools) - it is entirely up to you.
You are not alone
Following training, we are happy to accompany you in the implementation of the adopted measures. The scope of our engagement can be agreed individually. It can be regular reviews (e.g. weekly, monthly) or a one-off review after a certain period of time (e.g. quarterly) or even technical support (e.g. setup & configuration of tools) - it is entirely up to you.