Post History

Besides what Olin already said, I guess too many people were taught C using K&R book, which was great at the time, but it completely neglects modern SW engineering best practices (encapsulation, data hiding, modularization, etc.), many of which were popularized to the wider programmer audience by C++ and later by Java, since these languages support OOP and in this paradigm modularization (which `static` in C is for) is essentially a must (in C++ you have namespaces, classes and all sort of mechanism to do so).

In particular, separation of the interface of a module from the implementation is essentially made using `static` vs `extern` functions: write the interface in a header file where you *declare* all the public functions the module must export, then include the header in the corresponding source file (`.c` file) where you implement the public functions using all the private (`static`) helper functions you need.

One of the staple of good SW design is to avoid *fat interfaces*, i.e. interfaces with a lot of functions that don't need to be public, but are there "just in case". C programmers that cram their headers with all the functions in their modules probably haven't been exposed to OOP languages or are too inexpert in modern C programming practices (you can do OOP even in C, but it requires quite a lot of discipline since the language won't help you there)

Another alternative is that they are "old timers" that grew up with assembly and C at low level, where legacy code written for "bare metal" systems didn't need too much SW engineering best practices to work well. After all, if all you have is an MCU with 16k or so of Flash and some kiBs of RAM (and you are a good programmer) you can write pretty good software even using C as an higher level assembly. 

The problem is that this doesn't scale well for bigger systems. Once your project code base size hits the thousands of source code lines of C you are in for very nasty surprises if you don't employ higher level techniques, and one of the most basic techniques is using `static` to compartmentalize functions in the module they belong to.