Many resources exist talking about the better coding rules to adopt, we can learn good coding rules from :<\/p>\n
- \n
- Reading a book or a magazine.<\/li>\n
- Websites.<\/li>\n
- From a colleague.<\/li>\n
- Doing a training.<\/li>\n<\/ul>\n
We can also work with an expert for few months to elevate the coding skills of the team. However, it’s not easy to find the right person and it could cost a lot of money to the company. But why searching for an expert, if we can be inspired by\u00a0genius developers like Linus Torvalds. Indeed, you have just to explore the source code developed or maintained by him\u00a0to have a good idea of how we must develop an efficient C code.<\/p>\n
Linus Torvalds\u00a0is genius because it’s the creator, and for a long time, principal developer of the\u00a0Linux kernel and he also created the most popular distributed revision control\u00a0system\u00a0Git<\/a>. That’s it, no need to search for other arguments \ud83d\ude42<\/p>\n
Inside the git source code<\/strong><\/p>\n
Let’s take a look at a code snippet from git:
\n![](\"http:\/\/www.cppdepend.com\/img\/git.png\")
<\/p>\nHere are some remarks about this code:<\/p>\n
- \n
- The functions are declared as static.<\/li>\n
- The functions\u00a0return an error code.<\/li>\n
- The function has few parameters.<\/li>\n
- The\u00a0function exit as early as possible.<\/li>\n
- The variables are declared as static.<\/li>\n
- The variable naming is easy to understand.<\/li>\n
- The methods are very short.<\/li>\n
- It\u2019s well indented.<\/li>\n
- No extra comments in the body. The code explains easily itself.<\/li>\n
- The function bodies are well indented.<\/li>\n
- The define guards are clear.<\/li>\n<\/ul>\n
If we\u00a0navigate across all the git source code we can remark the coherence of the implementation. The same best practice rules are applied to each function. To be sure let’s\u00a0 search for the\u00a0static functions:<\/p>\n
from m in Methods where m.IsStatic select m\r\n<\/pre>\n
The treemap is very useful to have a good idea of code elements concerned by a CQLinq query, the blue rectangles represent the result.<\/p>\n
![\"\"](\"http:\/\/cppdepend.files.wordpress.com\/2012\/10\/git2.png\" "\\"git2\\"")
<\/a>
\nAlmost all functions are declared as static to be visible only in the translation unit where there are declared.<\/p>\nInside the Linux kernel source code<\/strong><\/p>\n
Let\u2019s switch to the Linux source code and take as an example this function implementation:<\/p>\n
![\"linux11\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux11.png\")
<\/a><\/p>\nThe code looks very clean, indeed the \u00a0function<\/p>\n
- \n
- Has\u00a0only a few lines of code.<\/li>\n
- The signature is well defined.<\/li>\n
- It\u2019s well commented.<\/li>\n
- It\u2019s well indented.<\/li>\n
- The variable names are very clear.<\/li>\n
- the\u00a0const correctness is satisfied.<\/li>\n
- Check the entry parameters and warn if they not satisfy some conditions.<\/li>\n<\/ul>\n
The same \u00a0function could be implemented by another developer like this<\/p>\n
![\"linux12\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux12.png\")
<\/a><\/p>\nThe coding style has a big impact on\u00a0the source code readability, investing some hours to train developers, and doing periodically a code review is always good to make the code easy to maintain and evolve.<\/p>\n
Let\u2019s go inside the Linux kernel source code using\u00a0CppDepend\u00a0<\/a>and discover some basic coding rules adopted by their developers.<\/p>\n
Modularity<\/strong><\/p>\n
Modularity is a software design technique that increases the extent to which software is composed of separate parts, you can manage and maintain modular code easily.<\/p>\n
For a procedural language like C \u00a0where no logical artifacts like namespace, component or class do not exist, we can modularize by using directories and files.<\/p>\n
Here are some possible scenarios :<\/p>\n
- \n
- Put all the source files in one directory<\/li>\n
- Isolate files related to a module or a submodule \u00a0into a specific directory.<\/li>\n<\/ul>\n
In case of the Linux kernel, directories and subdirectories are used to modularize the kernel source code.<\/p>\n
![\"linux15\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux15.png\")
<\/a><\/p>\nEncapsulation<\/strong><\/p>\n
Encapsulation is the hiding of functions and data which are internal to an implementation. \u00a0In C, encapsulation is performed by using the keyword static. These entities are called file-scope functions and variables.<\/p>\n
Let\u2019s search for all static functions by executing the following CQLinq query<\/p>\n
![\"linux17\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux17.png\")
<\/a><\/p>\nWe can use the Metric view to\u00a0have a good idea how many functions are concerned. In the Metric View, the code base is represented by a Treemap. Treemapping is a method for displaying tree-structured data by using nested rectangles. The tree structure used in a CppDepend treemap is the usual code hierarchy:<\/p>\n
- \n
- Projects contain directories.<\/li>\n
- Directories\u00a0contain files.<\/li>\n
- Files\u00a0contains struects, functions\u00a0and variables.<\/li>\n<\/ul>\n
The treemap view provides a useful way to represent the result of a CQLinq request, so we can visually see the types concerned by the request.<\/p>\n
![\"linux2\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux2.png\")
<\/a><\/p>\nAs we can observe many functions are declared as static.<\/p>\n
Let\u2019s search now for the static fields:<\/p>\n
![\"linux3\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux3.png\")
<\/a><\/p>\nThe same remark as functions, many variables are declared as static.<\/p>\n
In the Linux kernel source code, the encapsulation is used whenever the functions and variables must be private to the file scope.<\/p>\n
Use structs to store your data model<\/strong><\/p>\n
In C programming the functions use variables to achieve their treatments, these variables could be:<\/p>\n
- \n
- Static variables.<\/li>\n
- Global variables.<\/li>\n
- Local variables<\/li>\n
- Variables from structs.<\/li>\n<\/ul>\n
Each project has its data model which could be used by many source files, using global variables is a solution but not the good one, using structs to group data is more recommended.<\/p>\n
Let\u2019s search for global variables with a primitive type:<\/p>\n
![\"linux4\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux4.png\")
<\/a><\/p>\nonly very few variables are concerned, and maybe we can group some of them into structs, like (elfcorehdr_addr and\u00a0elfcorehdr_size) or (pm_freezing and pm_nosig_freezing).<\/p>\n
Let function be short and sweet<\/strong><\/p>\n
Here\u2019s from the\u00a0linux coding style web page<\/a>, an\u00a0advice about the length of functions:<\/p>\n
Functions should be short and sweet, and do just one thing. They should\r\nfit on one or two screenfuls of text (the ISO\/ANSI screen size is 80x24,\r\nas we all know), and do one thing and do that well.\r\n\r\nThe maximum length of a function is inversely proportional to the\r\ncomplexity and indentation level of that function. So, if you have a\r\nconceptually simple function that is just one long (but simple)\r\ncase-statement, where you have to do lots of small things for a lot of\r\ndifferent cases, it's OK to have a longer function.<\/pre>\n
Let\u2019s search for functions where the number of lines of code is more than 30<\/p>\n
![\"linux14\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux14.png\")
<\/a><\/p>\nOnly a few methods have more than 30 lines of code.<\/p>\n
Function Number of parameters<\/strong><\/p>\n
Functions\u00a0where NbParameters > 8\u00a0might be painful to call and might degrade performance. Another alternative is to provide a structure dedicated to handling arguments passing.<\/p>\n
![\"linux7\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux7.png\")
<\/a><\/p>\nonly 2 methods have more than 8 parameters.<\/p>\n
Number of\u00a0local variables<\/strong><\/p>\n
Methods, where NbVariables is higher than 8, are hard to understand and maintain. Methods, where NbVariables is higher than 15, are extremely complex and should be split into smaller methods (except if they are automatically generated by a tool).<\/p>\n
![\"linux9\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux9.png\")
<\/a><\/p>\nonly 5 functions have more than 15 local variables.<\/p>\n
Avoid defining complex functions<\/strong><\/p>\n
Many metrics exist to detect complex functions, NBLinesOfCode, Number of parameters and number of local variables are the basic ones.<\/p>\n
There are other interesting metrics to detect complex functions:<\/p>\n
- \n
- Cyclomatic complexity is a popular procedural software metric equal to the number of decisions that can be taken in a procedure.<\/li>\n
- Nesting Depth\u00a0is a metric defined on methods that is relative to the maximum depth\u00a0of the more nested scope in a method body.<\/li>\n
- Max Nested loop equals the maximum level of loop nesting in a function.<\/li>\n<\/ul>\n
The max value tolerated for these metrics depends more on the team choices, there are no standard values.<\/p>\n
Let\u2019s search for functions candidate to be refactored:<\/p>\n
![\"linux8\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux8.png\")
<\/a><\/p>\n<\/p>\n
only very few functions could be considered as complex.<\/p>\n
Naming convention<\/strong><\/p>\n
There\u2019s no standard for the naming convention, each project managers could choose what they think it\u2019s better, however, what\u2019s very important is to respect the chosen convention to have an homegenous naming.<\/p>\n
In case of Linux, the structs must began with a lower case, and we can check if it\u2019s true for the whole kernel source code, let\u2019s execute the following query:<\/p>\n
![\"linux5\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/linux5.png\")
<\/a><\/p>\n<\/p>\n
Only 4 structs began with \u201c_\u201d instead of a lower case letter.<\/p>\n
\u00a0Indentation<\/strong><\/p>\n
The indentation is very useful to make the code easy to read,\u00a0here\u2019s from the\u00a0linux coding style web page<\/a>\u00a0 the motivations behind the indentation:<\/p>\n
Rationale: The whole idea behind indentation is to clearly define where\r\na block of control starts and ends. Especially when you've been looking\r\nat your screen for 20 straight hours, you'll find it a lot easier to see\r\nhow the indentation works if you have large indentations.\r\n\r\nNow, some people will claim that having 8-character indentations makes\r\nthe code move too far to the right, and makes it hard to read on a\r\n80-character terminal screen. The answer to that is that if you need\r\nmore than 3 levels of indentation, you're screwed anyway, and should fix\r\nyour program.<\/pre>\n
\u00a0Conclusion<\/strong><\/p>\n
Exploring some known open source projects is always good to elevate your programming skills, especially if they are developed and maintained by experts. No need to download and build the project, you can just discover the code from GitHub.<\/p>\n","protected":false},"excerpt":{"rendered":"
Every project has its own style guide: a set of conventions about how to write code for that project.\u00a0Some managers choose basic coding rules, others prefer very advanced ones and for many projects, no coding rules are specified, and each developer uses his style. It is much easier to understand a large codebase when all … Continue reading “Write Efficient C Code: Learn from Linus Torvalds”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[7,56],"class_list":["post-898","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-c","tag-linus-torvalds"],"_links":{"self":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/898","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/comments?post=898"}],"version-history":[{"count":11,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/898\/revisions"}],"predecessor-version":[{"id":1473,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/898\/revisions\/1473"}],"wp:attachment":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/media?parent=898"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/categories?post=898"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/tags?post=898"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}