- Summer of std: General Utilities
Summer 2019 is the Summer of the Standard Library for Utah C++ Programmers! This month, Richard Thomson will give us a tour of a variety of small utility classes and functions in the standard library. Topics to be covered include: * std::unique_ptr and std::shared_ptr * std::pair and std::tuple * std::optional, std::variant and std::any * std::function and function objects * std::ref and std::cref Food will be provided, so please RSVP for a proper head count.
- Summer of std: the Filesystem Library
Summer 2019 is the Summer of the Standard Library for Utah C++ Programmers! This month, Richard Thomson will give us a tour of the Filesystem library (https://en.cppreference.com/w/cpp/filesystem) that was incorporated into C++17. The standard filesystem library is an adaption of the Boost.Filesystem library and shares many similarities with it. Topic covered will include: * Dealing with paths and filenames * Iterating over directories * Querying file and directory attributes (permissions, etc.) * File and directory operations Food will be provided, so please RSVP for a proper head count.
- Summer of std: Standard Library Algorithms
Summer 2019 is the Summer of the Standard Library for Utah C++ Programmers! This month, Richard Thomson will give us a refresher on algorithms in the standard library (https://en.cppreference.com/w/cpp/algorithm) and how to incorporate them into our code. Topic we will cover include: * How do algorithms relate to containers and iterators? * How do I reason about algorithmic complexity? * Why should I prefer algorithms over raw loops? (See Sean Parent, "No Raw Loops" https://www.youtube.com/watch?v=qH6sSOr-yk8#t=2m10s) * Non-modifying algorithms * Modifying algorithms * Sorting/partitioning algorithms * Writing your own algorithms Food will be provided, so please RSVP for a proper head count.
- Monitoring Code Quality with SonarQube
SonarQube, https://www.sonarqube.org/, is an open source, language agnostic tool for monitoring the quality of your code base. There are commercial derivatives that provide more enterprise level features, but the base open source version is quite functional. When combined with the open source C/C++ analyzer, https://github.com/SonarOpenCommunity/sonar-cxx, you can create a quality dashboard for your code base. This month, Richard Thomson will give us an introduction to SonarQube and walk us through the process of installing and configuring SonarQube for a C++ project. Some of the topics will include: * How to integrate SonarQube with your version control system * How to integrate SonarQube with your bug tracker * How to integrate external analysis tools like cppcheck, clang static analysis, etc. * How to integrate custom checks, such as searching your code base for TODO comments representing hidden technical debt * How to explore code trends over time Food will be provided, so please RSVP for an accurate head count.
- Unit Testing Legacy Code
In Michael Feathers's book "Working Effectively With Legacy Code", he defines legacy code as any code without unit tests. Legacy code is difficult to work with because you never know if you're introducing new bugs when you make a change. The change could be a bug fix, a minor enhancement or a major new feature. Without automated tests, it can be difficult to know if we're making forward progress. We may be introducing bugs that are distant from the local area we are changing due to coupling and other non-obvious connections between code. This month, Richard Thomson will guide us through a collection of strategies for testing legacy C++ code. The full details are presented by Michael Feathers in his book, but we'll discuss the basics and look at some scenarios and strategies that are specific to C++. Some problems you can run into that make testing difficult: * My code is connected to API calls, e.g. global functions * My code is embedded in a UI class method * My code is connected to singletons * My code is connected to other classes * My code is in a private method * My code is in a private class, e.g. not exported in a shared object Food will be provided, so please RSVP for an accurate head count.
- What's New in Clang/LLVM 7?
This month, Richard Thomson will give us an update on what's been going on in the world of clang and associated tools. Clang 7.0.1, released December 21, 2018, is the current stable release. Food will be provided, so please RSVP for a proper head count.
- C++ Interpreters
This month, Richard Thomson will give us a demonstration of C++ interpreters. First, we'll look at cling (https://root.cern.ch/cling), an interactive clang implementation. Next, we'll look at Matt Godbolt's compiler explorer (https://godbolt.org/). Finally, we'll look at a new entry in this category of tools Read-Compile-Run-Loop (RCRL) (http://onqtam.com/programming/2018-02-12-read-compile-run-loop-a-tiny-repl-for-cpp/) that was presented at CppCon 2018. Food will be provided, so please RSVP for a proper head count.
- Live Coding: Hacker's Delight
The book "Hacker's Delight" (https://amzn.to/2BI19VM) describes a bunch of "hacks" for low-level bit twiddling and manipulation. In this meetup, Richard Thomson will guide us through a live coding session implementing a selection of these "hacks" using test-driven development. Along the way, we will discuss testing strategies, code organization, test organization and refactoring of tests, implementation and packaging. Food will be provided, so please RSVP for a proper head count.
- How to build a JIT compiler in C++ with LLVM
This month, Mark Leone will give us a presentation on how to build a JIT compiler in C++ with LLVM. Food will be provided, so please RSVP so we have a proper head count. Abstract: In this talk I'll show how to compile a simple programming language into machine code using the LLVM compiler toolkit. I'll start with a simple lexer (using re2c) that converts a stream of characters into a stream of tokens (e.g. numbers and identifiers), followed by a simple parser (using recursive descent) that produces a syntax tree. Then I'll show how to generate LLVM intermediate code (IR), optimize it, and generate machine code using the LLVM JIT engine. Full source code will be available afterwards. No compiler experience will be required, although a reasonable familiarity with C++ will be assumed. Check out the LLVM Tutorial (https://llvm.org/docs/tutorial) for a preview of similar material. About the speaker: Mark Leone has been working with C++ as a graphics software engineer for 20 years. He recently joined the OptiX ray tracing team at NVIDIA here in Salt Lake City. He has over two dozen movie credits for his previous work at Pixar and Weta Digital (in New Zealand).
- Facebook's Folly Futures Library