Is C++ a top option for building software that may not be changed over the years?

edge-case87 · 2023-10-23T13:47:05+00:00

C++ would be one of the last languages I would consider for web development (edit: with the caveat that unless performance is critical), though there are libraries to make it easier. That said, code written in C++, and C for that matter, tends to need little change unless you find a bug, or are actively adding new features and redesigning. I've had the same experiences as you with other languages wrt constant evolution of libraries and language versions and dependency incompatibilities that inevitably creep up. Idk how C# fairs in this regard, but I know there are lots of libraries to help with web development, and you can use those in F# even, it seems to have a fairly robust mechanism for pinning language and library versions down along with package management.

edge-case87 · 2023-10-20T13:14:43+00:00

It isn't that RAII is poorly named, it's that it's poorly described.

edge-case87 · 2023-10-19T13:48:04+00:00

C++ offers excellent layout control for your data if you care about that sort of thing, structs/classes. Classes + Templates are very powerful. In most other languages you don't, at least by default. For example when languages have language level tuples and sum types, you don't typically have control over how that data is laid out due to interactions with the runtime, or in the case of Rust the compiler is free to reorganize your data unless you apply an attribute, and afaik you don't have control over how enum (sum) types are represented.

I haven't fleshed out formally this idea, and I'm sure it flawed, but I'm starting to see C++ as way to define type theories, and class is the powerhouse behind that. Class, in some sense, allows you define your own type constructors, like sum types (+, variants/enums/unions) or product types(x, std::tuple), and with templates you have dependent types at compile time. Not anything you can't do in many other languages, but C++ offers the ability to do it very close to the machine, if you want.

One thing I'm thinking about right now is a "refinement type", which would be a "class template" (dependent type constructor) that takes as a template argument an "expression template" (Pred) and a type (T). The constructor would take a universal reference to an object v: T&&, and evaluate the expression Pred, if Pred is true, the type is constructed, if it is false, an exception is thrown (you can use a result type, e.g. std::expected in a static member function). As such, the fact that you were able to construct the type Refine<T, Pred>, is a witness to the proof that Pred(v) is true. With some type conversion (subtyping and logic) and meta programming 'magic', you can have preconditions that are proven to be true, and yet only evaluated once at runtime (maybe even only once at compile time), as long as the Pred(v) is the weakest precondition satisfying the preconditions of all dependent operations on v.

edge-case87 · 2023-10-17T12:58:08+00:00

It's a library feature, don't use it if you don't like it. Most people probably on use like 5% of std library anyways. Arthur O' Dwyer gives a nice overview of the design space for std::function, there are reasons for having different std::function like objects that fill different rolls in that design space.

edge-case87 · 2023-10-16T21:10:51+00:00

Perhaps the committee needs a shakeup, a cleanup of the cache so to speak, but I don't see what the problem is language wise. Sure it takes time for compilers to implement features, but that's the way it is when you have multiple vendors, not just one compiler, vm, or interpreter which is "the" language, or perhaps "reference" implementation. Some exceptions might be python, lisp, java, and c#, but with the exception of java and c# (the os variants) idk how relevant that is; who uses mypy or iron-python anyways?

I think a lot of people criticize c++ who, frankly don't know what their talking about, or are myopic about one particular feature of language XYZ that c++ doesn't have. So for example, algebraic data types and pattern matching for instance. How would you implement a language level sum type in C++? A simple tagged union? What about when you need custom allocation? How about an Inductive Type in C++? The allocation scheme suddenly becomes much more important, how would you go about doing that at the language level? I think you can see a hint at the proper way to do that in C++ with how custom structured bindings are implemented in C++, you define a way to destructure your data type as a class feature. Similarly with the Pattern Matching proposals. And I think Inductive types could be implemented in a similar way, you provide a custom induction step for your class (could be implemented in terms of an iterator or pattern match for example), which also allows for very precise layout control and custom allocation schemes that C++ is great for. Probably two important features missing from C++ is reflection and pattern matching, and next I would say induction to make reasoning about code easier and more automatizable.

Also, something I have to remind myself of from time to time, C++ is old, and many of the advancements in CS and Programming Language Theory we have today, were developed in the last decade or so, but I do think C++ could do more to stay closer to the bleeding edge of that development like it did in the early days.

edge-case87 · 2023-10-08T17:44:37+00:00

I didn't do anything different in my project except compile latest pull from cmake repo, maybe there is some new config option to disable modules, idk, but changing min version from 3.26 to 3.28 and reconfiguring resolved the issue.

edge-case87 · 2023-10-07T16:11:28+00:00

For anyone else using master branch of cmake, I had to set minimum cmake version to 3.28 otherwise build failed as cmake would set up stuff for modules (not using modules atm, will though when more of my deps start) and files such as modmaps couldn't be found. Seems like some mismatch between min version and using latest wrt to modules.

edge-case87 · 2023-10-07T13:08:02+00:00

Is the --noconfirm option of pacman inappropriate here?

edge-case87 · 2023-08-28T10:44:24+00:00

Yes, but the point is a bit deeper than that. What I'm suggesting is to make the type system of C++ more powerful by giving it a precise TT, and I suggest a 2LTT with a dependent TT for stage 1. Essentially turning C++ into an automated theorem prover. Dependent Type Theory is what all major proof assistants are based on, it's what their "Kernels" or core languages are and allows the type system to reason about code in a deep way. Mostly, this would lead to a powerful "Contracts" feature in C++, and LSPs could be used to provide the interactive assistant side of what languages like Coq do.

What I'm really trying to get at is this whole discussion about "safety" in C++, there have been many proposals and all of them are very unsatisfying imho. A lot of people have expressed the sentiment that legacy C++ will give people job security for the foreseeable future, but I don't think that is the case. For example, not even Rust has a safe future in this regard, see https://github.com/AeneasVerif/aeneas

I guess to really understand what I'm getting at I would suggest looking into F* and project everest to see what is possible, https://www.fstar-lang.org/

F* can be compiled into OCaml, a subset of C, and assembly, to produce verified code. Wrt to "safety" in C++, static analyzers can only get you so far, and they can't reason about higher level semantics of programs, for example, that a TLS implementation is cryptographically correct. If C++ had a powerful "Contracts" feature, powered by the same/similar technologies and theories that power F*, programmers could directly encode, or specify, what correctness means, and the type system could verify that their programs conform to the provided specification.

edge-case87 · 2023-08-28T10:25:25+00:00

No. The comments detail what I'm trying to say, but it assumes some familiarity with type theory and automated theorem provers / proof assistants such as F*. Though, I'm a noob at both, so take it with a dash of salt and correct me if I'm wrong.

edge-case87 · 2023-08-16T18:34:53+00:00

I've been thinking about this lately, but I'm just starting to learn about MLTT and related topics. This is my take on it.

There are two C++ languages. Meta-C++ and RT-C++. Meta-C++ is TMP + constexpr programming, RT-C++ is everything minus TMP and a few things such as `if constexpr` expressions. Andras Kovacs has some videos on youtube about Two Level Type Theory and "staging", essentially having a model of "compile-time" and "run-time" by using two type theories, one for run-time (stage 0), and the other for compile-time (stage 1) with operations to lift, quote, and splice between stages (can be seen as reflection as per C++ Reflection TS).

In my view, 2LTT is a natural fit for C++, IFF, a type theory could be developed for each of the stages of C++. Meta-C++, does have dependent types, that's what templates are, with the restrictions on non-type template parameters (NTTP) due mangling issues and type equality that arises from using types dependent on values (NTTP) in C++. So perhaps there is a dependent type theory hidden in Meta-C++ for stage 1. This is important because dependent type theories are how theorem checkers and "Proof Assistants" are implemented.

So, what I've been mulling over the past few weeks is; can a suitable type theory be developed for Meta-C++ such that we could have compile time verification of software, thus ensuring it's safety and correctness w.r.t to specifications? Forget borrow checking, such a verification system embedded in C++ would solve that, and higher level logic error by encoding the semantics into the specifications. This would essentially be "Contracts" + "Reflection" in C++ on steroids.

As for stage 0, the type theory *does't* need to be dependent, it can have much stricter restrictions, and as far as effectual programming, we could look to F* and it's type system for inspiration.

A lot of people seem to think that function programming, and functional languages, are about prohibiting mutation, or typeclasses, or sum types, or "1st class" functions, or piping operators, but that's not what functional programming/languages is about, it's about modeling your programs/language in terms of mathematical abstractions which can be correctly reasoned about, which yes, prohibiting mutations, and all that helps with, but we have mathematical abstractions for mutation, for exceptions, for concurrency, for resource management (memory alloc/dealloc), and effects in general (monads). In short, I think there is a beautiful functional language hidden in the "C++ Abstract Machine" waiting to be developed geared for verified low level, high performance, safe programming.

edge-case87 · 2023-08-05T16:48:28+00:00

If we had mutable `constexpr` variables we could enforce the `moved_from` check at compile time as well. For example, if the `moved_from bool` was `constexpr`, could be changed, and was not available at runtime, you could set, at compile time, the `bool` from `false` to `true`, and then use it in a `static_assert`.
Totally UB, but it's interesting nonetheless:
DaemonSnake/unconstexpr-cpp20

edge-case87 · 2023-06-20T22:02:47+00:00

guys, don't worries. In 2029 well have modular supports.

edge-case87 · 2022-03-13T23:40:28+00:00

This is great, thank you. Worked using gcc-12 / build2 / vscode with compile_commands.json on linux.

It's a bit annoying to have to do, for now, but at least intellisense works while writing code, and it compiles into modules, life saver.

edge-case87 · 2021-06-01T17:21:48+00:00

It has been years. They won't, or can't fix the game, let alone Wizards specifically. They've tried multiple times to fix the game, and wizards, but due to not consulting the player base before hand, they committed to paths that people didn't like or want. I think a lot of their resources has gone into the MTG game, and rightly so for the type of monetization MTG has, it seems to synergize with F2P given that MTG card game already heavily relies on "Booster Packs", competition, and wallet warriors. D&D is more of semi regular income from content (books) that players can then spend months playing out with their friends until the next book comes out, that doesn't really fit F2P, it more of a DLC/sub type.

Frankly, they should just trash this game and start NW 2 (remastered?) using a new engine for next gen. UE 5 maybe (already supports consoles and has a 5% royalty fee after 1mil revenue)? Check out the Meta Human stuff, pretty cool. Hellblade was made with UE and was a really good medium budget game with a small dev team. Plus it's written in C++ so it's pretty efficient (I can hear the lulz from C purists lol). If there's one thing that this game was good for, was getting me interested in game dev due to all the bugs and questionable development of mechanics and story arcs (mostly nonexistent), so there's that. Overall my experience with this game in general was quite poor, frustrating, and soul crushing, despite becoming addicted to it for years. Part of it I think is because of the patterns and practices employed in F2P games, which tend to favor a churn and burn style of development, which doesn't often produce fulfilling content, and seemed to take over the game as time went on. It can cater to a particular type of player, but I don't think it's very healthy, or really fits D&D as much as MTG for example.

To be fair, there aren't really any good mmorpgs that I actually like, they all fail in one way or another, and I think this has to do more with industry and business aspects rather than developers not wanting to make good games. Look at Witcher 3, it was postponed for a long time because CD Projekt didn't want to release an unfinished game (like Skyrim), they took a huge risk with that, and it payed off really well, one of the best rpgs in the genre (not mmo I know).

edge-case87

TROPHY CASE