A short note on how the usage of advanced language features like lambda expressions might destroy a development teams ability to fully understand a codebase.
Currently I code in C# and I love lambdas. So do many of my team members. The project I am partly involved in started out as a C# 3.0 project and over the years evolved to using version 4.5. Although available right from the beginning it took some time until the usage of lambda expressions within our project picked up and by now I would say 2 third of us use lambda expression. However, the other third still opposes the use of lambda expressions. Those team members mostly argue that they wanted to stick to what they are used to and find lambdas less readable. Actually, these statements should have already sounded the alarm. What happened then was that over the last couple of month we saw a number of issues and bugs pop up which were rooted in the misinterpretation of code. When we analyzed these issues we learned that people who did not use lambda expressions themselves could not understand what the code does and therefore misused code or created code duplicates. Some developers even stated that they somehow blind out lambda expressions!
I found this quite worrying.
Starting off with a code-base all team members had a shared understanding of,
we came to the point where a significant number of developers could not fully
understand our own codebase.
We write coding guidelines which
define the number of characters a source code line should not exceed or how if
statements are formatted to improve the readability of code. But we completely
miss out on defining which language features should be used or better not be
used to assure understandability of program sources.
Heavily nested procedural control
flow structures are what we programmers who grew up with C++, Java and C#
understand. By now however, all of those programming languages saw the introduction
of some kind of syntax to define anonymous functions (lambdas in Java 8, C# and C++11). I don't know what the solution to this should be, it
will depend on many things like the education of developers, codebase,
available tool support, the team approach to change or willingness to learn.
But whatever the answer to use or not use advanced/new language features is, I
am sure a conscious decision and discussion on the
problems that might arise helps to preserve understandability of program code.
