GAS-ssg VS conan

For this week's lab I packaged my GAS-ssg using conan and CMake.

For this week's lab I implemented Github Actions for my GAS SSG. First I went back and got my tests from last week working. Even though I implemented testing many of them were failing for reasons I didn't have time to get to, which I thankfully got the chance to get figured out this week. The biggest issue that held me up last week was file input not working if I didn't compile my program as I normally do, which I realized was because I hadn't changed my Visual Studio working directory - so my files were being compiled from one folder while the project was in another - obviously the path was wrong when compiling from the project folder.

I picked Gus's SSG to work on. I had work on his project before because we use the same C++ language. We use same testing framework, which is Catch2. So I generally understand how his SSG and Testing Tool work.

For my part I added some testing capabilities to my SSG using Catch2. Catch2 was super easy to set up and involved downloading one header file from their github repo and including it in my program. There are a number of ways you can choose to have Catch interact with your project, either by having Catch define your main i.e

This week I've been implementing some formatting and linting tools for my SSG via clang-format and clang-tidy. It took some doing to get them set up, at first I was very confused about what exactly clang was vs LLVM, what power tools was vs the command line version, and how to use all of the above.

For this week's lab I added a feature from docusaurus to add tags to my GAS SSG's generated HTML pages for added SEO. I started by logging an issue with a description of the functionality I was looking to add, and started working on it.

In the meantime, Kien had (made a pull request of his own)[https://github.com/gusmccallum/GAS-ssg/pull/20] which, less excitingly, had nothing wrong with it. I had to get git cli to add his as a remote branch, and getting that working took some doing but with his help I got it running and was ready to merge. What ensued was a whole lot of banging my head against a wall figuring out why the merge wouldn't work, but eventually triumph and a successful merge. Somehow I had changed the URL to my origin to his branch's URL, but setting that back to the correct one solved my problems and the merge was complete.

======== Gus's Repo: Github Repo My Repo: Github Repo My Issue: Issue #19 My Pull Request: PR #20

This week was a good way to see what the process of doing proper line by line comparison looks like, with two branches being merged one after the other. First, I logged issues for more relevant return codes and markdown horizontal rule syntax.

I worked with Gus again and his GAS-SSG for this lab. I decided for the markdown support, the syntax I would add would be the "# " header syntax. So I added an Issue for adding the markdown support and created a pull request with the forked branch I made. In the code I modified Gus' if statements that handled the file types to include a block that would look for the ".md" extension and also added a new file type code to represent markdown files. Furthermore, I made some adjustments to the file reader so that when it read a txt file it would handle the header/title features that were implemented by Gus. As for handling the markdown syntax, I added a makeHeader1() function that would take a string and add

Conan is a package manager for C/C++. See: https://conan.io/.

The way it works is that you can provide "recipes", which are Python scripts, that automate the process of collecting source code (usually from a remote Git repository, or a remote source tarball), patching it, making its dependencies and transitive dependencies available, building for specific platform and architecture (via any number of build systems), then packaging up and serving binaries. There's a lot of complexity involved.

Here are the two recipes I mentioned:

libcurl: https://github.com/conan-io/conan-center-index/blob/master/r...

OpenSSL v3: https://github.com/conan-io/conan-center-index/blob/master/r...

Now, for the sake of this thread I want to highlight three things here:

- Conan recipes are usually made by people unaffiliated with the libraries they're packaging;

- The recipes are fully Turing-complete, do a lot of work, have their own bugs - therefore they should really be treated as software comonents themselves, for the purpose of OSS clearing/supply chain verification, except as far as I know, nobody does it;

- The recipes can, and do, patch source code and build scripts. There's supporting infrastruture for this built into Conan, and of course one can also do it by brute-force search and replace. See e.g. ZLib recipe that does it both at the same time:

https://github.com/conan-io/conan-center-index/blob/7b0ac710... -- `_patch_sources` does both direct search-and-replace in source files, and applies the patches from https://github.com/conan-io/conan-center-index/tree/master/r....

Now, good luck keeping track of what's going on there.

There were various approaches recommended depending on our language and ecosystem. My classmates who developed using Node.js were recommended npm, and PyPI or poetry for Python. Since my program is written in C++, I was recommended to look into one of vcpkg or conan, but I ultimately did not use either package manager.

Hi u/instinkt900, Conan maintainer here. Thanks for your feedback! Please remember that we actively monitor and respond to our issue tracker on GitHub (https://github.com/conan-io/conan/issues/new/choose), we’d love to hear about your specific use cases or pain points, so that we can improve your experience and that of other users. The motivation behind most of the updates in Conan 2.0 was precisely feedback from the community, and to improve our ability to continue delivering features in the constantly changing C++ ecosystem. We can certainly do this at a quicker pace, with some exciting new features recently released and in the pipeline: package metadata, transparent backup of downloaded package sources, cache least-recently-used cleanup, etc. A lot of the big decisions that we took for Conan 2.0 were taken with consensus from expert users and contributors (https://conan.io/tribe) and https://github.com/conan-io/tribe. Some specific workflows may not have 1:1 replacements in Conan 2.0, and are likely to affect some of the “less travelled roads” of Conan 1.x, including some features that were always marked as experimental. We are happy to hear feedback so that we can best satisfy these use cases. Conan 2.0 also includes a more sophisticated API to cover cases where the built-in integrations may not satisfy users needs. For what it’s worth - we have also heard very positive feedback from users about how Conan 2.0 simplifies their workflows when compared to Conan 1.x. The C++ tooling ecosystem is fragmented and moves at different speeds, including our users. So it’s always a fine balancing act, but we don’t want to leave anyone behind! An example is Conan Center - over 90% (~1200) of all recipes have been migrated to support Conan 2.0, while still maintaining compatibility with Conan 1.x, precisely to avoid breaking users that are still on Conan 1.x.

Solution: don't use git submodules - use a package manager like Conan or vcpkg.

The closest thing we have at the moment is conan[1]. It’s a cross platform package manager that attempts to implement “toolchains”, whereby different build systems can be integrated[2]. This is a big problem with package management in C/C++, there’s no single, standardised build system that most projects use. There isn’t even a standardised compiler! So when hosting your own packages using Conan, often you need to make sure you build your application for three different compilers, for three different platforms. Sometimes (for modern MacOS) also for two different architectures each.

If you control the compiler AND build system you can get away with just one package for most cases. This true for Microsoft’s C/C++ package manager, NuGet[3]

Historically, the convention has been to use the package manager of the underlying system to install packages, as there are so many different build configurations to worry about when packaging the libraries. The other advantage of using the system package manager is that dependencies (shared libraries) that are common can be shared between many applications, saving space.

[1] https://conan.io/

Anyway, the problems are today starting to get fewer, as more an more adopt standard cross-platform portable build systems, a.k.a. CMake and package managers such as vcpkg or Conan. Together this will take care of building, installing, linking and using the entire dependency tree.

Simply use a package manager: Crypto++ is available on both vcpkg and Conan.

If you want a specific version or provide a more integrated workflow that is easier to use across platforms and among many developers, use a package manager like vcpkg or Conan.

I do however always recommend using a package manager: vcpkg or Conan to install and integrate third party libraries (together with CMake). This normally solves all the typical problems with dependencies.

There's a few, look into Conan or vcpkg (the latter is my personal recommendation).