Alignment Day: Clean ABAP for better planning and lower costs
Future viability is de facto only of little value for the daily business of software development. Like the term sustainability, it sounds reasonable – but unfortunately there is no time for it right now. And so money is burned every day. Decisions in favor of short-term productivity incur a debt with considerable interest rate on the code without being recognized. And the repayment is not long in coming – even if that is not always realized. The result: growing frustration, conflicts, demotivation, unreliability, quality defects, rising costs, hesitation, customer dissatisfaction.
Developers feel this development immediately. But other stakeholders are often not so clear about the connections between their decisions and unwanted results. The Alignment Day is designed to change this. It is aimed at managers, project leaders, even customers of software development to explain the conditions for the possibility of greater smoothness in long-term high productivity. The hypothesis behind it: Better understanding will lead to better decisions.
Sustainability in software development is not an esoteric idea, but a matter of economics. It is a matter of increasing the fitness of the software development and the company.
The Alignment Day provides tangible explanations why the situation of software development is largely as depressing as it is – and delivers concrete recommendations for improvement. Apparent “fashionable terms” like Agility, Scrum/Kanban, Clean Code are reduced to the essentials and justified. The result is a common understanding of what software development needs in order to have the reliability that does justice to its central position in business.
Overview of the training content:
- The unrecognized requirement of the customer: long-term high productivity
- Eight reasons for the previous neglect of future viability in software development
- The five pillars of long-term high productivity
- Of technical debt and delivery addiction
- Protect and support the bottleneck in the software development process
- Test-driven development as the foundation for long-term high productivity
- Higher productivity through active attention design for every day
- Decoupling value delivery and quality production to reduce conflicts
- Promise Like a Pro: Higher reliability through more realistic promises
- Complexity and business value estimates for reasonable prioritization
- Controlling quality production with priorities and fine grained requirements
- Forecasts of delivery dates with greater accuracy and less stress through simulation at any time
Duration: 1 day, number of participants: max. 100, target groups: manager, project manager, product owner, analyst, developer, architect, tester
Developer-oriented requirements analysis for clean ABAP
Future-proof software has one prerequisite: good requirements. Because software is not exempt from the proverbial garbage in, garbage out. Clean software development must therefore pay special attention to the quality of its input.
But what are good requirements? Expressions that appear good and sufficient to a product owner/customer are not equally suitable for rapid or even sustainable implementation by developers.
High-quality development work requires requirements in a form that already provides information about the software architecture and allows easy verification of the maturity and stability of the implementation. The traceability of the development progress is to be supported by the requirements analysis as well as the traceability of individual features in the code.
An agile approach that uses use cases, epics or user stories as input for programming is not enough. Programming needs more concrete input before it can start with architecture planning and implementation. A translation “into the language of programming” is necessary.
The training raises awareness of the need for high quality requirements and provides approaches to requirements analysis from a developer perspective. The result is faster, more reliable, and more predictable development.
Overview of training content:
- Analyze requirements together with product owner/customer
- Incremental requirements decomposition with slicing
- Message-oriented requirements exploration with Event Storming
- Architecture patterns in comparison: MVC, Layers, Hexagonal, Clean, IODA
- IODA architectural design without functional dependencies
- Acceptance tests as a goal of the requirements analysis
- Dealing with unclear requirements
- Criteria for a triage of customer requests
- Basics of a predictable development process
Duration: 4 days, number of participants: max. 15, target groups: developer, architect, product owner
Radical Object-Oriented Software Development for Clean ABAP
Object-orientation is mainstream – and mysterious at the same time. The promises of object orientation are great – but for many developers they are not being fulfilled. And where procedural thinking still is prevailing, it is difficult to get started with object-orientation.
Future-proof ABAP systems without object-orientation are hardly conceivable. The advantages of object-orientation for long-term high productivity through comprehensibility and testability are simply too great to be ignored. In addition, there is a great potential for better work organization even in terms of short-term productivity.
The training offers an introduction to object-orientation in contrast to the mainstream. It goes back to the original vision of Alan Kay, which offers a more natural approach to the concepts than the usual “class-orientation”. Such “radical” object-orientation also fits better into an agile approach, because it does not compulsively translate requirements for the behavior of software into nouns. Object-orientation is a means to adapt to the purpose of value creation.
But the training not only provides an intuitive access to the common concepts of object-orientation such as class, interface, encapsulation, but also alightweight visual notation to model code in an object-oriented way. The joint design of software in a team becomes possible and proves to be a natural space for exchange between all participants. Sustainable software needs not only collective code ownership, but also collective design ownership.
Overview of training content:
- Purpose of the original definition of object-orientation
- Message-orientation as the core of object-orientation
- Integration Operation Segregation Principle
- Principle of Mutual Oblivion
- Criteria for the type of classes
- Instance classes vs. static classes
- Behaviour classes vs. data classes
- Interfaces for encapsulation
- Polymorphism for testability
- Classes as part of a module hierarchy
- An admonition not to optimize for re-use
- Visual modeling of object-oriented software in a team
- Behaviour-oriented design
- outside-in design
Duration: 4 days, number of participants: max. 15, target groups: developers and architects
Test-first Coding for Clean ABAP
Future-proof ABAP systems stand and fall with their correctness. Every bug that is found reduces customer/user confidence and leads to conflicts; every bug that is fixed reduces development capacity for value-adding features. Short-term productivity at the expense of correctness is a guarantee for poor sustainability.
Systematic automated testing is a necessary defense against incorrectness of any kind. This has long been known in the software industry – but many ABAP teams do not find the right access to it. Hard to test ABAP legacy code is one of the reasons for this; another is the presentation of test-driven approaches in the literature, which often appears dogmatic and only describes limited scenarios.
This is where this training comes in: It first develops a solid motivation with the participants to face the difficulties of automated testing, teaches technical dexterity and then provides complementary approaches to test-first coding. The aim is to give the participants an eclectic attitude, which, depending on the problem, uses the best approach in a completely undogmatic way.
Overview of the training content:
- Justification for why test-first really matters
- Automated acceptance tests as the basis for mature and stable software
- The test matrix: adapting the approach to the degree of difficulty of the problem
- Coding test-first with
- Classic TDD
- Informed TDD
- TDD as if you meant it
- Rediscover prototypes for preliminary coding
- Tests as drivers of modularization
- Test types from acceptance test to scaffolding test
- Expose functional dependencies as an obstacle to testing
- DIP and IoC for testing dependent codes
- ABAP development in Eclipse
- ABAP test frameworks ABAPUnit, Test Double and Test Seams
Duration: 4 days, number of participants: max. 15, target group: developers