essing and optimization techniques from this tool. Also its a bookkeeping for reproducible builds.
* 3rd point is required to enable incremental builds. Also means that builds are deterministic.
* Handle optimization techniques (parallelization, incremental builds, object file database, whatever else we invent)
* Note that we are not limited to toolchain executables, anything can be invoked as long as it complies to conditions.
* There already exist tools which look in this direction, for ex. [Ninja](https://ninja-build.org/).

**Project configuration**

Responsibilities:

* Tool operates with *two* scripts: project description script and project configuration script.
* *Project description script*, well, it describes your project. Which files to use, what artifacts to create, toolchain flags, dependencies, project-specific flags, other meta-information.
* *Project configuration script* fills the blanks in description script. Most prominent are: toolchain choice, optimization levels, debug information, project-specific flags, custom flags/additions.
* Supports, again, two important operations: produce configurations for dependencies and produce build script for further execution.
* Note that we don't try and recursively execute on dependencies! We only tell what do we want to get, it's not our job to find and deliver them!

**File management**

Responsibilities:

* Fetch stuff from net: library lists, sources, precompiled binaries etc.
* Locate and tuck stuff locally. Each artifact so far can be identified with 3 configuration files: project description, project configuration, toolchain description. The first one can maybe be left out but then customly modified variants can be an issue.
* Create installations of the project, i. e. assemble all those dependencies from across filesystem into one spot, so it can be sanely distributed.
* Probably strongly integrated into virtual environment.

**Virtual environment management**

Responsibilities:

* Isolate project from system and other projects.
* Primary function: being asked to make a specific project/tool with specific requirements (configuration) available. Environment then decides how to handle it: find something locally, download, build - whatever it takes.
* Primary function: Manage PATH and dynamic library locations. Bunch of backstage magic is begging to happen here.
* Secondary function: Set up defaults to keep things DRY (like your toolchain).

This may seem unnecessary, but it is essential step towards reproducible builds: now we have (almost) perfect information about what is available to the project. True, that some of it can inferred (direct project dependencies) but some are not (like exact toolchain configuration, or other tools).

Also others (for ex. Python) already realized usefulness of such abstraction and are making tools to handle it while we are still doing our woodoo dances around compilers.

You may ask now, WTF I want to make my project in one line. And yes, now you can have it, the 6th tool: **Project management tool**. Let it make your life easy:

* Set up new projects, define project structure, conventions whatever else.
* Generate project description/configuration files.
* Execute all necessary steps to actually build a project.
* Integrate into your IDE nicely so you never even have to touch command line.

But seriously I don't care if it's easy to set up project in one line or easily link a famous library when everything is a dumpster fire and any step left or right leads to hours of suffering and guide/manual smoking (yes, CMake, I look at you).

I don't know, maybe it's just me, but everyone for some reason jumps directly to last item on the list and handwaves the rest. It's literally the least important one, and obviously most desirable one: a nice facade hiding complex machine. Except such build tools usually find crutches behind itself instead.

This is where my mind is now. Maybe some abstraction levels are wrong. Maybe we need to merge/split something, or completely rework the workflow? I don't know. If you know - help everyone to fig

ure it out.

Anyways I'm super tired right now, hope this wall-of-text makes at least some sense.

https://redd.it/el8o4m
@r_cpp

Why Scikit-learn is Optimum for Python-based Machine Learning
https://medium.com/@Oodles_AI/why-scikit-learn-is-optimum-for-python-based-machine-learning-c13970438f71

https://redd.it/el9fnp
@r_cpp

Why CMake encourages distributing it's *.cmake files instead of *.pc for libs configuration.

Some time ago it was a standard that must libraries distributed XYZ.pc files for pkg-config that could be later consumed by any build system (or none). Recently I see trend that it's encouraged to distribute appropriate FindXYZ.cmake or XYZConfig.cmake.

Why is that so? What additional information can be conveyed through cmake files that is crucial for libraries?

https://redd.it/el9b0u
@r_cpp

A priority queue implementation in CUDA applied to the many-to-many shortest path problem
https://github.com/crosetto/cupq/

https://redd.it/elac6i
@r_cpp

Anjuta and Test Driven Development

I love working with Anjuta. It was with me during my early days of programming on Linux and taught me a few basics regarding creating programming projects.

Now, the question. I'm working on a rather large C++ library, and I want to implement Test Driven Development, but haven't really found anything that will work natively on Anjuta. I've previously worked with Qt's TDD tools, but have very little experience using others. So this is a kind of growth opportunity for me and I'd like to see what I can use.

I know both Google and Boost provide TDD tools, but which would you recommend or are there others you'd think about using with Anjuta?

Any and all help is appreciated.

https://redd.it/elbiiy
@r_cpp

HttpListener in C++

Hey guys,

Is there in C++ something similar to HttpListener from C#?

Problem at hand is that I need to send http request from React app to my C#/C++ application. I managed to successfuly implement that using HttpListener class from C# but I would prefer to do it in C++.

I tried using boost sockets with WebSockets in JavaScript but it did not quite work. WebSocket connection status hanged at CONNECTING, it never fired onopen event to confirm that connection is established.

https://redd.it/elehna
@r_cpp

msvc -isystem

https://devblogs.microsoft.com/cppblog/broken-warnings-theory/

Is there any news on that? Afaics it's still in 'experimental' state after 2+ years.

Also still no CMake support: https://gitlab.kitware.com/cmake/cmake/issues/17904

https://redd.it/elewps
@r_cpp

Is there any reason why C++20 does not contain constexpr functions for converting to and/or from strings?

Since [More constexpr containers](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0784r7.html) and [Making std::string constexpr](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0980r1.pdf) were accepted to C++20, allowing transient allocations with strings, is there any reason why there is no way to convert the string to numeric values and vice versa in constexpr context? p0980r1 basically makes everything constexpr in the string header, except for the streaming operators, `getline` and the string conversions. While it's kind of obvious why the first two are not constexpr, I don't see any reason why the last one couldn't be. Initially I thought this would be supported by `std::from_chars` and `std::to_chars` since they are non-allocating, but there seems to be no push to make these constexpr either. The C functions with similar functionality are also out of the picture due to... well, being C functions.

Is there a way something like this could still get into C++20, at least for the from\_chars-like variant (e.g. via NB comments), or at least C++23? Or is there something I'm missing?

https://redd.it/elfpmk
@r_cpp

Need to recover or go to old version of main.cpp in CLion [URGENT]

Hello everyone,

So I did something really stupid. I had a "main.cpp" file in my project in which I had started work on an assignment. Since I have another project where I use the main.cpp as scratch file I went into the important (non scratch) project, removed what was in the main.cpp file and started typing some scratch things. I saved it, ran it and closed CLion. Now I reaaaaaaalllly need to go back to the previous version of the file in the important project asap.

In other words, can I go back to a previous saved version of a main.cpp file? control-zetting does not work since I closed the application already.

Thanks in advance!!!

https://redd.it/elgx9d
@r_cpp

Changing from inheritance to std::variant inverts your header include hierarchy

I have some code I originally wrote in a dynamically typed language, and I'm converting it to C++. This involves applying type discipline to a design which was not designed with static typing in mind.

The code in question (is unrelated to the web, but) was inspired by the idea of cascading style sheets (CSS): it's a simplified declarative description of complicated runtime objects, so that you describe the style of an object with data and something else constructs it.

An important point is that different subtypes of object style have different sets of valid properties. So for instance something describing a linear slider has linear min/max properties, while something involving rotation has properties of rotational (angle) limits.

My first approximation was to create a class hierarchy with common-to-all properties in the base class, and many derived classes for the various specific styles. Standard OOP.

However I decided I wanted to change the style objects to be value types, so that they can be passed by const& or stored by value, without needing to use std::shared\_ptr or other memory management.

In the inheritance model, more-specific style classes included the base class with common properties inside of the derived object. In the updated design, the former base class (now a value type not a base) becomes the bigger object, containing within it the same common properties and a std::variant of all specific styles as a sub-object.

What I found interesting was in the inheritance design the specific style header(s) included the base style header, but with a std::variant based design that relationship is inverted; what had been the base class header now includes all the of the specific style header(s) (in order to be able to describe what's in the std::variant).

This may seem to be a trivial detail about header includes, but I believe in this case it also a deeper point about the difference between inheritance based designs and std::variant based designs.

**tl;dr:** When using inheritance, the more specific class(es) depend(s) on the more abstract class. When using std::variant, the more abstract class depends on the more specific class(es).

https://redd.it/elhf4z
@r_cpp

Grisu-Exact: a variant of Grisu, always producing shortest & correctly rounded outputs

I developed yet another float-to-string conversion algorithm based on Grisu and Ryu. It outperforms Ryu when the number of digits is small (up to 6\~7 for float's, up to 15\~16 for double's). The [paper](https://github.com/jk-jeon/Grisu-Exact/blob/master/other_files/Grisu-Exact.pdf) is not peer-reviewed so the algorithm might contain an error. Also, I didn't thoroughly test if the produced output is really shortest and correctly rounded, although it seems correct. Please check this repository if you are interested:

[https://github.com/jk-jeon/Grisu-Exact](https://github.com/jk-jeon/Grisu-Exact)

https://redd.it/elhev9
@r_cpp

C++Now 2020: Call for Talk Submissions
https://cppnow.org/announcements/2019/12/2020-CfS/

https://redd.it/elsv3q
@r_cpp

C++ real world applications for non-engineers

I love to code with C++, but I'm not an engineer, and I feel it is more for engineers who program for firmware and microcontrollers, my question how can I can use C++ to program real world applications to get hired?

P.s: I'm not native English speaker so forgive me for any mistakes.

Thank you in advance

https://redd.it/eltc9l
@r_cpp

Launching the Meeting C++ Community Survey
https://www.meetingcpp.com/meetingcpp/news/items/Launching-the-Meeting-Cpp-Community-Survey.html

https://redd.it/eltzcu
@r_cpp

C++ Inliner Improvements
https://devblogs.microsoft.com/cppblog/c-inliner-improvements-the-zipliner/

https://redd.it/eluo8d
@r_cpp

Dermot Hogan and Huw Collingbourne are reviewing a tool to detect memory and GDI leaks in Visual Studio
https://www.bitwisemag.com/2020/01/deleaker-review-finding-memory-leaks-in.html

https://redd.it/eltrp5
@r_cpp

Fun with variadic lambdas, fold expressions... another zip()

https://godbolt.org/z/WMGg76

So, I've been messing around with C++17's fold expressions, std::apply() and variadic lambdas for a small matrix expression template library I'm working on. I put together a nice implementation of Pythons zip() function to make range based for loops natural and have pulled it out into a gist. It supports all the STL containers (even std::vector<bool>).

Check it out, have I missed something: [github](https://gist.github.com/ConorWilliams/2dc0be178c0917617e475f9da27bf3c6)

https://redd.it/em0twe
@r_cpp

App

Looking to start learning how to make an app for IOS. Where is the best place to start?

https://redd.it/em21kc
@r_cpp

Im learning C++ and Im learning STL now. What should I do next after STL ?

Ive learned everything from Pointers to ploymorphism, streams, inheritance, smart pointers, operator overloading , OOP programming and now Im on a STL just getting into generic programming. Im learning online by myself, and I was wondering can I get a job with my knowledge of C++ now ? And how ? If not should I learn mooore C++ ? What do u recommend ?

Edit: I do practice on a daily basis. Itd be nice if I make friends with actual programmers here.

https://redd.it/em3516
@r_cpp