Eiffel?

I passed the public competitive hiring process for a faculty position in algorithms and data structures at the Universidade Federal de Lavras, along with my new friend Montserrat. We had met during the exams, talked a bit, and then ran into each other again when we both started at the university. Montserrat had a degree in Chemistry and a PhD in Computing. We’d both be responsible for teaching algorithms and data structures in the first three semesters of the program.

When we arrived, an initial version of the curriculum already existed, and the inaugural class had completed its first semester. The computing professors already working at UFLA were teaching a general programming and computing course, common to all majors. The existing curriculum documentation was very basic, and there was no detailed description of each course’s content. Our first task was to work on those descriptions and build the syllabi for the courses in our area.

I brought a somewhat unconventional view to that discussion. At UFMG, I had taken classes with Professor Bigonha, both in programming languages and in object-oriented programming. Especially in the latter, he frequently mentioned a researcher and professor named Bertrand Meyer, creator of the design by contract paradigm. Bigonha’s enthusiasm for the topic rubbed off on me, and when I started thinking about the curriculum for UFLA, I remembered those classes. I went to talk to him at UFMG, and he pointed me to some references so I could go deeper into the subject. Among them was the Eiffel language, defined by Bertrand Meyer himself, which implemented object orientation in a very pure way and already had built-in support for design by contract.

Bertrand Meyer had also written about teaching programming, defending the idea that object orientation should be taught from the very beginning, without first going through an imperative language only to then “reprogram” the student’s way of thinking into an object-oriented mindset. Since I had gone through that shift in mindset not long before, I found the idea extremely interesting and quite modern. It wasn’t a proposal driven by the job market, but we knew the market was clearly heading in that direction. Major languages, like Java, followed that paradigm. So I argued to my colleagues that a new and still little-known CS program should bet on a modern methodology aligned with the future. That meant teaching object orientation from the first semester.

As for the choice of language, Java was the main candidate. It was still relatively new, but was quickly becoming mainstream. In my view, though, Java had two problems. The first was the syntax, derived from C, full of symbols like braces and parentheses, which made reading hard for beginners. The second was the need to explain, right in the first class, what something like public static void main(String[] args) meant. I thought that would be a nightmare and would just scare students at the very beginning of their journey into programming. Other alternatives, like C++, had similar problems.

Eiffel, on the other hand, had a Pascal-inspired syntax, much more readable for beginners. Besides, it was fully object-oriented, which prevented students from “escaping” the paradigm and writing imperative code in disguise. That would work as a kind of pedagogical guardrail. On top of that, design by contract was built into the language, making students think explicitly about program correctness and about when defensive programming made sense. In my view, that was a huge advantage for training good programmers. With this set of arguments, I managed to convince both Montserrat and the other UFLA colleagues, and we decided the program would be based on Eiffel and on Bertrand Meyer’s books.

With the language and methodology set, we also sorted out the division of responsibilities. Montserrat would be in charge of the first semester, and I’d handle the second. For me that was perfect: I never had much patience for beginners, and Montserrat turned out to be an excellent intro-to-computing teacher. As for the content, I proposed a structure very close to the one I had experienced at UFMG: in the second semester, basic data structures (queues, stacks, trees, and the like), and in the third semester, slightly more advanced topics and some more interesting algorithms.

After the first semesters, we saw some interesting results. The first was a student who already had experience with Delphi (a language also based on Pascal, very popular at the time), who came to tell us that after studying object orientation and Eiffel, he started understanding some aspects of Delphi he had been using without really knowing how they worked. A second aspect was making it clear to the students that what matters is knowing the concepts well: languages come and go, and whoever knows the concepts can more easily move from one to another when needed.

Meanwhile, new professors were being hired for the program in various areas, but some important courses in the curriculum still didn’t have anyone assigned to them. But that’s a story for the next chapter.