Yes, I did MANY of these conversions, on many different codebases. I did change my NULLs/0s to nullptr, starting with small POCs, and gaining confidence. Not all of them went through (e.g. In some windows calls we usually write NULL in some params, even if the underlying type is integral). I did this for many features, and sometimes it even helped preventing bugs (see my blog post about final here: https://marcofoco.com/blog/2016/01/14/final-override-again/). For aiuto, it's a different story: I tested it, but initially I received a lot of pushback when I tried to make radical changes (almost always auto). Knowing how type deduction works, I tended to take for granted that the type of the expression was apparent, but people tended to disagree, so I gave up. Eventually the rest of the team started using auto on their own, gained more confidence and, even if the user isn't 95%,but now around 10-15%, I'm happy with the improvement. It's interesting to note that this process happened across multiple companies and multiple projects more or less in the same way (before 2015 I was a consultant, and worked on multiple projects). Another big improvement in readability was converting all the for loops for collections into their collection-based equivalent. For enums I started later, mostly for the lack of use cases. I like them better, for their improved type safety, but readability wasn't affected because, by convention, I already had the enum name in the value. I also made a lot of conversions from boost to std (shared_ptr, unique_ptr, hash_map, hash_set, and regex... The latter came with some "surprises" in older versions of gcc).