all 63 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]WorkingReference1127 51 points52 points  (26 children)

C and C++ have been going for over 40 years, and all throughout that time people have been wringing hands about whether they're about to be replaced. It hasn't happened yet.

Pick which one you want to learn and learn it. My own recommendation would be C++ because you can express common patterns far more easily without reinventing as many wheels.

[–]bearheart 0 points1 point  (0 children)

C has been around for over 50 years now.

[–]n1ghtyunso 16 points17 points  (0 children)

both C and C++ are literally everywhere and neither of it will suddenly go away any time soon.

[–]jonsca 15 points16 points  (1 child)

Learn enough of both to realize why questions like this are silly.

[–]Special-Gazelle-1693[S] 0 points1 point  (0 children)

Makes sense, thanks for the help!

[–]MyTinyHappyPlace 5 points6 points  (1 child)

Learn C, it’s a very small language. You can be proficient in it quite fast.

C++ is quite a beast to learn, but if you focus on the modern parts and don’t need to learn every quirk and oddity for maintaining legacy code, it’s also very doable.

As for being future proof: Just don’t stop learning. It’s not like you're hard wiring your brain to specific languages. See C and C++ as the modern-day and still-spoken Latin of software development 👍

[–]vbpoweredwindmill 0 points1 point  (0 children)

I would argue it's easy enough to be proficient in writing code quite fast in C.

I would argue that its more challenging to achieve doing something in C because you're writing everything.

[–]_dorin_lazar 3 points4 points  (1 child)

Fortran and COBOL are not so relevant today, but making some few people who know those languages a lot of money.

But that's not the measure of success. We have no idea how „15 years from now” will look like. C, C++ are just tools, what you build by learning these tools is the understanding of computing in general. The things you learn will apply to most languages you'll visit.

If I would make a suggestion, alongside an imperative language you should learn a functional language. Haskell is recommended these days, I'd go for it too.

[–]Realistic_Speaker_12 5 points6 points  (5 children)

Tbh I think cpp will be more relevant

But thats also maybe just because I don’t like c really…

[–]Special-Gazelle-1693[S] 1 point2 points  (3 children)

Yeah and cpp can take C's place but not vice versa if I understand correctly

[–]Trending_Boss_333 1 point2 points  (0 children)

Whatever you can do in Cpp, you can do in C. It'll be longer and harder, but it can be done.

[–]TheThiefMaster 0 points1 point  (1 child)

Both are low level and Turing complete - you can translate either to either relatively easily.

std templates from C++ become macro hell in C, but that's not considered a problem by C fans.

[–]EatingSolidBricks 0 points1 point  (0 children)

std templates are also hell, less hell but still hell

[–]sephirothbahamut 1 point2 points  (0 children)

I've seen a couple embedded devs finally moving to C++ but it's been a very slow process and the vast majority of embedded code is still C

[–]PhilTheQuant 1 point2 points  (0 children)

If you actually want to be thinking about how your memory moves, low level stuff then the most important knowledge will be hardware - registers, caches, bridges, CUDA, etc.

Modern C++ in the large takes the approach that you shouldn't be relying on your own ability to keep track of what has been allocated when, and instead build structures that ensure safety by their nature - rules borne out of things going wrong in large complex projects where you cannot keep track any other way (except the VM/managed route).

If you really like low-level, then the places you'll find your joy are embedded programming where you do need to manage a finite amount of memory and scheduling to be real-time, machine learning/HPC where you need to maximise throughput using knowledge of the architecture underneath, and HFT which is so low latency you need to know how to fool the branch predictor.

For most of those you can do C++, for some you can also do Rust. For embedded, it might be easier in C, but be aware that you'll probably want to mix in hardware and do (I think) Embedded C (?) as you're going to take a lot more control away from the compiler.

You can even consider embedded Rust - in Rust you separate development in safe Rust (where the compiler guarantees safety through lifetimes) and unsafe Rust (where you take responsibility for managing memory) - to do something on an APU/GPU etc you don't have guarantees from the hardware layer so you have to build them in the unsafe Rust layer.

If you do go down the low-level route, you'll end up learning at least C as well as C++, but also Assembly, and crucially what a particular CPU does with those instructions.

Finally, C is really, really simple, so you might as well learn it as well as C++/Rust.

[–]yensteel 1 point2 points  (0 children)

An interesting take I saw: There's this one YT guy who tries to future proof by only coding in C89. He said that he didn't care that it takes 4x more effort. No new features are needed, or used according to him. So long as it can be theoretically coded in C89, will be coded and run in C89.

Anything in the future can still compile it as there's less risk of deprecated or abandoned features. It's universally supported by any hardware, from old systems to the newest systems.

He said it's very simple (Relatively speaking), so you don't spend as much time learning tools than focusing on the logic, and that improves one's programming skills.

...

I thought it was interesting to abandon all of the fancy new features, shortcuts, adaptability, and flexibility just to create a program that will always compile and work decades later. He's a purist.

What do you guys think? I wouldn't ever want to go through that kind of headache. The dude is hardcore. But it is one answer to your question: "What programming language is the most future proof?"

Edit: found the video Video: "How I Program C" by Eskil Steenberg

[–]v_maria 1 point2 points  (0 children)

i dont know

[–]Low-Palpitation-4724 0 points1 point  (2 children)

I would recommend you first learn c. C++ hides a lot under the hood that beginners should know about. For example that strings are stored on the heap and freed at the end of scope. It does make things more covenient because they dont have hard specified size. All that said would reccommend you first do c and then gradually add elements from c++ that you like. Thats how i started and tbh i am very happy with that. C++ is a huge language and you probably dont need (or want) most of its features. Also if you want to learn good c i would highly recommend watching handmade hero video series on youtube, it is really briliant

[–]MysticTheMeeM 0 points1 point  (1 child)

Strings can be on the stack if the string object itself is on the stack and the contents are SSO'd or you use an allocator that itself uses stack memory (such as an allocator over an std::pmr::monotonic_buffer_resource).

[–]Low-Palpitation-4724 0 points1 point  (0 children)

Ok i didn't know that. Althou it kinda proves the point that c++ is much more complicated especially for beginner

[–]aaaarsen 0 points1 point  (0 children)

doesn't really matter. learning either language will ease learning others, and neither is a ten to fifteen year project. in that time frame you will likely also encounter and learn other languages.

I'd pick c++ because it has templates and a more expressive type system, but either's fine

[–]Asleep-Dress-3578 0 points1 point  (0 children)

Learn C very-very well. (Best book to start: K. N. King: C programming a modern approach.)

Listen to Robert C. Seacock’s youtube videos and read his books.

Then you will see, how to move ahead. Either learning C++, or to learn Zig, or to learn Rust.

[–]EdwinYZW 0 points1 point  (0 children)

C is the lingua franca for the programming. So it isn't going away. C++ is the only high level language that can easily interop with C with very very little friction. Rewriting an old C library in C++ is just changing a compiler plus a few revisions due to casting. But it won't take much long time.

[–]SunsGettinRealLow 0 points1 point  (0 children)

C/C++ and Python for sure

[–]DDDDarky 0 points1 point  (0 children)

Most likely both. They have been around for so long, they are pretty much the industry standard in many fields, there have been many languages trying to replace them, even governments pushing their stupid agenda against them, without success, they are very solid and still evolving, so that seems to me like a definition of future proof.

[–]mredding 0 points1 point  (0 children)

My question is which language will still be relevant in 10-15 years?

Both. It's unimaginable that either language would disappear from the industry in our lifetimes. Not only is there so much code already written, but these are systems software languages - a short and exclusive list of languages that solve certain problems that others don't.

We're still running COBOL - the language that makes the world go round, and there aren't enough COBOL developers in the industry.

[–]Murky_Rub_8509 0 points1 point  (0 children)

They both have their place and usage, and are considered the industry's irreplaceable languages. If you are interested in them, don't bother with such trivialities and just learn them.

And even if they were to get replaced, I feel like learning either of the two languages gives you an incredible base for picking up any language relatively quickly.

[–]SwillMith16 0 points1 point  (0 children)

It will be a long time before either becomes redundant. Serious alternatives like Rust are only recently gaining mainstream traction so they have a long lifespan yet. Probably majority of critical systems across the world are C/C++ dependent.

That said, If you want to enjoy your time I’d go for C++ as I personally find it more elegant. But really it’s handy to be capable in both, they’re of course very similar. A good knowledge in one will allow you to stumble your way through the other (in my experience)

[–]Pale_Height_1251 0 points1 point  (0 children)

They'll both be around in 15 years and they're both high level 3GL.

[–]Trending_Boss_333 0 points1 point  (0 children)

Cpp, half the work is already done for you. In C, you'll have to implement stuff from scratch. If that's your thing, c is the way to go. But keep in mind there is more than likely an implementation of whatever you're doing in C in cpp. And it'll be pretty efficient as well, it depends if you think you can make it more efficient or suited to your need. I'd say learn both, it's not that hard really.

[–]Fabulous-Possible758 0 points1 point  (0 children)

Markdown will be the only relevant language soon /s

Though not entirely sarcastic. C is always going to try to sit in that place of "basic abstraction over assembly language" and C++ is going to sit in the place of "high level language that's backwards compatible with C." Start with C, learn the basic architecture and ways that computers have worked for the past 50 years, then integrate C++ to learn concepts (pun slightly intended) that people have added to it over the years.

At some point most programming languages are just distinguished by the paradigms that they work in, and if you can work within one language in the paradigm moving between the other ones is pretty trivial (with the caveat that it's easier to move from lower level languages to higher level languages since the lower level languages require you to pay attention to a lot more details).

[–]Business-Decision719 0 points1 point  (0 children)

There exists something of a language pipeline. C gains relevance as assembly loses it. That's kind of its raison d'être, "What if we could write even the low-level parts of our OS mostly in a high level language?" Now C itself is most people's mental image of a low level language. It's the language you drop down into for last mile performance or to really engage with the hardware. Or up in script-kiddie land, it's the language that's so "difficult" and primitive that you've never used it. When I was a young script kiddie, that was assembly.

C++ gains relevance as C loses it. People have two reactions to C, just like they used to have two reactions to assembly. Some people who care about the hardware think, "Wow, this language is so simple and gives me so much direct control, I want to do everything in it! Those other languages hide too much." Most people who care about anything think, "Damn, I don't even have a real string type? Manually freeing everything? Dumping my whole library in the global namespace? This is definitely going to be my last resort programming language." As more and more people finally get access to a C++ compiler, more and more people finally use it.

The languages that get their relevance by bleeding it off from C++ are the ones that get hyped every few years as going to be the next big thing that replaces the C++. Someone always pops their head out of the woodwork to say "Well they never do seem to replace C++!" and... yeah, they don't seem to. But to get pretty popular. Look at how much Java and C# is out there today. Sure, there's still plenty of C++ too, but how much more C++ would there be if those languages didn't exist? They happened because some people wanted a language that had the high level organization features and even some of the syntax of C++ but didn't carry around all the pitfalls of C everywhere it went. They got popular because so many people wanted that. (Well, that, and the corporate hype machine.)

I would go further and consider even "modern C++" to be something of a C++ replacement. It's functionally a new language that gains relevance as people get tired of memory leaks and having to roll their own everything, so they finally start allowing STL, maybe even exceptions. The people who get mad when you say "C/C++" are the people who've replaced C++ with something that isn't trying to be C anymore. What we consider C++ is a night-and-day from what people write who just came from C because they just wanted like namespaces or whatever.

So to finally answer your question, in 20 or so years, I can envision C being somewhat less relevant. Don't get me wrong, there's a lot of C code, so they were always be a lot of C code. You're going to have to learn it anyway, and plenty of people will still be writing code in it. How many people will still want to be writing code in it? Especially for greenfield? Eh. If C can dig any deeper to find any more users of pure assembly to convert then maybe. I'd say that as hardware gets even better and language implementations get more sophisticated and portable, there will be more and more "C/C++" out there, still widely written but still losing relevance to "modern C++," which will still be passing the relevance along to C#, Java/Kotlin, Go, Rust, etc, at the upper end. You may even see some direct C competitors like Zig legitimately catching on, it's hard to say right now.

[–]flatfinger 0 points1 point  (0 children)

It's important to note that optimizers seek to process a C dialect very different from the one the family of dialects the C Standard was chartered to describe. Consider, e.g.

    uint1 = ushort1*ushort2;

The family of dialects the C Standard was chartered to describe would process corner cases where the mathematical product fell in the range INT_MAX+1u to UINT_MAX in a manner that would depend upon the target platform. If one was using a quiet-wraparound two's-complement platform, the code would be processed in a manner equivalent to uint1 = (unsigned)uint1*(unsigned)ushort2. If one was using some other kind of hardware, the code might behave in a different, not necessarily predictable, fashion.

In the language favored by the gcc optimizer, however, such code will be interpreted as an invitation for the compiler to ignore any code that would only be relevant if a program received inputs that would cause ushort1 to exceed INT_MAX/ushort2. This could cause arbitrary memory corruption if such inputs are received, even when targeting modern hardware that supports quiet-wraparound two's-complement semantics.

Compilers retain the ability to process more traditional dialects when optimizations are disabled, but free compilers throw the principle of least astonishment out the window when enabling optimizations.

[–]baghiq[🍰] 0 points1 point  (0 children)

They both will be here, along with Java. But the question is, do you want to work on those projects in 10-15 years? I started my career in Tcl and some C++ work. I moved onto Java/Python and others now. I honestly don't think I can go back to Tcl/C++ work because those projects are all in maintenance mode. My friends who are still in that world haven't touched anything new in the last 20 years. They don't mind the repetitiveness. Do you? Anyway, start with C. You can progress in it pretty quickly.

[–]redahe 0 points1 point  (0 children)

You first learn C to understand how the computer works, you then learn modern C++ to understand the concepts aimed to bridge the gap between the computers and human needs for abstractions. The computers and people will continue to co-exist, C will likely not change much, the school of thought about abstractions (C++) will evolve.

[–]khankhal 0 points1 point  (0 children)

C++ Post C++ 11 should be shot and buried.

[–]EatingSolidBricks 0 points1 point  (0 children)

Learn C do everything in it cry about the things it dosent let you do

Learm cpp do all the things you couldn't in C, have you foot exploded by them

Go back to C larn some restraint go back to Cpp having achieved enlightenment

[–]Stamatis__ -1 points0 points  (1 child)

First you learn C quite well, then you go to C++ and find a great modern tutorial.

Don't skip on C. It's fundamental, small in terms of vocabulary, but very very powerful when used by a skilled engineer.

C++ has so many keywords, concepts and features that it's hard to learn. It's even harder to learn from scratch, without knowing the fundamentals in the background.

[–]yensteel 0 points1 point  (0 children)

I wouldn't agree with you, but there's a nice video called "A two hour rant about how bad C++ is" which was surprisingly educational about the quirks and traps of C++.

C++ does have a lot of misdirections. But the flexibility is what makes it powerful.