A working reference for SAP ABAP as it is actually written in productive landscapes — from classic procedural and dynpro code through ABAP Objects to modern expression syntax and ABAP SQL. Built from accumulated real SAP project notes, patterns and examples, and organised so that each technology carries an explicit lifecycle status: what is current, what is classic but still live, and what is there for historical reference.
That last part is the point. Real SAP systems run several generations of ABAP at once. A reference that shows only the newest syntax is no help when you open a twelve-year-old pricing routine; one that shows everything without saying which is which is no help either.
- Covers: ABAP language fundamentals, internal tables, ABAP SQL, modularization, ABAP Objects, classical reports, selection screens and dynpro, three generations of ALV, BAPIs, BAdIs and the enhancement framework, messages and exceptions, and performance — including the modern (7.40-generation) expression syntax throughout.
- Does not cover: RAP, CDS, AMDP, ABAP Unit, or ABAP Cloud beyond the boundary explained in Chapter 21. That is a deliberate boundary, not an oversight.
- Examples are illustrative. They are written to teach a pattern, not to be dropped into production unchanged. See How to Use.
- Not official SAP documentation. For anything version-sensitive, the ABAP Keyword Documentation is the authority.
- 21 structured chapters plus a quick-reference Examples section
- 100+ annotated ABAP examples drawn from real project work
- Explicit classic-to-modern lifecycle guidance on every major technology
- Internal tables and modern expressions —
VALUE,FOR,REDUCE,FILTER,COND, table expressions, secondary keys - ABAP SQL in depth — joins, subqueries, aggregation,
FOR ALL ENTRIESand its pitfalls, dynamic SQL - Three ALV generations side by side —
CL_SALV_TABLE,REUSE_ALV_*,CL_GUI_ALV_GRID - Integration and extensibility — BAPIs, BAdIs, enhancements, BDC, RFC, with the transaction and authorization implications spelled out
→ Chapter 21 — Classic vs Modern ABAP
The chapter that ties the rest together: why productive landscapes contain several ABAP generations, what to use for new on-premise development, what remains classic but relevant, what is historical reference, and what changes under ABAP Cloud. Includes a decision table for the common maintenance and greenfield scenarios.
| I need to… | Chapters |
|---|---|
| Get the language fundamentals right | 01 · 02 · 03 · 04 · 05 |
| Work with internal tables and modern expressions | 06 · 07 |
| Read or write database data safely | 08 · 15 |
| Structure and reuse code | 09 · 10 |
| Build a report or a screen | 11 · 12 · 13 |
| Integrate or extend standard SAP | 14 · 15 · 16 · 17 |
| Handle errors, log, and tune | 18 · 19 |
| Review code against a checklist | 20 |
| Decide between classic and modern | 21 |
Chapters and examples are labelled with one of these. Full definitions in Chapter 21.
| Label | Meaning |
|---|---|
| CURRENT / RECOMMENDED | Reach for this in new on-premise development |
| CLASSIC BUT STILL RELEVANT | Widespread and supported; you must be able to maintain it |
| LEGACY / HISTORICAL REFERENCE | Superseded — read it, don't write it |
| ABAP CLOUD / MODERN CONTEXT | Belongs to, or explains, the ABAP Cloud development model |
| VERSION-DEPENDENT | Availability depends on your release — verify before relying on it |
| Folder | Topic | Description | Context |
|---|---|---|---|
| 01-ABAP-Basics | ABAP Basics | Program structure, report events, syntax fundamentals | Current |
| 02-Data-Types | Data Types | Elementary types, structures, type conversions | Current |
| 03-Variables | Variables | DATA, CONSTANTS, inline declarations, FORM/PERFORM | Current + legacy |
| 04-Operators | Operators | Arithmetic, comparison, built-in math functions | Current |
| 05-Control-Statements | Control Statements | IF, CASE, CHECK, COND, SWITCH | Current |
| 06-Loops | Loops | LOOP, DO, WHILE, control breaks, GROUP BY, COLLECT, ranges | Current + classic |
| 07-Internal-Tables | Internal Tables | Table types, keys, VALUE/FOR/REDUCE/FILTER, field symbols | Current |
| 08-Open-SQL | ABAP SQL | SELECT, joins, aggregation, CRUD, SAP LUW & transaction ownership | Current + version-dependent |
| 09-Modularization | Modularization | Function modules, conversion exits, RFC, macros, SUBMIT | Classic + legacy |
| 10-Objects | Objects / OOP | Classes, visibility, inheritance, static vs. instance | Current |
| 11-Classical-Reports | Classical Reports | List events, WRITE, dynamic tables + authorization | Classic |
| 12-Selection-Screens | Selection Screens & Dynpro | Selection screens, PBO/PAI, screen modification, popups | Classic |
| 13-ALV | ALV | CL_SALV_TABLE, REUSE_ALV_*, CL_GUI_ALV_GRID, field catalogs, events | Current + classic |
| 14-Function-Modules | BDC / Batch Input | CALL TRANSACTION, BDC tables, message handling, authorization | Classic |
| 15-BAPIs | BAPIs | BAPIRET2, transaction control, standard call pattern | Classic, still relevant |
| 16-BADIs | BAdIs | Classic vs. new BAdIs, filters, implementation pattern | Current + classic |
| 17-Enhancements | Enhancements | User exits vs. customer exits, enhancement points, modifications | Classic + legacy |
| 18-Debugging | Messages & Exceptions | MESSAGE, exception handling, application log | Current |
| 19-Performance | Performance & Memory | Internal table tuning, ABAP Memory, database access | Current |
| 20-Best-Practices | Best Practices | Naming conventions, code review checklist | Current |
| 21-Classic-vs-Modern-ABAP | Classic vs Modern | Lifecycle map, ABAP Cloud boundary, decision table | Start here for context |
| Examples | Examples | Strings, dates/times, conversions | Current + legacy |
- Jump to the chapter matching your need via Find It Fast, or read Chapter 21 first for the lifecycle map.
- Each chapter follows the same shape: introduction → examples → best practices → common mistakes → interview & review checkpoints → related transaction codes.
- Understand what kind of snippet you are reading:
- Complete examples — self-contained programs or classes (for instance the ALV reports in Chapter 13). These show a full working structure.
- Contextual snippets — the majority. They demonstrate one statement or pattern and assume surrounding declarations. Adapt the names and types to your own program.
- Examples are illustrative, not production-ready as-is. They are simplified to make the pattern visible: error handling, authorization checks and locking are shown where they are the point being made, and abbreviated where they are not. Review any snippet against your own standards before using it, and syntax-check it in your target system.
- This guide uses the modern expression syntax introduced across the ABAP 7.40 generation — inline declarations,
VALUE,NEW,CONV,CORRESPONDING,COND,SWITCH,REDUCE,FILTER,FOR, table expressions and string templates. - Individual ABAP SQL features require later releases. SQL expressions in the field list, host expressions, and internal tables as data sources all arrived progressively across the 7.4x/7.5x releases, not all at once. These are flagged VERSION-DEPENDENT where they appear.
- This guide deliberately states no exact minimum release or support-package numbers. Verify each feature against the ABAP Keyword Documentation for your target system before relying on it.
- Terminology: SAP's current umbrella term for the SQL statements is ABAP SQL; "Open SQL" is the historical name and is still in wide use. Both appear here. The chapter folder keeps its
08-Open-SQLname so existing links continue to work. - Tooling: ABAP Development Tools (ADT) for Eclipse is recommended; the classic workbench (SE38/SE80/SE24/SE37) is assumed knowledge where transaction codes are referenced.
- SAP developers maintaining productive ABAP who need a working example fast, with the context to know whether the pattern is still the right one.
- Engineers modernizing classic ABAP who need to tell deliberate legacy from accidental legacy before they change anything.
- Developers working across SAP GUI and modern ABAP syntax, where both generations sit in the same program.
- Technical leads reviewing implementation patterns — the per-chapter review checkpoints and the Chapter 20 checklist are written for that use.
Newcomers to ABAP will find the chapters readable in order, but the reference is written for people who already program.
Corrections and additions are welcome — particularly anything that fixes a technical inaccuracy or clarifies a lifecycle classification.
- Fork the repository and create a branch (
git checkout -b improvement/topic-name). - Keep the existing chapter structure and lifecycle labelling.
- For anything version-sensitive, cite the ABAP Keyword Documentation rather than asserting a release number.
- Open a pull request describing the change.
Licensed under the MIT License — free to use for learning, teaching and reference.
Serhat Mercan — SAP Technical Lead · Enterprise SAP Engineering · ABAP / ABAP Cloud · SAP BTP
- GitHub: github.com/serhatmercan
- LinkedIn: linkedin.com/in/serhat-mercan