Forem: Batuhan Ipci

Today I sat for my last final exam, which also means I am now done with all my courses at Seneca College. It feels strange to suddenly come to a stop from the crazy busy schedule I was pursuing for the last many semesters. Suddenly, I have all the time in the world to do whatever I like, but first, I must pay back my sleep debt.

2022 has been great in terms of personal growth. I learned to navigate the strange world of remote learning which at times got difficult. I also learned to work under pressure from my many programming courses and work in the open through my open-source development class. Working collaboratively on open-source projects with people I don't know made me more confident in my programming skills. Just a year ago, my GitHub profile had barely any projects uploaded, but now I have developed the muscle memory to intuitively upload all my projects in GitHub, make frequent commits, and have gotten good at navigating my way around it.

Some 2022 Accomplishments 🎉

December open-source contributions 🚀

This month I challenged myself to work on many small issues within just 10 days. I enjoyed working for Seneca College's internal project repos, therefore, picked two of them to work on.

My two most recent open-source contributions were made for a Seneca College Internal Project. I decided to go ahead and make 2 different pull requests to this repo to challenge myself to learn new skills.

1) My Photohub 📸

Integrate `github-upload` with the rest of the working code #33

SerpentBytes posted on Dec 07, 2022

Description

github-upload.js file is currently in the root directory and is disconnected from the service.

Move the code to ./worker/functions and ensure it works when we run the scripts to boot up the backend.

View on GitHub

The solution

This issue required me to understand how two of my other peers before me were writing the code. Through this, I was able to practice my skill in reading and understanding other people's codes and then integrating them.

Integration `github-upload` with the rest of the app #35

batunpc posted on Dec 09, 2022

Fixes https://github.com/humphd/my-photohub/issues/33

As discussed in the issue, current behavior of the app is completely isolated from github-upload function using Octokit. Which was implemented at https://github.com/humphd/my-photohub/pull/11

This PR integrates the "upload images to authenticated repo using github-upload" functionality into the front-end, as it was programmatically written for client side.

Steps to reproduce

First create an public repository with the desired name.
Next, navigate to Settings > Developer settings > PAT > Tokens(Classic) to create a brand-new token. Ensure you have provided PAT permission to the created repository from step 1.
After token is created you can start the app with npm run start and follow the rest of the steps. After you have uploaded an supported type image and click on upload, you will see raw directory within the repo you have created. It will look something like this.

View on GitHub

2) vscode Extension for Seneca 🧩

I had no prior experience working with VS Code extensions, so I had to study some VS Code documentation before making this pull request. Making a VS code extension can get difficult if the features needed are big.

Feat: provide screen stats #11

gulyapulya posted on Nov 07, 2022

Would be great to collect such information such as screen time per user for every course work which mainly requires working in vscode (many programming courses) to get an idea of average hours per week per course and maybe personal screen hours stats. Can check if the user is actively working and disable timer if the person has not been typing anything for more than 20 mins (tbd).

View on GitHub

The solution

feat: initial implementation of session time counter extension #16

batunpc posted on Dec 10, 2022

Resolves https://github.com/Seneca-CDOT/vscode-seneca-college/issues/11

I have added the initial implementation to measure active window time for current session for the user. You can investigate extensions/session-time-counter/src/extension.ts to see my implementation.

During the process I had such questions like;

What could be the conditions to measure active window time?
If the number of characters deleted should also be counted as written? (can be an follow up issue)

As we build this extension maybe we need to clarify these crucial questions and file corresponding issues to help with the development process.

Let me know what you think 🤩

View on GitHub

3) Climate Action Secretariat - CleanBC Industry Fund 🏢

As I was browsing for some issues to contribute to, I came across this repo by the government of British Columbia. I liked the project and decided to make a small contribution here.

Tech Debt: Regexes for phone numbers and emails live in multiple places #1221

pbastia posted on Nov 30, 2022

We have regex patterns that are duplicated across multiple files:

app/server/middleware/graphql/validateRecord.ts app/data/jsonSchemaForm/customFormats.ts

It would be nice to keep them in a single file.

View on GitHub

The solution

Refactor and optimize regexes for phone numbers and emails #1251

batunpc posted on Dec 08, 2022

Fixes https://github.com/bcgov/cas-cif/issues/1221

As mentioned in the issue, this PR resolves the existing duplicated regex and optimizes them into one single file.

Note: Currently, I am turning this into draft PR and will be updating soon.

View on GitHub

Reflection

I am really happy with the contributions I have done over the last 3 months. I have big goals planned for 2023 to develop both personally and professionally.

Master any CLI tool with this one weird trick

Batuhan Ipci — Thu, 15 Dec 2022 06:56:25 +0000

Just like most developers, I live in the terminal, I savor the ability of automation and the boundless things I can do with it.

Before I start, I want to briefly remark on my setup;

My setup 👽

I used to use bash and know the best as my default shell, but I solely switched to zsh because it become the default in macOS, likewise I use ohmyzsh as my framework. It is a pleasant experience and easy to manage the prompt and plugins.

I recently heard about prezto which is a fork of ohmyzsh but haven't tried it yet (most of the plugins I use are in ohmyzsh) it is more customizable and less bloated than ohmyzsh.

I use iTerm2 as my terminal, it is a great alternative to the default macOS terminal and has a lot of features - customization.

Writing completion spec 📝

Recently I have contributed to Fig
Specifically to their autocomplete feature withfig/autocomplete which is an open-source project that aims to provide auto-completion for CLI tools.

This is a preview of the autocomplete feature in Fig, the tool taplo is what I wrote the completion spec for.

How it works ❓

While it required some brainstorming and a bit of research, it was a smooth experience to contribute to this project, and I learned a lot. First, I followed their documentation on writing a completion spec, which is well written, and learned a lot about the basic CLI terminology (i.e. command, subcommand, option, argument). Corresponding to what tool you choose to write the completion spec for, you need to learn a bit about the tool itself, which is cool because you get to know the tool better.

I tackled the issue missing spec for taplo #1532.

Taplo is a CLI tool for working with TOML files, and it includes features like linting, formatting, and validation. I honestly didn't know much about TOML before I started working on this, but I learned a lot about both the tool and TOML itself.

Some CLI tools have man pages and in such situations like writing completion spec, people usually use them as a source to learn about the tool and its subcommands options, etc. (Usually they have the best reputation for being the most accurate source of information). Though, the tool I chose to write the completion spec, taplo, did not have any manual entry pages. Even better! I found their website and documentation which was really helpful.

Takeaways 💯

Maintainers of withfig/autocomplete are super active and helpful. They constantly add more issues related to writing brand-new completion specs and improving existing ones. Writing completion specs, I think, is one of the best gateways to learning about CLI tools in depth and contributing to open-source. Also, if you are using Fig you can actually use the completion specs you wrote in your terminal!

The storm before the calm: finals week

Batuhan Ipci — Sun, 11 Dec 2022 06:35:57 +0000

I am sure all students can relate to how stressful finals week is!
Going to sleep at 6 am, and waking up at noon is now the new norm and has been for the last 2 weeks. I have been through many finals weeks by now, but this one is the most uniquely brutal. I underestimated the amount of work before signing up for all the difficult courses that I did in September.

The good stuff

Before starting release 0.4, I was stressed out! I was worried about finding a big enough issue that I could comfortably work on and make it before the deadline. But then I thought why not work on many small issues and challenge myself to do multiple pull requests.

I picked my favorite Seneca College project my-photohub and successfully created two pull requests there.

PR1: For the first pull request I had to integrate a previously implemented functionality github-upload into the rest of the application.

Next, I found another very interesting project bcgov/cas-cif This was a project by the government of British Columbia and I thought it would be nice to contribute to this project.

All I had to do as described below, was refactor and optimize the regex for emails and phone numbers across multiple files.

I also ended up doing a last-minute contribution to vscode-seneca-college extension repo for the issue regarding displaying user stats such as screen time and edits made per hour.

This issue required me to do some research and learn about vscode APIs. Since I had never done any vscode extensions before I had to study the documentation and look through some examples before diving into the code.

Endless learning 📖

All of the issues I picked taught me something new. So far, my progress has been smooth without any major bugs or hurdles.

The struggle 😪

Fitting in multiple assignments in a short time span is hard! This week has been about four things: open-source development, cloud computing, mobile app development, and robotics. I had very little time to dedicate to other courses. However, despite the hurdles and bottlenecks, I feel pretty good about my accomplishments so far.

December goals

Batuhan Ipci — Sun, 04 Dec 2022 08:08:09 +0000

Attaining mastery of any skill means we need to learn, practice, fail, and iterate in the learning process many times. I can say the same for my open-source development journey. Being able to contribute to open-source projects has been a highlight of this year and in the last month of 2022, I plan on continuing my open-source development to keep up the momentum I built over the last two months. I have a few goals outlined for this month that I would like to accomplish by the end of the year.

Improve on code reviews:

Earlier I wrote a blog about my code-reviewing process and how it did not go too well. I want to practice doing some more code reviews throughout this month and get better at giving constructive and effective feedback.

More open-source project contributions:

Honestly, I should have started this task a couple of days ago, however, life happened and I got into a late start. I found a couple of potential repositories I would like to contribute to over the next week:

My Photohub: I have already contributed to this project a few weeks ago where I created the UI of the progressive web app (PWA) using React. I plan on working on the other issues filed for this project and try to get closer to the finished product of this project.
Intel/cve-bin-tool: There are several issues in this repository that are interesting to me, particularly the ones about creating checkers. I would say it is not very coding-heavy, but it needs a lot of research before doing it.
Some other interesting repositories I came across while looking for some projects were:
- d3
- FreeCodeCamp
- Vue
- React
- Bokeh

Refactor, improve and package palpatine

I have been working on building my static site generator palpatine for the last two months. However, I have not had the chance yet to package it up to create my first release yet. When I attempted to package it up a few days ago, I ended up with a lot of errors and bugs that would require lots of time to debug. I plan on sitting with it next week again.

Solve Advent of Code problems

This year, I am also challenging myself to keep up with solving the Advent of Code challenges!

Try out Advent of Cyber

I also found out about this amazing challenge from a classmate and would love to give it a try!

Fun fact: This year my classmates and I started building a browser based cybersecurity game with three.js
When I found out about Advent of Cyber, I knew I had to give the challenges a try to learn different cybersecurity concepts in a fun and engaging way.
This year, I am also challenging myself to keep up with solving the Advent of Code challenges!

Building the Frontend of a Progressive Web App Using React

Batuhan Ipci — Fri, 02 Dec 2022 05:16:12 +0000

Keeping up the pace of continuous progression and development, I sought out for more challenging issues to fix after Hacktoberfest.

Seneca-CDOT has many amazing open-source projects to which students are actively contributing - telescope, my-photohub, vscode-extension, and so on - and from those options, I chose to work on My Photohub as I found the idea of storing a picture on a GitHub repo very innovative. It was also a new project and I wanted to be among the first time contributors.

Here is a small description of the project taken from the README.md

My Photohub is a web app that makes it easy to share your photos on the web. My Photohub takes your images and optimizes them for the web, creates a beautiful HTML page to show them, and hosts everything in a new GitHub Repository owned by you! Your photo web page is made available to the world via GitHub Pages. Best of all, everything is free, and you are in control of the end product.

The Issue

I tackled the issue - Create a PWA UI for accessing the service and raised PR here. To get started, I first had to understand what is a Progressive Web App.

What is a Progressive Web App (PWA)?

As stated in the mdn web docs:

Progressive Web Apps (PWAs) are web apps that use service workers, manifests, and other web-platform features in combination with progressive enhancement to give users an experience on par with native apps.

Some examples of PWAs are Spotify, Uber, AliExpress, Starbucks, and many more!
PWAs have faster load times, are more cost-effective to develop, and with the aid of service workers can even be used offline.

Offline First 🤔

As stated in the mdn web docs:

The "offline first" — or "cache first" — pattern is the most popular strategy for serving content to the user. If a resource is cached and available offline, return it first before trying to download it from the server. If it isn't in the cache already, download it and cache it for future usage.

This was an interesting concept to me as I had never thought of or built anything keeping offline first in mind. So, I dug a little deeper and researched more about it.

Here is an awesome resource to learn about offline-first.

The PWA React App

To get started I first did:

npx create-react-app my-app --template cra-template-pwa

After running the command, this is what gets generated.

Notice, how we have something called service workers here. This was pretty foreign to me.

What are Service Workers?

Service workers essentially act as proxy servers that sit between web applications, the browser, and the network (when available). ( source: mozilla)

Service workers are scripts that a browser executes, without any direct connection with the DOM. The entire offline experience is possible because of service workers, allowing features such as background synchronizations and push notifications. It provides content and the ability to cache assets in a web browser. Due to this caching mechanism, the app can work offline.

The Process in Brief

To create a PWA we need:

HTTPS — The app should be served over a secure network
Service Worker — A script handling network calls and asset caching
A manifest.json file — A JSON file containing design details

Then, I had to start working on the core frontend components of the site.

1) Navigation bar
2) A photo-uploading interface
3) An authentication dialog box

Reflection

I learned a lot of new things through working on this project. The concept of PWAs, Service Workers, and GitHub APIs was a lot to work on within one project.

Makefiles can be helpful in your CI Workflow

Batuhan Ipci — Wed, 30 Nov 2022 22:47:44 +0000

While developing palpatine, I used Makefile to automate the process of building and running the project.

Currently, it looks something like this:

setup: 
    @if [ "$(shell uname)" = "Darwin" ]; then \
        brew install gcovr; \
        brew install lcov; \
    fi
    @if [ "$(shell uname)" = "Linux" ]; then \
        pip install gcovr; \
    fi

dependency:
    cd build && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png

prepare:
    @echo ">>> Building palpatine ...";
    @if [ -d ./build ]; then rm -rf ./build; fi
    @mkdir build; 
    @cd build; \
    cmake -S .. -B .; \
    make; \

    @echo ">>> Done";
    @echo ">>> Run ./palpatine [options] to start the application";


test:
    @echo ">>> Running tests ...";
    @cd build; \
    cmake --build . --target unit_tests ;
    @cd build/tests; \
    ./unit_tests;

codecov:
    @echo ">>> Running tests ...";
    @cd build; \
    cmake --build . --target unit_tests ;
    gcovr --html -o build/index.html ;

Most of the set of rules of this Makefile are self-explanatory, also the echo logs I've set makes it easier to understand. I’m going to explain the ones that are not that obvious.

dependency rule is a interesting one. It initially changes the directory to build and then runs cmake with --graphviz=dependency.dot flag. This flag generates a dependency.dot file which is a graphviz file. Then, it runs dot command with -Tpng flag to generate a dependency.png file in build directory. This png file is a dependency graph of palpatine.
codecov rule builds unit_tests target just like test rule. Then, it runs gcovr command with --html flag to generate a index.html file in build directory. It helps to visualize the code coverage of the project.

Few weeks ago, I have added CI workflow to palpatine.

jobs:
  build:
    runs-on: macos-latest
    steps:
    - uses: actions/checkout@v2
    - name: setup
      run: |
        make setup
    - name: configure
      run: |
        cmake -H. -Bbuild -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug"
    - name: building
      run: |
        cmake --build build --config Debug --target unit_tests -j4
    - name: testing
      run: |
        cd build/tests && ./unit_tests
        bash <(curl -s https://codecov.io/bash)

This workflow runs on macOS and it does the following:

It checks out the code from the repository.
It runs make setup to install gcovr and lcov.
It runs cmake to configure the project.
It builds the project.
It runs the tests.
It uploads the code coverage report to codecov.

In the next releases, I am planning to automate the CI workflow with Makefile commands. I will update this post when I do that.

The perfect open-sourcer does not exist

Batuhan Ipci — Fri, 25 Nov 2022 00:00:36 +0000

Breakthrough

Over the last four months, I have set some goals to become a better open-sourcer.
They looked something like this:

[x] Contribute to an open-source project and build influence in the community
[x] Make a commitment to a project and build up credibility as a maintainer
[x] Do a meaningful code review and answer issues

Being young and having less experience in open source community, made all of these seem out of reach. Nevertheless, I carried them out. Regardless of what goals you might have, I want you to go through your version of a breakthrough.

During the process, what became clear to me was to put my commitment to the goals I wanted to achieve. I have this desire to be perfect in things I do, but ironically this leaves my work overdue and ultimately I end up not doing them. Though, once I achieve them, I wonder why I haven't done them earlier.

It's easier to achieve your goals than you think, but being perfect about them is not.

Contribute small to big 🐛🗻

Contribute to an open-source project and build influence in the community

Whether you contribute small or big chunks of code, being consistent about them carries vital importance. Small contributions to a particular project help you to get familiar with it at first and leads to something bigger.
Take a look at some pull requests I have raised to the following projects; withfig, cve-bin-tool, my-photohub, pr-approve-generator.

palpatine static site generator with unlimited power!⚡

Make a commitment to a project and build up credibility as a maintainer

One of the personal projects I love developing is palpatine. I blogged about it here and I am constantly adding new features to it! So far it has reached 5 starts and keeps growing with the help of the open-source community.

Keeping good maintenance on and marketing your projects is, I believe, a very significant part of open source. There are so many developers all around the world on GitHub potentially finding your project worthwhile.

Read Code Like A Book 📖 🧙

Do a meaningful code review and answer issues

Almost everyone seems to have had a hard time reviewing other people's codes. My experience was not very different, I too found it utterly challenging. So much so that, I was putting off writing this blog for the longest time. I understand, however, that being able to review other people's code is an important trait to have and a difficult skill to attain. It takes time and practice to be able to look at code and give constructive feedback about them so that it helps the project and the developer.

I reviewed the codes of two of my classmates from;

Review 2️⃣

I am no expert at code reviews yet, without writing much I want to click on the Submit review button as soon as I can. You as a developer may relate, there might have been times you found other developers more experienced than you are, and not wanting to review their code. However, in such a situation, reviewing good or poor-quality code can improve you as a developer drastically. Along the way, I found myself searching and learning a lot about things I didn't know.
This resource was the most important piece that helped me to make an impactful review.

Better open-source player 👾

After accomplishing all the goals I counted above, ironically it feels easier to do them again. Before I attempted any of those, it was very overwhelming, they all seemed like it was out of my capability. Do not wait for your work to be perfect and get started with what you truly love.
The feeling of accomplishment is so rewarding that you will be able to say; "you could do it once again."

C++ unit testing with Catch2 🧪👨‍🔬

Batuhan Ipci — Tue, 15 Nov 2022 20:17:35 +0000

Writing unit tests for my static site generator - palpatine, taught me an entirely new testing framework called Catch2. For my Hacktoberfest pull request this year I had done a unit testing contribution for a repository and I am currently working on building a microservice for my cloud computing class which requires us to use Jest for JavaScript unit testing. So, I can say that I have some experience with unit testing and continuing to develop my skills in it.

Building good unit testing skills takes time as it requires us to think about our code more deeply. What should the input look like? What is the expected output and what are some of the edge cases? In my normal, day-to-day, personal projects, I did not pay much attention to testing. But I know that it is important for real-world development.

Trust the code 🌱

As the name suggests, unit testing is about testing small units of code or components of an application or system to ensure that it is behaving the intended way. An application has building blocks that work in harmony with one another. By testing out these building blocks or units and checking that it is behaving the right way - we can trust the code!

What if some codes are hard to test? Well, that means that it probably needs to be broken down. This also means that unit testing encourages modularity.

If a unit of code uses another unit as a dependency we also need to ensure that the dependent unit is being used the right way.

Why choose Catch2?

There are many established testing frameworks for C++ such as Google Test, Boost.Test, Cute, CppUnit, and many more. However, what sets Catch2 apart from the others is its ease of use and simpler learning curve. Not just that. Catch2 also has great documentation and tutorials that I could read and follow. Also, over the summer, I completed a Udemy course on CMake and there I found a template for testing with Catch2. That template was really useful for me in setting up the configurations to get started.

As a beginner in writing tests, I would say Catch2 was not as simple for me to learn as more experienced programmers suggest. I had to spend a few days reading through the documentation, going over YouTube videos, and looking through many many examples online before I could write my first test. But once I started writing, it felt easier to go on.

As stated in Catch2's documentation:

Catch2's main advantage is that using it is both simple and natural. Test names do not have to be valid identifiers, assertions look like normal C++ boolean expressions, and sections provide a nice and local way to share set-up and tear-down code in tests.

Setting it up 🛸

I first had to start by downloading the catch2.hpp file and then #include it

#include <catch2/catch_test_macros.hpp>

And then I had to define this on top.


#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do


// this in one cpp file

The TEST_CASE macro is used for introducing test conditions. It is used to group the test cases for a particular unit of code.

SECTION is defined beautifully in their documentation:

Another way to look at sections is that they are a way to define a tree of paths through the test. Each section represents a node, and the final tree is walked in depth-first manner, with each path only visiting only one leaf node.


TEST_CASE("CLI Parser works perfectly", "[parser]") {

std::vector<std::string> vct{"./palpatine"};

SECTION("Without any args") {

REQUIRE_THROWS_AS(get_options(vct), std::runtime_error); 
}

As mentioned earlier, my CMake course provided me a template to work with that I could modify and use for my testing purposes. If you check my CMakeLists.txt file you will see:


if(ENABLE_TESTING)

set(TEST_MAIN

"unit_tests")
set(TEST_SOURCES

"main.cpp")

SET(GCC_COVERAGE_COMPILE_FLAGS "-fprofile-arcs -ftest-coverage")

SET(GCC_COVERAGE_LINK_FLAGS "--coverage")

SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS}" )

SET( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}" )

add_executable(${TEST_MAIN} ${TEST_SOURCES})

target_link_libraries(${TEST_MAIN} PUBLIC

${PALPATINE_LIB}

argparse

Catch2::Catch2WithMain 
)
add_test(NAME ${TEST_MAIN} COMMAND ${TEST_MAIN})
endif(ENABLE_TESTING)

Test coverage 💯

My project also has a test coverage provider that shows the lines that are covered by the test and the percentage of coverage. For my test coverage provider, I chose to use gcovr. It had clear documentation on setting it up and I could do it without facing any trouble.

From their documentation.

Gcovr provides a utility for managing the use of the GNU gcov utility and generating summarized code coverage results.

The command for running the test coverage is:

gcovr

As you can see in the image below, I am able to see the lines covered by my tests!

If you want your coverage to look colorful, just pip it with lolcat 😃

Final thoughts ☕︎

Writing tests for C++ was harder compared to the other projects I have worked on. As the codebase evolves, I need to also make sure that the tests get updated over time.

Static analysis tooling with CMake

Batuhan Ipci — Sat, 05 Nov 2022 07:19:51 +0000

Regardless of whether I am an experienced programmer or not, it is tough to write the perfect code. Ideally, I would like to detect every potential flaw, and bug and debug them to the appropriate standard in no time! But this is a tough concept, and relying only upon your developer instincts for analyzing code is insufficient, especially if you are writing in C++.

While analyzing code yourself and self-proofing is a vital skill that every developer needs to practice, having a professional tool like clang-tidy gives me more confidence that my code adheres to C++ standards.

Setup clang-tidy ⚙️

I recently integrated clang-tidy in palpatine using CMake modules, you could browse the cmake directory of palpatine where I kept the StaticAnalyzers.cmake module.

To set this up from scratch, first install clang-tidy with brew install clang-tidy on macOS, or if you are on Linux install it with sudo apt-get install clang-tidy.

After successfully installing, I have added the most commonly used clang-tidy checks into the .clang-tidy dotfile.

Note: Notice the WarningsAsErrors: '' field in this file, it is responsible for labeling the warnings as errors. Although, currently it is not active as I haven't provided any value. But if you would like to activate it, you could replace the empty value with "*".

Power of CMake 🧰

See the directory called cmake in the root directory of palpatine.
Having cmake modules within the directory cmake is commonly used, the purpose of doing is to include() custom CMake functions to be used later in the project.

Mine looks like this -

There are 2 files (AddGitSubmodule.cmake, StaticAnalyzers.cmake) and 2 corresponding functions palpatine uses. Our attention will be on StaticAnalyzers.cmake.

After adding the module StaticAnalyzers.cmake we need to configure it in a way that clang-tidy will always run whenever we build the project using CMake (i.e. cd build && cmake .. && make). However this might not be the "intended behavior" in every project, maybe you prefer running it at the end after you are satisfied with your implementation for reducing each CMake build time. That said, there is a neat way of setting this as an option in the file CMakeLists.txt.

Navigate to the root CMakeLists.txt file of palpatine and see in this line , I have defined a CMake option that lets me switch between weather I decide to use clang-tidy or not.

Now go back to the module StaticAnalyzers.cmake and notice the first line we are checking is if the option is turned ON or OFF (i.e. if(ENABLE_CLANG_TIDY)) If this option was set to OFF, CMake would ignore this module.

if(ENABLE_CLANG_TIDY)
    find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)

    if(NOT CLANG_TIDY_COMMAND)
        message(WARNING "🔴 CMake_RUN_CLANG_TIDY is ON but clang-tidy is not found!")
        set(CMAKE_CXX_CLANG_TIDY "" CACHE STRING "" FORCE)
    else()
        message(STATUS "🟢 CMake_RUN_CLANG_TIDY is ON")
        set(CLANGTIDY_EXTRA_ARGS
            "-extra-arg=-Wno-unknown-warning-option"
    )
    endif()
endif()

The find_program() CMake command, will search for the clang-tidy that is already installed in your system. If it is unsuccessful in finding it, it will complain with big, fat, and red warning 🔴 in the terminal. Check if you indeed installed it in your system with; clang-tidy --version. If it is successful, 🟢 will indicate your CMake configured clang-tidy with no trouble.

clang-tidy in action 🚧

Run the traditional set of CMake build commands in your terminal in the root directory of palpatine.

mkdir build && cd build && cmake .. && make

A combination of these commands is one way of creating a build folder and configuring it with CMake;

After CMake can see the command clang-tidy , finally configure it with the project.

set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};-p=${CMAKE_BINARY_DIR};${CLANGTIDY_EXTRA_ARGS}" CACHE STRING "" FORCE)

add_custom_target(clang-tidy
    COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target ${CMAKE_PROJECT_NAME}
    COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target clang-tidy
    COMMENT "Running clang-tidy..."
    )

Delete the existing build folder and re-run this set of commands mkdir build && cd build && cmake .. && make to test if clang-tidy produces any warnings in the terminal.

In project palpatine, the output looks like the following -

There is also a vscode extension called CMake Tools from Microsoft. It provides this set of buttons that automates the CMake build progress;

This is beneficial in a way if you want to integrate CMake and visualize the warnings in vscode before running it on CLI.

If I build palpatine using CMake Tools vscode displays the warning within the file.

Conclusion

C++ is developing rapidly and reviewing code is not enough to keep up with the latest standards. Using static analyzers like clang-tidy inevitably helps us to write defect-free code. You might as well learn from the warnings produced by clang-tidy.