It’s 1989, and if you’ve been writing C for as long as I have, you know the pain of the "K&R" days. Don’t get me wrong, Kernighan and Ritchie’s book was our bible, but as every hardware vendor started rolling out their own C compilers, things got… messy. You’d write a perfectly good routine on a VAX, move it to a PC or a Sun workstation, and suddenly the compiler is screaming about function prototypes or how you’re handling pointers.
The Era of Function Prototypes
The biggest win in this new ANSI standard (which many are calling C89) is the formalization of function prototypes. In the old days, you could call a function with the wrong number of arguments, and the compiler would just shrug its shoulders and let you crash at runtime. Now, we can actually tell the compiler what to expect.
/* The New Way: Prototypes */
int calculate_total(int items, float price);
int main() {
/* The compiler will actually catch this now! */
// int total = calculate_total(5); // Error: too few arguments
return 0;
}
It feels like the language is finally growing up. We’re also getting the void * type, which is a godsend for generic memory handling, and the const qualifier, which might actually help the optimizer do its job for once.
Why It Matters
Standardization means portability. For those of us trying to build tools that last, not being tethered to a specific vendor's quirks is everything. We’re seeing more "Write once, compile anywhere" (well, almost) becoming a reality. The "Wild West" of C is being fenced in, but in a way that lets us build bigger, more reliable structures.
The Horizon
As we look toward the 90s, C is clearly the dominant force. With a standard in place, I expect to see even more sophisticated libraries and operating systems built on this foundation. Some people are talking about "C with Classes" (C++), but for my money, a solid, standardized C is where the real work gets done. I'll be porting my old libraries to C89 over the holiday break-it’s going to be a long winter.