ABAP feature, in comparison to other programming languages

I'm just talking about things that I perceive. Actually I think ABAP is already a very powerful platform. I wish we can make it better.

Advantage: high run-time performance. It is very fast, compared to other high-level programming languages. Some high-level languages are fast, such as C# and Java, and ABAP feels as fast. Some high-level languages, such as Python, is relatively slow.

Disadvantage: no central "common" code library, or no tutorial on "common" code library. This disadvantage lets us keep reinventing the wheel sometimes. Fortunately there are language built-in array list/ balanced search tree/ hash table feature called "internal tables" so that we don't need to reinvent these.

Advantage: some features are carefully designed, such as the CP operator and its syntax, also range table. The CP operator does comparison of string against a string that can contain wildcard characters. For example, we use wildcards in DOS/Windows file name matching, such as "*.zip" matches all files ending with ".zip". In ABAP, the CP operator uses "*" (asterisk or "star")to represent any sub-string and "+" (plus) to represent any single character. However, the merit of it is that it contains an escape character, "#". Using it, you can represent literal asterisk and plus characters by putting it before each of them. For example "#*" matches a "*" character.

The range table is also carefully designed, so that it can be used to represent a sequence of inclusion conditions and a sequence of exclusion conditions, such as: (col1 = "X" OR col1 = "Y") AND col2 = "X" AND NOT (col1 = "X" OR col1 = "Y" AND col2 = "X").

Disadvantage: no "generic programming" support. Unlike C++, C# and Java, there is still no "generic" support in ABAP. To tell the truth, "generic" support eases programming, but also has its disadvantage: setting the break point breaks all generic calls, but sometimes I just want to break into the instantiation of a specific type parameter, e.g. I can't break only into List<int> but not List<string>.

Advantage: debugger supports "goto statement". This feature is quite useful when you missed a previous execution of several statements and those statements can be safely executed again. This feature was seen in Visual C++ also, but not all debuggers support this feature.

Disadvantage: it's too easy to mix old syntax with new syntax, e.g. number-based exception in object-oriented context. ABAP uses two kinds of exception handling, one using exception name mapped with a sy-subrc (return code) value at method/ function exit and another with OO-based try-catch statement. The sy-subrc exception handling brings another disadvantage:

Disadvantage: syntax allows non-strict variable initialization and exception handling. Maybe this is an advantage regarding ease of learning, but regarding programming safety, it's dangerous to ignore or mishandle unknown exceptions. Although there is still no "one correct way" to use OO exception (such as in C# or Java), it is still a good practice to handle known exceptions and log all unknown exceptions. C# checks variable initialization strictly (perhaps also Java, I'm not sure). The ABAP kind of non-strict exception handling allows bypassing an exception silently.

Disadvantage: no "finally" branch for "try" statement (exception handling). This is a missing feature in ABAP. It exists in both Java and C#. It doesn't exist in C++, but it's still acceptable since C++ classes have destructors.

Disadvantage: (also exists in other programming environments, not specific to language) no common routine for diagnostic, configurable error logging. Sometimes such a facility makes it sweet to log exceptions and helps troubleshooting a lot. The customer benefits in this way.

Advantage: database oriented. This makes it quite easy to draw data from a SQL database. Database transaction can also be programmed reasonably. Update routine is useful to do transaction in one shot. It's nice.

Disadvantage: (compiler) only the first compilation error is listed. This is quite an inconvenience. Compiler building courses in university have instructions on how to build a compiler that can recover even on syntax error, to report more errors at one compile. It would be nice if ABAP can have this feature, too.

Advantage: easy to parse; easy to learn; case-insensitive. Many people using SAP systems are not professional developers. They need a simple, intuitive language.

Disadvantage: function chaining doesn't work when specifying explicit parameters. In ABAP, when a function call is served as another function's argument, this is called "function chaining". e.g. FuncA( FuncB( ) ). This is not any special feature in most other programming languages, such as C#, Java, C++, Python, Haskell, Javascript, but it is special in ABAP. When the number of parameters is more than one, then function chaining isn't allowed. This results in somewhat more local variables. It may be related to the "easy to parse" aspect of its syntax.

Disadvantage: interface of methods/ functions need to be defined in the GUI (and is client/ server architecture, which is slow). This fussy work makes people reluctant to write short methods/ functions. However, writing short methods/ functions is a key way to make code more condensed and modularized (another way contributing to this is generic programming).

Advantage: interface supports method name aliasing (C# also does, called "explicit interface member implementation"; Java seems not). Such as:

public class A : IInterfaceB
{
    void IInterfaceB.SayHello()
    {
    }
}

CLASS cl_a DEFINITION.
  PUBLIC SECTION.
    INTERFACES i_interface_b.
ENDCLASS.

CLASS cl_a IMPLEMENTATION.
  METHOD i_interface_b~say_hello.
  ENDMETHOD.
ENDCLASS.