What are some conventions that are often mistaken for language features?

Question

Some programming languages have constructs that because of their frequent use are often mistaken for language features.

For example, many people think that self is a keyword in Python, but it's just the conventional name for the first argument to a method (you can use any variable name you want):

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

Another example: when I was learning R, I thought the syntax for filtering a vector was kind of weird:

d[d %% 2 == 0] # even elements only

At first I thought d %% 2 == 0 was some sort of lambda that gets magically applied to every element of d, until I realized that this is a straightforward application of R's vectorized operations: d %% 2 == 0 returns a vector like [TRUE, FALSE, FALSE, ...], and then d just uses that list to filter values that are at positions marked as TRUE.

What are some other constructs that may first appear to be specially designed language features, but are just straightforward applications of the language's core syntax & semantics?

Answer 1

else if

for instance in C#.

If you learned BASIC (including Visual Basic) first, you'd be likely to think else if functions like a special keyword, because ElseIf is a keyword in BASIC. In BASIC the rule is that all multi-line If statements must end in End If, so we would have to nest If statements in the Else clause like this:

If foo = bar Then
    foo = foo + 1
    bar = bar + 1
Else 
    If foo > bar Then
        foo = foo - 1
        bar = bar + 1
    Else
        If foo < bar Then
            foo = foo + 1
            bar = bar - 1
        End If
    End If
End If

but by using the ElseIf keyword, we can eliminate the extra End Ifs, like this:

If foo = bar Then
    foo = foo + 1
    bar = bar + 1
ElseIf foo > bar Then
    foo = foo - 1
    bar = bar + 1
ElseIf foo < bar Then
    foo = foo + 1
    bar = bar - 1
End If

Now compare to C-style languages like C#. There, the curly braces { and } serve a similar role to BASIC's Then and End If. However, the rule for when braces are required differs from the rule for when End If is required. C# doesn't care if you have line-breaks in your else clause, it just cares if it can be considered a single statement. So you can write:

if (foo == bar)
{
    foo = foo + 1;
    bar = bar + 1;
}
else if (foo > bar)
{
    foo = foo - 1;
    bar = bar + 1;
}
else if (foo < bar)
{
    foo = foo + 1;
    bar = bar - 1;
}

without any extra braces, because the else of your second if is already a single statement, equivalent (up to meaningless line breaks) to:

if (foo < bar) { foo = foo + 1; bar = bar - 1; }

and likewise the else of your first if is a single statement, equivalent to:

if (foo > bar) { foo = foo - 1; bar = bar + 1; } else if (foo < bar) { foo = foo + 1; bar = bar - 1; }

In other words, else if isn't some special keyword (like it was in BASIC), it's just an else followed by an if.

Answer 2

NULL in C or C++ is often mistaken for something magical, but its' a preprocessor defined as 0 or (void *)0. When learning C or C++, you test pointers against NULL. Later on, you learn that you can just do if (ptr).

In other languages such as Objective-C or C#, nil/null is part of the language, even if it does essentially the same thing.

Answer 3

The standard C library.

After programming C for 10 years or so reading the sourcecode of software by Dan Bernstein made me realize that you can use C without using printf, malloc and all the other stuff we take for granted.

Answer 4

in Delphi, classes almost always start with T. TObject, TStringList, TButton, etc. Its a carry-over from Turbo Pascal days. Pointers to objects start with P. PObject, etc. Its not required, but its so commonly adhered to that it wouldnt suprise me if some Delphi developers think its a language requirement.

Answer 5

Defining constants as all upper case, e.g. in C:

#define SECONDS_IN_DAY   86400

The same convention (with different syntax) is used in many other languages (e.g. const in C++, define in PHP), but whether the identifier is uppercase is not enforced by either the preprocessor or compiler. CamelCase is commonly used for consts in C# -- again it is a convention, not something enforced by the compiler.

Ruby does assume a identifier beginning with an upper-case is a constant, and will issue a warning if it's value is changed.