sdmg15

:: Ubuntu 23 Workspaces

2023-06-28T00:00:00+00:00

A new feature I discovered after installing Ubuntu 23.

Tbh it’s not quite new feature, it exists since but I never took advantage nor given any time to it. But recently I switched to a new computer and installed Ubuntu 23 on it. Coming from ubuntu 18.04.

I was really impressed by the way the UI has evolved a lot. It’s kind of more smooth and more attractive than previous versions I think, again this is only my point of view.

The new Ubuntu 23 quite looks like MacOS :) yeah I think they have some points in common.

As also a Mac user I’ve always wanted to have the three fingers touch switch on Ubuntu. For those of you who don’t know what it is here is a sample of what using three fingers on the touchpad looks like on Mac.

With the advent of Ubuntu 23 (Lunar codename) we have something similar, not quite similar but that can be a “replacement” of that with more features: WORKSPACES.

As said at the begining the feature is not quite new, it’s just that it’s now I’m starting taking advantage of it, and I thought it will be worth sharing maybe this could help more developers in increasing their productivity.

So workspaces? What are they?

With workspace you could have a great segregation between differents tasks/projects you’re working on.

If you’re like me you could have 2 or more projects you could be thinkering on and sometimes you have multiple code editors opened while doing switching maybe from your code editor to browser and back you may get inside the wrong editor stuffs like that. This will take you time to look again for the right code editor where the project you’re working on is opened etc.

One of the tools that is used daily is browser. As developer we sometimes have ton of browser tabs for multiple projects and we can easily get lost in searching tabs that are related to the project we’re working on, with workspaces this belongs to the past.

Workspace helps you separate different instances of applications you’re using for differents projects. They will really help you increasing your productivity while being organised. specific

If you like multi-tasking, you could have an external monitor, one workspace is on the monitor another one in your laptop !

Creating workspaces: limited vs unlimited

In order to save some memory you could limit the number of workspaces you want to created during your sesssion. To do so open Settings then go to MultiTasking. In the same window there are more settings related to multitasking adjust and tweak atr your convenience. This will all depend on the amount of memory you have so choose wisely.

In order to create a new workspace, wherever you’re at this moment use three fingers and swipe up on your touchpad. Once done you’ll have window similar to the one below.

As An alternative to the previous method, you could just presssuper key or windows key.

The three small windows at the top there represents the number of active workspaces I have. And the last one is where you could click to create a new workspace. And… that’s it, upon click, your new and fresh workspace is ready.

Switching between workspaces is really easy, you swipe horizontally with three fingers on the direction where the workspace you’re heading to is located and voila!

What’s really fascinating is how the apps on the dock on the left adapts to be only to the one that I have opened on a specific workspace.

Workspaces and memory consumption

I haven’t done any benchmarking yet between having 10 tabs opened in one browser and have two distinct instances each with 5 tabs for example. If you have more information about this you can drop them in the comments. In the meantime I’ll conduct my own research and update this section accordingly.

The only advice I can give here at the moment, is that if you notice any memory consumption spikes, just think about reducing or limiting the number of workspaces you have.

This is just a quick productivity hack I thought sharing, some may have been using this since previous versions of ubuntu, but as said I knew them since but never bothered checking at them, now I did and found them interesting.

What’s you’re experience working with ubuntu workspaces? Until next time !

:: C++ User Defined Literals

2020-08-21T00:00:00+00:00

The advent of C++11 introduced a lot of new awesome features into the language going from Lambda Expressions, Exception Specification with noexcept, Constant Expressions, auto type specifier to User Defined Literal and more… I’ve already covered the basics of Lambda in my previous post, if you haven’t read it yet I recommend you to. Today what will get our attention are UDLs. UDL or User Defined Literal for long is a C++ feature that helps you provide some shorthand construction of your object types, to the user of your interface.

The standard library itself comes in with some predefined literal suffixes suchs as sv (String View) which lets you contruct a string view from a string literal e.g auto myStringView = "This is a new string view"sv; In order to be able to use the sv literal you’ll need to use the required namespace using namespace std::literals.

You could also write custom suffixes for your custom types e.g auto myType = "some string for my type"_mytype; that’s where this post aim to drive you through.

The language has a ton of predefined literals that we won’t cover here but instead will see how to write ours. But before being able to do so there are some few rules as usually that we need to be aware of. Ready? Let’s go …

The syntax and supported parameter types

As during each war, if you want to have a chance to come out winner, you need to get prepared well, this is what this section is all about means preparing our weapons !

The Syntax

The syntax of UDLs is almost similar to the one you use when declaring a function or a function template operators. The defined operator is called Literal Operator or Literal Operator Template if it’s a template.

Yes man thanks for the info, but please dissimulate the doubt in me…

Hehe yeah let’s move straight to it. Considering that it follows the same rules as normal functions declaration we’ll omit return type specification and other specifiers to just focus on what interest us.

The global syntax follows this pattern:

1
operator ""_ud-suffix(ParamType)

Where :

_ud-suffix is a character sequence preceded by an underscore (_) that will constitute your actual customized prefix. eg: auto operator ""_myType(ParamType)
ParamType is the type that will be used when the compiler will be perfoming the unqualified lookup to match the viable overloaded operator.

The values that ParamType supports are discussed in the next section. The syntax is so simple right? Now let’s see what are the values supported by ParamType to complete our cake.

Supported parameter types

As stated earlier, UDL will let you produce objects of your defined type by providing a custom suffix. The only literal types that are allowed before your suffix are integer literal, character literal, string literal and floating point literal.

1
2
3
4
auto distance = 10_km; // Integer Literal
auto monthObj = "january"_month; // String Literal
auto weight = 10.49_kg; // Floating Point Literal
auto asciiCode = 'C'_ascii; // Character Literal

For every types in the previous listing, there should be a corresponding overloaded operator defined, else the program will be ill-formed:

For user defined integer literals, the compiler will perfom an unqualified lookup and if the overload set includes a definition with ParamType equals to unsigned long long this overload will be selected and the user defined literal expression will be considered as a call to the function operator "" myType(xULL) where x is the literal without the ud-suffix. eg:

Let’s suppose we are in a stock market and we want to place some orders to buy 100 shares of an asset:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <type_traits>

enum class Side{
    BUY = 1,
    SELL = 2
};

struct Order {
    explicit Order(int qty, Side side = Side::BUY) : qty_(qty), side_(side) {}
    int qty_;
    Side side_;
};

auto operator ""_order(unsigned long long qty) {
    return Order(qty);
}
 
auto main() -> int {
 auto newBuyOrder = 100_order;
 std::cout << newBuyOrder.qty_ <<"\n";
}

Compiler Explorer

We can interpret the line 20 as auto newBuyOrder = operator ""_order(100ULL).

For user defined floating point literals, the compiler will still perfom the unqualified lookup and if the overload set includes a definition with ParamType equals to long double this overload will be selected and the user defined literal expression will be considered as a call to the function operator "" myType(fL) where f is the literal without the ud-suffix

1
2
3
4
5
6
auto operator ""_kg(long double amount) {
    // Construct some object here
}
auto main() -> int {
auto weight = 10.10_kg;
}

We can interpret the line 5 as auto weight = operator ""_kg(10.10L).

For user defined character literals (all its variant included: wchar_t, char8_t etc.) a corresponding overload with the variant type need to be defined, except the case where some can fit into others.

1
2
3
4
5
6
7
8
9
auto  operator  ""_p(char c) {
	return Person{10, c};
}

auto main() -> int {
    auto p = 'C'_p; // will call operator "" p(C)
    auto p2 = u8'P'_p; // compiles, p2 type is char until C++20
    auto p3 = L'P3'_p; // Will fail, need to include wchar_t in the overload set
}

For user defined string literals (all its variants included, const wchar_t*, const char16_t etc) an overload following the form

1
operator ""_ud-suffix(Type, std::size_t)

need to be defined. Where Type is one of the variant and std::size_t is the size of the string excluding the terminating null character \0.

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream> 

struct Person{
    Person(const char* name, std::size_t len){}
};
auto operator ""_p(const char* name, std::size_t len){
    return Person{name, len};
}

auto main() -> int {
  auto person = "king arthur"_p;
}

Compiler Explorer

NOTE: For user defined integer literals and floating point literals, if the overload set doesn’t include what is described above, but there is an overload for character literals, that overload will be used as fallback by the compiler otherwise the program will be ill-formed. Let’s see that with an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Money {
    explicit Money(int amount) : amount_(amount){}
    int amount_;
};

auto operator ""_euro(const char* amount) {
    // The amount is a string, cast it to int
    // then construct the object
    return Money( std::stoi(amout) );
}

auto main() -> int {
  // call operator "" euro("100")
  auto money = 100_euro;
}

This line 14 will then correspond to a call to operator ""_euro("100").

You said literal operator template are similar to function template declaration, but I wrote a User Defined Literal operator template and the compiler is yelling at me :sad:

Oh don’t do that, at least without following the rules. The rules for defining literal operator template are as follows:

The template parameter should be only one argument which must be a non-type template parameter pack with type char
The operator should have empty parameter list, means the function should not take any argument

In terms of code it means the declaration should be of this form template<char...> auto operator ""_P(). The call to such operator will result in operator ""_P<'c1', 'c2', 'c3'..., 'ck'>(), where c1..ck are the individual characters of the integer or floating point literal.

Let’s suppose we want to sum all digits of a given number we could write something like this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    #include <iostream>
    #include <array>
    #include <algorithm>

    template<char... t>
    auto operator"" _sumOfDigits(){
        int r = 0;
        [&](const std::array<char, sizeof...(t)>& a){
            std::for_each(a.begin(), a.end(), [&](char c){
                r += c - '0';
            });
        }({t...});
        return r;
    }

    auto main() -> int {
        auto sum = 912_sumOfDigits;
        std::cout << "The sum of digits is : " << sum << "\n";
    }

The UDL at line 17 will be treated as a function call operator ""_sumOfDigits<'9, '1', '2'>().

The defined literal fo string_view (sv) you shown doesn’t have an underscrore at the beginning why does my own has one, are you kidding me ?

Oh good catch! The literals that don’t have the underscore before their suffix are reserved means only the standard library can define such literals alas!

Users and use cases of UDLs

You’ve scrolled enough ! If you reached here means you already know the basics of UDL congrats. But there may be still this question intriguing you: who uses UDLs and when should I use them?

Well, there are a lot of libraries out there that provide UDL for their types. For example nlohmann::json which is a JSON library for modern C++ provides the suffix _json so that you can construct JSON from raw string literals.

1
auto order = R"({"OrdID": "1", "Instrument": "btc_usd"})"_json;

The std::chrono library has also a lot of defined literals to help you construct time and date easily and quickly. Remember to include the required namespace with using namespace std::literals

1
2
auto milliseconds = 10000ms;
auto seconds = 1000s;

UDL comes in a handy way when you’re writting your unit tests as stated in this talk by Matt Godbolt (https://youtu.be/nLSm3Haxz0I?t=1149).

I also wrote a toy library called Nkap to demonstrate the usage of UDLs, you can check the source code of the repo https://github.com/sdmg15/nkap.

This is just to name few, you can also go ahead and take advantage of the feature to provide such shorthand objects construction for your types !

Final Thoughts

In the stampede to modern C++, adding UDL to your toolbox will help you write strong programs, keeping you also at the cutting edge. I admit it’s a lot to take in, but recognize with me that the pain is temporary whilst the glorry is eternal :smile: !

References

:: C++ lambda: The basics

2019-11-24T00:00:00+00:00

If you have a Math background, you’ll have probably already heard about Lambda. In Programming in general and in C++ specifically, the concept may not resemble at all at what you think but don’t be afraid, in this post I’ll briefly introduce you to what Lambdas are and how to use and take advantage from them.

Before lambda: the earlier age …

The Standard Template Library (STL) is composed of containers. Iterating over them is quite easy, you can choose to use a build-in Algorithm like for_each or even use a raw for loop. But as a rule of thumb it’s recommended to use standard algorithms, because they express well the intend and make the code cleaner.

The for_each algorithm overload that we will use takes three parameters:

The first one is an iterator pointing at the beginning of the container
The second one is another iterator but that points at this time after the end of the container
The third one is a Callable

A Callable maybe a class or a struct that overrides the bracket operator (operator()), or a function pointer/reference.

Let’s enlight our words with the following example:

1
2
3
4
5
6
#include <iostream> 
  struct TestCallable {
    void operator() (int param){
       std::cout << param << "\n";
    }
  };

When passed as the third argument of for_each the operator will be called with the specified argument.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <algorithm>
#include <array>
#include <iostream>

struct TestCallable {
  void operator()(int param) { std::cout << param << "\n"; }

};

  auto main() -> int {
  std::array<int, 4> a = {1, 2, 3, 4};

  std::for_each(a.cbegin(), a.cend(), TestCallable());

  return 1;
}

Compiler Explorer

The above snippet will print the elements of the container. This is what we call High Order Functions (HOF).

As you can see we were obliged to declare an external class and then overrides its bracket operator before being able to use it as a callback in the for_each algorithm. It maybe annoying having to do that everytime that we need a callback for doing a specific task.

Wait, you’re saying that everytime that I need a callback I’ll have to write such class? I’m abandoning here …

No don’t run out, I’m sure you have guessed that if I’m talking to you about that “problem” it’s because a solution actually exists, just keep scrolling :wink:.

Lambda to the rescue

Lambda is a feature introduce since C++11. It provides a concise way to create simple function object. The code we wrote earlier can be written like this using lambdas :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Compiler Explorer : https://godbolt.org/z/Fr4utK

  #include <array>
  #include<iostream>
  #include <algorithm>

  auto main() -> int {
    std::array<int,4> a = {1,2,3,4};

    std::for_each( a.cbegin(),a.cend(), [](auto param){
        std::cout << param << "\n";
    });

    return 1;
  }

Compiler Explorer

Note that we are not anymore using TestCallable as the third parameter. The two code will basically perform the same task, just that this one is using a lambda. Cleaner right?

Dude is that obscure syntax you want me to introduce in my code base?

Well, the lambda syntax can be obscure but once you’ve understood the meaning of each branches you will feel that your soul is now different from others :smile:

Depicting the different parts of a Lambda

Overall structure

A lambda is a closure type. It’s structured as follow since C++11: [](parameters) *specifier* -> *trailing return type* { *body* }

[]: called the capture list or lambda introducer. It’s there that we will specify the variables that will be available in the Lambda scope. It helps introducing the lambda.
(parameters): Called the parameter list. It’s inside the brackets that we will specify the parameters that the lambda will take when called. You probably already know this from traditionnal functions. The brackets are optional.
specifier: It can be either constexpr or mutable, it’s an optional value.
Trailing return type: It’s an optoinal value, preceeded by an arrow -> which specifies that we are using the trailing return type syntax. When not specified the return type of the lambda will be deduced using template type deduction rules.
body: It’s where you write the content of your lambda.

With all that on hands, we can now write as much examples as we can:

Example One:

1
2
3
4
5
6
7
8
9
10
// Compiler Explorer https://godbolt.org/z/ysp-p_

#include <iostream>

auto main() -> int {
  auto sumLambda = [](int a,int b) -> int { return a + b; }; // Declaring about lambda
  auto sum = sumLambda(4,5); // Calling the lambda with 4 and 5 as parameters 
  std::cout<< "The sum is: "<< sum << "\n";
  return 1;
}

Compiler Explorer

Example Two:

1
2
3
4
5
6
7
8
9
10
#include <iostream>

auto main() -> int {
  
  int age{20};
  auto changeAge = [](){ age = 10; std::cout << age << "\n"; };
  changeAge(); // Invoking the lambda at this point taking not parameters.

  return 1;
}

Compiler Explorer

When writting such syntax, internally the compiler will generate a unique unnamed class that overrides the operator() just like we did before. The type of the lambda is only known at compile time, we need to use auto keyword so that the compiler will replace it by a type he generated.

The generated operator() by the compiler is by default const if we didn’t explicitly required it not to be by putting mutable in the specifier list.

To visualize how the compiler generates that I used CppInsights which helps us see what the compiler sees :eyes:. Here is the link to the First Example using cppinsights, https://cppinsights.io/s/3feb5a61. There you’ll see and understand more about what I was describing.

Okay cook but dude, your second example is not running what’s going on?

Oh well, even me I don’t know what’s wrong. Just kidding let’s move to the next section to understand what’s wrong.

Lambda captures list

In the lambda body, variables of the parent scope (the scope in which the lambda was declared) are not available. If you want to make them being available you’ll need to specify that in the capture list. We don’t specify them randomly, there are some rules to follow:

[=]: will capture all variables in the parent scope by copy.
[&]: will capture all variables in the parent scope by reference.
[&a,b]: will capture a by reference and b by value
[&a]: will capture a from the parent scope by reference. It’ll be the only variable captured in this case.
[a]: will capture a from the parent scope by copy. It’ll be the only variable captured in this case.
[&a,=]: will capture a by reference and others by copy.

You should note that any capture may appear only once, so you cannot [a,a] else the compiler will scream of pain. You also cannot do something like [&, &i](){}; because you are already capturing all by reference, so the second term is not necessary. Those are just few examples of misuses of the capture list that will leave your compiler unhappy.

So coming back to our Example 2 we can rewrite it accordinly:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>

auto main() -> int {
  
  int age{20};

  // Defining the lambda and capturing `age` by reference
  auto changeAge = [&age](){ age = 10; std::cout << age << "\n"; };
  changeAge(); // Invoking the lambda at this point taking not parameters.

  return 1;
}

Compiler Explorer

If you were to capture age by value, you’ll have a compilation error, untill you write mutable in the specifierpart of the lambda, remember, this is because the generated operator() is by default const and in the lambda body we are modifying the value of age. The code will look like this if you want to capture age by value:

1
2
3
4
5
6
7
8
9
#include <iostream>

auto main() -> int {
    int age{20};
    // Defining the lambda and capturing `age` by value
    auto changeAge = [age]() mutable { age = 10; std::cout << age << "\n"; };
    changeAge(); // Invoking the lambda at this point taking no parameters.
    return 1;
}

Compiler Explorer

But if we were only reading the variable age without modifying it, the mutable here will be useless.

Note that when capturing by value, a copy of captured symbols are created in the lambda scope, so any modification of those symbols will be on their copy. If you want the modification to affect the original symbol you’ll probably need to capture by reference instead.

Default Capture list with initializers

When capturing variable you may decide to give them some default values. An example will be more illustrative:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <utility>

auto main() -> int {
  int fuel = 10;
  int time = 1000;

  auto changeFuelAndPrint = [fuel = 20, &ltime = std::as_const(time)]() {
    std::cout << "Fuel default value in lambda: " << fuel << "\n";
    std::cout << "Read only ltime: " << ltime << "\n";
  };
  changeFuelAndPrint();  // Will print 20

  return 1;
}

Compiler Explorer

The variable fuel in the lambda scope will be initialized to 20. The variable ltime is captured by reference and initialized with a time, with the std::as_const utility, the variable ltime will be read-only in the lambda body. You can play with that by creating multiple examples.

I noticed that you declare lambda first after then calling it in another line, ca we do better?

Yes sure IIFE ( Immediately Invoked Function Expression)

IIFE and Lambda

Lambda expressions are closure objects. They can be immediately invoked by putting () right after their declaration.

1
2
3
4
5
6
7
8
9
10
#include <iostream>

auto main() -> int {
  []() {
    std::cout << "Hello IIFE"
              << "\n";
  }();  // Invoking the lambda immediately, so it'll print "Hello IIFE"

  return 1;
}

Compiler Explorer CppInsights Link

If your Lambda was taking parameters, you’ll need to specify them in the brackets.

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>

auto main() -> int {
  [](int valOne, int valTwo) {
    int r = valOne + valTwo;
    std::cout << r << "\n";
  }(4, 2);  // Invoking the lambda immediately with parameters 4 and 2, it'll
            // print 6

  return 1;
}

Compiler Explorer

The simplest lambda you can write

1
2
3
4
auto main() -> int {
    []{};
  return 1;
}

The code above actually compiles, I won’t argue about it you have all the necessary weapons to understand how it’s behaving :wink:

Where to use Lambda

There are really a lot of places where you can take advantage of lambdas:

You can use them as callbacks
They help in complex initialization scenarios
You can use them to perform some inner actions without actually interferring with variables in the parent scope
They can be used to implement custom deleters for smart pointers. Employing the lambda way without capture incur no size penalty on the resulting smart pointer.

Lambda expressions come in a really handy way, but you just have not to abuse of them, still consider using traditionnal functions when necessary. If you don’t use them well you’ll fall under missed optimization opportunities.

Final thoughts

Ah, Lambda ! We came to our end !

Personnally I like the syntax of lambda syntax, it becomes intuitive after you understand how it works. As the C++ language evolve quickly, some additions were made to lambda such as templated lambda (C++20) it’s uncovered in this post.

Now that you have enough information about this mindblowing subject, I can now throw you in the nature to go and seek deep information on it :wave:

References

1 - https://eel.is/c++draft/expr.prim.lambda

2 - https://en.cppreference.com/w/cpp/language/lambda

3 - https://www.bfilipek.com/2019/02/lambdas-story-part1.html

:: GPG-signing your Git commits

2019-03-31T00:00:00+00:00

Have you ever wondered what the “verified” button near each commit hash in github/gitlab means? And maybe you want to have the same each time you commit? If you are curious like me and want to have it then here we go ! In this post I will guide you along the way on how to GPG-sign your commits using Git and Github (Not mandatory). Already excited ? Let’s go!

Why do I need to sign my commits any way?

If you are the Developer of an Open Source software (Or not) that deals with people money or at least with critical information then you may need to sign your commits to prove that it was really you who did the changes and not someone else. In that way if someone takes the control of your source code and make commits without them being signed with your GPG key then people will consider them as suspicious commits. In one phrase signing your commits help other people to know that the changes that was made are coming from a trusted source (You or the Organization that is maintaining the code).

GPG Cryptography ?

Heuh… Has someone said cryptography?

GPG stands for GNU Privacy Guard it allows you to encrypt and sign your data and communications. It uses a set of cryptographic algorithms in order to achieve those operations. With GPG utililties we will be intalling below you generate a key pair : Private Key and Public key. The Private key is the one required for signing commits (So it is like your password you need to keep it secret). The Public key is one you could be sharing with everyone.

Don’t panic, you don’t need to master all of those algorithms or concepts in order to have your commits marked with “verified” :smile:. But if you want to know more about to read more about cryptography check this and this.

Okay thanks for those links but I want to get my commits signed :smirk:

Generating a new GPG key

The operation is relatively straightforward. We will be using Github as the hosting platform for our source codes. Let’s no waste time anymore.

NB : All the commands you’ll see below have been tested on Ubuntu only.

If you don’t yet have any existing GPG key then continue ready, else jump to the step 4.

Github supports the following GPG key algorithms :

RSA (Rivest Shamir Adleman)
ElGamal
DSA (Digital Signature Algorithm)
ECDH (Eliptic Curve Diffie Hellman)
ECDSA (Eliptic Curve Digital Signature Algorithm)
EdDSA (Edwards-curve Digital Signature Algorithm)

If you generate your key with an unsupported algorithm by Github you may get errors (Something I’m sure you don’t want). A way not to have any error is to continue following my steps …

1. We will need first to install the GPG command line tools. To do so open your favorite terminal (With Ctrl + Alt + T in my case) and run the commands below :

1
2
    sudo apt update
    sudo apt install gpg

And to check if everything is installed you can run the command gpg --version. The minimun required version for this purpose is 2.1.17. If everything is Ok then let us move to the step 2.

NB: To get the utility from sources or for your platform click here

2. To generate a new key pair paste the text below in your terminal gpg --full-generate-key or gpg --full-gen-key for short version.

You will be prompted to chose the type of key you want. We could be spotting the RSA which is fortunately supported by Github and is even the default algorithm. We will chose it. Press enter and continue;
In the next prompt enter 4096, which represents the length in bits of the key;
At this moment you will be prompted to specify the validity duration of the key. Enter 0 if you do not want the key to expire (Let us chose this option);

After the confirmation of the validity duration you will be asked some personnal information that will be linked to the key.

NB: Make sure the email address you will enter is a verified email address on Github.

After entering and verifying your information you will be asked to enter a passphrase. The passphrase here is the password that will be required to enter before using the private key. It’s a guard for preventing someone else using your keys. Enter a strong one and save it jealously!

You can now take a cup of coffee while waiting the generation of the keys to be ended :coffee:

Mine has finished generating. You’ll have a similar output to this one

  gpg: key F9BE7A92520A3D02 marked as ultimately trusted
  gpg: revocation certificate stored as '/home/user/.gnupg/openpgp-revocs.d/1C4ACE74C12E904FBAFA79EDF9BE7A92520A3D02.rev'
  public and secret key created and signed.

  pub   rsa4096 2019-04-01 [SC]
        1C4ACE74C12E904FBAFA79EDF9BE7A92520A3D02
  uid                      john <john@mail.com>
  sub   rsa4096 2019-04-01 [E]

That means your keys have been generated successfully :tada:

It’s already taking me too long to have my commits signed I’ll give up

Hey do not give up, there are only few steps left!

3. The command below just displayed us public key (Notice the pub), but private key is required for signing commits or tags. Enter the following command to display the private key of all your available GPG keys : gpg --list-secret-keys --keyid-format LONG. It will now output you something like this one :

sec   rsa4096/F9BE7B91520A3D02 2019-04-01 [SC]
      1C4ACE74C12E904FBAFA79EDF9BE7A92520A3D02
uid                 [ultimate] me <me@mail.com>
ssb   rsa4096/3CA2083CEAA89B9E 2019-04-01 [E]

Make sure that before running the command there is no one around you :eyes: But even if someone has your private key and don’t know your passphrase it will be impossible for the person to use your keys that is why it is always recommended to have a passphrase set.

4. From the previous output you need to copy the Key id of the key you want to use. For our example the key id is F9BE7B91520A3D02 and use it with this command

1
  gpg --armor --export F9BE7B91520A3D02

It will print you a large set of random characters starting with -----BEGIN PGP PUBLIC KEY BLOCK----- and ending with -----END PGP PUBLIC KEY BLOCK----- which represents your public key. We will now add it to our github account.

Telling Github about my Generated keys

After have successfully generated the keys we now to inform Github about the generated keys.

1. In the upper-right corner of any page, click your profile photo, then click Settings. As illustrated below

2. In the user settings sidebar, click SSH and GPG keys.

3. Click New GPG key.

4. In the “Key” field, paste the GPG key you copied when you generated your GPG key.

5. Now Click Add GPG key.

Hey dude I don’t use Github what should I do?

If you are using Gitlab the process is quite similar to the one of Github. But if you are using none of them, then you’ll need to read the documentatiion from your favorite host to know how to do so.

Telling GIT about your signing key

At this point we are almost done! There is only one command to run in order to inform Git that we now want to use signing key for each of our commits :

1
git config --global user.signingkey YOUR_KEY_ID_HERE

Run the command we used to list the Key ids before and select the one you want to use then replace the YOUR_KEY_ID_HERE with it. So in our case we will have git config --global user.signingkey F9BE7B91520A3D02

I just did a new commit with git commit -m "Testing" but it didn’t work what’s going on ?

Ha I can realize that you are really hurried :sweat_smile:

For the commit being definitely signed, you need to add another option (-S) to the command you typed. So if we sum up we will have :

1
git commit -S -m "Signing commit"

To sign your tags (Releases) there is also an available option to do so :

1
2
git tag -s mytag # Creates a signed tag
git tag -v mytag # Verifies the signed tag

… Visual results in Github

After you commit, you can now push the changes to the upstream server (Github in our case). If you push to Github you will have the Verified badge now being added to all of your commits :smile:

Is that not beautiful? It combines at the same time beauty and security!

Is that what we call black magic? 🤔

Yes somehow ! You can consider cryptography signature as one !

Summary

Arrived at the end, we achieved our goal which was to have our commits signed using GPG (Gnu Privacy Guard) key. Note that even without doing all what we did in Github but doing those in Git you will still have your commits signed and if you give a commit hash to someone with your public key he will be able to proove that you were or were not the one who did the commit. Github is just there to have a beautiful display (With the “verified” badge) of the result.

References

:: 1,2,3 Hello World :tada: !

2019-02-10T00:00:00+00:00

Hello everybody ! Today I’m introducing my personnal blog.

What motivated me

I read a lot from blog posts, HN (Hacker News), Meduim, Dev and maybe from your blog too :wink: , and while reading I come accross various interesting articles, I get always excited while reading them and appreciate how articles Authors took their time to write and explain with simple words sometimes a really tough concept.

Writing about subject you think you know increase your knowledge on it actually, because you have to get sure about what you are writing, you’ll get yourself documented again in order to write a solid and consistent article or blog post.

There’s also that feeling when you have constructive feedbacks and when your post has helped and saved day of some People/Developers or motivated them or at least had an impact on them, by that time you start feeling like a genius :smile:

Writing I think is putting your knowledge into practice, putting your knowledge into practice to help others, putting your knowledge into practice to even verify if you know, putting your knowledge into practice for good !

One last thing is that as a Software Engineer Aspiring this is a good step to take, in order to show and describe my works and thoughts on various subjects to other people.

Above are some of the facts not in a specific order that get me motivated; Thus the feeling of writing keeps animating me.

Conclusion …

So my point is that writing is a skill that you cannot develop without writing, as the advise I gave in the about page practicing is the key, and to get experienced at whatever you do, you have to practice, So I always follow that advise !

I’m not an experienced writer, and you’ll never know how to write if you don’t actually do it !

As I keep saying, learning is a really long journey, if you are ready to take the ship with me then… LET’S GO !

Thanks