Components Programming

C++26 Wraps Up: Notes from the Croydon WG21 Meeting

2026-04-05T09:00:00-03:00

Photo credit: Herb Sutter

The ISO C++ committee wrapped up C++26 on March 28 in Croydon, UK. Around 210 people participated (130 in person, 80 remote) representing 24 nations, resolving the last of 411 national body comments. From here the document goes to its final approval ballot. No more features, no more additions. C++26 is done.

This was my first in-person WG21 meeting. I’ve been a member since 2022 and attended remotely before, but I’ve followed the language’s evolution since the C++0x era, when “0x” was becoming a running joke and nobody was sure it would ship. Being there for the closing of C++26 felt like the right moment to finally show up.

Contracts: Approved, Debated, Divisive

Contracts made it into C++26. The final vote was 114 in favor, 12 opposed, 3 abstaining. That level of opposition is unusual for a feature at this stage, and the debate in the room was tangible.

My perspective on contracts comes from Eiffel and its Design by Contract philosophy. In that model, contracts are part of program semantics. A precondition violation means the caller has a bug. A postcondition violation means the callee has a bug. Responsibility is unambiguous, and violations are always bugs, never runtime situations to be handled flexibly.

C++ took a more configurable path. That’s not necessarily wrong; C++ has always been a language of options. But the added flexibility comes at a visible cost in conceptual simplicity. The gap between what C++ calls “contracts” and the original Design by Contract philosophy is wider than I expected.

Reflection: The Big One

If contracts were the most debated feature, reflection was the most transformative.

C++26 reflection enables compile-time introspection of types, members, and program structure, things that previously required external tooling or heavy template metaprogramming. GCC already has an implementation merged in trunk.

This changes what’s possible inside the language. Not incrementally, but categorically. The way we write libraries, generate code, and express abstractions is going to look different. I think we’ll be discovering new patterns around reflection for a long time.

The Evening Session That Changed My Direction

One evening session was about a structural problem that’s been building for years: there are far more proposals than there is implementation capacity. Compiler teams at Clang, GCC, and MSVC are stretched thin. The bottleneck is no longer design. It’s implementation. Features get approved on paper and then take years to become usable.

Several ideas came up: that paper authors should bring at least partial implementations, that proposals should be tested against reality before advancing, and even that AI-assisted tooling could help lower the barrier. That last one triggered a visible reaction in the room: murmurs, people speaking out of turn, frustration. It was a brief moment, but telling.

What stayed with me was the core message from the implementers. The next day, I started contributing to both Clang and GCC, at the library and compiler level. Not out of any grand plan, but because the message landed: if you care about the language moving forward, help build it.

Being There

There’s something about being in the room that remote attendance can’t replicate. The hallway conversations, the body language during debates, the energy when a contentious vote lands.

C++ keeps getting more powerful, and the cost of keeping up is real. But the community behind it is deeply invested in getting it right, and that was evident in Croydon.

I’m glad I was there for this one.

C++26 Wraps Up: Notes from the Croydon WG21 Meeting was originally published by Fernando Pelliccioni at Components Programming on April 05, 2026.

Thanks Alex, once again!

2020-02-20T09:00:00-03:00

Once again, I would like to thank my friends Alex Stepanov and Paul McJones for this beautiful gift.

I have been looking for this book for years. It is a very difficult book to get.

I have no words to thank you.

Thank you!

Thanks Alex, once again! was originally published by Fernando Pelliccioni at Components Programming on February 20, 2020.

Algorithms and specifications

2020-02-19T09:00:00-03:00

In this article I want to talk about 2 topics in which I think that most programmers tend to fail: Algorithms and Specifications.

I’m going to use a real experience, which happened some time ago:

For 4 years now I have maintained a multi-currency node (Bitcoin, Bitcoin Cash and Litecoin) called Knuth (a.k.a. Bitprim). In November 2017 Bitcoin Cash made its first protocol change after its birth in August of the same year. My job at that time was to update the code of our node to support the protocol changes. From that moment I want to write this article, but … for one or several reasons I did not do it at that moment, I am doing it now.

The most important change was in the Difficulty Adjustment Algorithm, from now DAA.

Here the description of the algorithm.

I do not want to go into detail about the concept of difficulty or the DAA. For this you can refer to: Difficulty.

What interests me are points 2 and 3 of the description of the DAA:

2. Let B_last be chosen[2] from [B_n-2, B_n-1, B_n].
3. Let B_first be chosen[2] from [B_n-146, B_n-145, B_n-144].

Both point to the footnote [2]:

2. A block is chosen via the following mechanism:

Given a list: S = [B_n-2, B_n-1, B_n]
a. If timestamp(S[0]) greater than timestamp(S[2]) then swap S[0] and S[2].
b. If timestamp(S[0]) greater than timestamp(S[1]) then swap S[0] and S[1].
c. If timestamp(S[1]) greater than timestamp(S[2]) then swap S[1] and S[2].
d. Return S[1].

See GetSuitableBlock

The specification of the algorithm points to its implementation, in a function called GetSuitableBlock. Here the code:

/**
 * To reduce the impact of timestamp manipulation, we select the block we are
 * basing our computation on via a median of 3.
 */
static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
    assert(pindex->nHeight >= 3);

    /**
    * In order to avoid a block is a very skewed timestamp to have too much
    * influence, we select the median of the 3 top most blocks as a starting
    * point.
    */
    const CBlockIndex *blocks[3];
    blocks[2] = pindex;
    blocks[1] = pindex->pprev;
    blocks[0] = blocks[1]->pprev;

    // Sorting network.
    if (blocks[0]->nTime > blocks[2]->nTime) {
        std::swap(blocks[0], blocks[2]);
    }

    if (blocks[0]->nTime > blocks[1]->nTime) {
        std::swap(blocks[0], blocks[1]);
    }

    if (blocks[1]->nTime > blocks[2]->nTime) {
        std::swap(blocks[1], blocks[2]);
    }

     // We should have our candidate in the middle now.
    return blocks[1];
}

What the algorithm does is basically create a sequence of 3 elements (array), order it from least to greatest and return the second element.

The complexity in time of this algorithm is:

Best case: 0 swaps, 3 comparisons
Worst case: 2 swaps, 3 comparisons
Average case: 7/6 swaps, 3 comparisons; assuming a uniform distribution of the input data.

Now, look again at the algorithm. An array is being created (using the input data), then sort it up and return the middle element. This is a known algorithm and is called median, in particular, median of 3 elements.

The median is a selection algorithm. Unlike the sorting (inplace) algorithms, the selection algorithms should not mutate the input data, but return one of the elements.

Here is a sketch of the median of 3 algorithm, in C++:

template <TotallyOrdered T>
auto max(T const& a, U const& b) {
    return b < a ? a : b;
}

template <TotallyOrdered T>
auto median_3_ab(T const& a, T const& b, T const& c) {
    // precondition: a <= b

    return ! (c < b) ? b :        // a, b, c are sorted
                       max(a, c); // b is not the median
}

template <TotallyOrdered T>
auto median_3(T const& a, T const& b, T const& c) {
    return b < a ? median_3_ab(b, a, c)
                 : median_3_ab(a, b, c);
}

Or if you prefer the inline version of the algorithm:

template <TotallyOrdered T>
auto median_3(T const& a, T const& b, T const& c) {
    if (b < a) {
        if (c >= a) return a;  // b, a, c are sorted
        return max(b, c);      // a is not the median
    } else {    // a <= b
        if (c >= b) return b;  // a, b, c are sorted
        return max(a, c);      // b is not the median
    }
}

I leave the analysis of the code for the reader, for the lazy: what the algorithm does is simply select the middle element between a, b and c, pretending that the 3 were sorted in ascending order. It does this without mutating or reordering the input data.

The time complexity of median_3 is:

Best case: 0 swaps, 2 comparisons
Worst case: 0 swaps, 3 comparisons
Average case: 0 swaps, 8/3 comparisons; assuming a uniform distribution of the input data.

Now, we could use our new algorithm in the original GetSuitableBlock function:

static
CBlockIndex const* GetSuitableBlockNewVersion(CBlockIndex const* pindex) {
    assert(pindex->nHeight >= 3);
    return &median_3(*pindex->pprev->pprev, *pindex->pprev, *pindex);
}

Much shorter and understandable, right?.

Before continuing, we have to fix something: we do not know if the Natural Ordering specified in the CBlockIndex class is given by the block’s timestamp (nTime attribute). We need a version of median_3 that accepts a form of comparison specified by the user: we need you to accept a strict weak ordering relation (for more information see here).

template <Regular T, StrictWeakOrdering R>
auto max(T const& a, U const& b, R r) {
    return r(b, a) ? a : b;
}

template <Regular T, StrictWeakOrdering R>
auto median_3_ab(T const& a, T const& b, T const& c, R r) {
    // precondition: a <= b

    return ! r(c, b) ? b :           // a, b, c are sorted
                       max(a, c, r); // b is not the median
}

template <Regular T, StrictWeakOrdering R>
auto median_3(T const& a, T const& b, T const& c, R r) {
    return r(b, a) ? median_3_ab(b, a, c, r)
                   : median_3_ab(a, b, c, r);
}

Now, we can correctly implement GetSuitableBlockNewVersion, comparing by nTime:

static
CBlockIndex const* GetSuitableBlockNewVersion(CBlockIndex const* pindex) {
    assert(pindex->nHeight >= 3);
    return &median_3(*pindex->pprev->pprev, *pindex->pprev, *pindex, [](auto const& a, auto const& b){
        return a.nTime < b.nTime;
    });
}

We have one last problem to solve. Let’s make a small test of the original algorithm and the new one:

struct CBlockIndex {
    size_t nHeight;
    size_t nTime;
    CBlockIndex* pprev;
};

int main() {
    CBlockIndex ba {1, 1558731500, nullptr};
    CBlockIndex bb {2, 1558731500, &ba};        //same nTime as previous
    CBlockIndex bc {3, 1558730000, &bb};

    auto r = GetSuitableBlockNewVersion(&bc);
    cout << "GetSuitableBlockNewVersion: " << r->nHeight << endl;

    r = GetSuitableBlock(&bc);
    cout << "GetSuitableBlock:           " << r->nHeight << endl;
}

The code above prints:

GetSuitableBlockNewVersion: 1
GetSuitableBlock:           2

What we are trying to prove with the previous code is the stability of both algorithms. Our median_3 algorithm is stable which means that the relative order of the equivalent elements is preserved (for more information see here).

To prove it with data, we will use the previous example, in which we have the following input data for our algorithms:

s = [{1, 1558731500}, {2, 1558731500}, {3, 1558730000}]

Where the first element of each pair is nHeight, the identifier of the block, and the second element is the timestamp called nTime. Note that the nTime of the first 2 elements is the same.

If we sort the previous sequence by nTime using a stable ordering algorithm, such as Merge sort we would have something like this:

s = [{3, 1558730000}, {1, 1558731500}, {2, 1558731500}]

Note that the middle element is the one with nHeight = 1. This indicates that our algorithm behaved in a stable manner but not the original algorithm used in the Bitcoin Cash DAA.

In my first implementation of DAA in the Bitprim node I used a code similar to median_3 which was also stable, since I had not verified the code of the specification, I had mistakenly assumed that it was also stable. Then this caused runtime errors of our node on a difficulty change. It did not always happen, but there was a particular case in which we could detect it. After several hours of debugging I could detect that the problem was that the algorithm used by me was not compatible with the “specified” in DAA.

Therefore, I had to “correct” my algorithm to make it non-stable in the same way as that of the specification.

Actually, if I remember correctly, the first version of the DAA specification did not mention the GetSuitableBlock code, but said that the median of 3 elements was calculated. Since the implementation of the median was “incorrect” they had to adapt the specification to be consistent with the code. Keep in mind, that once the code of a Bitcoin node (or any cryptocurrency) is in operation, a modification in its behavior introduces incompatibilities with previous versions and produces the so-called forks. So once the code is running, it’s about not changing it. For this reason it is why the specification had to be adapted instead of correcting the code.

Before finishing, let’s make a comparison of both algorithms, GetSuitableBlock vs. median_3:

median_3 does not make any swap, GetSuitableBlock can make between 0, 7/6 or 2 swaps, unnecessarily. (Efficiency)
GetSuitableBlock creates an array, unnecessarily. (Efficiency)
median_3 performs 2, 8/3 or 3 comparisons, GetSuitableBlock always performs 3 comparisons. (Efficiency)
median_3 is stable, GetSuitableBlock is not. median_3 is what anyone expects from an algorithm that calculates the median of 3 elements. (Correctness)

And now, to conclude, some conclusions:

The author of the DAA specification could have chosen a known and “standard” algorithm, but he did not. And perhaps the worst of all is that the specification refers to the code. The code must never be specification. The code must be created from a specification. So if a specification refers to code, there is no such specification.

Bye!

Algorithms and specifications was originally published by Fernando Pelliccioni at Components Programming on February 19, 2020.

Elements of Programming Authors' Edition (free ebook)

2019-06-28T09:00:00-03:00

These are fresh news.

This year Elements of Programming celebrates 10 years since its publication, but this time the gift is for us:

Alex Stepanov and Paul McJones have just released Elements of Programming Authors’ Edition in two versions:

A free PDF, click here to download it.
A trade paperback from Semigroup Press, just for USD 9.94, click here to buy it.

Amazon listing coming soon.

Thanks again, Alex and Paul!

Elements of Programming Authors' Edition (free ebook) was originally published by Fernando Pelliccioni at Components Programming on June 28, 2019.

My 'The Gift of the Arabs' talk (Spanish)

2018-11-26T09:00:00-03:00

Hello!

I share with you the links to the video and slides of my talk entitled The Gift of the Arabs, which was presented at the Algorithms Study Group meetup in May 2017 in Buenos Aires, Argentina.

The content of my talk is based on Three Algorithmic Journeys and From Mathematics to Generic Programming by Alex Stepanov.

It’s my interpretation of what would have been his fourth episode, which was never presented, and would have had the same name.

Hope you like it!

Link to the Video

Link to the Slides

Regards!

My 'The Gift of the Arabs' talk (Spanish) was originally published by Fernando Pelliccioni at Components Programming on November 26, 2018.

Honorable Mention 'Senator Domingo Faustino Sarmiento'

2016-11-30T09:00:00-03:00

On November 29, 2016 I had the honor and pleasure to receive, as a member of the scientific team of the National Commission of the Outer Limit of the Continental Shelf (COPLA), the Honorable Mention “Senator Domingo Faustino Sarmiento”, for our work, which made possible the determination of the new Outer Limit of the Continental Shelf of the Argentine Republic. [1]

The award was presented by the Vice President of the Nation, Gabriela Michetti along with the Senator Omar Perotti.

The Honorable Mention “Senator Domingo Faustino Sarmiento” is the highest award given by the Honorable Senate of the Nation to natural or legal persons of the cultural, sports, professional and academic work, for his entrepreneurial work aimed at improving the quality of life of another individuals, institutions and their communities. The ceremony was made in the “Salón Azul” (Blue Room) of the Honorable Senate of the Nation.

The event was also attended by the vice minister and president of COPLA, Carlos Foradori, former minister Jorge Taiana, former vice minister Fernando Petrella, congress representatives Mario Pais, Dalmacio Mera, Norma Durango, Beatriz Mirkin, and Daniela Castro. In addition they participated prominent figures of the academic and scientific scope.

Minister Susana Malcorra could not be present since she has traveled to Cuba for the funerals of Fidel Castro in representation of Argentina.

References

[1] The Limit was approved on 11 March 2016 by the United Nations, by consensus, ie without a single vote against. See: The Outer Limit of the Argentine Continental Shelf.

Links to News

Honorable Mention 'Senator Domingo Faustino Sarmiento' was originally published by Fernando Pelliccioni at Components Programming on November 30, 2016.

My '¿Fastware?' talk (Spanish)

2016-11-16T09:00:00-03:00

Hello!

Here is the the link to the slides of my talk entitled “¿Fastware?” (Spanish resource), which was exhibited at the “Second C++ Buenos Aires Meeting” on July 14, 2016.

At that meeting we had the pleasure to view excellent talks provided by our colleagues Agustín (K-Ballo) Bergé, Francisco Tufró y Hernan Saez. See the other talks here..

I hope you like our presentations and you feel like to join our community.

Kind regards!

My '¿Fastware?' talk (Spanish) was originally published by Fernando Pelliccioni at Components Programming on November 16, 2016.

Palindromes and more

2016-06-06T09:00:00-03:00

I decided to write this article from a question I saw in stackoverflow.com

Here the link to the question.

The questioner tries to write an algorithm to identify whether a “word” is a palindrome or it is not. The algorithm is written using the Java programming language

I do not want to analyze the algorithm proposed by the questioner, but I want to analyze the most voted answer algorithm. The latter has 73 votes versus 65 votes that have the accepted answer (to today’s date, June 6, 2016).

Here the link to the algorithm that I want to analyze.

Here the code:

public static boolean isPalindrome(String str) {
    return str.equals(
       new StringBuilder(str)
       .reverse()
       .toString()
    );
}

The algorithm works correctly and the logic is very intuitive. Basically compares for equality the input word against its reverse.

The problem with this algorithm is that it is very inefficient compared to the optimal algorithm.

I made a comment to the author of the algorithm on Stackoverflow: “Compare the complexity of your algorithm with respect to others.”
The user @aioobe replied: “I think it’s the same complexity as the other solutions, no?”

He is right.
I was not very specific in my comment. @aioobe surely assumed that I was referring to the asymptotic computational complexity and he is ok, because usually, when we say “complexity” without specifying anything else, it is assumed that we are referring to the asymptotic computational complexity.

Asymptotic Computational Complexity

Asymptotic asymptotic computational means how the algorithms respond in time and space as the input grows.
It is usually associated with the O-notation introduced by Paul Bachmann in his book Die Analytische Zahlentheorie in 1894. [1]

This way we can measure the scalability of algorithms without relying on machine architecture, CPU speed, the programming language in which is implemented the algorithm, etc…

While it is very useful in many circumstances, this method of measurement it is not accurate, but it is approximated.

For more information on O-notation and asymptotic complexity, see [2].

Concrete Computational Complexity

Another way to measure algorithms is no use approximations but concrete quantity of operations, depending on the input to the algorithm.

For example, imagine the algorithm to find the minimum (or maximum) of \( n \) elements. We can say that the algorithm has linear complexity (in time), or the algorithm is \( O(n) \). But specifically, the algorithm needs \(( n - 1 )\) comparisons to find the minimum element.

Back to Palindromes

Again, the code of the algorithm.

public static boolean isPalindrome(String str) {
    return str.equals(
       new StringBuilder(str)
       .reverse()
       .toString()
    );
}

I called Algorithm I to the previous code. (“I” as inefficient).

We could say that Algorithm I is \( O(n) \), but, how can we guarantee it without knowing the complexity of the components in which the algorithm is based?

To do this, we must review the Java documentation. For example, consider the String.equals() function. [3]

As you may have noticed on the previous page, the Java documentation does not include the time and space complexity of algorithms and data structures.
I consider this a failure, because it hinders us specifying the complexity of our algorithms, at least of the algorithms that are based on classes provided by Java.

To continue trying to specify the complexity of the Algorithm I, we have no choice, we have to review the source code of Java classes.
Consider the source code of String.equals() (click on the link and find the equals function.)

As you can verify the code String.equals() has linear complexity in time, \( O(n) \).
Specifically, String.equals() does \( n \) comparisons (inequality). (Beyond the noise imposed by Java, such as casts, instanceof, etc …).

The space complexity of String.equals() is constant, that is, \( O(1) \).
This means that it uses a constant memory beyond the input of the algorithm.

Determining the complexity

We will determine the complexity of the Algorithm I analyzing each component.

String.equals(). Linear time, \( n \) inequality comparisons. Constant space.

StringBuilder.reverse(). Linear time, \( 2 \left\lfloor\dfrac{n}{2}\right\rfloor \) assignments. Constant space.

StringBuilder.toString(). Linear time, \( n \) assignments. Linear space, \( n \) elements.

StringBuilder constructor. Linear time, \( n + 16 \) assignments. Linear space, \( n + 16 \) elements.

So the overall complexity of Algorithm I is:

Time: In the worst case, when the word is a palindrome, this algorithm takes \( n \) inequality comparisons and \( 2n + 2 \left\lfloor\dfrac{n}{2}\right\rfloor + 16 \) assignments.
Space: \( 2n + 16 \) elements.

As you can see, this algorithm is very inefficient, it uses a lot of memory (unnecessarily) and as discussed below, takes over \( 8x \) operations optimal algorithm.

Improving the algorithm (naïve version)

Call the following code Algorithm N (N as naïve). Algorithm N presents a substantial improvement over the Algorithm I.

public static boolean isPalindrome(String str) {
    int n = str.length();
    for (int i = 0; i < n; ++i) {
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    }
    return true;
}

Time: In the worst case, when the word is a palindrome, this algorithm takes \( n \) inequality comparisons.
Space: Constant

No extra memory usage and runs approximately \( \dfrac{1}{4} \) of operations that the Algorithm I. While the code is a bit more complex now, it is an easily understandable code, the increased code complexity is negligible compared to the improvement in efficiency.

Optimal Algorithm

As we can see in the picture below, there is no need to do \( n \) comparisons to determine whether a word is a palindrome.

It is enough to do just (about) half the comparisons:

If n is even, it performs \( \dfrac{n}{2} \) comparisons
If n is odd, it performs \( \dfrac{n - 1}{2} \) comparisons.

The following code will be called Algorithm O (O as optimal).

public static boolean isPalindrome(String str) {
    int n = str.length();
    for (int i = 0; i < n/2; ++i) {
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    }
    return true;    
}

Time: In the worst case, when the word is a palindrome, this algorithm performs \( \left\lfloor\dfrac{n}{2}\right\rfloor \) inequality comparisons.
Space: Constant

Algorithm I, detailed analysis

As explained earlier, the Algorithm I is much more inefficient than Algorithms N and Algorithms O.
But besides the complexity analysis, we have to consider other issues that affect the efficiency of the Algorithm I.

Each component used in the Algorithm I come with certain performance penalties that go unnoticed.
Let us analyze in detail.

Construction of StringBuilder

Dynamic memory allocation of the StringBuilder object (heap, free store, or whatever you call it).
Zero-Initialization of members of StringBuilder. [4]
Dynamic memory allocation of the StringBuilder’s internal array.
According to the documentation, the size of the internal array is equal to 16 characters plus the size of the original String. [5]
Zero-Initialization of Array’s members. Length and the array itself. [4]
Copy of the bytes of the original String to the StringBuilder’s internal array.

reverse() (StringBuilder)

Mentioned above. This function does not use additional memory and it is efficient at runtime.

toString() (StringBuilder)

Dynamic memory allocation of the String object (heap, free store, or whatever you call it).
Zero-Initialization of members of String. [4]
Dynamic memory allocation of the String’s internal array.
Zero-Initialization of Array’s members. Length and the array itself. [4]
Copy of the bytes from the StringBuilder’s internal array to the String’s internal array.

equals() (String)

Mentioned above. This function does not use additional memory and it is efficient at runtime.

Garbage Collection

The GC must release any additional memory (unnecessary) that was used and obviously this operation is not “free.”

Data Cache Misses

Another drawback associated with unnecessary memory consumption is the probability that our objects are too large to fit into the cache, causing cache misses impacting on runtime performance.
Another factor that increases the probability of cache misses are the indirections (references, pointers) to distant memory locations.

Memory footprint

To analyze the memory consumption of Algorithm I, we will use a concrete example. We will use a 9-char palindrome, the word is “evitative”.

isPalindrome("evitative");

While memory consumption of Algorithm I depends on the Virtual Machine and the Runtime Environment that we are using, in this case we will use a specific platform that is detailed here.

Basically in our example two objects are created, one StringBuilder and one String.

StringBuilder:

The StringBuilder objects have the following memory representation.

A StringBuilder object consists of two parts (not necessarily contiguous in memory):

First part: usage size of the array (length() of StringBuilder) and a reference to the array where the data resides.
Second part: array size (capacity() of StringBuilder) and the array.
The array size is 16 characters plus the number of characters of the original String (“evitative”) [5]. In the picture, those 16 extra characters are shown in red, to emphasize that it is wasted memory. In Java, the characters have a size of 2 bytes. [6]
So in our example, the array will have a size of \( 2 \cdot (9 + 16) = 50 \) bytes.

In Java all objects have a header (if known any implementation that does not have it, let me know) in our platform the header is 12 bytes. In other popular platforms can be 8 or 16 bytes, see here [7].

Another thing to consider is the padding, which is basically a memory space that is added to meet the alignment requirement. In our case, the objects must be placed in 8-multiples memory addresses.

In summary, our StringBuilder object has the following memory size (in bytes):

First part: \( 24 \)
Second part: \( 16 + 2n + 32 + padding \) [8]

Total: \( 8(\left\lceil\dfrac{n}{4}\right\rceil + 9) \) bytes

String:

The String objects have the following memory representation.

A String object consists of two parts (not necessarily contiguous in memory):

First part: reference to array (where data resides) and a hash.
Second part: the size of the array (length() of String) and the array.

The String object here described belongs to the Java 8. In older versions of Java, the String class had more fields, therefore memory size was bigger. [7]

In summary, our String object has the following memory size (in bytes):

First part: \( 24 \)
First part: \( 16 + 2n + padding \) [8]

Total: \( 8(\left\lceil\dfrac{n}{4}\right\rceil + 5) \) bytes

Total memory footprint:

The total memory used by our StringBuilder and String objects is \( 16(\left\lceil\dfrac{n}{4}\right\rceil + 7) \) bytes.

In our example \( n = 9 \), so the memory used is \( 16(\left\lceil\dfrac{9}{4}\right\rceil + 7) \) bytes, which represent 160 bytes of extra memory, only to determine whether “evitative” is a palindrome or not.
Remember, these 160 bytes is a totally unnecessary memory consumption.

Benchmarks

I was doing some benchmarks where it can be seen that the Algorithm I is about 8.5x slower than Algorithms O and N.

I’m leaving out some other benchmarks that show a \( \approx 500x \) difference against Algorithm I.

You can see the source code of the benchmarks in my GitHub account.

The explanation of the benchmarks and the code will be pending for a future article.

Algorithm N versus Algorithm O

While previously we saw that the Algorithm O performs half of operations than Algorithm N, in the worst case; the runtime of both algorithms is affected by several factors, including: the length of the word, if the word is palindrome or not, and other factors relevant to the platform.

In many cases Algorithm N is faster than Algorithm O.

We will discuss this in a future article.

Ultimate solution?

I believe that none of the three algorithms presented in this article represent an ultimate solution, and none of them is a Component.

A component should be something that can be reused and, in many cases, the algorithms described in this article are not suitable for re-use.

In addition, the three algorithms only accept a String as input. A palindrome is not just a sequence of characters that reads the same forwards and backwards. A palindrome can be found in music, in numbers and also in nature.

I am no expert in genetics, but I know that palindromes can be found in DNA strands.
Palindromes in DNA are so important that some experts consider them to be responsible for preventing the extinction of the human race (and other species too). Without palindromes in DNA, incorrigible and irreversible genetic mutations would occur, causing the extinction of the species, with the passing of generations. In a future article we’ll talk about this topic.

Pending issues

Replicate the Algorithm I in C# and analyze its efficiency in execution time and memory consumption.

Conclusions

The Algorithm I is an excellent example of brevity and readability, it makes good use of abstractions available to achieve this goal. The problem with Algorithm I is that it is a terrible example of efficiency.

Abstractions facilitate our work, let us concentrate on the problem to be solved without having to think about the context, in this case the computer.

While abstractions are good, they have a big disadvantage. They make us forget how the machine works.
Modern programmers often abuse of abstractions and they do not have knowledge about very important things that affect the behavior of our programs, such as memory, cache, load/store buffers, branch prediction, pipelines, memory models, vector instructions (SIMD), etc …

As programmers, we must know in detail the computer, the programming language and the complexity of the components we use. Unfortunately modern programmers are just focused on things like testing, agile, metaprogramming and frameworks/libraries whose lifetime is longer than two years.

I do not want to forget to mention that the best of all abstractions was discovered by Leibniz in 1679. That abstraction is what allows us to model the real world in a computer. That abstraction is the Bit.

Finally, it is noteworthy that Algorithm I could be useful as a postcondition:

public static boolean isPalindrome(String str) {
    //postcondition: Result := reverse(str) = str
    int n = str.length();
    for (int i = 0; i < n/2; ++i) {
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    }
    return true;    
}

Acknowledgements

I want to thank Mario dal Lago and Javier Velilla for reviewing the article and suggest corrections.
And finally, since we can say that we owe our lives to palindromes, so, a special thank to them. :)

Notes

Byte = 8-bits.
There are architectures where 1 byte is not necessarily equivalent to 8 bits. These architectures are unusual today. There is no standard that specifies the size of a byte, but can say that the de facto standard is that 1 byte = 8 bits, is most common in modern computer architectures.

Platform used for the analysis in this article:

CPU
- Intel Core i7-4700MQ CPU @ 2.40GHz, Haswell
- 4 Cores, 8 Threads
- L1 Data Cache Size 4 x 32 KBytes
- L1 Instructions Cache Size 4 x 32 KBytes
- L2 Unified Cache Size 4 x 256 KBytes
- L3 Unified Cache Size 6144 KBytes
RAM: 8192 MBytes, DDR3
Operating System: Windows 10 Home 64-bit
Java
- Version 1.8.0_60
- Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
- 64-bit HotSpot VM.
- Compressed Oops enabled.
- Objects alignment: 8 bytes.

For analysis on other platforms, please refer to [7].

References

[1] Zahlen means “Numbers” in German. Hence the set of integers is identified with the letter \( \mathbb{Z} \).

[2] The Art of Computer Programming Volume 1, by Donald E. Knuth [3rd Edition, page 107].

[3] Why I call String.equals() “function” and no “method”?. Here is the answer.

[4] In Java the integral data types and arrays of integral data types are initialized to 0, guaranteed by the language specification. 4.12.5 Initial Values of Variables

[5] Java String class

[6] Java Primitive Data Types

[7] Analysis of memory consumption on other platforms.

[8] The formulas for calculating the padding of the internal arrays of StringBuilder and String (in bytes):
StringBuilder internal array padding = \( 8\left\lceil\dfrac{2n + 48}{8}\right\rceil - (2n + 48) \)
String internal array padding = \( 8\left\lceil\dfrac{2n + 16}{8}\right\rceil - (2n + 16) \)

(These formulas are specific to the platform described in the article)

The general formula for the padding of objects is:

\[alignment\left\lceil\dfrac{size}{alignment}\right\rceil - size\]

Palindromes and more was originally published by Fernando Pelliccioni at Components Programming on June 06, 2016.

My 'Intro to Generic Programming' talk (Spanish)

2016-06-02T09:00:00-03:00

Hello!

Here is the the link to the slides of my talk entitled “Introduction to Generic Programming” (Spanish resource), which was exhibited at the “First C++ Buenos Aires Meeting” on March 31, 2016.

At that meeting we had the pleasure to view the excellent talk provided by our colleague Agustín (K-Ballo) Bergé, entitled “The C++ Way”, where he tells us about the new features incorporated in C++11 and C++14 .

I hope you like our presentations and you feel like to join our community.

Kind regards!

My 'Intro to Generic Programming' talk (Spanish) was originally published by Fernando Pelliccioni at Components Programming on June 02, 2016.

Vin d'honneur

2016-05-04T09:00:00-03:00

On May 4, 2016, I was invited by the Argentine Minister of Foreign Affairs, Susana Malcorra, to the Vin d’honneur (Wine of Honor) that took place in the Golden Hall of the San Martín Palace, on the occasion of the Salute to the members of the National Commission on the Outer Limit of the Continental Shelf (COPLA).

Many thanks to the Minister and congratulations to the whole team!

The most extensive limit of Argentina - Our border with humanity

References

Official Twitter of Susana Malcorra

Vin d'honneur was originally published by Fernando Pelliccioni at Components Programming on May 04, 2016.

The Outer Limit of the Argentine Continental Shelf

2016-03-11T09:00:00-03:00

On 11 March 2016, the plenary of the 40th Session of the United Nations Commission on the Limits of the Continental Shelf (CLCS) approved the Recommendations on the Argentine presentation of the Outer Limit of the Continental Shelf. The Argentine Republic had presented the outer limit of the continental shelf of the whole Argentine territory - continental, insular and Antarctic Argentina - to the CLPC on April 21, 2009.

It has been an honor and pride for me to have been a member of this team and this project, which I hope will serve to improve the quality of life for all Argentines.

Congratulations to the team!

The most extensive limit of Argentina - Our border with humanity

References

COPLA-2016_1

The Outer Limit of the Argentine Continental Shelf was originally published by Fernando Pelliccioni at Components Programming on March 11, 2016.

Alex Retirement

2016-01-14T09:00:00-03:00

Alex has retired.

This is a very nice Commemorative Stamp, by Joyce Croft and Alexander Zeyliger of A9.

I have to confess that I feel sad because I really wished that Alex continue contributing ideas for much longer time.
But he has retired and I’m happy for him.

I wish you an excellent and well-deserved rest with your family and friends.

auto who = successor(alex);

Thanks!

Alex Retirement was originally published by Fernando Pelliccioni at Components Programming on January 14, 2016.

Thanks Alex!

2015-11-25T09:00:00-03:00

I am very pleased to have received these two gifts.

These are two great books.

It is an honor for me that are autographed by one of the greatest of our discipline.

Do not deprive the pleasure of reading them.

Elements of Programming on Amazon.

From Mathematics to Generic Programming on Amazon.

Thanks again, Alex!

Thanks Alex! was originally published by Fernando Pelliccioni at Components Programming on November 25, 2015.

What's your favorite flavor of Object?

2015-09-26T09:00:00-03:00

In this article I want to continue the discussion about the terminology that we, programmers, use daily; following the line of “Using the proper terminology: Method?”.

Introduction

Programmers, especially since the popularization of Object-Oriented Programming, use the word Object without really thinking about its meaning.

Always struck me all the terminology related to the O-O paradigm, because I believe that many of the definitions of this paradigm are ambiguous or to vary between different authors.

What “Object” means?

In computer science, and especially in programming, there is no formal or a single definition of “Object”.
Different authors of programming languages and textbooks was given different meanings to it.

I will try, in this article, to present and analyze the different definitions and reach a conclusion about what definition is more in line to the programming style adopted in this blog.

Simula

Here is the definition provided by the authors of the Simula programming language:

An object is a self-contained program (block instance) having its own local data and actions defined by a “class declaration”. The class declaration defines a program (data and action) pattern, and objects conforming to that pattern are said to “belong to the same class”. [1]

The above definition is important because Simula is considered the first object-oriented programming language.

Three things stand out:

An object has own data.
An object includes actions.
Membership of an object to a class

Smalltalk

Although Simula is the first object-oriented programming language of, the strong marketing of objects paradigm arose with Smalltalk.
One can say that Smalltalk is the most influential language in regard to Objects.

According to the Smalltalk-72 instruction manual [2]:

Every entity in Smalltalk’s world is called an object. Objects can remember things and communicate with each other by sending and receiving messages. Every object belongs to a class…

The same three things of the Simula definition stand out, but with variations:

An object has its own data: “remember things”.
An object includes actions: communication by messages is a particular form of action.
Membership of an object to a class.

And, according to Smalltalk standard [3]:

An object is a computational entity that is capable of responding to a well defined set of messages. An object may also encapsulate some (possibly mutable) state.

It stands:

An object has its own data: “state”.
An object includes actions: communication by messages is a particular form of action.
New concept: mutability.

Eiffel - Object-Oriented Software Construction

Object-Oriented Software Construction is one of the most important references in terms of object-orientation. It was written by Bertrand Meyer, the designer of the Eiffel programming language.

Eiffel is one of the called purely object-oriented languages, because even the built-in types, as integer or real, are created by classes.

Here the definition of object given by Meyer in OOSC [4]:

Object: A run-time data structure made of zero or more values, called fields, and serving as the computer representation of an abstract object. Every object is an instance of some class.

The above definition states:

An object has its own data: “made of zero or more values”.
Membership of an object to a class.

C++

C++ is a language that supports objects technology.
C++ has a definition of the object very different to which most programmers are accustomed:

According to the C++ standard [5]:

… An object is a region of storage. [Note: A function is not an object, regardless of whether or not it occupies storage in the way that objects do. —end note] …

C programming language

You may wonder why I’m including the C programming language in this list if it does not include features of object-oriented languages.

While the C language is not an object-oriented language, it includes in its standard [6] a definition of object:

object: region of data storage in the execution environment, the contents of which can represent values…

Elements of Programming

Elements of Programming is the magnum opus of Alexander Stepanov and Paul McJones.
According my consideration, it is on the way to become a classic text of programming, so I recommend to all those lovers of this beautiful discipline that do not deprive yourself to read it.

An object is a representation of a concrete entity as a value in memory. An object has a state that is a value of some value type. The state of an object is changeable. Given an object corresponding to a concrete entity, its state corresponds to a snapshot of that entity…
…
An object type is a pattern for storing and modifying values in memory. Corresponding to every object type is a value type describing states of objects of that type. Every object belongs to an object type. An example of an object type is integers represented in 32-bit two’s complement little-endian format aligned to a 4-byte address boundary. [7]

In the above definition, Stepanov and McJones try to take away from any kind of programming paradigm and establish a more general definition of what an object means. While clear differences with the other definitions are noted, you can see some similarities with them:

An object has its own data: “value in memory”, “state”.
An object includes actions: “storing and modifying values in memory” are basically actions or behavior.
Membership of an object to an object type.
An object is mutable/changeable.

Conclusions

As you have noticed, there are a variety of definitions of object. Some match in certain features, some not.

The blog author prefers the definition given by Stepanov and McJones in Elements of Programming. I consider it the most complete, practical, broad and based on a solid mathematical foundation definition.

It is the most complete definition, because it begins to develop a taxonomy of ideas as Entity, Species, Genus, which serves as the basis for object definition and other definitions. These definitions are not included in this article to learn more about it please refer to the book.

It is the most practical definition, since it is aware that all programs run on computers with memory and these constitutes the only available realization of a universal computational device.

It is the broadest definition, since it does not exclude non-object-oriented languages.

Again, I made my choice, but there is not need to say that you can choose any definition you like, just make sure that your thinking is free of influences disseminated by the Objects propaganda machinery :)

“Terminology” series:

Using the proper terminology: Method?
What’s your favorite flavor of Object?

Notes / References

Clarification: The emphasis/bold in each of the definitions is on my own.

[1] SIMULA 67: COMMON BASE LANGUAGE, by Ole-Johan Dahl, Bjørn Myhrhaug and Kristen Nygaard. Publication No. S-22. Classes 1. 3. 3 [page 6]

[2] Smalltalk-72 Instruction Manual by Adele Goldberg and Alan Kay [page 44]

[3] ANSI Smalltalk Standard v1.9 199712 NCITS X3J20 draft, Section 3.1 [page 9]

[4] Object-Oriented Software Construction (2nd Ed) by Bertrand Meyer [1997, page 1198]

[5] ISO International Standard ISO/IEC 14882:2014(E) – Programming Language C++, current working draft (at Aug, 2015), section: 1.8 [intro.object] paragraph 1.

[6] ISO/IEC 9899:201x Committee Draft – Programming languages — C (last draft available at Aug, 2015), section: 13.15.

[7] Elements of Programming by Stepanov and McJones [2009, page 4]

EoP’s concrete entity definition: An abstract entity is an individual thing that is eternal and unchangeable, while a concrete entity is an individual thing that comes into and out of existence in space and time… Blue and 13 are examples of abstract entities. Socrates and the United States of America are examples of concrete entities…

What's your favorite flavor of Object? was originally published by Fernando Pelliccioni at Components Programming on September 26, 2015.

Using the proper terminology: Method?

2015-08-12T09:00:00-03:00

In this series of articles I intend to review why we, as programmers, use certain terminology, certain words, some of which I consider inappropriate.
In this case want to talk about the word method.

First of all …

What is a method?

Any programmer knows that an object [1] has state and behavior.
The state is stored in fields and behavior is achieved through methods. A method (in programming) is a sequence of instructions, is part of an object or class. [2]

But …

Why “method”?

What is the difference between a method and a procedure?

A procedure is a sequence of instructions. [2]

The only difference is that a method must belong to a class while in the definition of procedure it is unclear whether it belongs to a class or not. The term “procedure” is used long before the existence of the term “class”.

In summary, a method is a procedure that is a member of a class.
So, we have member procedures and free procedures (outside a class).

I keep wondering …

Why we use the term “method” insted of “procedure”?

My guess is that with the establishment of Java as one of the most popular programming languages, also saw the popularization of its terminology. From that moment, other languages and programmers adopt the terminology popularized by Java and it becomes more frequent use than traditional terminology.

Now, I want to make a search through the history of programming languages to understand why we began calling “method” to the “procedures”. I will go from modern to ancient times …

Java

In Java, there are no free procedures, all procedures have to be a member of a class, these member procedures actually are called methods.

According to Java 8 specification [3]:

The body of a class declares members (fields and methods and nested classes and interfaces), instance and static initializers, and constructors.
Method declarations describe code that may be invoked by method invocation expressions.

The Java specification describes the relationship between a method and a class, but it does not specify what the word “method” means.

Beyond the definition, in the specification we will not find why language designers decided to call “method” to procedures, so we must go even further back.

Java inherits most of its syntax (not its semantics) and terminology from C++.

C++

C++ born in the late 1970s, as a superset of the C programming language with the addition object technology.

Therefore, in C++ we have member procedures and free procedures, called member and non-member functions.

According to the C++ standard [4]:

Member functions: Functions declared in the definition of a class, excluding those declared with a friend specifier, are called member functions of that class.

In other words, the word “method” is not used by C++ programmers. Maybe some C++ programmers use it because the term is very popular today; but neither the C++ standard nor the core C++ programmers use “method”.

So … What is the correct term for the code that models the behavior of objects? Is it “method”? Is it “procedure”? Which language uses the most appropriate terminology?

I must go back in time.

C++ inherits its objects “side” from the Simula programming language.

Simula

Simula is considered the first object-oriented programming language.
It is a statically typed language based on ALGOL 60.

Simula allows procedures to be declared within a class and also outside it. The former are called the local procedures and the last non-local procedures. [5]

So, if C++ and Simula not make mention of something called “method” Where does Java take that word? Is it an invention of language designers? Is it copied from some other language?

The answer is …

Smalltalk

Smalltalk is an object-oriented programming language, it is inspired by Simula (in part), it was developed during the 1970s and was born in the early 80’s.
Unlike Simula, Smalltalk is a dynamically typed language.

Smalltalk incorporates the concepts of messages and methods.

According to the Smalltalk standard [6]:

A message is a request to perform a designated computation. An object is a computational entity that is capable of responding to a well defined set of messages. An object may also encapsulate some (possibly mutable) state.
An object responds to a message by executing a method. Each method is identified by an associated method selector. A behavior is the set of methods used by an object to respond to messages.
A method consists of a sequence of expressions. Program execution proceeds by sequentially evaluating the expressions in one of more methods. There are three types of expressions: assignments, message sends, and returns.

As I could not find references of the word “method” on languages older than Smalltalk, I consulted Paul McJones, member of the Software Preservation Group and coauthor of Elements of Programming. I consider Paul an authority when it comes to computing and programming language history.

Fernando: … Do you know any programming language, before Smalltalk, that use the word “method”? …

Paul: You ask a very interesting question. I think you are correct that the word “method” was first used in that sense by the Smalltalk community. I looked through some early documents, such as the Smalltalk-72 Instruction Manual, and I don’t see “method” being used yet… Dan Ingalls’s 1978 POPL paper on Smalltalk-76 is the earliest paper I’ve found so far that uses method in the sense you are interested in…

Paul believes, as I do, that the word “method” was first used by the Smalltalk community. He also said that he was reviewing old manuals; the word “method” seems to emerge between 1972 and 1976, acording to the Smalltalk-72 Instruction Manual [7] and a paper of 1978 which talks about Smalltalk-76. [8]

In other words, I’m pretty sure the Smalltalk community coined the term, but they didn’t do from the beginning but as the language evolved.

Other languages

Here I want to discuss other programming languages that also support object technology to verify how “procedures” are called.

Eiffel

Eiffel is is a language born in the mid 1980s and, like C++, is a direct heir of Simula.

In Eiffel every member of a class is called feature. The state is called attributes and the behavior routines. In turn, the routines are divided into functions and procedures depending on whether or not return a result. [9]

In Eiffel all routines are members of a class, the existence of free procedures is not allowed.

Python

The Python programming language supports free and member procedures. They are called functions and methods respectively. [10]

Python caught my attention because it’s created a few years before Java; the first implementation of Python is about 1989 [11] while Java first implementation is from 1995 [12].
It seems that this breaks my guess that Java was the promoter of the word “method”.

While the first implementation of Java comes out in 1995, in just a few years, in 1998, Java was one of the most popular languages. Instead, Python had a longer way to popularity, it began to be popular in 2003/2004. [13]
So my guess is still valid, the promoter of “method” was Java and not Python.

Returning to Python, the word “method” is mentioned in recent versions (3.4.3 and 2.7.10) of the language documentation.
Then I hesitated about whether Python uses “method” from its origins or its terminology was mutating over time, especially with the popularity of Java.
Thanks to excellent job done by the python.org guys keeping the historical versions of documentation I could verify that the word “method” is used since version 0.9.1 [14] (unless the documentation has been altered over time, but I hope that is not the case).

In other words, Python is the first language, after Smalltalk, to use the word “method”. At least in the languages I could verify.

Now I wonder, why Python used method instead of a more common term?. No one better than the creator of language, Guido van Rossum to enlighten. I wrote an email to him, Guido was very kind to answer and let me quote him:

Fernando: Why did you use “method” instead of any other word? Have you taken from Smalltalk? Or,… from any other programming language?

Guido: Good question. I don’t recall, but it’s likely that I was somehow influenced by Smalltalk, or people around me who were influenced by Smalltalk. I definitely opened a big book about Smalltalk to learn about byte code, and I also recall we had a Smalltalk implementation that we sometimes played with (some things that were wrong with that influenced some of my philosophy for Python).

Guido does not remember well, but admits to being influenced by Smalltalk at that time.

C#

C# is a programming language that is born being very similar to Java (almost identical) with some reminiscences of C++.
Then, over the years the language formed his own identity.

C# copy many terms of Java. One of the words that copy is “method”.

According to the C# standard [15]:

A method is a member that implements a computation or action that can be performed by an object or class.

Unlike Java spec, the C# standard defines the meaning of the word “method”.

As C# is a widely used language, especially by followers of the Microsoft “philosophy”, it is a major contributor on the popularization of the term.

Objective-C

Objective-C is a language developed in the early 1980’s. Like C ++, born as a super-set of C adding object technology.
Unlike C++, the object model of Objective-C is based on Smalltalk and not in Simula.

Objective-C, like Smalltalk, has the concept of messages and methods. [16]

Languages before Smalltalk

I looked in manuals, standards and documentation of programming languages older than Smalltalk, unrelated to object-oriented programming, but very recognized for their influence on others languages.
Specifically, the languages are Fortran, Algol and C. The word “method” is not mentioned in the documentation of any of them. Instead they use terms like routine, subroutine, procedure or function [17].

Other sources

To enhance my investigation I’ve done a search in some books (about programming in general) I have at my disposal:

Elements of Programming by Alexander A. Stepanov and Paul McJones
The Art of Computer Programming Volumes 1, 2, 3 and 4A by Donald E. Knuth

I found no reference to the word “method” in any of the 3,456 pages of these 5 books. Obviously the word “method” appears on several occasions, but not in the sense that I’m looking for.

Pending issues

Read documentation/manuals about the following programming languages:
- Lisp
- Scheme
- Ada
- Modula-2
- Common Lisp
Look at some classic texts:
- A Discipline of Programming by Edsger W. Dijkstra
- Algorithms and Data Structures by Niklaus Wirth
- Structured Programming, First Edition Edition by Edsger W. Dijkstra, C. A. R. Hoare and Ole-Johan Dahl
- Systematic Programming: An Introduction by Niklaus Wirth
Send the question to the following programming languages designers:
- Alan Kay
- Dan Ingalls
- Dick Gabriel
- James Gosling
- Anders Hejlsberg

I have tried to contact them, unsuccessfully at the moment.

Conclusions

The word “method” was introduced to programming by the Smalltalk community. Smalltalk was not practically used in the industry in the late 80’s and early 90’s, so I think the word “method” was not as common as it is now.

Maybe it was a mistake of the Smalltalk designers had not used existing nomenclature, or maybe not, as Smalltalk introduced a object model different from Simula and that change perhaps merited a change of names. It is very difficult to determine if it was a wrong decision or not.

Java and Python adopt Smalltalk terminology in their vocabulary. I do not find a strong relation between Smalltalk and Java / Python justifying the use of the term, this makes me think that the use of “method” is an error in these languages. Although, as I said, is very difficult to judge whether the decision to use certain nomenclature is wrong or not.

C++, Objective-C and Eiffel used similar terminology than its predecessors, perhaps with some variations, which may be minimal or necessary to adapt to changes introduced by the languages.

Some languages, such as C#, copied Java features, but also copied the “error” to incorporate “method” to its terminology.

The word “method” is infiltrated into the vocabulary of programmers.
There is no turning back ;)

You can use the term that you like, I’ll keep using procedure or function (as long as I remember that I do not like the word “method”).

Acknowledgements

Special thanks to Paul McJones and Guido van Rossum for kindly respond to my questions and for giving very useful information.
Also thanks to Mario dal Lago and Javier Velilla for reviewing the article and suggest corrections.

Notes / References

[1] Here we refer to the definition of “object” in the context of Object-Oriented Programming:
Object-Oriented Software Construction (2nd Ed) by Bertrand Meyer [1997, page 1198]
which differs from the definition of “object” given in:
Elements of Programming by Stepanov and McJones [2009, page 4]
This last definition is preferred by the author of the blog. If it is not specified, the reader must assume that I am talking about the definition given by Stepanov.

[2] This is a simplified definition, for a more detailed definition refer to: Object-Oriented Software Construction (2nd Ed) by Bertrand Meyer [1997, page 174]

[3] The Java Language Specification (Java SE 8 Edition), Chapter 8 [pages 191, 192]

[4] ISO International Standard ISO/IEC 14882:2014(E) – Programming Language C++, current working draft (at Aug, 2015), sections: 9.3 [class.mfct] and 8.3.5 [dcl.fct]

[5] There is almost no bibliography available about Simula, but here you can find an excellent collection of old manuals.

[6] ANSI Smalltalk Standard v1.9 199712 NCITS X3J20 draft, Section 3.1 [page 9]

[7] Smalltalk-72 Instruction Manual by Adele Goldberg and Alan Kay [page 44]

[8] The Smalltalk-76 Programming System. Design and Implementation

[9] Specified in:
Object-Oriented Software Construction (2nd Ed) by Bertrand Meyer [1997, pages 174, 175]
and:
Standard ECMA-367. Eiffel: Analysis, Design and Programming Language. 2nd edition (June 2006), Section 8.5.10 [page 38]

[10] Python 2.7.10 Documentation

[11] A Brief Timeline of Python

[12] The History of Java Technology

[13] On the popularization of languages, one of the sources on which I rely is Tiobe Index. Although I have some doubts about the measuring method, Tiobe it is the best we have today.
The other source is my memory. I do not remember Python as a popular language in the 90’s.
I think Python starts to become popular with the boom of dynamic languages in the early 2000’s and it had an even greater impetus to the creation of the Django web framework.

[14] Repository of older versions of Python

[15] Standard ECMA-334. C# Language Specification. 4th edition (June 2006), Section 8.7.3 [page 34]

[16] Objective-C has neither a standard nor a specification. The only “formal” documentation I could find was a website:
Programming With ObjectiveC
Kimberley Hagan wrote me to share a resource that she thinks may be valuable for Objective-C programmers, so here I leave the link in case you want to hit a glance:
Objective-C: Guide and Resources

[17] For documentation on FORTRAN, ALGOL and C: ISO/IEC JTC1/SC22/WG14 - The international standardization working group for the programming language C.

Using the proper terminology: Method? was originally published by Fernando Pelliccioni at Components Programming on August 12, 2015.

Stepanov's new book: From Mathematics to Generic Programming

2014-11-06T09:00:00-03:00

The new book by Alexander Stepanov, and his colleague Daniel Rose, is about to go on sale.

The book is based on the “Algorithmic Journeys” course taught by Alex at A9.

I had the honor of reviewing the draft version, and I can say it’s a wonderful book!
It combines mathematics, programming and history in a gorgeous and unique way. (It amazes me the knowledge that this guy has.)
It is a pleasure to read.

I enjoyed reading it the same way I enjoyed watching the videos of the course.
I strongly recommend it for all programmers who love their profession.

You can pre order it on Amazon here.

Eager to have the printed version in my hands.
(If my friends from Argentina Customs let me)

Thanks Alex!

Stepanov's new book: From Mathematics to Generic Programming was originally published by Fernando Pelliccioni at Components Programming on November 06, 2014.

Components Programming

2014-10-28T09:00:00-03:00

As you may have noticed, Components Programming is the name of this blog. And perhaps you’re wondering, what Components Programming means?

It is convenient to clarify it now, since, in upcoming articles I want to test several programming languages to determine which ones are good for Components Programming.

So, what Components Programming means? What is a Component?

No one better than Alex to explain it:

“One view of a Component is: you take a piece of code, ripped out something, and this is a Component. Let me tell you: No, it is not a Component. It’s like, if you rip a piece of meat out of my leg. It’s not a functioning component, it’s a pound of flesh.

A Component is something which solves a problem in a general way. It is something which is not specific, and then could be used by all the applications which needs this particular problem being solved.

A programming language is suitable for Component Programming if it satisfies the following conditions:

It could describe a general purpose components.
Without losing efficiency

The second condition is very, very important, because, obviously in any language you could construct anything. As long as your language is Turing-complete you could describe just about anything… but might be very, very slow. There are many languages which claim to possess powerful abstraction facilities. But if you start using these facilities everywhere, for example:

From now on in my language I no longer use int32 I just going to use Integer

Guess what? If you start doing it your performance is going to collapse. It’s not just going to be slow, you are going to be slow compared with stuff written this language without using abstractions.

That is, efficiency is a two-fold efficiency:

A component is relatively efficient is when instantiated it’s as fast as a code (non-generic / hand-written) written in the same programming language.
A component is absolutely efficient is when instantiated it’s as efficient as anything that could be done on a given machine, basically, as fast as assembly language.

So I want a language that allows me Generality and Absolute Efficiency. That is, I can program as general as a like, that is I could talk about things like Monoids and Semigroups. And on the other hand, when the code compiles I could look at assembly code and say ‘this is good!’

Now, we get to an interesting question. How do we know that a language is powerful enough to do that?

Long time ago I came up with a test whether your language is good enough. And you could come up with the following thing ‘If you could implement a major operating system then the language is good enough’. It is a hard test, you obviously don’t know whether you implemented in a general way or not.

So I came with a very, very simple test, and I claim this test which allows me (I still use it) to determine whether a language is suitable for what I want to do or not.

There are three programs which I need to implement in a general way to know that a language is suitable. These three programs are:

swap: the program which takes two things, and swaps.
min: the program which takes two things, and figures out which one is smaller.
linear search: the program that goes through bunch of stuff and finds whatever.

You could say ‘Well Alex, are these too simple?’ Well, if we cannot do simple things, it is very unlikely that we will be able to do hard things. I want to see solutions to simple problems. People always thing that exiting thing has to be very complicated. I claim exiting things tend to be very simple and basic.

So, every time you want to come to me and say ‘Alex why don’t we use a new language’. My answer is: ‘Three programs. Go, try implementing them in your favorite language. When you do them in a general way, and at least relatively efficient, then, let us talk’.”

Well, now we know what a component is and how to test if a programming language is suitable for Components Programming. We will begin the test in the upcoming articles.

Stay tuned.

References

[1] Efficient Programming with Components: Lecture 4, Part 1

Components Programming was originally published by Fernando Pelliccioni at Components Programming on October 28, 2014.

Writing min function, part 5: Stabilizing the algorithm

2014-10-05T09:00:00-03:00

This is the fifth article of the series called “Writing min function”.

Finally I will address the last pending issue.
To see the importance of the point I want to show to you, we have to write another function of our API, the max function.
This issue is not related to C++, you could be see it in the implementation of the min/max functions of any programming language. Because of that, I want to go back to pseudo-code.
So, let’s take min written in pseudo-code and adapt it to write max.

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
min(a, b) {
    if (a < b) return a
    return b
}

// Requires:
//       a and b are of the same type, here called T,
//  and, cmp models StrictWeakOrdering on T
min(a, b, cmp) {
    if (cmp(a, b)) return a
    return b
}

Now, it easy to write the max function:

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
max(a, b) {
    if (a < b) return b
    return a
}

// Requires:
//       a and b are of the same type, here called T,
//  and, cmp models StrictWeakOrdering on T
max(a, b, cmp) {
    if (cmp(a, b)) return b
    return a
}

Min and max are almost the same, the only difference resides at the two return clauses.

Now, to see the problem, let’s write some usage code:

usage_with_employees() {
    e1 := employee {1, "John", 5000.0}
    e2 := employee {2, "Peter", 6000.0}
    e3 := employee {3, "George", 4500.0}
    e4 := employee {4, "Frank", 5000.0}

    min_e1 := min(e1, e2, salary_comparator{})
    max_e1 := max(e1, e2, salary_comparator{})
    min_e2 := min(e1, e4, salary_comparator{})
    max_e2 := max(e1, e4, salary_comparator{})

    print(min_e1.name) //#1
    print(max_e1.name) //#2
    print(min_e2.name) //#3
    print(max_e2.name) //#4
}

According to the code above, what will be printed by the lines marked as #1, #2, #3 and #4?

Let’s analyze it:

min_e1 is the employee with lower salary between e1 and e2. Because 5000 (John salary) is less than 6000 (Peter salary) then e1 is the min employee, so in #1 “John” will be printed. Trivial case.
max_e1 is the employee with higher salary between e1 and e2. Doing a similar analysis, in #2 “Peter” will be printed. Another trivial case.
min_e2 is the employee with lower salary between e1 and e4. But, in this case both salaries are equal, so, what will be printed? Well, according to the implementation of our min function, in case of equality (or equivalence) the second return clause will executed, so, in this case “Frank” will be printed for #3.
max_e2 is the employee with higher salary between e1 and e4. Doing a similar analysis, in #2 “John” will be printed.

Let’s focus on the last two cases, where we have the equal or equivalent objects. Are our min and max functions correct?
What should they return in that case?

You might wonder:
“Why worry about returning one or another object if both are equal?”
In mathematics, this question makes sense, because for example, in the set of Natural numbers, 14 is equal to 14, indeed they are identical, so in:

min(14, 14)

returning the first 14 or the second 14 does not matter, because they are the same number.

But, in computer science we deal with things that reside in memory (objects). In a computer I can represent, for example, the chair where I’m sitting now. My chair maybe is equal to the chair next to me, but for sure they are not the same chair, they are not identical.
So, in cases like this, it is important to distinguish exactly what to return.

Let’s look at what options we have for returning in case of equality of the objects:

min returns a and max returns a
min returns a and max returns b
min returns b and max returns a
min returns b and max returns b

Our min/max functions fall in the case number 3. But… why? Have we consciously designed in that way?
Which of these options is more correct?

The 1st case looks good, both functions returns the same object in case of equality, the left-hand object. Sounds consistent.
The 4th function too, both functions returns the same object, but… they are returning the right-hand object… hmm, at least to me, it seems a bit odd.
The 3rd case sounds more illogical still.

But, what about the case 2?

The answer here lies in the concept of stability.
Surely you know the property of stability from algorithms such as sort.
An stable algorithm preserves the relative order of equivalent objects.

But, what have to do stability and sorting with min and max?
“To see it, let us implement another function that could be done with two objects and a strict weak ordering on them, namely, a sorting function” [1]

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
sort_2_wrong(ref a, ref b) {
    if (!(a < b)) swap(a, b)
}
//Note: ref if used for passing by reference
//Note: the swap function exchanges the values a and b.

sort_2_wrong has two problems:

it does more work than necessary, because equivalent objects are swapped
it is not stable, because the relative order of equivalent objects is not preserved.

“Stability is an important property, and we should not abandon it without necessity. As a matter of fact, it is trivial to fix the problem by performing the swap only when the second object is strictly less than the first” [1]

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
sort_2(ref a, ref b) {
    if (b < a) swap(a, b)
}

Now, we can see that there should be a relationship between min, max and sort_2: after we sort two elements, the first one should be the minimum and the second one should be the maximum.

// Type Requirement:
//            a and b are of the same type, here called T,
//       and, T models TotallyOrdered
// Postcondition: 
//       a = min(a, b) and b = max(a, b)
sort_2(ref a, ref b) {
    if (b < a) swap(a, b)
}

In the code above, note the specification of the postcondition written as a comment:

a = min(a, b) and b = max(a, b)

But this postcondition never holds. Our min function returns the second object and our max function returns the first one when both objects are equivalent.
We need to make min and max stable [2]:

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
min(a, b) {
    return b < a ? b : a
}

// Requires:
//       a and b are of the same type, here called T,
//  and, cmp models StrictWeakOrdering on T
min(a, b, cmp) {
    return cmp(b, a) ? b : a
}

// Requires:
//       a and b are of the same type, here called T,
//  and, T models TotallyOrdered
max(a, b) {
    return b < a ? a : b
}

// Requires:
//       a and b are of the same type, here called T,
//  and, cmp models StrictWeakOrdering on T
max(a, b, cmp) {
    return cmp(b, a) ? a : b
}

You could argue, “Stability is not a property of the min (or max) function, according to its definition. So, if we add stability to min, it will become something else, other than min”

Thoughts like this are wrong.
The first thing you have to think is: What is the definition of min?
Remember, this is Computer Science, we deal non-identical things.

Think!. What are our options?
There are three ways a library can implement min:

Random
Anti-Stable
Stable

The random way is obviously crazy and expensive.
The stable way is more useful and as efficient as the anti-stable one.

So, what would you choose?

Whatever your decision, you must specify (document) in your library/API the behavior of min (and max) in case of equality (or equivalence) of its arguments.
Do not make me guess or have to look at the implementation details of your API to discover the behavior!
This would be wrong, for sure.

We will see in the following articles some languages/libraries whose specification is definitely wrong.

Conclusion: Make min and max functions stable, and so consistent with the other functions of your API.
Specify their behavior in the library documentation.

The Series

   Part 1: The rise of Concepts
   Part 2: Understanding Concepts
   Part 3: Weakening the ordering
   Part 4: Const-Correctness
   Part 5: Stabilizing the algorithm

References

[1] Notes on Programming by Alexander Stepanov [2007, Pages 61-62]
[2] Note the use of the Conditional operator

Writing min function, part 5: Stabilizing the algorithm was originally published by Fernando Pelliccioni at Components Programming on October 05, 2014.

Writing min function, part 4: Const-Correctness

2014-09-24T09:10:00-03:00

This is the fourth article of the series called “Writing min function”.

I still have to solve two mistakes made in the code of the previous posts. One of them is C++ specific, and the other it is a mistake that could be made in any programming language.

Originally, I wanted to address the two mistakes in the same article, but when I started writing about the first one, the article became longer than I wanted, so I will address each mistake in separate posts.

Therefore, this article will deal with an issue that only concerns to C++ programmers, so if C++ is not of your interest, feel free to jump directly to the fifth article.

In general, I want that the algorithms written in my articles are not tied to a specific programming language, but in order to write the algorithms in a practical way, I have to do it in a real language, and C++ is my choice. Once the mistakes have been corrected, with the help of other people, I’ll start writing the min function in other programming languages.

So, to start, I’ll update the usage code example to reflect things I would like to do using the min function:

void raise_salary(employee& e, float increment) {
    e.salary += increment;
}

The raise_salary function is very simple, takes a reference (non-const) to an employee and increases her salary by increment. I would like to use it in the following way:

void usage_with_mutable_objects() {
    employee e1 {1, "John", 5'000.0f};
    employee e2 {3, "George", 4'500.0f};

    raise_salary(
        min(e1, e2, salary_comparator{}),
        500.0f
    ); //#1 Compile-time error
}

(employee and salary_comparator were defined in Part 3)

In #1 we get a compile-time error, but, why? Remember our last version of the min function:

template <TotallyOrdered T>
T const& min(T const& a, T const& b) {
    if (a < b) return a;
    return b;
}

template <typename T, StrictWeakOrdering Cmp>
    requires SameType<ArgumentType<Cmp>, T>
T const& min(T const& a, T const& b, Cmp cmp) {
    if (cmp(a, b)) return a;
    return b;
}

(Note: When I refer to the min function, actually I am not referring to a single function, but to a family of functions)

It takes two constant-references to two objects (and a comparator); and returns a constant reference to one of the objects. That means that the returned reference cannot be modified, because it is returned as const. The raise_salary function tries to modify the object returned by the min function, causing the compilation-time error, because you can’t modify something declared as const.

If I manually expand (or “inliniarize”) the code of the functions min and raise_salary I would get something like:

// manually-inliniarized code

employee e1 {1, "John", 5'000.0f};
employee e2 {3, "George", 4'500.0f};

employee const& m = e1 < e2 ? e1 : e2;
m.salary += 500.0f; //Compile-time error

In the last code, it is more clear that we are trying to modify something that is constant. The variable m is a constant-reference pointing (or rather, referencing) to e1 or to e2. Both e1 and e2 were not declared as constant, so they are mutable objects. Then, why the min function returns a constant reference and not just an ordinary (non-const) reference? Consider the following variation of a wrong min function:

//Obs: It is not valid C++ code (ill-formed code)
template <typename T, StrictWeakOrdering Cmp>
    requires SameType<ArgumentType<Cmp>, T>
T& wrong_min(T const& a, T const& b, Cmp cmp) {
    if (cmp(a, b)) return a;
    return b;
}

It is not valid C++ code (or using Standard C++ terminology, it is ill-formed code), it doesn’t compiles, because we are trying to return something that is constant as non-constant. And what’s up with that? Well, suppose that the wrong_min function compiles, in a fictitious programming language, then consider the following usage code:

void usage_wrong_min() {
    employee const e1 {1, "John", 5'000.0f};
    employee const e2 {3, "George", 4'500.0f};
//...

The two employees are declared as const objects, meaning that they are immutable objects, so, they cannot be modified. Then consider the folliwing usage of the wrong_min function.

//...
    employee& m = wrong_min(e1, e2, salary_comparator{});
//...

Because, wrong_min function returns a non-const reference, we can assign the result of the function to a non-const reference, and then we could modify the object referenced by m:

//...
    m.salary += 500.0f; //#2
}

Remember that the wrong_min function is not valid, but, if it were valid, we would be in trouble, since we would be modifying an object that can not be modified, because it is constant or immutable.

You might wonder: “But… they are objects, so they reside in memory, and memory can be modified,… what is the problem with that? ”

According to the C++ Standard [1], “…any attempt to modify a const object during its lifetime (3.8) results in undefined behavior.” In practice, a const object could be placed by the compiler (and the operating system) in a read-only segment of memory. Any attempt to write to read-only memory causes a segmentation fault, probably causing an abnormal termination of the process (program crash).

That is the reason why C++ protects us from writing things like wrong_min.

Returning to the min function, then, why not remove const from everywhere? Let’s see:

template <TotallyOrdered T>
T& min(T& a, T& b) {
    if (a < b) return a;
    return b;
}

If we wrote the min function as above, then we would have problems with the following code:

int m = min(5, 7); // Compile-time error

The code above doesn’t compile. Why? In C++, the values 5 and 7 are called integer-literal, more specifically they are called decimal integer literal (base ten). Literals are something that can’t be modified, they are constants. So to accept the code above we have to return to our original min function, using const everywhere. But, remember, we want our min function also allows us to work with mutable objects.

So, we want a function that:

Returns a constant-reference if any of its parameters is a constant object, or,
Returns a non-constant-reference if both parameters are non-constant objects.

The simplest way to do it in C++ is a little verbose, but it works:

template <TotallyOrdered T>
T const& min(T const& a, T const& b) {
    if (a < b) return a;
    return b;
}

template <TotallyOrdered T>
T& min(T& a, T& b) {
    if (a < b) return a;
    return b;
}

We have to repeat the code, the first function covers the case 1 and the second one covers the case 2. Maybe in a future version of C++ this can be done without the need for repetition of code.

So I’m going to write the full family of min functions we have so far:

template <typename T, StrictWeakOrdering Cmp>
    requires SameType<ArgumentType<Cmp>, T>
T const& min(T const& a, T const& b, Cmp cmp) {
    if (cmp(a, b)) return a;
    return b;
}

template <typename T, StrictWeakOrdering Cmp>
    requires SameType<ArgumentType<Cmp>, T>
T& min(T& a, T& b, Cmp cmp) {
    if (cmp(a, b)) return a;
    return b;
}

template <TotallyOrdered T>
T const& min(T const& a, T const& b) {
    if (a < b) return a;
    return b;
}

template <TotallyOrdered T>
T& min(T& a, T& b) {
    if (a < b) return a;
    return b;
}

Remember that in the following article I will address the last outstanding issue. So do not take the above code as totally definitive.

And, with the code above, we can write things like the following:

employee const e1 {1, "John", 5'000.0f};
employee const e2 {2, "Peter", 6'000.0f};
employee e3       {3, "George", 4'500.0f};
employee e4       {4, "Frank", 5'000.0f};

employee const& m1 = min(e1, e2, salary_comparator{});
employee const& m2 = min(e1, e3, salary_comparator{});
employee const& m3 = min(e4, e2, salary_comparator{});

min(e3, e4, salary_comparator{}).salary += 500.0f;
//or
raise_salary(
    min(e3, e4, salary_comparator{}), 500.0f
);

Finally, I wrote another version of the min function that looks simpler because it prevents writing the same code twice, but it uses some template-metaprogramming (TMP) hacks.

The code looks like the following:

template <TotallyOrdered T, TotallyOrdered U>
    requires SameType<T, U>
HERE_SOME_MAGIC min(T&& a, U&& b) {
    if (a < b) return (HERE_SOME_MAGIC)a;
    return (HERE_SOME_MAGIC)b;
}

Then, I presented the code to Alex, because I wanted to know what he thought, and he answered me with the following advice:

- Alex Stepanov: “My standard advice: concentrate on algorithms and data structures. Do not spend time on meta-programming. If it is not in Knuth (or something like Knuth), do not do it.” [2]

At first I did not understand the reason for his answer, but then, after spending hours focusing on details of the template-metaprogramming code, I understood that it is better to focus on real problems, which are the algorithms.

Even so, if you want to take a look at the code, write me by private and I will gladly share it (See About page).

I didn’t want to make an article explaining Const-Correctness so long, because there are countless books and articles on the Internet [3] that explain the topic better than me. But as I tried to explain some things, I thought it was necessary to extend the explanation, which ended in this article.

The Series

Part 1: The rise of Concepts Part 2: Understanding Concepts Part 3: Weakening the ordering Part 4: Const-Correctness Part 5: Stabilizing the algorithm

References

[1] Latest publicly available C++ Draft Standard (n3797) (at September 2014) [dcl.type.cv] paragraph 4: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf

[2] Here Alex refers to Donald Knuth, but more specifically to his series of books, called “The Art of Computer Programming” (Amazon)

[3] For better references about Const-Correctness and ROM-ability, see:

Standard C++ FAQ about Const Correctness:

https://isocpp.org/wiki/faq/const-correctness

The “Guru of the Week” (GotW) articles about Const-Correctness (the original and the new one), from Herb Sutter:

http://www.gotw.ca/gotw/006.htm http://herbsutter.com/2013/05/24/gotw-6a-const-correctness-part-1-3/

Technical Report on C++ Performance, Chapter 7.1, “ROMability”:

http://www.open-std.org/jtc1/sc22/wg21/docs/TR18015.pdf

Writing min function, part 4: Const-Correctness was originally published by Fernando Pelliccioni at Components Programming on September 24, 2014.

Writing min function, part 3: Weakening the ordering

2014-07-15T05:39:29-03:00

This is the third article of the series called “Writing min function”.

Now we understand what Concepts are (do we?), I will try to complete the min function.

What do I mean with “complete”?

Well, first we need to see how to use our min function, for that purpose I want to use a real programming language.
So in this article I will write code in C++. Why C++?, it is a topic for another article.
But, don’t worry if you’re not a C++ programmer, the code will be easy to understand, and, the ideas that I want to talk here are very important for programming algorithms, beyond the programming language.
Later on, I will try to write the same code (and analyze it) using another programming languages.

This is the C++ equivalent of the min function code from Part 2:

//Note 1: this code is Concept-enabled C++.
//Note 2: Still has errors!
template <TotallyOrdered T>
T const& min(T const& a, T const& b) {
  if (a < b) return a;
  return b;
}

(We will see how to define the TotallyOrdered concept in C++ later. For now, think in the mathematical definition presented before )

And we use it in this way:

void usage_with_builtin_types_simple() {
  int a = 12;
  int b = 34;

  //using variables
  cout << min(a, b); //print the result on standard output

  //using integer-literals (base10)
  cout << min(1, 2);

  //using variables and literals
  cout << min(a, 2);

  //assigning the result (copying the result)
  int m1 = min(a, b);
  int m2 = min(1, 2);
}

These are very simple examples using the int builtin type, but our min function is supposed to be Generic, so it has to operate with all types that satisfy the TotallyOrdered concept. So let’s see a little more complicated example.

Suppose we maintain the employee database of a company and we want to take two employees and know which is the minimum of the two:

//A simplified Employee class written in C++
struct employee { string name; float salary; };

And now we use the min function with Employees:

void usage_with_employees() {
  employee e1 {"John", 5'000.0f};
  employee e2 {"Peter", 6'000.0f};
  employee e3 {"George", 4'500.0f};
  employee e4 {"Frank", 5'000.0f};

  employee m = min(e1, e2); // #1
}

What happend at #1?

Well, we should get a compile-time error saying that the employee type doesn’t satisfy the TotallyOrdered concept.

Why?

First, in C++, there is no way of comparing two Employees using the less-than-operator required by the TotallyOrdered concept.
If we use old-C++, without Concepts (or duck-typing templates) we will get a compile-time error pointing to the min function, saying that a < b could not be done.

min.cpp: In instantiation of 'const T& min(const T&, const T&) [with T = employee]':
min.cpp:23:26:   required from here
min.cpp:10:9: error: no match for 'operator<' (operand types are 'const employee' and 'const employee')
   if (a < b) return a;
         ^

The error message is not very instructive, right? The error message points to the min function, when the real problem is in the use of it, specifically in line marked as #1 in the usage_with_employees() function.

If we use a dynamic duck-typed programming language (like Python or Javascript) we will get a similar error but at runtime.

The compiler (or interpreter) doesn’t know how to do a < b for Employees, so this is the reason why we get the error.
So, how to make Employee to satisfy the TotallyOrdered concept? Let’s start satisfying the requirements imposed by the concept:

Employee must satisfy the Regular concept.
We have to provide an operator< with the signature:
Employee x Employee -> bool
The operator< must be a total ordering relation.

For now I want to skip the points 1 and 3, we will see them later. Let’s focus on point 2 (remember, it is a syntactic requirement), we have to give the compiler a way to compare two Employees.

bool operator<(employee const& a, employee const& b) {
  return ???????;
}

This is the canonical C++ way for implementing a less-than-operator, but … What should I put on line 2?

This should be answered by the designer of the Employee class. Well…, that’s me (?).

Remember that total ordering is, roughly speaking, some kind of Natural Ordering. So we need to know what is the natural ordering of Employees. Maybe the natural ordering of employees is by name, maybe by salary, … I don’t know. This depends on the domain of the application. In a company, I think, employees may have a unique identification number, which seems to be a good candidate for implement total ordering. So, let’s modify our Employee class:

struct employee { int id; string name; float salary; };

Now, let’s finalize our less-than-operator using id as the natural ordering:

bool operator<(employee const& a, employee const& b) {
  return a.id < b.id;
}

Now, we have an Employee class with a natural ordering (by id) that satisfies the TotallyOrdered concept (remember, we are ignoring the points 1 and 3).

But, what if we want to know who is the lowest paid employee, and then raise his salary. Should we modify the less-than-operator to compare by salary?

bool operator<(employee const& a, employee const& b) {
  return a.salary < b.salary;
}

Is it OK? No, we are imposing an unnatural ordering to employees by default, it is not the right way to do it.

Changing the Employee’s natural ordering is not an option, so, we need another way of selecting the minimum employee using an unnatural ordering relation.
What we need is another min function, one that takes a relation as parameter.
Let’s do it using the old-C++ way (without Concepts):

//Note: It compiles, but is incorrect, still, be patient!
template <typename T, typename C>
T const& min(T const& a, T const& b, C cmp) {
  if (cmp(a, b)) return a;
  return b;
}

Now we can write code like the following:

struct salary_comparator {
  bool operator()(employee const& a, 
                  employee const& b) const {
    return a.salary < b.salary;
  }
};

void usage_with_employees() {
  employee e1 {1, "John", 5'000.0f};
  employee e2 {2, "Peter", 6'000.0f};
  employee e3 {3, "George", 4'500.0f};
  employee e4 {4, "Frank", 5'000.0f};

  // using natural employee ordering (by id)
  employee m = min(e1, e2);

  // using another (unnatural) ordering
  employee m2 = min(e1, e2, salary_comparator{});

  // using another (unnatural) ordering, with lambdas   
  employee m3 = min(e1, e2, [](employee const& a, 
                               employee const& b) {
          return a.name < b.name; 
  });
}

But so far, I have not mentioned anything that an experienced programmer does not know, the use of predicates (the cmp comparator) is a common thing in practically all programming languages. What most programmers (and most of the APIs provided by programming languages) forget is to specify the semantics requirements of the predicate.

So, what are the semantic requirements? We need to answer: What our comparator (cmp) is?

A comparator is a Relation, that is, a binary Predicate. What kind of relation? It is an Ordering. What kind of ordering? Is it a Total Ordering relation? Well, let’s check it:

Remember, a Relation r is a Strict Total Ordering if:
For all a, b and c in the domain of r, the following must hold:
Transitivity: if r(a, b) and r(b, c) then r(a, c)
Trichotomy: only one of the following holds, r(a, b), r(b, a) or a = b

It’s easy to prove that the transitivity axiom holds, let’s leave it as an exercise for the reader.
What about trichotomy? Let’s prove it with an example.
Given our previous defined employees:

employee e1 { 1, "John", 5'000.0f };
employee e2 { 2, "Peter", 6'000.0f };
employee e3 { 3, "George", 4'500.0f };
employee e4 { 4, "Frank", 5'000.0f };

And our salary_comparator, here called r in order to abbreviate the text:

Take e1 and e2: According to trichotomy: only one of the following holds, r(e1, e2), r(e2, e1) or e1 = e2
What is the result of r(e1, e2)? r(e1, e2) means e1.salary < e2.salary, which means: 5000 < 6000, so it holds. The other two propositions are false (intentionally omitted), so trichotomy holds in that case.
Take e1 and e3: Following the same analysis, r(e1, e3) means e1.salary < e3.salary, which means: 5000 < 4500, so it doesn’t hold. But r(e3, e1) means … 4500 < 5000 which is true, and the last proposition is false (again, intentionally omitted), so trichotomy holds.
Now, take e1 and e4: Following the same analysis, r(e1, e4) and r(e4, e1) are both false, so, the proposition e1 = e4 have to be true if we want trichotomy holds.
Is e1 = e4 true?
No! because e1 is not equal to e4, they are differents employees, they are not the same.

Then, the trichotomy axiom does not hold, that is, the salary_comparator relation is not a Total Ordering on the Employee Set. This means that Total Ordering is too restrictive.

So, what kind of ordering relation should be our Comparator?

Partial Ordering?
No, we saw in Part 1 that Partial Ordering is too weak to define min. We need something between Partial and Total Ordering: what we need is called Weak Ordering[1].

Roughly speaking, weak ordering says that if r(a, b) and r(b, a) are false, then, a and b are equivalents.

So, let’s modify the min function to introduce weak ordering:

//Note: yes! you guess it, it is incorrect, still!
template <typename T, StrictWeakOrdering Cmp>
   requires SameType<ArgumentType<Cmp>, T>
T const& min(T const& a, T const& b, Cmp cmp) {
  if (cmp(a, b)) return a;
  return b;
}

The code above means that we have a function called min, that takes two formal parameters, a and b, both of the same type, called T.
The funcion has a third formal parameter, cmp, that models the concept called StrictWeakOrdering. The “requires” clause means that T (the type of a and b) and the argument type of the Comparator (Cmp) must be the same.

Well, in this article I explained what Weak Ordering means and why it is important, I want to end it with a quote from Alex:

“Mathematicians are happy with Total and Partial ordering. But most of them don’t know what is Weak Ordering. It is not a common term in mathematics but it is essential in computer science, because when we want to order things, we want to order by something. For example by social security number, by name, by age”.

In the next article, finally, I will tell you what are the mistakes that remain to be addressed.

You can get the complete source code on my Github repository.

The Series

   Part 1: The rise of Concepts
   Part 2: Understanding Concepts
   Part 3: Weakening the ordering
   Part 4: Const-Correctness
   Part 5: Stabilizing the algorithm

References

[1] For a formal definition of Weak Ordering see:
http://www.elementsofprogramming.com/eop-concepts.pdf

Writing min function, part 3: Weakening the ordering was originally published by Fernando Pelliccioni at Components Programming on July 15, 2014.

Components Programming

C++26 Wraps Up: Notes from the Croydon WG21 Meeting

Contracts: Approved, Debated, Divisive

Reflection: The Big One

The Evening Session That Changed My Direction

Being There

Thanks Alex, once again!

Algorithms and specifications

Elements of Programming Authors' Edition (free ebook)

My 'The Gift of the Arabs' talk (Spanish)

Honorable Mention 'Senator Domingo Faustino Sarmiento'

References

Links to News

My '¿Fastware?' talk (Spanish)

Palindromes and more

Asymptotic Computational Complexity

Concrete Computational Complexity

Back to Palindromes

Determining the complexity

Improving the algorithm (naïve version)

Optimal Algorithm

Algorithm I, detailed analysis

Construction of StringBuilder

reverse() (StringBuilder)

toString() (StringBuilder)

equals() (String)

Garbage Collection

Data Cache Misses

Memory footprint

StringBuilder:

String:

Total memory footprint:

Benchmarks

Algorithm N versus Algorithm O

Ultimate solution?

Pending issues

Conclusions

Acknowledgements

Notes

Platform used for the analysis in this article:

References

My 'Intro to Generic Programming' talk (Spanish)

Vin d'honneur

References

The Outer Limit of the Argentine Continental Shelf

References

Alex Retirement

Thanks Alex!

What's your favorite flavor of Object?

Introduction

What “Object” means?

Simula

Smalltalk

Eiffel - Object-Oriented Software Construction

C++

C programming language

Elements of Programming

Conclusions

“Terminology” series:

Notes / References

Using the proper terminology: Method?

What is a method?

Why “method”?

Why we use the term “method” insted of “procedure”?

Java

C++

Simula

Smalltalk

Other languages

Eiffel

Python

C#

Objective-C

Languages ​​before Smalltalk

Other sources

Pending issues

Conclusions

Acknowledgements

Notes / References

Stepanov's new book: From Mathematics to Generic Programming

Languages before Smalltalk