News for hackers. Stuff that matters.
Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Saturday December 05, 2020 @09:50AM (#25314924)
I think using this feature is the wrong advice. Frankly I think much of modern C++ should be rejected. If you want to use a language like with those features then fricken switch language! There are countless better alternatives today: Rust, Swift, D, Haskell etc.

Many are stuck on C++ for legacy reasons. I have worked in such large C++ legacy systems for many years in the past. The average programmer simply cannot deal effectively with this modern C++. It is too complex.

I’ve been down that road being exited about new C++ features only to realize that I’ve actually reduced the productivity of my co-workers.

Often I wonder if C++ programmers all suffer a Stockholm syndrome. They have come to sympathize with their hostage taker C++, making up excuses for the many ways C++ abuse and terrorize them.

I go to these C++ conference talks in occasion and I see people in ecstatic praise about how some genius C++ guru came up with an elaborate convoluted solution to something which is like two lines of code in a sane programming language.

Seriously I think C++ has drained so much of their brainpower that they have simply not been able to look outside and see how the grass is greener everywhere else.

Re:Std::visit is everything wrong with modern C++ (2017) by jasode on Saturday December 05, 2020 @11:40AM (#25315815)
>I think much of modern C++ should be rejected [...] then fricken switch language! There are countless better alternatives today: Rust, Swift, D, Haskell etc.

The reality is that many projects are enabled more by existing libraries & tools rather than blank slate clean language syntax.

Some example domains of libraries & tools where C++ is the 1st-class client instead of Rust/Swift/D/Haskell:

+ deep learning: NVIDIA CUDA api is C++

+ HPC High Perfomance Computing: Intel MKL math library is C++

+ physics engine for video games: Unreal game engine is C++

+ latest cpu chip : ARM Allinea dev tools for the new ARM/Neoverse chips (e.g. latest AWS Graviton2 servers) is C++

+ Qt GUI is C++

Because of the extensive C++ ecosystem, you get a counter-intuitive situation where programming the latest cutting-edge apps requires a 35-year-old language from 1985 instead of the newer Rust language from 2012. I predict this delta of tools+libraries between C++ and Rust/Swift will continue to exist for 10+ years. Recommending/lecturing people to use Rust/Swift/D overlooks the reasons that many programmers use C++. It's not a random choice.

E.g., a realistic starting point for a project might be: "What's a good game engine... oh, it's Unreal, and that's C++." -- instead of -- "Rust has clean syntax of ownership and borrow with "&" ampersand symbol instead of ugly warts of unique_ptr<T> and std::move() in C++ so I'll code a game in Rust."

Sometimes, we look at the ecosystem first, and then work backwards from that to make programming choices.

It's when you have the luxury of a greenfield project that doesn't need legacy dependencies that choosing alternative cleaner syntax of Rust/Swift is possible. Amazon AWS and MS Azure are examples of doing new bare-metal projects with Rust instead of C++.

Re:Std::visit is everything wrong with modern C++ (2017) by guenthert on Saturday December 05, 2020 @12:58PM (#25316644)
To add to that, not all software is written by those who identify chiefly as software-engineers. In, e.g. the embedded world, software is often written by those who are electrical engineers by profession, who use assembler, C, C++, FORTH or Python if they are lucky and rarely venture further. Consequently for some MCUs available tools are only for C/C++ (and of course assembler). Often those engineers are more concerned how much the MCU costs or how much power it dissipates, rather than how elegant the language is they are programmed in. It's a pity, but part of reality.
Re:Std::visit is everything wrong with modern C++ (2017) by ryandrake on Saturday December 05, 2020 @01:57PM (#25317219)
Yea, there is a lot of this in the embedded world. "Software" is just another line item on the BOM, like connectors and bolts. Source it as cheap as possible or find some junior EE in house who barely knows C to do it. That code is going to get written once and never read again.
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @12:18PM (#25316237)
All true. Ironically the main thing keeping C++ relevant is the lack of a standard cross platform ABI. The moment interop with the C++ ecosystem becomes easier, the newer languages look so much more attractive.
Re:Std::visit is everything wrong with modern C++ (2017) by rualca on Sunday December 06, 2020 @03:30AM (#25322041)
> Ironically the main thing keeping C++ relevant is the lack of a standard cross platform ABI.

I find that statement very odd, because in my experience the bane of C++, and perhaps the primary reason to look for alternatives, is C++'s lack of a standard ABI.

The lack of a stable ABI is C++'s main source of bit rot, and the main technical point that justifies migrating projects, even legacy ones, into other programming languages. If not for the ABI issue, most of the technical points used in favour of jumping away from C++ into some bandwagon of the moment would be moot.

Re:Std::visit is everything wrong with modern C++ (2017) by Gibbon1 on Sunday December 06, 2020 @03:57AM (#25322159)
If C++ had a stable defined API then you could just import a C++ library blob into python, or rust, or whatever and it would just work. That you can't is what keeps people developing projects in C++ instead of more productive and sane languages.
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Sunday December 06, 2020 @08:39AM (#25323401)
Yeah, 'ironically' because although your points are quite correct, so are Gibbon1's.

'paradoxically' would have been a better word choice on my part

Re:Std::visit is everything wrong with modern C++ (2017) by spaetzleesser on Saturday December 05, 2020 @10:32PM (#25320780)
Very true. It also makes working with C++ harder. It’s so easy to use different libraries with C#, Java or Python vs the struggle it is to integrate a C++ library.
Re:Std::visit is everything wrong with modern C++ (2017) by matkoniecz on Saturday December 05, 2020 @01:41PM (#25317039)
Exactly - right now I write program in C#. Not because C# is cool or because I like its syntax but because it is what Unity supports.

It could be C++, if I would go with Unreal Engine.

I used Squirrel in past, solely because for some reason it was modding language of OpenTTD.

I am not fan of any of them, I am not an expert in any of them. But it was more effective that writing from scratch 3D engine or AI backend to use something else.

Re:Std::visit is everything wrong with modern C++ (2017) by sideeffffect on Sunday December 06, 2020 @06:25AM (#25322789)
Why not F#? :)
Re:Std::visit is everything wrong with modern C++ (2017) by v-yadli on Sunday December 06, 2020 @07:13AM (#25323010)
I love to write F# (I built FVim), but there's still gap towards high performance game programming. In C# you get a lot of low-level unsafe constructs with zero allocation overhead that integrates very well with the external libraries. In F#, you either get a clumsy library special form (without proper syntax support), or the idea itself is considered "only for C# interop uses" and thus not prioritized.

F# has been in this position: a smaller team that tries to align with C#, without a language implementation team backing them (unlike Roslyn-C#), yet constantly feeding innovations back into the dotnet ecosystem. You can see a lot of example where F# piloted the idea, and later C# adopted and extended it in its own way, and F# struggling to catch up in that OO-centric world

(Disclaimer: MS employee, but not on the language teams)

Re:Std::visit is everything wrong with modern C++ (2017) by matkoniecz on Tuesday December 08, 2020 @05:37AM (#25343719)
Why F#?

I need a good reason to use one more programming language and one more dependency.

Also, how many Unity examples and tutorials and knowledgeable people are using C# and how many F#?

Re:Std::visit is everything wrong with modern C++ (2017) by nyanpasu64 on Saturday December 05, 2020 @08:04PM (#25319958)
I agree with most of your post, but I think MKL is Fortran and C/C++, and implements the BLAS API. I recall that BLAS has a Fortran interface and a CBLAS (C, not C++) interface, and I used the latter. And Rust can call out to C ABI code.
Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:27PM (#25316315)
(Small periodicity note here: Rust 1.0 was in 2015, not 2012. This makes your point even stronger, imho)
Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Saturday December 05, 2020 @12:34PM (#25316383)
How about Nim, which transpiles to C++ and therefore has first-class support for C++ interop?
Re:Std::visit is everything wrong with modern C++ (2017) by matkoniecz on Saturday December 05, 2020 @01:44PM (#25317073)
So to solve overly large C++ complexity I will add further layer increasing complexity?

And add critical third-party dependence?

And learn one more programming language that is rarely used?

Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Saturday December 05, 2020 @02:41PM (#25317627)
We're talking about what language you can use instead of C++, without losing access to C++ libraries. Nim doesn't have the unnecessary complexity of C++, and being rarely used is not a problem. How does it add “third-party dependencies”?
Re:Std::visit is everything wrong with modern C++ (2017) by matkoniecz on Tuesday December 08, 2020 @05:41AM (#25343731)
In this case Nim is “third-party dependency”.

"being rarely used is not a problem" it is a problem if I want to find docs, tutorials or people with more experience willing to help me

"instead of C++" as soon as something breaks I will need to debug both Nim and C++

Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Sunday December 13, 2020 @04:15AM (#25405301)
When it's the language you're using, it's a first-party dependency.

The official tutorial and manual is great and comprehensive. There are many kind people with more experience on the Nim forum.

You won't need to debug C++, just like you don't need to debug JavaScript if you transpile to it from, say, CoffeeScript or Dart.

Re:Std::visit is everything wrong with modern C++ (2017) by rualca on Sunday December 06, 2020 @03:32AM (#25322049)
> We're talking about what language you can use instead of C++, without losing access to C++ libraries.

Congratulations, your suggestion requires you to maintain two entirely separate languages, one of which is not standard nor mature, not to mention maintaining interoperability bugs.

Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Sunday December 06, 2020 @05:10AM (#25322476)
Umm you don't need to maintain two languages. And who cares about a language being “standard”?
Re:Std::visit is everything wrong with modern C++ (2017) by nimmer on Tuesday December 08, 2020 @09:05PM (#25354486)
If someone replaces complex and difficult code using a good, lean and fast library it would be an improvement.

And yet you could argue that it's "adding further layer / critical third-party dependence" and so on.

Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Saturday December 05, 2020 @11:26PM (#25321031)
> The reality is that many projects are enabled more by existing libraries & tools rather than blank slate clean language syntax.

As I said, sometimes for legacy reasons you must use C++. My point is to use a sane subset of C++ an ignore the modern crap. You are only going to make life harder for co-workers, and future maintainers. If the modern C++ features themselves are what attracts you specifically to C++ rather than some library you need to use, then that is when I suggest switching language.

> deep learning: NVIDIA CUDA api is C++

You can do deep learning much better in Julia. It is a nicer language, allow iterative development in a REPL and will typically give you higher performance as well.

And who on earth does machine learning in C++? People typically use Python today. C++ is an implementation detail. A necessary evil for a slow language like Python. But given a choice people pick Python as their interface, not C++, because C++ is a horrible language to use, which you should only use when you absolutely have to.

> HPC High Perfomance Computing: Intel MKL math library is C++

Again you could actually use Julia for that. Next generation climate models running on super computers is built in Julia, specifically because it is fast. A language with 1/10th the cognitive load of C++.

> physics engine for video games: Unreal game engine is C++

Sure, as I said, sometimes you need to use C++ for legacy reasons. But who on earth writes the game logic in C++? Typically you use Lua, JavaScript, GDScript or something else because people don't use C++ when they can avoid it. Historically it has been hard to avoid C++ when creating a physics engine, because you need the kind of high level performance and memory control C++ gives.

> Qt GUI is C++

Yes, which I have spent a lot of my career coding. And which cannot be compared to the insanity of modern C++. Qt tries to keep C++ somewhat sensible.

I could add VTK. Old school C++, which is fairly readable, unlike modern C++. As I said if you have some deep geek desire for fancy language features, find another language.

> Recommending/lecturing people to use Rust/Swift/D overlooks the reasons that many programmers use C++. It's not a random choice.

Problem is that you missed my central point. I didn't say you could go out and replace C++ in every instance with any of these languages. I specifically made it clear that for legacy reasons that may not be possible. And yes that may include that the functionality you need only exists in C++. My point was to write your code in cold old C++, which most people can actually somewhat fathom. If you want to geek out, C++ is a terrible place to do it.

> What's a good game engine... oh, it's Unreal, and that's C++.

Yeah... so Unreal Script was made because C++ is such an amazing language? You know I use Godot Engine, mostly written in C++, but I don't have to relate to that fact. I just code in GDScript. Fortunately the makers of Godot was no so sadistic as to require their users to code in C++.

> It's when you have the luxury of a greenfield project that doesn't need legacy dependencies that choosing alternative cleaner syntax of Rust/Swift is possible.

I think you are kind of overselling the need for using C++. You fail to mention in any of your examples that C++ is very frequently wrapped and not the preferred interface. E.g. TensorFlow is written in C++, but who the hell interface with it from C++? No, people use Python as much as possible.

Or how about Qt. The most popular way to create Qt GUI code today is through QML, not through their C++ APIs. You also failed to mention that in most game engines such as Unreal you can do almost your entire game in a script language. It is typically only the Engine designers who have to program in C++.

You have to consider each case, but frequently wrapping C++ works just fine and may make you a lot more productive. VTK is written in C++ but it is also frequently if not mostly used through bindings to other languages.

If you cannot wrap C++, then embedding a script language may work well. I have written simple game engines in C++ with Lua. I found myself pushing more and more functionality over to my Lua layer as I experienced how much productive language that was.

Re:Std::visit is everything wrong with modern C++ (2017) by andi999 on Monday December 07, 2020 @10:32AM (#25333076)
originally CUDA is C. C++ came later.
Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @10:17AM (#25315121)
Maybe there's some truth to what you're saying. But at the same time, there aren't many alternatives that tick all the boxes C++ does (performance, portability, maturity and stability). Together with the amount of C++ code that exists, I don't see C++ going away anytime soon.

Ironically, if one wants all of those things, the best alternative at the moment may be the C language.

Re:Std::visit is everything wrong with modern C++ (2017) by jandrewrogers on Saturday December 05, 2020 @11:44AM (#25315852)
A major feature of modern C++, and one of the most difficult to replace, is its expressiveness and optional strictness. You don't get this with C (or most other languages). The metaprogramming and compile-time facilities for example, while complex, are indispensable for some code bases. This becomes evident when you try to port rigorous modern C++ code bases to other programming languages du jour. A surprising amount of C++ is difficult to express with equivalent behavior and performance in a similar amount of code.

I play around with new system languages by implementing parts of database engines (typically written in modern C++) in the new language. It terms of abstract code architecture, you can port a C-style database design with relative ease -- most new system languages aim to be an improved C with direct portability in mind -- but not modern C++-style database design, and the latter is unambiguously superior for performance and correctness when writing database engines. C++ will continue to see a lot of usage as long as it is difficult or impossible to write code in other languages that is functionally equivalent to C++.

Re:Std::visit is everything wrong with modern C++ (2017) by ncmncm on Saturday December 05, 2020 @12:51PM (#25316563)
This.

For C++, the overarching criterion for almost any language feature is how useful it is for capturing semantics in an easy-to-use, performant, powerful, and generally usable library.

The consequence is that using new core language features in non-library code often seems unnecessarily complicated, but a library constructed using the feature as intended is insanely powerful.

The result is that you can write libraries in C++ you cannot write in other languages, and you can call into libraries that are so powerful only from C++.

In most other languages, using a library means you give something up: usually performance, and often it comes with restrictions. The standard of usefulness for C++ libraries is very high, and always increasing.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @01:06PM (#25316713)
While this is true in general, we are talking about a library feature that many people want to move into a language feature, specifically because of the drawbacks of it being a library.
Re:Std::visit is everything wrong with modern C++ (2017) by ncmncm on Saturday December 05, 2020 @11:16PM (#25320988)
That a library implementation of pattern-matching would be unsatisfactory exposes a weakness in the core language. Usually, it is better to strengthen the language to the point where a library component can do the job. Sometimes, though, that is too hard, and you give up and do it directly in the core language. It should always be noted as a failing.

Something similar happened with coroutines, although what we did get has hooks that a library should be able to patch into, to achieve wonders not yet seen.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @11:53PM (#25321147)
Yeah, I do agree that this is the best way to go. We'll see!
Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Saturday December 05, 2020 @11:43PM (#25321097)
I have the complete opposite experience. Through my whole career writing C++, that language has been in the way due to all its idiosyncratic behavior. One spends so much time trying to figure out a way around some crazy boiler plate code requirement in C++ only to realize that no, it simply isn't possible to do it in a sane way in C++.

Switching to Swift I felt almost everything worked as it should. It was almost a bit boring not having to deal with all the usual crap that C++ would give me. I am willing to be you can write any C++ system much better in Swift. C++ would probably have a performance edge, but in 95% of cases not enough to be worth dealing with an ugly language like C++.

> C++ will continue to see a lot of usage as long as it is difficult or impossible to write code in other languages that is functionally equivalent to C++.

I would challenge you to give me any language construct that is indispensable for a particular type of program which cannot be done more elegantly in another language and with less headache.

I cannot think of a single feature in C++ which I have ever missed in any other of my preferred languages.

Re:Std::visit is everything wrong with modern C++ (2017) by jandrewrogers on Sunday December 06, 2020 @02:10AM (#25321758)
You likely design very different software systems than I do. I don’t have the luxury of ignoring performance, efficiency, and scalability. I don’t have any particular love for C++, there are many things wrong with it, but sadly there isn’t a practical alternative that doesn’t have worse trade offs. Ironically, I largely refused to use C++ until C++11. I delivered systems in a long list of other languages before that time; my usage of C++ is relatively recent. My choice is pragmatic and based on experience.

If you can’t think of reasons to use C++, that isn’t because reasons don’t exist.

Re:Std::visit is everything wrong with modern C++ (2017) by rualca on Sunday December 06, 2020 @03:37AM (#25322069)
> One spends so much time trying to figure out a way around some crazy boiler plate code requirement in C++ only to realize that no, it simply isn't possible to do it in a sane way in C++.

It seems you're complaining about the outcome of poor and ill-advised engineering practices instead of a programming language.

And your description also covey's the idea that you had people who knew very little about C++ trying to figure out how to use it in ways that they have no idea was possible to use.

I get the appeal of a good scapegoat. Yet, from your description it seems you're trying to dump the blame on a lot of engineering problems you're creating for yourself on a tool.

Re:Std::visit is everything wrong with modern C++ (2017) by a-nikolaev on Sunday December 06, 2020 @01:14AM (#25321537)
Maybe the idiosyncratic BS of C++ is what's hard to express in a saner language? If someone only used hammers all their life, then they will say that a microscope is a bad hammer, which is kind of true =D
Re:Std::visit is everything wrong with modern C++ (2017) by bennofs on Saturday December 05, 2020 @11:51AM (#25315956)
Can you summarise how modern C++ database design differs from C-style design?
Re:Std::visit is everything wrong with modern C++ (2017) by jandrewrogers on Saturday December 05, 2020 @12:51PM (#25316565)
C-style designs rely heavily on macros and aliasing, there is minimal type safety and most correctness properties can only be determined at runtime. Resource management is extremely manual which is both fiddly in the amount of code and error prone. Lots of function pointer passing instead of generics. Macros are used to hide just how tedious a lot of it is but they aren't safe. PostgreSQL is an exceptionally tidy example of a C-style database engine.

In C++-style designs, you end up writing surprisingly little code, having metaprogramming scaffolding generate most of the code for you while doing fairly deep correctness and type safety checks at compile-time. Someone has to write the scaffolding libraries but they aren't that large, just tedious, and they get reused. Resource management, change detection, etc is automagic because C++ makes that easy to hide even in complex cases like DMA I/O. Every data structure and algorithm is highly optimized for the local use case and using the most highly compressed representation reasonable in context. It would be impractical to write all of this code and analyze it manually.

I used to write databases in C99. It required several times the lines of code relative to C++17, with worse results, even if you include the scaffolding libraries. C++17 implementations, done well, is much closer to writing a specification for a subsystem design and behavior and having the compiler generate an optimized implementation for that specification and exporting types that hide the fiddly details that can be safely composed with other generated types, than writing code. The scaffolding is also generic and flexible: some can generate an OLTP database engine just as easily as an OLAP database engine largely by changing the subsystem specifications and composing things differently. This would not be possible without heavy use of the metaprogramming facilities to both generate the types and guarantee that type interactions will still be safe and reasonably optimal.

Re:Std::visit is everything wrong with modern C++ (2017) by noahl on Saturday December 05, 2020 @02:23PM (#25317468)
I'd be curious to know what the libraries are that allow this sort of database engine design. Are there any open source examples?
Re:Std::visit is everything wrong with modern C++ (2017) by jandrewrogers on Saturday December 05, 2020 @11:34PM (#25321060)
I’ve never seen one in open source but I’ve written a couple over the years and seen a few others. It forces you to solve many difficult metaprogramming challenges elegantly so it is a good excuse to achieve some mastery. I’ve burned more hours than I care to admit trying to figure out how to achieve seemingly simple results. Also, until C++17, this was an exercise in masochism due to the limitations of the expressiveness and type inference, which is why so few people tried. Basically, there were a lot of unpleasant rough edges that went away with C++17 because the language wasn’t smart enough previously. C++20 will also be a big step forward for this, whenever the compilers become usable.

One thing to understand is that these libraries are highly opinionated about the abstract architectural model. It doesn’t make a lot of sense to mix components from user space and kernel space designs, for example, though both have advantages separately. It tends to be more along the lines of one abstract architectural model and enormous amounts of elasticity and flexibility within that model based on the data models, workloads, transaction semantics, and hardware you are targeting. You also still have to write a spec that makes sense from a database engineering standpoint.

At least for me, there are still significant parts of a database engine for which I haven’t built a metaprogramming scaffold. That is largely a matter of time and effort. Other parts I haven’t had to write much code for years but still get state-of-the-art implementation to spec.

Ultimately, I’m trying to automate away my job.

Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Saturday December 05, 2020 @11:49PM (#25321124)
The problem with such fancy meta programming in C++, is that while it may be a thrill to program for a C++ wiz you may end up with making something that is completely unmaintainable, because nobody else can grasp what you wrote.

Compare to writing a database system in something like Go. Sure you make end up with 50% more code, but you could have anybody up and running reading and understanding the code within 3 days.

IBM have done studies of this and found that fancy code is not all that valuable. It ends up falling in disuse over time as people don't get it. I have seen my fair share of C++ code which simply had to be tossed because nobody at the company could understand what the previous whiz kid had written.

Re:Std::visit is everything wrong with modern C++ (2017) by jandrewrogers on Sunday December 06, 2020 @01:43AM (#25321660)
That’s the beauty of the evolution of C++. Metaprogramming has become increasingly maintainable, as making it a first-class capability of the language is a core focus of the people designing it. The learning curve is finally low enough that it is practical. I think it is fair to say that C++17 is the first version where that is true.

You can’t write a comparable database engine in Go, fundamentally. The language lacks features required for competitive performance. The code difference will be much more than 50% trying to get the most out of what Go is capable of in this domain.

The point of writing code this way isn’t to be clever or for a “thrill”, it objectively produces superior performance, reliability, and maintainability. Defects scale with the number of lines of code regardless of language. Type safe code gen is a powerful tool.

Re:Std::visit is everything wrong with modern C++ (2017) by krelian on Sunday December 06, 2020 @10:51AM (#25324254)
>The learning curve is finally low enough that it is practical. I think it is fair to say that C++17 is the first version where that is true.

What are the specific C++17 features that make this a reality?

Re:Std::visit is everything wrong with modern C++ (2017) by coliveira on Sunday December 06, 2020 @01:24PM (#25325376)
Just look at the new features in C++17 that simplify the use of templates, like variadic templates, constexpr everywhere, automatic type detection working together with templates, etc. The last versions of C++ are mostly about making using templates easy, which allows programmers to operate at a different level than languages such as Go and Python.
Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @10:48AM (#25315381)
But at the same time, there is no alternative that ticks all the boxes C++ does (performance, portability, maturity and stability).

As you identified yourself, that's not entirely true, because C offers all of those things. But the really tragic thing about the status quo is that because there is so much sunk effort behind the C and C++ ecosystem, the resulting momentum makes it difficult for new languages that are simply better to gain traction.

In a way, C++ is the ultimate demonstration of how important the surrounding tool, library and developer ecosystem is to the success (== usefulness in practice) of a programming language. If the language itself were the dominant factor, the writing would have been on the wall when almost every language at a higher level than C was adding features like first class functions and C++ was trying to do something vaguely similar with overcomplicated binder templates.

A language with nicer syntax for working with higher-order functions, Haskell say, might have used

    xs = [1, 2, 3, 4, 5]
    n = count_if (<3) xs
But for many years in C++, the closest theoretical equivalent would have been to write something like

    xs = // some standard container type, tediously constructed
    n = count_if(xs.begin(), xs.end(), bind2nd(less<int>(), 3))
instead. Obviously hardly any real programmers ever did that, and it's true that modern C++ is better in several relevant ways, but it's been literally decades and it still hasn't entirely caught up.

Meanwhile, several much more promising languages are struggling to break into the kinds of markets they deserve to because they haven't achieved a critical mass of support. And the world continues to suffer the loss of productivity and problems with security and reliability that come from using a language like C++ for things that do actually matter. It's an understandable situation, but still a regrettable one.

Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @10:54AM (#25315412)
> As you identified yourself, that's not entirely true, because C offers all of those things.

You're right, I contradicted myself there a bit. Fixed. But C is almost a subset of C++, except for some technicalities. So it's a bit hard to call it an actual alternative. Switching from C++ to C is more or less a matter of restricting oneself to less functionality (which in some cases is a good thing, but I digress).

Other than C it's hard to point at a solid alternative for many C++ use cases.

> In a way, C++ is the ultimate demonstration of how important the surrounding tool, library and developer ecosystem is to the success

Indeed! This is something that any language wanting to compete with C++ must get right. It's a hard thing to do.

Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @11:29AM (#25315722)
This is something that any language wanting to compete with C++ must get right. It's a hard thing to do.

I suspect it's actually an impossible thing for a new language to do on its own, because it's not really a technical problem in the first place. It needs a new language with a "killer feature" and serious resources backing it to break through. Several of the relatively success new(ish) languages have combined those two attributes, with the language being in some sense the favoured one for writing software that runs on a certain platform.

Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Saturday December 05, 2020 @11:34PM (#25321061)
My point was that you should just use old-school C++ if you need to use C++. If your desire is to use fancy language features, and that is your primary focus, then you should switch language.

People should just accept that they work with a legacy language and not try to turn C++ into Haskell, Rust or something it isn't. They just turn it into a worse mess than it already is.

Most C++ code that exists and which is useful is written in old school C++ anyway and could be continued to be maintained that way and wrapped for other users.

And really C++ performance is IMHO somewhat overrated. It depends entirely on what you are doing. I think it was the CouchDB creator. He made his first version in C++. He struggled hard. Then he switched to Erlang, despite Erlang running on a VM he got magnitudes higher performance and had to write less than half the code.

You know the ones who squeezed the most performance out of the Playstation 2 did it using LISP and not C++. They used LISP to create a DSL for PS2 assembly code. Thus they could do high level LISP coding as well as low level assembly all in one.

And today you got many scientists needing high performance computing switching to Julia. Fortran will usually outperform C++ on number crunching. And there are quite a number of cases where Julia will outperform Fortran.

Yes in real time systems with tight memory requirements something like Julia is not a good choice. But then again in those cause you may actually want to prefer C or Rust.

Re:Std::visit is everything wrong with modern C++ (2017) by arc619 on Saturday December 05, 2020 @11:00AM (#25315462)
Another option is to gradually replace parts of the C++ with Nim code set to output to C++. As such you get the advantages of a high level, low friction language with fast compile times and move semantics, ABI compatibility with C++, and a really nice FFI. You can import or export functions and so on between the languages, use any C++ libraries in Nim (or visa versa), and even directly emit C++ from Nim if required.

Gradually porting like this lets you keep using your code base whilst introducing new or overly complex stuff in a language that's faster and easier to write (usually ends up with less than half the LoC of the equivalent C++ but often way, way less than that). Metaprogramming is also very nice, easier to reason about and perhaps most importantly, even with lots of macros doesn't noticeably affect the fast compiles.

Another advantage is once you have some Nim code you can choose to change the target to C or ObjC (or even JS or LLVM) so you're actually increasing portability.

This all depends on how you rank 'maturity' of course. Nim's been around for longer than Rust and Go IIRC, and it's been rock solid for me but you may have different parameters. It certainly helps being able to directly use libraries for C and C++ if you can't find an appropriate Nim implementation.

Edit: For contrast, consider the challenges in the article for variants in C++, then the equivilent object variants in Nim:

    type
      MyVarKind = enum mvkNumber, mvkString
      MyVariant = object
        case kind: MyVarKind
        of mvkNumber:
          num: int
        of mvkString:
          str: string

    var myVariant = MyVariant(kind: mvkNumber)
    myVariant.num = 1
    myVariant.str = "Oops"  # Error: 'str' is not accessible using discriminant 'kind' of type 'MyVariant'
Re:Std::visit is everything wrong with modern C++ (2017) by FpUser on Saturday December 05, 2020 @11:40AM (#25315804)
How do you deal with debugging?
Re:Std::visit is everything wrong with modern C++ (2017) by arc619 on Saturday December 05, 2020 @12:09PM (#25316147)
In VSCode and Neovim there's a visual debugger but in general you can compile with `--debugger:native` and use GDB, for example:

A guide to debugging and profiling: https://nim-lang.org/blog/2017/10/02/documenting-profiling-a...

Guide for working directly with GDB-Nim: https://internet-of-tomohiro.netlify.app/nim/gdb.en.html

A walk through and extra info with the language devs: https://www.youtube.com/watch?v=DmYOPkI_LzU

Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @12:27PM (#25316316)
But would you then be debugging the automatically-generated C++ code, which is presumably harder to read than the original Nim source code?
Re:Std::visit is everything wrong with modern C++ (2017) by arc619 on Saturday December 05, 2020 @01:42PM (#25317049)
Technically yes, but directives are inserted so GDB reports the line number, source code, and parameters of the Nim file.

However GDB shows the name mangling suffix in generated code, and types are their native types. There's a script called nim-gdb to add pretty printers for types to the GDB output to show the Nim source types.

Perhaps surprisingly though, the C and C++ generated output itself is fairly straightforward, even with name mangling suffixes. The inserted directives tell you the Nim source line so you can navigate it fairly well if you want to, and the suffix means the variable is unique referenced in the code. As far as I know you can use any debugger that supports the target language, though I've not tried anything but GDB myself.

It's very rare for me to dig into the generated code but sometimes I'm curious about the data structure analog in the target language. In the case of Nim's object variants, last time I looked when compiling to C they were ultimately reduced to simple checked union types.

Re:Std::visit is everything wrong with modern C++ (2017) by FpUser on Saturday December 05, 2020 @03:36PM (#25318073)
Looks more or less workable but I guess not as good as what you get in Visual Studio
Re:Std::visit is everything wrong with modern C++ (2017) by arc619 on Sunday December 06, 2020 @04:43PM (#25326936)
Not yet, no. I hope with companies like JetBrains working on their Nim plugin https://plugins.jetbrains.com/plugin/15128-nim we'll see more focus put on a smooth IDE based debugging experience in particular.
Re:Std::visit is everything wrong with modern C++ (2017) by vips7L on Saturday December 05, 2020 @11:19PM (#25321002)
When compiling to C++ does nim use a GC?
Re:Std::visit is everything wrong with modern C++ (2017) by arc619 on Sunday December 06, 2020 @03:51PM (#25326511)
Yes, if the target is C++ then the whole output will be in C++, including code for GC operations, so you can directly inspect how this is translated. You can actually choose between several GCs for different needs: https://nim-lang.org/docs/gc.html

It's worth mentioning that by default all types in Nim are stack allocated, and you have full manual memory management to the same level as C/C++ but with better type safety and less boilerplate. The GC is only used when you tag a type as `ref`, in strings, and the 'vector' dynamic list type, `seq`.

The newer GC, ARC (not related to Swift's ARC), is similar to RAII - scope based, non-atomic, deterministic, shares memory between threads but not stop-the-world, and uses move semantics: https://nim-lang.org/docs/destructors.html

This makes the GC a nice to use addition for resource management but not a fundamental requirement or speed limitation.

In my experience the default (thread-local refc + cycle collection) GC is very performant already, but it's straightforward to write code that works entirely on the stack, or create objects that wrap manual heap allocs, or use custom external memory allocators. Passing `--gc:none` removes the GC entirely from the compilation target, for example if you're working with very constrained embedded devices with the caveat that less of the stdlib is available (currently).

The ARC GC (doesn't handle cycles unlike it's sibling ORC) is aiming to be lean enough to be used in hard realtime and memory constrained embedded systems. For hard realtime though I'd expect most people would just manually manage their types anyway on the heap or stack.

If you're doing interop between Nim and C++ and want Nim's GC to manage types that you're passing directly to pure C++ code, you can tell the GC that the data is still being used with GC_Ref() or not with GC_Unref(). There are a few libraries for C/C++ interop, such as: https://github.com/nimterop/nimterop

Personally in this case I would probably just manually allocate memory memory in Nim or C++ and not use GC'd types across boundaries for clarity if nothing else, still it's an option if your design requires it.

Finally, there is a tool to help auto-translate C/C++ to Nim with the c2nim tool: https://github.com/nim-lang/c2nim and docs: https://github.com/nim-lang/c2nim/blob/master/doc/c2nim.rst

Re:Std::visit is everything wrong with modern C++ (2017) by jeltz on Saturday December 05, 2020 @10:21AM (#25315167)
Rust has all of those other than portability. Rust's ecosystem while it is missing some things it also has things which are lacking in C++ like a good mature package manager.
Re:Std::visit is everything wrong with modern C++ (2017) by cycloptic on Saturday December 05, 2020 @11:02AM (#25315482)
C++ has several package managers, of varying levels of maturity. Here's a few:

https://github.com/conan-io/conan

https://github.com/microsoft/vcpkg

https://github.com/cpp-pm/hunter

Another option if you're on Linux/BSD is to use your native package manager. C++ packages are usually included in those repositories. You also may be able to install Brew, Nix, or Guix on any given distribution.

Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Saturday December 05, 2020 @12:37PM (#25316418)
>Another option if you're on Linux/BSD is to use your native package manager.

There goes the portability.

Re:Std::visit is everything wrong with modern C++ (2017) by cycloptic on Saturday December 05, 2020 @01:09PM (#25316756)
No, portability is easily achieved with those by using containers.
Re:Std::visit is everything wrong with modern C++ (2017) by andi999 on Saturday December 05, 2020 @11:45AM (#25315858)
I never learned rust, but from what I read loving the borrow checker also requires Stockholm syndrom.
Re:Std::visit is everything wrong with modern C++ (2017) by cxvxx on Saturday December 05, 2020 @12:23PM (#25316291)
It's more like snowboarding or any activity with a high initial learning curve before a big payoff: It's hard, even painful, at the beginning, and you might come home covered in bruises, but eventually it "clicks" and it's a lot of fun.

Stockholm Syndrome is more about convincing yourself that a bad situation is good because you're stuck in it. I don't think there are too many people "stuck" with Rust yet. On the contrary, I think the borrow checker is a draw.

Re:Std::visit is everything wrong with modern C++ (2017) by User23 on Saturday December 05, 2020 @10:49AM (#25315386)
> Rust has all of those other than portability.

That's crippling. Arguably the best use case for C++ is coding video games, and portability is huge there.

Re:Std::visit is everything wrong with modern C++ (2017) by stu2b50 on Saturday December 05, 2020 @10:54AM (#25315421)
The modern video game platforms are: PC, Xbox Series, PS5, Xbox One, PS4, Switch, Android, iOS, Web

Of which Rust has backends for all them, even the web via wasm.

While Rust is not as portable, it's not like it's strictly limited to well functioning x86 boxes, it'll produce binaries for anything that LLVM supports, which is quite a lot by now.

Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @10:58AM (#25315449)
> Of which Rust has backends for all them, even the web via wasm.

Are those backends officially supported on consoles? Do all those consoles have libraries and tools (profilers, debuggers, etc) that support Rust?

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:32PM (#25316359)
They are not directly supported by the vendors. That said, tools that work on C and C++ will at least somewhat work on Rust, so you also get sorta kinda half support even if it's not officially supported.

We'll see if this changes in the future, especially with some of the names doing Rust dev in these places.

Re:Std::visit is everything wrong with modern C++ (2017) by bsagdiyev on Saturday December 05, 2020 @11:23AM (#25315677)
Internally I know Sony had a Rust compiler for the PS4, I don’t know much more than that (like if it was used for anything). Just saw the repo was updated quite often so it was definitely still WIP at least, and it had some code samples for console apps. Never tried it on my dev console to see if it worked.
Re:Std::visit is everything wrong with modern C++ (2017) by stu2b50 on Saturday December 05, 2020 @11:22AM (#25315659)
Yep, like in C++ it's trivially easy to use the platforms C apis. And indeed the debugger does work on all platform.
Re:Std::visit is everything wrong with modern C++ (2017) by Torkel on Saturday December 05, 2020 @11:04AM (#25315500)
Modern C++ isn’t all that portable either.
Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @11:10AM (#25315554)
IMHO the last big upgrade to C++ was C++11, which is supported by lots of toolchains. It added move semantics, decent smart pointers, and a crapload of other improvements.

C++14 and C++17 were minor upgrades by comparison, so I'd say C++11 can rightly be called modern C++, though others may disagree.

Re:Std::visit is everything wrong with modern C++ (2017) by ncmncm on Saturday December 05, 2020 @12:54PM (#25316599)
I see that you are wholly unaware of C++20, which (combined with '14 and '17) is as large a step from C++11 as C++11 was from C++98.
Re:Std::visit is everything wrong with modern C++ (2017) by FartyMcFarter on Saturday December 05, 2020 @01:13PM (#25316785)
C++20 is barely out yet, and not supported by any toolchain. If that's the only version that counts as modern C++, then I agree that modern C++ isn't portable :)
Re:Std::visit is everything wrong with modern C++ (2017) by jcelerier on Saturday December 05, 2020 @11:46AM (#25315879)
c'mon, you can run C++17 code on Commodore 64 (https://www.youtube.com/watch?v=zBkNBP00wJE) and MS-DOS (https://www.youtube.com/watch?v=yHrC_rZUaiA), what more do you want ?
Re:Std::visit is everything wrong with modern C++ (2017) by rndgermandude on Saturday December 05, 2020 @11:48AM (#25315909)
I'd argue that Rust is as portable as C++, if not more so, in the sense that there are no real barriers in the language itself that limit portability. It's harder to write un-portable code in Rust than in C++, because a lot less in idiomatic rust is undefined or food-gunable.

Of course when it comes to practical portability today then you're right as there are plenty more C++ compilers for different platforms than Rust compilers (then again, there are more C compilers than C++ in that regard). This may eventually change over time, tho, but it sure is something to consider today.

PS and edit: I don't mind you disagreeing with me, but would anybody care to illuminate me as to what your disagreement is about?

Re:Std::visit is everything wrong with modern C++ (2017) by tester756 on Saturday December 05, 2020 @11:19AM (#25315635)
>performance, portability, maturity and stability

sounds like C# and Java with only performance being questionable, but Java's used in HFT, so it definitely can compete.

Re:Std::visit is everything wrong with modern C++ (2017) by whimsicalism on Saturday December 05, 2020 @11:23AM (#25315674)
> Java's used in HFT, so it definitely can compete.

This is a bad argument and if you're using Java, you're not competing in the very speed-critical parts of HFT. Nor is Java common among HFT shops at all.

well-written C++ is much faster than Java.

Re:Std::visit is everything wrong with modern C++ (2017) by tester756 on Saturday December 05, 2020 @06:39PM (#25319493)
I know people who sit in HK and have been doing HFT/Quant stuff for years and they say something completely different - that Java's popular among biggest trading/stock systems.

So saying that

> Nor is Java common among HFT shops at all.

Sounds weird, especially when it appears among job postings.

Re:Std::visit is everything wrong with modern C++ (2017) by qppo on Saturday December 05, 2020 @11:21AM (#25315655)
GC is usually out the window if you're debating using C++
Re:Std::visit is everything wrong with modern C++ (2017) by dkersten on Saturday December 05, 2020 @11:09AM (#25315540)
When I use C++ (for personal projects), it tends to be because of the libraries I want to use (eg EnTT[1] or Immer[2], both of which use templates so can't be easily used from other languages). Eventually something like Rust or D may have equivalents to all the libraries I want and I could use those for such projects instead, but for now, if I want to use those things, I need to use C++.

You may also want to look at this talk: "What C++ got Right" [3], where the guy shows some nice things that C++ does that other languages don't. The other languages versions of the code he shows does tend to be simpler and nicer, but the C++ versions tend to give you more control. Some people value that control (rightly or wrongly) and other languages that don't provide it will never feel right to them.

I do personally quite like Rust and I'm eagerly watching Zig and some of the other new contenders, so I'm all for moving to something more pleasant than C++, but modern C++ gives just enough new niceness that I don't feel pushed to jump ship until the alternatives check more boxes.

[1] https://github.com/skypjack/entt

[2] https://github.com/arximboldi/immer

[3] https://www.youtube.com/watch?v=bMSrNBcir4Y&t=1757s

Re:Std::visit is everything wrong with modern C++ (2017) by suby on Saturday December 05, 2020 @05:50PM (#25319192)
I'm not replying to detract from your point, because I agree with you whole heartedly that competing ecosystems are not mature enough to dethrown C++ if you're someone who is pragmatic and wants to get things done. C++ has an enormous number of high quality libraries with often no equivalents in competing languages.

There are some compelling ECS frameworks emerging in Rust if anyone is interested, though.

Legion -- https://github.com/amethyst/legion

Hecs -- https://github.com/Ralith/hecs

Shipyard -- https://github.com/leudz/shipyard

Specs -- https://github.com/amethyst/specs

Bevy -- https://github.com/bevyengine/bevy -- not strictly comparable as it's an entire game engine, but it's built around an (imo) more ergonomic fork of hecs.

Some benchmarks -- https://github.com/rust-gamedev/ecs_bench_suite

Re:Std::visit is everything wrong with modern C++ (2017) by dkersten on Sunday December 06, 2020 @05:11PM (#25327111)
There are some great ECS frameworks for a lot of languages these days, but in my personal opinion (rightly or wrongly), EnTT is in a league of its own in terms of features and performance, its very mature, constantly improved, and, possibly the most important part, I have experience using it.
Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Sunday December 06, 2020 @12:04AM (#25321192)
The logic seems a bit circular to me. I cannot imagine you would have even discovered those libraries if not for the fact that you specifically wanted to use C++ libraries. Neither game engines nor immutable data structures is anything special about C++.

You could have used Godot, Unity3D and a whole host of other game engines if you wanted to make a game. If immutable data structures is your thing, wouldn't a functional language be a better fit, such as Haskell?

But I do know the problem you talk about. I have mostly used C++ in the past because you could not get any good GUI libraries in other languages.

I have played around with Zig a bit. Tried Rust earlier, but it seems to me to duplicate many of the things I didn't like about C++: slow compile times, complexity, verbose syntax.

Zig I am still making up my mind about. It looks to be on the right track. But for now I think Swift and Go are pretty good alternatives to C++, a bit depending on what you are making.

Personally I prefer Julia, but that is not exactly a drop in replacement for C++. You don't get fine grained control over memory usage and it is not suited for real time systems or small memory footprint. Zig is great at all those things though. Julia does replace C++ however in most case where you simply need raw number crunching performance, such as simulations, scientific computing, machine learning etc.

Re:Std::visit is everything wrong with modern C++ (2017) by rualca on Saturday December 05, 2020 @11:06AM (#25315512)
> The average programmer simply cannot deal effectively with this modern C++. It is too complex.

I interpret this assertion with a high dose of incredulity and skepticism.

You're specifically referring to a single class that's a part of C++'s standard library.

C++'s standard library is extremely spartan when compared with other programming languages, such as Java.

It's unbelievable that C++'s inclusion of stuff such as std::visit in its standard library renders it "too complex" when the extend and arcane nature of other standard libraries are incomparably higher.

Hell, some toolkits and frameworks are incomparably far more complex and we don't see them accused of being unusable.

Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Sunday December 06, 2020 @12:13AM (#25321241)
I am talking about the total cognitive load of modern C++. Not one specific class.

I highly doubt people express in public that a particular library is too complex. They simply choose not to use it. I remember some Boost Graph library once. What a a mess. I never expressed publicly that I couldn't figure out how do use it. Nobody does that, because nobody wants to appear stupid. Instead I just wrote a graph library in C++ from scratch myself. Discovered that was faster than figuring out the template insanity in that Graph library.

I have worked on usability for a number of years and done usability testing on people. And rarely if ever do anyone ever blame the system. They blame themselves. Or they shut up because they don't want to appear stupid.

That is why when you do usability testing you have to sit an observe people. You cannot rely on questionnaires because people seldom admit the system was complex.

Actually observing a variety of people try to program modern C++, would likely have been a rather sad experience.

Re:Std::visit is everything wrong with modern C++ (2017) by porknubbins on Saturday December 05, 2020 @10:41AM (#25315323)
Its interesting to me that in between the irreducible complexities of hardware/ x86 ops and real world domains C++ has emerged as an middle level of complexity in this stack. You can explore C++ features and syntax for years and there are entire podcasts and conferences that mostly just talk about language features and never run out of things to say. I wonder if some programmers are attracted to this complexity either for the challenge or because they enjoy exploring abstract human made systems.
Re:Std::visit is everything wrong with modern C++ (2017) by mlang23 on Saturday December 05, 2020 @10:46AM (#25315368)
It is not only legacy reasons why people are "stuck" with C++. In embedded and real-time applications, using a high level (GC'ed) language like Haskell is totally out of the question. D and Rust might be feasable, but typically lack the FFI you need for integration. I mention this because I recently wrote a DSP program for a (eurorack) synthesizer module, and C++ was pretty much the only sensible option. And I actually used variant in that codebase, even sending a (trivially copyable) variant over a RT queue to separate RT thread from UI. And std::visit was pretty useful in that context. I dont think it makes sense to rant against particular language/library features. Almost all of them are there fore a reason. It might just be that you dont see the reason right now. The design space for code is huge.
Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Sunday December 06, 2020 @12:15AM (#25321252)
You are specifically describing being stuck with C++ for legacy reasons despite trying to disprove it. You say you cannot use D and Rust because of the FFI needed for integration. How is that not a legacy issue? You got existing C++ code you need to integrate with. How is that not a legacy issue?

What I am talking about is that if you don't have to use a C++ library to solve your task, there is simply no sane reason to pick C++.

Re:Std::visit is everything wrong with modern C++ (2017) by mlang23 on Sunday December 06, 2020 @12:10PM (#25324826)
From such a futuristic point of view, I guess you are right. However, it will likely take a few decades until your wish is granted and everything has been rewritten language X. Calling all interfaces your OS gives you legacy is pretty far stretched man :-)
Re:Std::visit is everything wrong with modern C++ (2017) by FpUser on Saturday December 05, 2020 @11:37AM (#25315792)
I consider myself good architect but I am miles away from being deeply familiar with all of the sourcery of its metaprogramming facilities. I have real things to do and prefer to invest most of my mental efforts to more practical and productive things.

I however do use C++ to write servers and if I do not try to play language guru in my code modern C++ along with the STL feels incredibly easy to use.

[dead]
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @10:30AM (#25315232)
Against massive initial skepticism, I’m becoming very impressed with Rust. I’m now going to be ‘that guy’ - apologies.

After years of being annoyed by Rust people claiming C++ is dying or too unsafe or whatever, I expected this to be another C# - a sort of C-with-training-wheels for people who care more about productivity than perf. Something I could safely ignore.

This ‘borrow checker’ stuff sounds great for kids, but for disciplined experienced C++ guys it’s at best a non feature and at worst would just get in the way, like GC, right?

In fact, I’m finding the reduced mental overhead (not just from borrow, but from the language as a whole being smaller and more consistent) is a huge win. Even learning the language and stdlib as I go.

I’ll still use C++ proudly where it’s the best choice, but I’d put some effort into trying Rust first. As a cpp-master-race guy, that surprised the crap out of me.

Re:Std::visit is everything wrong with modern C++ (2017) by amelius on Saturday December 05, 2020 @10:39AM (#25315303)
Have you tried writing self-referential data structures, like doubly linked lists?
Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @11:02AM (#25315480)
Why would you write your own basic data structures when the standard library provides them for you? I haven't written an implementation of a doubly-linked list by hand in a very long time.

If your point was about explicit ownership being a little more tricky with self-referential structures, that's true, though the existence of std::collections::LinkedList shows that it's entirely possible to manage these structures and at least you still get the benefits of explicit ownership for the structure and the data within it.

Re:Std::visit is everything wrong with modern C++ (2017) by amelius on Saturday December 05, 2020 @11:20AM (#25315648)
> Why would you write your own basic data structures when the standard library provides them for you?

I think the problem with this view is that Rust is not being used as a true programming language (like for implementing algorithms), but more as a "glue language".

If all the interesting stuff has to be done in libraries in "unsafe" mode, and all the uninteresting stuff (gluing) is done with borrow checking, then Rust is more a glue language. Which is fine. But don't call it a general purpose programming language.

Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @11:45AM (#25315870)
I respectfully disagree. Using tools provided by the standard library is common practice in any general purpose programming language. It just means that the algorithms you're implementing can concentrate on the novel aspects that provide additional value and not get bogged down with reinventing wheels for the basic implementation details.

Also, you seem to be suggesting that it's necessary to use unsafe code to implement these data structures in Rust. For something like the doubly-linked lists that were mentioned in an earlier comment, it usually suffices to use tools like Option and Rc for the links and to encapsulate the logic that manages those links inside functions like push_back and pop_back that you are surely defining to mutate your data structure anyway. Is there something specific you have in mind where this kind of strategy doesn't work and unsafe code is the only solution?

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:39PM (#25316442)
Someone above suggests boot::intrusive. Do you also think that means C++ is a "glue language"?
Re:Std::visit is everything wrong with modern C++ (2017) by xigoi on Saturday December 05, 2020 @12:45PM (#25316514)
So any language that doesn't force you to constantly reinvent the wheel is a “glue language”?
Re:Std::visit is everything wrong with modern C++ (2017) by j16sdiz on Saturday December 05, 2020 @11:21AM (#25315657)
I write my own basic structure when I need specific implementation for performance. Most of time its about memory layout or caching a specific internal pointer for some hot code.
Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @11:39AM (#25315797)
Sure, but unless the high performance code you work with is very different in nature to the high performance code I've worked with, you probably have a small set of carefully implemented and probably very well optimised structures in your toolbox and write everything else using them. You do need to deal with the explicit ownership semantics in Rust when you're first implementing those tools, but that's a probably minor inconvenience up front and afterwards things mostly just work like the equivalent data structures in any other programming language, but with the added safety guarantees from the ownership system and borrow checker.
Re:Std::visit is everything wrong with modern C++ (2017) by bluecalm on Saturday December 05, 2020 @11:40AM (#25315818)
Double linked list is just an example. There are other both more useful and harder to generalize structures like various kinds of trees for example. Anyway, if your question is why implement your own data structures then it's very likely C/C++ isn't a proper tool for your job anyway.
Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @11:54AM (#25315992)
There are other both more useful and harder to generalize structures like various kinds of trees for example.

Trees are usually easy because each node has a single parent all the way up to the root and ownership can follow the same hierarchy. More general graphs are a little more tricky, but the same techniques that you can use to implement a specific case like a DLL generalise. For example, in Rust, you can combine Option and Rc to handle, respectively, the intermediate states while the structure is being manipulated and the shared ownership semantics.

Re:Std::visit is everything wrong with modern C++ (2017) by nchi3 on Saturday December 05, 2020 @10:59AM (#25315456)
Self-referential data structures are a code smell in non-GCd languages, and I think I have neither used or written a doubly linked list since university.

You can do both in unsafe rust though. But you probably shouldn't no matter what high level non-GCd language you use.

/Another ex-cpp-master-race guy who has been impressed with Rust

Re:Std::visit is everything wrong with modern C++ (2017) by cycloptic on Saturday December 05, 2020 @11:34AM (#25315769)
I see doubly-linked lists and other self-referential structures all the time in low-level code. Boost even has a whole library dedicated to them: http://www.boost.org/libs/intrusive
Re:Std::visit is everything wrong with modern C++ (2017) by nchi3 on Saturday December 05, 2020 @01:15PM (#25316801)
Yeah, hence high level non-GCed language. Using heap allocated linked lists is rarely the way to go if you're not developing for embedded.

However, if you're developing for embedded you'll probably want to be familiar with unsafe either way if you're going to use Rust.

Regarding self-referencing: Rust encourages you to design differently, which I've found leads to nicer and more thought out designs most of the time. Not all algorithms are possible (or efficient) without it though, and for those you'll have to use unsafe if you _really_ have to implement them yourself.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:38PM (#25316429)
For a really interesting take on this area, see http://dtrace.org/blogs/bmc/2018/09/28/the-relative-performa...

Specifically, the discussion about intrusive vs non-intrusive data structures and their frequency.

Re:Std::visit is everything wrong with modern C++ (2017) by cycloptic on Saturday December 05, 2020 @03:28PM (#25318002)
It would be interesting to see how that measures up in a different test where the accesses are all from a cold cache.
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @12:26PM (#25316312)
I have not. Does the borrow checker make things difficult? Isn’t there a weak_ptr equivalent?

Though honestly, in C++ it is very rare I use something other than vector (potentially wrapped for specific use case, like boost flat_map)

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:37PM (#25316416)
There is a weak_ptr equivalent; the borrow checker makes it basically impossible to use references to implement it. You can still do it with raw pointers exactly like you would in C++ too.

(And yes, it's a niche data structure, vecs are far more common, but it's people's go-to "the borrow checker restricts you too much" example anyway.)

Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @12:55PM (#25316615)
Thanks, that’s illuminating.

Seems a counter productive go-to argument given the amount of effort we (c++ coders) generally put in to avoiding non-adjacent memory access :)

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @01:10PM (#25316765)
You would think so, but it's sort of just become a standard thing on forums, someone claims that linked lists are impossible, someone else talks about how you can do them in various ways (possibly linking to the "Learning Rust with Too Many Linked Lists" book, which is awesome, by the way), and how you don't actually need them in real code, followed by someone saying that this is just Rust stockholm syndrome and they use linked lists all the time... just the fun of being on forums :)
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @02:39PM (#25317607)
Haha, forums gonna forum I guess. Reminds me of the “but how can I trust std containers to allocate for me? Anything could happen!” crowd in the 90s and early 2000s.

FWIW I think the Rust community has done itself a disservice by focusing on the safety benefits. Const by default and move by default are much bigger deals in the day to day coding experience, but it’s hard to get across just how awesome they are.

That book looks great, thanks - should take me through a few corners I’ve yet to meet while keeping me entertained.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @03:21PM (#25317921)
You're welcome. I sorta kinda agree on the safety thing; I wrote a blog post that kind of kicked off a whole discussion about this a while back; https://brson.github.io/fireflowers/ is a really beautiful summary of all of that.
Re:Std::visit is everything wrong with modern C++ (2017) by DerDangDerDang on Saturday December 05, 2020 @05:07PM (#25318873)
That was a wonderful read.

After 20 years of C++ and about the same number of hours of Rust, Rust makes me feel like Fire Mario because when I come to do a strict correctness and memory efficiency pass after writing something - it’s already correct. I suspect this will have a compound interest-like effect, similar to good code coverage empowering change.

Re:Std::visit is everything wrong with modern C++ (2017) by dralley on Saturday December 05, 2020 @10:09AM (#25315062)
Rust and D are not "strictly worse". They are better in some respects and occasionally worse in others, but even there the gap has been shrinking.
Re:Std::visit is everything wrong with modern C++ (2017) by otabdeveloper4 on Saturday December 05, 2020 @10:20AM (#25315158)
The context makes it clear that what's meant is "strictly worse as a C++ alternative".

Rust, like you said, isn't there yet. And I'd take issue with the claim that the gap has been shrinking - C++ right now is developing at a faster pace than Rust.

Re:Std::visit is everything wrong with modern C++ (2017) by chromatin on Saturday December 05, 2020 @10:23AM (#25315178)
Rust is excellent overall, but is lacking in interoperability (I mean, it is capable -- but iterop is burdensome, relatively). Related to the overall topic of sum types, there is ergonomic support in the form of built-in enum.

D is excellent overall (and I think sadly under-recognized for this), but it is lacking in ecosystem. Related to the overall topic of sum types, there is an excellent library, `sumtype` which recently hit 1.0 status.

I much prefer either of these to modern C++.

Re:Std::visit is everything wrong with modern C++ (2017) by api on Saturday December 05, 2020 @10:27AM (#25315207)
Interoperability is generally a disaster. Most languages can interoperate with C ABI functions, but even that is painful in some cases. It seems like most languages consider this an afterthought when it should be a central consideration. There will never be a time when everything is written in just one language.
Re:Std::visit is everything wrong with modern C++ (2017) by jeltz on Saturday December 05, 2020 @10:47AM (#25315376)
The only languages I know of with good C interoperability are C++ and Zig. This is definitely an area where Rust could improve.
Re:Std::visit is everything wrong with modern C++ (2017) by chromatin on Saturday December 05, 2020 @10:01PM (#25320643)
D has crazy good and easy C interoperability.

There is a near 1-1 mapping of types. C interop was a major design goal.

Dstep, which uses llvm/clang as a library, can translate headers for you. dpp I believe automagically at compile time translates C++/C headers.

Re:Std::visit is everything wrong with modern C++ (2017) by agersant on Saturday December 05, 2020 @07:35PM (#25319820)
You can add Lua to this list!

https://luajit.org/ext_ffi.html

Re:Std::visit is everything wrong with modern C++ (2017) by touisteur on Saturday December 05, 2020 @12:57PM (#25316631)
Don't forget Ada where interop with C is baked in the language spec and interop with c++ has been muuuch improved some years ago.
Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @02:14PM (#25317379)
How would you define "good C interoperability"?
Re:Std::visit is everything wrong with modern C++ (2017) by api on Saturday December 05, 2020 @03:39PM (#25318104)
Calling C functions with minimal fuss and good performance, which requires C header parsing and linking or DLL loading support. It also requires built in or standard library support for whatever convenience types and functions are needed to make using real C APIs pleasant and as safe as possible. Support for exporting functions and passing function pointers the other way is great too if it can be done.

Go with CGo is okay from a usability perspective but performance is poor. I haven't looked much at Rust's implementation so I can't comment. I've also heard Python is not bad.

Re:Std::visit is everything wrong with modern C++ (2017) by Silhouette on Saturday December 05, 2020 @04:23PM (#25318508)
Python was actually the reason I asked the question. There are multiple ways to integrate Python and C, depending on exactly what you want to do. The simplest is to use ctypes, which almost reduces calling C APIs in a DLL/SO to calling a function to load the shared library and then calling the APIs like any other function.

The most obvious practical limitation is that ctypes can only infer so much about the required parameter and return types of the C functions from how you call them, so you have to specify the types explicitly in your Python code in any other case. That's no harder than writing a C header file, though, and I expect there is probably a tool somewhere that would automatically generate the corresponding Python/ctypes code for the common use cases.

There are a few other warts that aren't quite as intrusive, including some restrictions relating to pointers and some verbose marshalling if you're passing strings around. But overall, it's a very convenient way to call out to C-style APIs from Python code that probably covers 95+% of practical use cases with only minor inconvenience compared to what you'd have written doing everything in either language on its own.

Re:Std::visit is everything wrong with modern C++ (2017) by vips7L on Saturday December 05, 2020 @11:40PM (#25321085)
Zig has the best C interop I've ever used. Just a simple import and it figures it out:

    const c = @cImport({
        @cInclude("types.h");
        @cInclude("stat.h");
        @cInclude("user.h");
    });
Re:Std::visit is everything wrong with modern C++ (2017) by vips7L on Saturday December 05, 2020 @11:09AM (#25315543)
I really wish D had the ecosystem. I think it could have excelled in a lot of the places Go has been used.
Re:Std::visit is everything wrong with modern C++ (2017) by api on Saturday December 05, 2020 @10:18AM (#25315144)
It’s not complex problems. It’s being close to the metal. Rust isn’t bad but it’s still not as good as C or C++ if you need to get every last bit of performance or need to be really close to the OS and hardware.

Rust is coming along though. It’s the first language I have seen that might unseat C++.

Re:Std::visit is everything wrong with modern C++ (2017) by MrBuddyCasino on Saturday December 05, 2020 @10:28AM (#25315214)
> Rust isn’t bad but it’s still not as good as C or C++

Can you elaborate in what way? I was under the impression the amount of low-level control was equal.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:40PM (#25316451)
I work at a company where we're doing software at all levels of the stack, from the firmware up. It is all in Rust. Even our firmware. It's working really well for us.
Re:Std::visit is everything wrong with modern C++ (2017) by elb2020 on Saturday December 05, 2020 @11:24AM (#25315688)
I think it's fair to call it a complex problem, if referring to the task itself, of creating performant software (which I assume is what he did). I agree with otabdeveloper in general. I'm learning C++, and over the past year there has been many occasions where I've found myself dumbfounded by patterns in the language. But, in 99% of the cases, the outcome is that the patterns are there for a reason. And the reason is performance.
Re:Std::visit is everything wrong with modern C++ (2017) by Cyph0n on Saturday December 05, 2020 @12:55PM (#25316610)
But Rust is a direct counterexample: it gives you comparable performance[1] to C++ while helping you avoid the common memory safety pitfalls of C++.

[1]: https://benchmarksgame-team.pages.debian.net/benchmarksgame/... (these benchmarks are not representative of all workloads, but it gives you a general idea)

Re:Std::visit is everything wrong with modern C++ (2017) by socialdemocrat on Sunday December 06, 2020 @12:18AM (#25321271)
Funny how people obsess about getting "every last bit of performance" and yet we are building applications in layers upon layers inside bloated Web browsers...

I think that is a bigger problem than using a language that gives you 10% less performance than C++. And anyway algorithms are typically are more important than the language in terms of performance.

Re:Std::visit is everything wrong with modern C++ (2017) by otabdeveloper4 on Saturday December 05, 2020 @10:28AM (#25315212)
> It’s the first language I have seen that might unseat C++.

Doubtful, as C++ has language standards and a visible, comprehensible story on how they evolve. C++ has also been evolving faster than Rust.

Right now Rust fills the "C++ with training wheels" niche - when you need a language in this space but don't have the energy or time to disentangle the sordid story of all the crufty legacy systems built around C++ after all this time.

But in principle if somebody made a well thought-out onboarding story for C++ then there's be little point in Rust.

P.S. But you say "my borrow checker" - well, sorry to disappoint you, people don't really care and actually view it as an impediment in learning Rust, not as a feature. If Rust had no borrow checker it'd be an even more popular language.

Re:Std::visit is everything wrong with modern C++ (2017) by Cyph0n on Saturday December 05, 2020 @10:42AM (#25315334)
The borrow checker is one of Rust’s selling main selling points, and was what got me into the language.

If you don’t see the value of compile-time memory safety in Rust, you probably haven’t spent hours debugging subtle runtime memory safety errors in a large C application.

Re:Std::visit is everything wrong with modern C++ (2017) by ncmncm on Saturday December 05, 2020 @01:17PM (#25316805)
This, anyway, is correct: In 30 years of coding maximal-performance C and C++ systems, I have not spent hours debugging subtle runtime memory safety errors. I have spent strictly more time tracking down compiler bugs.

I can count on one hand the memory errors I have debugged in five years. The longest took a half-hour. (Code that used a "relaxed" atomic load was moved to a place where it needed "acquire" -- which is the default.) So, I eagerly prefer (rounding up) 2.5 hours of debugging spent in five years over spending 5 extra hours every week -- 1750 hours in 5 years -- waiting on builds from a very slow compiler. (I don't know any reason why the Rust compiler could not be two orders of magnitude faster, and notably faster than a C++ compiler.)

My experience may be unusual in that I do not habitually depend on code badly-written by other people. My complaints about other people's code I do use are more typically about performance, conformability to requirements, or poor usability.

Re:Std::visit is everything wrong with modern C++ (2017) by Cyph0n on Saturday December 05, 2020 @01:56PM (#25317217)
I haven't been writing C for anywhere as long as you have, but I have definitely spent quite a bit of time printf() debugging and digging through corefiles in GDB. I also have never had to deal with compiler bugs, but that could be because IOS-XR uses a stable/old compiler toolchain.

I could be wrong, but I would wager that you are definitely an outlier among C and C++ developers. For the remaining majority, I believe that the compile-time memory safety guarantees that Rust provides are huge.

As to why your experience is different, it could be that you're simply (1) a talented programmer, (2) work with talented programmers, or (3) don't work on a large and complex legacy codebase, or some combination of the above.

Re:Std::visit is everything wrong with modern C++ (2017) by otabdeveloper4 on Saturday December 05, 2020 @11:50AM (#25315942)
Read my post again, please.

The people who choose Rust over C++ aren't (generally speaking, there are of course exceptions) doing because of the borrow checker. They're doing because Rust has Cargo and C++ doesn't.

Re:Std::visit is everything wrong with modern C++ (2017) by steveklabnik on Saturday December 05, 2020 @12:09PM (#25316142)
I think it is extremely hard to generalize here.
Re:Std::visit is everything wrong with modern C++ (2017) by nindalf on Saturday December 05, 2020 @10:22AM (#25315170)
I’d love to read your detailed comparison of C++ with all of the languages you mentioned. You seem certain that they’re strictly worse.

I can make the case that in some circumstances like low latency requirements, C++ is superior to a GC language like Haskell. But it’s harder to make the case that it’s “strictly” better.

Re:Std::visit is everything wrong with modern C++ (2017) by knuthsat on Saturday December 05, 2020 @10:31AM (#25315248)
Most abstractions discussed in the article have a runtime cost in Haskell and zero cost in C++.
Re:Std::visit is everything wrong with modern C++ (2017) by geofft on Saturday December 05, 2020 @10:13AM (#25315102)
The amount of complexity you can have in a system without it falling over is finite. You need to find simple tools, or at least comprehensible abstractions and simple compositions, to solve complex problems. You can only afford to use complex tools when solving simple problems.
Re:Std::visit is everything wrong with modern C++ (2017) by otabdeveloper4 on Saturday December 05, 2020 @10:18AM (#25315145)
C++ is a simple tool with comprehensible abstractions. You just don't understand it because you don't have experience with how computers and compilers work under the hood of dynamic languages.
Re:Std::visit is everything wrong with modern C++ (2017) by vnorilo on Saturday December 05, 2020 @10:35AM (#25315279)
This sounds pretty condescending to me. I've worked on C++ for a long time, including on bare metal and compilers, and yes, the abstractions are totally comprehensible. But keeping them in your headspace is a full time job. The sheer size of the standard belies "simple" tool.
Re:Std::visit is everything wrong with modern C++ (2017) by User23 on Saturday December 05, 2020 @10:54AM (#25315418)
I used to sit next to a member of the C++ standards committee. He was quite open that he didn't fully comprehend the abstract machine and had to rely heavily on documentation. And as you'd expect he's a wizard at C++. There are a lot of great things you can say about C++, but that it's easy to understand is not one of them.
Re:Std::visit is everything wrong with modern C++ (2017) by geofft on Saturday December 05, 2020 @10:49AM (#25315383)
(It's also very funny because deeply understanding how compilers and computers work under the hood and making sure our C++ code keeps running is, in fact, one of the things I do in my full-time job.)
Re:Std::visit is everything wrong with modern C++ (2017) by snazz on Saturday December 05, 2020 @10:22AM (#25315171)
That’s a big assumption to make. I think it’s valid to say that C++ is complex and more difficult to understand than other compiled languages without resorting to ad hominem arguments.
Re:Std::visit is everything wrong with modern C++ (2017) by otabdeveloper4 on Saturday December 05, 2020 @10:33AM (#25315267)
Haskell is much more complex than C++, for one example. (How many language extensions does Haskell have now? A hundred?)

C++ is easy to understand when you understand the mental model its abstractions target.

(In some sense you're right: the mental model of Haskell is mathematical, while the mental model of C++ is some sort of multi-core "Harvard architecture" machine. While it's true that math is a lot easier for the human brain to grasp, this isn't really related to language complexity per se.)

Re:Std::visit is everything wrong with modern C++ (2017) by detaro on Saturday December 05, 2020 @10:31AM (#25315238)
To be fair, the root comment started by suggesting mental illnesses in C++ programmers, so charged responses are to be expected.
Re:Std::visit is everything wrong with modern C++ (2017) by nchi3 on Saturday December 05, 2020 @10:35AM (#25315273)
Stockholm syndrome isn't a mental illness, nor is it derigatory.
Re:Std::visit is everything wrong with modern C++ (2017) by detaro on Saturday December 05, 2020 @12:40PM (#25316457)
Suggesting everyone using C++ isn't capable of properly evaluating it (which the comment author can clearly tell from the outside, for every use case) is "not derogatory"?

(and from what I understand "Stockholm syndrome" is not classified as a medical condition because it's questioned if it actually exists as thing that can be usefully delineated, not because it wouldn't qualify)

I'm certainly not claiming "C++ is perfect and everything else is useless" or "Rust doesn't stand a chance", but this "there has to be something wrong with you if you use it/ever consider it more suitable" is seriously annoying, and disappointing to see as the top comment here (even if it's not the worst pro-rust denigration of C++-users I've seen). And is damaging the chances Rust et al have in these spaces.

Re:Std::visit is everything wrong with modern C++ (2017) by nchi3 on Saturday December 05, 2020 @04:06PM (#25318361)
Medical condition is a very different thing from a mental illness though. I'm quite sure there aren't mental _illnesses_ which last 1-2 days like Stockholm syndrome does.

>Suggesting everyone using C++ isn't capable of properly evaluating it (which the comment author can clearly tell from the outside, for every use case) is "not derogatory"?

I see it more as "I wonder if they have given other languages a chance?". There's definitely a lot of C++ devs who aren't giving for example Rust a try, and don't see the negatives of C++ because they haven't experienced anything else lately.

If anything, it was derogatory towards C++, not the devs.

Re:Std::visit is everything wrong with modern C++ (2017) by detaro on Sunday December 06, 2020 @08:29PM (#25328496)
"Stockholm syndrome" suggests a lot more "aren't mentally capable of" than "wonder if they have".

And the answer to the question "I wonder if any C++ developer has ever given other languages a chance" is also a quite obviously "yes" (remember, the claim was about "all"), not "no, they never have".

Re:Std::visit is everything wrong with modern C++ (2017) by tener on Saturday December 05, 2020 @10:27AM (#25315205)
Simple using which metric? As far as programming languages go, C++ is one of the most complex ones. Which is funny because e.g. Haskell has way more advanced type system and still is easier to understand.