How do you ensure that you as programmer have writ

Question

I m looking to write some quality C code. Can someone point me to some articles , websites..whatever I need something with examples. I have already seen and read K&R C book.

But times have changed, some one must have more to say on quality C Code. and another important thing is How do you ensure that you as programmer have written quality C code??

Answer 1

Someone mentioned some compiler switches, but having syntactically smooth code is not going to ensure a quality end-product, because there's more to software quality than that.

There are several classifications of software qualities, but here's a list that you can use as a checklist:

• Correctness (does it work according to spec?)
• Reliability (can de user depend on it?)
• Robustness (does it work in unexpected situations?)
• Performance (does it do the job fast enough for the user?)
• Usability (is it user-friendly?)
• Verifiability (can its properties be verfified easily?)
• Maintainability (can modifications be made easily?)
  • Repairability (can defects be fixed within reasonable time?)
  • Evolvability (can new functionality be added simply?)
• Reusability (can the code easily be used in other projects?)
• Portability (can it run easily in different environments?)
• Understandability (can maintainers easily understand it?)
• Interoperatability (how well does it cooperate?)
• Productivity (efficienct and performant delivery)
• Timeliness (ability to deliver on time)
• Visibility (are all steps documented clearly?)

Answer 2

Traditionally, people have used lint to help out with this.

Answer 3

It's tough to see for your own self whether or not you are writing quality code, sure there's tons of automation and standards out there, but how can one apply everything they've seen out there?

This is where I'm a big fan of peer review as a method of judging code quality. Let other see (and also learn) from your code and that'll be the judge of quality.

Answer 4

It depends in part on what you mean by 'quality C' code.

One important aspect of the program is "does it do what it was designed to do"? That is hard to measure, but is crucial.

Then you need to know whether the code is acceptable to compilers - using the set of GCC compiler options provided by Cristoph would indicate that the code is in good shape. (Although I would quibble over -Wno-long-long, that depends on where your code might need to be be moved to).

The code layout is important. Is the code readable by humans as well as compilers? Is the layout uniform? Is it in one of the standard formats - there are several, all with major followings, and as long as you use one of them consistently, the code should be fine. Is it appropriately commented? That means enough comments, but not too many! The file should have a header comment indicating what's in it - and probably who wrote it, and maybe the licence under which it is distributed. There have been multiple questions on SO about that, including Professional #include comments. Writing code to a good layout standard is routine after a short time, though.

Documentation may be relevant - usually is relevant. How would someone else know that the code exists, what it does, how to use it, when to use it, when not to use it?

The code should be written with good enough algorithms - it should not use exorbitant amounts of memory, disk, or CPU time. It should also not leak resources. There's also no point in wringing the last CPU cycle of performance enhancement out of a routine that will be used once per run of a program, for a few milliseconds, when it starts up, unless you can demonstrate that it is a performance bottleneck for the program as a whole.

Wouter van Nifterick has given an excellent set of pointers too.

Answer 5

A previous discussion, what-are-some-good-resources-for-learning-c-beyond-kr, might point to more (books) examples.

Answer 6

Write unit tests!

It might be a bit more cumbersome to write unit-tests in C compared to more modern languages, but it is still very much worth it.

I would say that proper unit tests are the #1 way to ensure the quality of any code. You can use all the static analysis tools and code reviews you want, but nothing beats actually running the code and verifying the results.