ABAP has changed more in the last decade than in the twenty years before it. If you learned ABAP in the R/3 or ECC era — DATA declarations at the top, CONCATENATE for strings, MOVE-CORRESPONDING for structure mapping — the modern syntax can look like a different language. Three constructs do most of the heavy lifting in the new style: VALUE #( ), string templates, and CORRESPONDING #( ).
Here is what each one does, with the old pattern it replaces.
VALUE #( ): inline construction
The VALUE constructor expression builds a data object — a structure, an internal table, or an elementary value — inline, in a single expression. No separate declaration, no CLEAR, no APPEND loop for simple cases.
The old way of filling an internal table:
DATA lt_customers TYPE TABLE OF ty_customer.
DATA ls_customer TYPE ty_customer.
ls_customer-id = '1001'.
ls_customer-name = 'Acme Corp'.
APPEND ls_customer TO lt_customers.
ls_customer-id = '1002'.
ls_customer-name = 'Globex Inc'.
APPEND ls_customer TO lt_customers.
The modern way:
DATA(lt_customers) = VALUE ty_customer_table(
( id = '1001' name = 'Acme Corp' )
( id = '1002' name = 'Globex Inc' ) ).
Each pair of parentheses is one row. The # means "infer the type from context" — here from the ty_customer_table type, or from the target variable when used in an assignment.
VALUE also replaces CREATE DATA for data references and gives you a clean way to initialize structures:
" Old: declare, then clear, then fill field by field
" New: one expression
DATA(ls_order) = VALUE ty_order( order_id = '450001'
status = 'OPEN'
total = '1500.00' ).
VALUE #( ) is not just shorter — it makes the data's shape visible at the point of creation. When you read the code six months later, you see the content, not the ceremony.
String templates: say goodbye to CONCATENATE
String templates embed variables and expressions directly inside a string using |...| delimiters and { } placeholders. They replace CONCATENATE and most uses of the && operator.
" Old way
CONCATENATE 'Order' lv_order_id 'has status' lv_status
INTO lv_message SEPARATED BY space.
" New way
lv_message = |Order { lv_order_id } has status { lv_status }|.
The template is far easier to read, and it gets better: you can put full expressions inside the braces, including method calls and constructor expressions.
lv_message = |{ lines( lt_items ) } items, total { calculate_total( ) }|.
lv_label = |Customer: { ls_customer-name WIDTH = 20 ALIGN = LEFT }|.
Formatting options like WIDTH, ALIGN, and CASE go right inside the placeholder — no more chaining TRANSLATE or padding functions afterwards. There are also dedicated template functions: substring( ), replace( ), to_upper( ), and more, all usable inline.
One caveat: string templates always produce a string of type string. If you need a fixed-length c field, assign or convert explicitly. In ABAP Cloud and RAP code, string is usually what you want anyway.
CORRESPONDING #( ): functional structure mapping
MOVE-CORRESPONDING copies components with matching names between structures. CORRESPONDING #( ) is its expression-based counterpart — it returns the mapped structure as a value, which means you can use it inside larger expressions, method calls, and constructor arguments.
" Map a database structure to a UI-friendly structure, inline
ls_display = CORRESPONDING ty_display( ls_db_record ).
Where it really shines is mapping whole tables in one line:
" Old way: LOOP ... MOVE-CORRESPONDING ... APPEND ... ENDLOOP.
" New way:
lt_display = CORRESPONDING ty_display_table( lt_db_records ).
You can also control the mapping explicitly. MAPPING renames components, EXCEPT skips them:
lt_result = CORRESPONDING ty_result_table(
lt_source MAPPING id = customer_id
name = full_name
EXCEPT internal_flag ).
And because it is an expression, it nests naturally with VALUE:
DATA(lt_ui) = VALUE ty_ui_table(
FOR ls_db IN lt_db_records
( CORRESPONDING ty_ui_line( ls_db ) ) ).
CORRESPONDING #( ) turns structure mapping from a statement you write around your logic into a value you build your logic from. That shift — statements to expressions — is the heart of modern ABAP style.
Putting it together
Here is a small but realistic example — building a message list for a RAP validation, using all three constructs:
DATA(lt_messages) = VALUE ty_message_table(
FOR ls_item IN lt_items WHERE ( quantity < 0 )
( id = ls_item-id
text = |Item { ls_item-id }: quantity cannot be negative|
severity = 'E'
details = CORRESPONDING ty_details( ls_item ) ) ).
Inline table construction, string templates, and structure mapping in a single readable expression. That is modern ABAP: less ceremony, more signal. If you are moving to ABAP Cloud, this style is not optional decoration — it is how the language is meant to be written now, and the ATC checks will nudge you toward it.