The growth and popularity of C continues. The most recent TIOBE index of most popular programming languages saw C in a virtual dead heat with Java, knocking the latter off its perch for the first time in five years.
In his new book, Extreme C (left), Kamran Amini outlines the essential features of the language before moving onto encapsulation and composition, synchronisation, as well as advanced programming – with code samples – and integration with other languages, including C++, Java, and Python.
This extract, exclusive to Developer, explores structures within C, as well as touching on the reasons behind the almost 50-year-old language’s continued longevity.
From the design perspective, structures are one of the most fundamental concepts in C. Nowadays, they are not unique to C, and you can find their twin concepts nearly in every modern programming language.
But we should discuss them in the history of computation when there were no other programming languages offering such a concept. Among many efforts to move away from machine-level programming languages, introducing structures was a great step toward having encapsulation in a programming language. For thousands of years, the way we think hasn’t changed a lot, and encapsulation has been a centric means for our logical reasoning.
But it was just after C that we finally had some tool – in this case, a programming language – which was able to understand the way we think and could store and process the building blocks of our reasoning. Finally, we got a language that resembles our thoughts and ideas, and all of this happened when we got structures. C structures weren’t perfect in comparison to the encapsulation mechanisms found in modern languages, but they were enough for us to build a platform upon which to create our finest tools.
You know that every programming language has some Primitive Data Types (PDTs). Using these PDTs, you can design your data structures and write your algorithms around them. These PDTs are part of the programming language, and they cannot be changed or removed. As an example, you cannot have C without the primitive types int and double.
Structures come into play when you need to have your own defined data types, and the data types in the language are not enough. User-Defined Types (UDTs) are those types which are created by the user and they are not part of the language.
Note that UDTs are different from the types you could define using typedef. The keyword typedef doesn’t really create a new type, but rather it defines an alias or synonym for an already defined type. But structures allow you to introduce totally new UDTs into your program.
Structures have twin concepts in other programming languages, for example, classes in C++ and Java or packages in Perl. They are considered to be the typemakers in these languages.
Why user-defined types?
So, why do we need to create new types in a program? The answer to this question reveals the principles behind software design and the methods we use for our daily software development. We create new types because we do it every day using our brains in a routine analysis.
We don’t look at our surroundings as integers, doubles, or characters. We have learned to group related attributes under the same object. But as an answer to our starting question, we need new types because we use them to analyse our problems as a higher level of logic, close enough to our human logic.
Here, you need to become familiar with the term business logic. Business logic is a set of all entities and regulations found in a business. For example, in the business logic of a banking system, you face concepts such as client, account, balance, money, cash, payment, and many more, which are there to make operations such as money withdrawal possible and meaningful.
Suppose that you had to explain some banking logic in pure integers, floats, or characters. It is almost impossible. If it is possible for programmers, it is almost meaningless to business analysts. In a real software development environment that has a well-defined business logic, programmers and business analysts cooperate closely. Therefore, they need to have a shared set of terminology, glossary, types, operations, regulations, logic, and so on.
Today, a programming language that does not support new types in its type system can be considered as a dead language. Maybe that’s why most people see C as a dead programming language, mainly because they cannot easily define their new types in C, and they prefer to move to a higher-level language such as C++ or Java. Yes, it’s not that easy to create a nice type system in C< but everything you need is present there.
Even today, there can be many reasons behind choosing C as the project’s main language and accepting the efforts of creating and maintaining a nice type system in a C project and even today many companies do that.
Despite the fact that we need new types in our daily software analysis, CPUs do not understand these new types. CPUs try to stick to the PDTs and fast calculations because they are designed to do that. So, if you have a program written in your high-level language, it should be translated to CPU level instructions, and this may cost you more time and resources.
In this sense, fortunately, C is not very far away from the CPU-level logic, and it has a type system which can be easily translated. You may have heard that C is a low-level or hardware-level programming language. This is one of the reasons why some companies and organisations try to write and maintain their core frameworks in C, even today.
Interested in hearing industry leaders discuss subjects like this and sharing their use-cases? Attend the co-located 5G Expo, IoT Tech Expo, Blockchain Expo, AI & Big Data Expo, and Cyber Security & Cloud Expo World Series with upcoming events in Silicon Valley, London, and Amsterdam.