Overview

The description below applied when it was first written, and has covered a couple of months of posts.  It is no longer entirely inapplicable, but both projects have now been covered, for points if interest, pretty well up from low-level components up to the calling of main().

I am continuing to add posts, but with more general application, and many will not be restricted to spin-offs of the two original projects, nor even necessarily to C++.

To upgrade my general familiarity with modern C++ -- my projects for the past several years have been, to a very great degree, restricted to C++03 or at best C++11 -- I decided to undertake a couple of private projects using the most current versions of gcc I could get which would be likely to be available in a commercial setting under Linux (at the present time that is 12.1.0; any version of gcc 13 would mean building the compiler myself).  This means effectively full support for C++17, moderately full support for C++20 (support for modules has problems -- problems as in "compiler core dump" -- and support for coroutines is supported via a special switch, although coroutines are not of much use with the projects I undertook), and some support for a few C++23 features, notably std::expected (or most of it).

Choosing projects required two minimum criteria: first, they had to be substantial enough to require a real exercise of logic and data handling; secondly, they had to have the possibility of having enough usable data to make working versions which were not just unit tests. In addition, I wanted to avoid domains which either would be focussed on very low-level issues which tend to resolve into sets of system calls held together by intermediate code, usually keeping very close to C -- no new networking protocols -- or tend to make use of third-party suites which might vary considerably in terms of features and which would accordingly vary a great deal in real life (no use of enterprise messaging protocols, high-level web service interfaces, or the like) as these would tend to lead me away from the actual exercise of the most generally portable language features.  I did make one exception in using GTK 3 in one application, because it provided a legitimate context in which to use modern threading constructs.

I have a couple of applications in two very different areas now.  I will be posting regarding aspects of new language features and their usefulness, or about aspects of class, library, and test design.

The largest of these projects is an automated Breviary; the second is a local application for displaying data from downloaded data from LibraryThing.  Posts will mainly be, at the outset, on the breviary, but some posts on the LT app will be mixed in as well.

Posts will touch on language features, design, refactoring and general observations regarding the relation between the problem domain and the solutions.


Comments

Post a Comment

Popular posts from this blog

Boundaries

Imagine that you have a well-designed application, possibly using dependency injection. It will almost always have a very thin layer visible in main() - capturing command-line parameters and environment variables, mainly[1], and then a call to an Application class which manages the rest of the initial logic - setting up resources such as logging, doing substantive validation of parameters, and creating and running the objects on the next level down which actually carry out the work of the application. This is simply following the SRP at a high level.
Read more

Considerations on an Optimization

An application – actually, successive pair of applications – is meant to process (in the end) about three hundred or so entries to convert a simple markup into complex LaTeX markup. It also enhances the data with information drawn from a flat-file text database (i.e. literally a set of .txt files in a single directory). This application was originally written in rust, which is not my favourite language, but one worth exercising to a degree. The rust application covered a limited subdomain, and generally avoided unsafe rust code, although in some cases it had to use cell mechanisms which converted compile-time to runtime safety. The initial iteration had the text database as one large file, with some logic allowing for extended seeking through chapters. It soon became apparent, after extending my dataset to about twenty or so items, that this was going to result in an unacceptable runtime — it was taking longer to process than the later TeX processing took, and although in theory this w...
Read more