CCL is on GitHub Sponsors

CCL is an open-source software project and needs funding.

Consider supporting CCL via GitHub Sponsors.

To sponsor CCL, click the link above and choose a tier.

The Case for Sponsoring

Here I describe the problem that CCL tackles, after which I will attempt to convince you that CCL is the solution.

The Problem I Am Solving

Professional programmers only need one programming language to express programming, yet so many companies use several programming languages. For example, C++ is used where performance is critical, Python is used for machine learning tasks, C# is used to program video games, JavaScript is used to program graphical user interfaces, TypeScript is used to program better graphical user interfaces, Kotlin and Swift are used to program mobile apps (which also have a GUI), and so on. People say "use the right tool for the job". The problem is that people are using multiple tools for the same job. That is objectively the wrong application of engineering. The reason this approach is so prevalent is that no single programming language provides a convenient way to tackle all the important tasks involved in creating a software product. I get it, companies want to build products now. However, this approach has a cost, you pay with degraded developer productivity and you pay with performance losses, and that reflects on your bottom line and on the user experience you are able to deliver.

Imagine if you had one programming language that could do everything that all other programming languages can do, combined. Sounds great, right? Such language doesn't exist, but the only way we'll ever be able to produce such a language is if we focus on making one language better until that language gets there.

One of Rust's greatest contributions as a programming language is its borrow checker. The problem is, Rust's borrow checker could have been simply a static analysis tool for C++. Instead of just providing a tool that solved that problem in C++, they created a new language with that feature. This has happened before, one of Java's most touted features was its portability, but you can't run a Java program without first installing a Java virtual machine, the first of which was implemented in C++. It's more like "Write once, install and run anywhere", which is the experience we already had with applications written in C++. Instead of making a C++ virtual machine, they created a new language that had a virtual machine, without improving portability. This kind of thing is delaying progress. The creator of C++ did the right thing, he based his language on an existing one (C) instead of resolving solved problems.

I believe that, as an engineer, I should feel comfortable stating objective truths, which is why I say in no uncertain terms that despite C++ having serious flaws, it is the best programming language we have currently because it possesses the highest potential. C++ enables incredible performance, which drives innovation and leads to a better user experience. C++ has great modeling power, meaning you can represent real-world ideas in code very effectively. But C++ is complex and lacks a lot of features that are needed to build modern software products.

Don't get me wrong, there is a place for a simple and lightweight programming language like Python, because not all programmers are professional programmers. For example, physicists that need to write code to analyze data from a telescope aren't in the business of producing enterprise-grade software, but need to be able to program, and Python is great for that. But professional programmers don't get to shy away from the complexities of software development. That doesn't mean they should have to deal with messy tools that make them unproductive, it means that if we are going to build on one programming language, we must accept the inherent complexities that come with software development.

The Solution

C++ is a great foundation. If any programming language should be worked on to eventually have everything, C++ is it. That's because C++ ticks all the boxes:

• C++ runs on all kinds of operating systems and hardware architectures.
• C++ enables incredible efficiency, and efficiency is something that customers appreciate (just look at Apple silicon).
• C++ provides both low-level and high-level features, making it useful in a variety of use cases.
• C++ is a mature language, and it already enjoys a large pool of talent.
• C++ is a fast-evolving language, with a new ISO standard every 3 years or so.

Yes, C++ has flaws, but it's the best we got. Let's address C++'s flaws.

• It's too complex.

  This is true. C++ is complex, but that is because the problems it solves are complex. Python is simple, but it is not feasible to develop Crysis in Python. Someone has to face the hard problems, but that doesn't mean that those problems should go unsolved for everyone else. CCL aims to bridge that gap by providing tools and resources that make life in C++ easy.

• It's not memory-safe.

  This is true, currently. But the official Java garbage collector also isn't memory-safe, because it is written in C++, and the official Python interpreter also isn't memory safe, as it is written in C. It turns out that someone needs to provide the memory safety, and until they do, you don't have it. If you gain memory safety and remove performance, you're solving a problem while unsolving another one. We can do better than that.

• It's too cumbersome to use.

  This is true, and I am fixing C++'s productivity problem with CCL. A lot of C++'s complexity comes from the power it provides, and that power is, paradoxically, what makes it possible to produce libraries so convenient and ergonomic that using them is dead simple. All it takes is enough tooling to make C++'s nuances and intricacies ignorable.

My goal is to make it easy and painless to develop extraordinary software products. C++ Complementary Library (CCL) will provide developers with the resources necessary to build high quality software. It is not a fashion trend, it is not a logo sticker, it is a tool that solves technical engineering problems and its real-world usefulness can improve developer productivity and an organization's bottom line.

CCL's core selling points are:

• CCL is and always will be written entirely from scratch and completely free of third-party dependencies, which means:
  • CCL is fast to build and easy to consume in a C++ project.
  • Having more control over CCL makes it easier to change and improve it.
  • You get the guarantee that the code you're using is covered by just one license, and that license (the Boost Software License) is business-friendly.
• CCL already provides useful Unicode functionality, but it will eventually have every feature under the sun, including:
  • Native GUIs
  • GUIs based on custom vector graphics
  • 3D graphics
  • Game development
  • Web development tools
  • Machine learning
  • Scripting
  • Compression
  • Cryptography
  • Networking
  • Cybersecurity tools
  • Database management
  • Computer vision
  • Image processing
  • GPU compute
• CCL is written in C++20 from the ground up, meaning the API is modern and sleek.
• CCL embraces CMake, the industry standard tool for managing the build process of C++ code.
• CCL's API documentation is clean and readable, both in the header files and on the website.
• CCL's current features make it easy and convenient to do Unicode I/O in C++, and that productivity boost will expand into other areas as features are added.

This will take a while to realize fully, as there are a lot of features to work on, but CCL provides great value already by making Unicode I/O so effective and seamless. C++ is a complex programming language, but it is possible to make usage of C++ a pleasant and painless experience even for non-experts, and that is what I am doing with CCL.

Software is everywhere nowadays, and so much of it is made wastefully. We can change that.

---

---

Copyright © 2022-2024 Daniel T. McGinnis