Follow+Star Public Account Number, don’t miss out on exciting content
Source | Internet
The C language has been around for over fifty years, making it one of the elder statesmen among high-level programming languages.
Overview
No technology can last for 50 years unless it is genuinely better than most alternatives—especially in the computer industry. Since its inception in 1972, C has remained vibrant and is still one of the foundational building blocks we use to construct the software world today.
However, sometimes a technology persists simply because people have not yet invented something new to replace it. Over the past few decades, many other languages have emerged—some explicitly designed to challenge C’s dominance, while others have attempted to gradually undermine C’s supremacy through their popularity.
Arguing that C needs to be replaced is easy. Research in programming languages and software development practices suggests better ways to accomplish tasks than C. Yet, after decades of research and development, C’s position remains solid. Few other languages can outperform it in terms of performance, bare-metal compatibility, or versatility.
C vs. C++
Of course, C is most often compared to C++, as its name implies that C++ was created as an extension of the C language. The differences between C++ and C can be summarized as C++ being broader (in a positive sense) or more extensive (in a negative sense), depending on whether you ask a C or C++ programmer. (Laughs)
While C++ retains a C-like syntax, it offers many practical features that are not available in native C: namespaces, templates, exceptions, automatic memory management, and more. Projects requiring top-tier performance, such as those involving databases or machine learning systems, are often written in C++ to extract and utilize every bit of performance possible.
Moreover, C++ is continuously expanding more aggressively compared to C. The upcoming C++20 will introduce more features for developers, including modules, coroutines, synchronization libraries, and concepts that make templates easier to use. The latest version of the C standard has only seen minor updates, focusing on maintaining backward compatibility.
In fact, all the additional features in C++ can also become burdensome. The more C++-specific features you use, the higher the complexity introduced, making it more challenging to correct outcomes. Developers who limit themselves to a subset of C++ can avoid many serious pitfalls and additional burdens during development. However, some teams want to fundamentally guard against C++’s excessive complexity. Sticking with C forces developers to confine themselves to a subset. For instance, the Linux kernel development team has directly avoided C++.
Choosing C over C++ is feasible for you—and for any developers who will maintain your code—by adopting a strict minimalist approach to avoid entanglement with C++’s complexity. Of course, C++ has rich advanced features, which are justified in their own right. But if minimalism suits the current and future projects—and the teams responsible for them—then opting for C is wiser.
C vs. Java
For decades, Java has remained one of the mainstays of enterprise software development—and broadly speaking, one of the mainstays of development overall. Many of the most significant enterprise software projects are written in Java—including the vast majority of Apache Software Foundation projects—and Java remains a viable language for developing enterprise-level demand projects.
Java’s syntax borrows heavily from C and C++. However, unlike C, Java does not compile to native code by default. Instead, the Java Runtime Environment (JVM) JIT (Just-In-Time) compiles Java code to run in the target environment. In appropriate circumstances, JIT-compiled Java code can approach or even exceed C’s performance.
The philosophy behind Java’s “write once, run anywhere” also allows Java programs to run on target architectures with relatively few adjustments. In contrast, while C has been ported to many architectures, any given C program may still require tailoring to run correctly between, say, Windows and Linux, two different operating systems.
This combination of portability and powerful performance, along with a vast ecosystem of software libraries and frameworks, makes Java the preferred language for building enterprise applications.
Where Java falls short compared to C is in an area where Java never intended to compete: operating close to the underlying structure or directly interacting with hardware. C code is compiled into machine code, executed directly by the process. Java is compiled into bytecode, which is then interpreted into machine code by the JVM. Furthermore, while Java’s automatic memory management is an advantage in most cases, C is better suited for situations that must fully utilize limited memory resources.
That said, in some respects, Java can approach C in speed. The JVM’s JIT engine optimizes routines at runtime based on program behavior, allowing for many types of optimizations that are not achievable in pre-compiled C. While Java runtime automatically handles memory management, some newer applications can address this issue. For example, Apache Spark partially optimizes in-memory processing by using custom memory management code that bypasses the JVM.
C vs. C# and .Net
Nearly twenty years after its launch, C# and the .Net framework remain major components of the enterprise software world. Some say C# and .Net are Microsoft’s response to Java—a managed code compiler system and a common runtime library—many comparisons between C and Java also apply to C and C# or .Net.
Like Java (and to some extent Python), .Net offers portability across various platforms and a vast integrated software ecosystem. Given how much enterprise development occurs in the .Net world, these are significant advantages. When you develop programs using C# or any other .Net language, you can leverage a wealth of tools and libraries written for the .Net runtime.
Another advantage of .NET similar to Java is JIT optimization. C# and .Net programs can be pre-compiled like C, but they are primarily JIT-compiled by the .Net runtime, using runtime information for optimization. JIT compilation allows for various in-place optimizations for .Net programs that cannot be performed in C.
Like C, C# and .Net provide various mechanisms for direct memory access. Heap, stack, and unmanaged system memory can all be accessed through .Net APIs and objects. Developers can use the unsafe mode in .Net to achieve higher performance.
However, these come at a cost. Managed and unmanaged objects cannot be freely interchanged, and marshaling between them can degrade performance. Therefore, maximizing .Net application performance requires keeping the movement between managed and unmanaged objects to a minimum.
If you cannot afford the performance loss caused by the movement between managed and unmanaged memory, or if the .Net runtime is a poor choice for the target environment (e.g., kernel space) or may not be available at all, then C is what you need. Unlike C# and .Net, C is by default capable of unlocking access to memory.
C vs. Go
Go’s syntax borrows heavily from C—using braces as delimiters, statements ending with semicolons, and so on. Developers proficient in C can typically transition to Go effortlessly, even with Go’s unique features like namespaces and package management, which are not difficult for developers to grasp.
Code readability is one of Go’s guiding design goals: to allow developers to easily grasp any Go project and quickly become proficient with the codebase. C codebases can be challenging to understand, as they can easily accumulate project- or team-specific macros and #ifdefs. Go’s syntax and its built-in code formatting and project management tools are designed to avoid such structural issues.
Go also provides additional features like goroutines and channels, which are language-level tools for handling concurrency and messaging between components. In C, developers must manually implement these or rely on external libraries, but Go provides these features out of the box, making it easier to build software that requires them.
The most profound difference between Go and C lies in memory management. By default, Go’s objects are automatically managed and garbage collected. This is very convenient for most programming tasks. However, it also means that any program requiring deterministic memory handling becomes more challenging to write.
Go does include an unsafe package for bypassing certain types of type safety, such as reading and writing arbitrary memory using Pointer types. However, using unsafe comes with a warning that programs written with it “may be non-portable and not protected by the Go 1 compatibility guidelines.”
Go is well-suited for building command-line utilities and network services, as these rarely require overly detailed operations. However, for low-level device drivers, kernel-space operating system components, and other tasks requiring strict control over memory layout and management, it is better to use C.
C vs. Rust
In some respects, Rust is a response to the memory management challenges posed by C and C++, as well as many other shortcomings of these two languages. Rust compiles to native machine code, so in terms of performance, it is considered comparable to C. However, memory safety is Rust’s primary selling point by default.
Rust’s syntax and compilation rules help developers avoid common memory management errors. If a program has a memory management issue that violates Rust’s syntax, it will not compile. Newcomers to this language, especially those previously familiar with C, often find that they must learn how to appease the compiler, as C allows ample room for such bugs. However, Rust advocates argue that this short-term pain yields long-term rewards: safer code that does not slow down performance.
Rust also improves upon C through its tooling. By default, project and component management is part of the Rust toolchain, similar to Go. There is a default, recommended way to manage packages, organize project folders, and handle many other tasks that C requires to be managed separately, with each project and team handling them differently.
However, what is touted as an advantage in Rust may not be very appealing to C developers. Rust’s compile-time safety features cannot be disabled, so even the smallest Rust programs must adhere to Rust’s memory safety constraints. By default, C may be less safe, but it is more flexible and forgiving when necessary.
Another potential drawback is the size of the Rust language. Even considering the standard library, C’s feature set is relatively small. Rust’s feature set is vast and continually growing. Like C++, a larger feature set in Rust means more powerful capabilities, but it also means higher complexity. C is a smaller language, easier to model in the mind, and may be better suited for projects that are too small for Rust to warrant significant effort.
C vs. Python
Today, whenever software development is discussed, Python seems to always come up in the conversation. After all, Python is “the second-best language for all projects” and undoubtedly one of the most versatile languages, with thousands of third-party libraries.
The emphasis of Python, and what distinguishes it most from C, is favoring development speed over execution speed. A program that might take an hour to write in another language—like C—could be completed in minutes with Python. On the other hand, that program might execute in C in a few seconds but take a minute to run in Python. (A good rule of thumb: Python programs typically run an order of magnitude slower than their C counterparts.) However, for many tasks on modern hardware, Python is fast enough, which is a significant reason for its widespread use today.
Another major difference is memory management. Python programs are entirely managed by the Python runtime, so developers do not have to worry about the details of allocating and freeing memory. But similarly, the ease for developers comes at the cost of runtime performance. Writing C programs requires strict attention to memory management, but the resulting programs are often the gold standard for pure machine speed.
However, at a fundamental level, Python and C share a deep relationship: the Python runtime reference is written in C. This allows Python programs to wrap libraries written in C and C++. Many important modules in the Python ecosystem of third-party libraries, such as those in machine learning, have their core in C code.
If development speed is more important than execution speed, and if most high-performance parts of the program can be isolated into independent components (rather than spread throughout the code), then pure Python or a mix of Python and C libraries may be a better choice than using C alone.
Otherwise, Python would not have achieved its current success.
Disclaimer:This article’s material is sourced from the internet, and the copyright belongs to the original author. If there are any copyright issues, please contact me for removal.
———— END ————
● Column “Embedded Tools”
● Column “Embedded Development”
● Column “Keil Tutorials”
● Selected Tutorials from the Embedded Column
Follow the public accountReply “Add Group” to join the technical exchange group according to the rules, reply “1024” to see more content.
Click “Read the original text” to see more shares.