Reason: The order is unspecified.

Note: C++17 has stricter rules for the order of evaluation, but the order of function argument evaluation is still unspecified.

Let's look at a simple example:

//test.cpp

#include <iostream>

void foo(int a, int b) {
    std::cout << "a: " << a << " " << "b: " << b << std::endl;
}

int main() {
    int i = 0;
    foo(i++, i++); // (1, 0) | (0, 1) | (0, 0)

    return 0;
}

If you understand what I'm saying, then you're on the right track. If not, let's move on to the explanation.

Here's my proof. The output from gcc and clang is different:

• gcc

g++ -std=c++2a -O3 -Wall test.cpp -o test && ./test

test.cpp: In function ‘int main()’:
test.cpp:9:15: warning: operation on ‘i’ may be undefined [-Wsequence-point]
    9 |     foo(i++, i++); // (1, 0) | (0, 1) | (0, 0)
      |              ~^~
test.cpp:9:15: warning: operation on ‘i’ may be undefined [-Wsequence-point]
a: 1 b: 0

• clang

clang++ -std=c++2a -O3 -Wall test.cpp -o test && ./test

test.cpp:9:10: warning: multiple unsequenced modifications to 'i' [-Wunsequenced]
    foo(i++, i++); // (1, 0) | (0, 1) | (0, 0)
         ^    ~~
1 warning generated.
a: 0 b: 1

The function call could be evaluated as foo(0, 1) or foo(1, 0), but the order is not guaranteed. Technically, the behavior is undefined. In C++17, this code doesn't have undefined behavior, but it still doesn't specify which argument is evaluated first.

I compile in C++20 or use the best error detection during compilation with optimization by using a compiler flag.

If you want to learn more about this, check out these links:

• Why doesn't C++ have a specified order for evaluating function arguments?

• Evaluation order in C++

• Compilers and argument order of evaluation in C++

Before, we understood what is Flutter Version Manager (FVM) and how to be used. First, we need to understand, you really need this or not version management?

Why do we need Version Management in Flutter?

When working on Flutter projects, you may need to switch between different SDK versions to validate and test upcoming Flutter releases with your apps, which is very tedious and time-consuming. This is where Version Management comes to the rescue.

Which provides us with different types of Flutter versions for our machines. So that each time, Flutter can test the app against the updated Flutter release without waiting for installation and will be able to switch to the Flutter version accordingly.

How we performed version management

Actually, there are two ways to do this,

• Naive Approach (via aliases)
• Tool base (via FVM)

Naive Approach

It doesn't matter which operating system and which shells you are using, alias, all the same, some here and there technically.

Suppose this is your base directory for Flutter SDKs. $HOME/dev/flutter_sdks

And here you download different channels to flutter SDK

cd $HOME/dev/flutter_sdks
git clone -b stable https://github.com/flutter/flutter.git flutter_stable
git clone -b beta https://github.com/flutter/flutter.git flutter_beta
git clone -b dev https://github.com/flutter/flutter.git flutter_dev
git clone -b master https://github.com/flutter/flutter.git flutter_master

Now it's time to check everything present in your base directory.

 ╭─adityaa@naveen in ~/dev/flutter_sdks 
 ╰─λ ls
flutter_stable
flutter_beta
flutter_dev
flutter_master

Now it's time to aliases, open your .bashrc, .zshrc, config.fish, or whatever.

vim ~/.bashrc

# flutter sdks alias
 alias flutter="$HOME/dev/flutter_sdks/flutter_stable"
 alias flutterb="$HOME/dev/flutter_sdks/flutter_beta"
 alias flutterd="$HOME/dev/flutter_sdks/flutter_dev"
 alias flutterm="$HOME/dev/flutter_sdks/flutter_master"

Now you can use the naive version through aliases

Note! You can not only clone branches but also clone versions via a tag.

Tool based

Flutter Version Manager is a very important and easiest way to manage multiple Flutter SDK versions and channels without going into the complete installation setup whenever we need to access some other version for our projects.

FVM follows the same principle as our aliasing approach but the only difference is that FVM global Config and default directory use a symbolic link to a particular Flutter version.

Steps For Installation Of Flutter Version Manager

• First step is to check that Flutter, is installed or not on our system, to work on FVM. Run the following command on your terminal-

  flutter
  

  If the Flutter, is already installed on your system, it will show us some common commands used in Flutter.

  In addition to this, if you want to know your Flutter version, you can run the command.

  flutter --version
  

  This command will return the exact version of Flutter and Dart installed on our system.

• Now, in the next step we will have to activate FVM on our system, for that we will have to run the command

  pub global activate fvm
  

  ⚠️ Do not activate FVM using flutter pub global activate if you plan on using the --global flag. Only activate FVM using pub global activate fvm.

  Read dart.dev docs for more info on how to run global dart scripts.

• We will now see that some warnings are given at the end of the installation process, so we need to add the fvm path to the shell configuration file (.bashrc, bash_profile, etc.) before taking the next step

  export PATH="$PATH:`pwd`/flutter/bin"
  export PATH="$PATH:`pwd`/.pub-cache/bin"
  

  Now, the warning will be removed. For verifying that FVM is now completely activated, we will run the $echo PATH command, which will give us the path for the same.

SDK Version Install:

FVM allows us to install multiple types of Flutter releases or channels.

• version - use stable to install the Stable channel and v1.8.0 or 1.17.0-dev.3.1 to install the release.
• --skip-setup - will skip Flutter setup after install

fvm install <version>

Project Config SDK Version:

After that, we will see whether the project is configured to use a specific version or not. If not, we will install it on the appropriate version without arguments.

fvm install

Use an SDK Version

You can use different Flutter SDK versions per project. To do that, you have to go into the root of the project and:

fvm use <version>

If you want to use a specific version by default in your machine, you can specify the flag --global to the use command. A symbolic link to the Flutter version will be created in the fvmhome folder, which you could then add to your PATH environment variable as follows: FVM_HOME/default/bin. Use fvm use --help, this will give you the exact path you need to configure.

Flutter Installed Versions List:

Now by typing in the following command, we can list the installed version on our machine by using the below command. FVM will store the SDK version.

fvm list

Upgrade SDK Version:

Using the upgrade SDK version command, when we need to upgrade our current SDK version, so you have to call the command of your flutter SDK as in normal flutter installation.

fvm flutter upgrade

Set Up IDE:

Now we will see how to configure IDE. Below, we have shown how to configure the Android Studio and VS Code. Let's see it now.

⇒ Android Studio:

In your root project directory, copy the absolute path of the fvm symbolic link.
Example: /absolute/path-to-your-project/.fvm/flutter_sdk

After that, we will open Languages and Frameworks in the menu of Android Studio → Now, search for flutter and change the path to flutter SDK path. Now you can run it with selected versions of Flutter and debug it.

⇒ VS Code:

Now we will configure VS Code, here we will see how to complete the VS Code process.

Add the following to your settings.json. This will list all Flutter SDKs installed when using VSCode when using Flutter: Change SDK.

Use fvm list to show you the path to the versions.

List all versions installed by FVM.

{
  "dart.flutterSdkPaths": ["/Users/usr/fvm/versions"]
}

You can also add the version symlink for dynamic switch ``` JSON { "dart.flutterSdkPaths": [".fvm/flutter_sdk"] }

Use FVM in Your Project

The goal is to apply a specific Flutter version to your project by using FVM.

• Create a Flutter project in your development folder by executing flutter create project_name:

• Switch to your project directory and execute fvm use <version_you_want>:

• If you run fvm list once again, you can see a tick mark or active by the version you are using in the project:

If you want more information and configuration of the fvm, see the official docs.

If I make any kind of mistake, let me know in the comment box and correct me. And I hope that you like and are helpful to you this article.

For example, I have my Backup on one partition and content in another.

!Warning: Doing this requires editing the fstab file in the /etc/ be careful while doing this. Mistakes may cause boot or other issues.

Note: I don't have another drive, So I show in same drive and in different partition.

Identifying the Disk

There are two ways to do this. The first is through a GUI disk manager on your system or through the terminal. I recommend using the terminal, but it’s always good to double-check on a disk manager such as Disks, KDE Partition Manager, or GParted.

To do this though a program you can open the ‘Disks’ utility and identify the drive. You’re going to want to find the Device, UUID, and the type of file system. For my example, I will be mounting my Backup drive.

Removable Media: Mounting removable storage such as USB’s, SD cards, etc, in fstab will result in an un-bootable system if the removable storage isn’t present and connected at boot time.

Finding the device information though the terminal is very easy and in most cases preferred to using software.

Find the fdisk list command to see all drives and their partitions.

sudo fdisk -l

The blkid command allows you to display information about available block devices. This will allow you to view the file system type, UUID, labels, and more.

sudo blkid

Note down the UUID of the partitions that you want to mount at startup.

Make a Mount Point

Now that you know your disk UUID we will create the mounting directory. You can make this almost anywhere, but it is common practice to do this in the /media folder. Type the following command replacing “Backup” with whatever you want it to be called.

sudo mkdir /media/Backup

Edit /etc/fstab File

We will edit our fstab file. First we need to open the file in nano or whatever editor you want with superuser privileges.

sudo nano /etc/fstab

Now we will input the information of the disk, so it will mount on boot. You need to pay attention to how it is typed. Instead of typing a space make sure you hit tab. I start with a note (anything with a # will be ignored by the system) so it's easy to tell what drive is what. For my example I will type:

# Backup (dev/sda6)

Now the input will look something like this. Be sure to replace the UUID, mount point, and file system type to match your drive. See the image below.

UUID=9a86ee6c-caf0-4c35-8aa9-117949c1ee09       /media/Backup    ext4     defaults      0      0

Breaking that line down, we have:

• UUID=9a86ee6c-caf0-4c35-8aa9-117949c1ee09 - is the UUID of the drive. You don't have to use the UUID here. You could just use /dev/sda6, but it's always safer to use the UUID as that will never change.
• /media/Backup - is the mount point for the device.
• ext4 - is the filesystem type.
• defaults - is the default mount settings.
• 0 - determines which filesystem need to be dumped (0 is the default).
• 0 - determine the order in which filesystem checks are done at boot time (0 is the default).

Now we will CTRL-O, and it ENTER to save the file. Reboot your system and it should be mounted!

For our purposes defaults 0 0 will work fine.

Learn more about fstab settings here!

Test fstab

After you edit fstab, enter this command that will mount all drives set to auto-mount. If this gives you any errors ensure you’ve entered everything correctly.

sudo mount -a

If nothing is returned (e.g. no errors) then you should be good to go.

There you go. You should see all the drives you have configured to automatically mount in your system!

For more information follow this link,

Idempotency is something you might not see every day, but it is an important concept, especially when you are making payments.

As a developer, you are always wanting things to go smoothly, but in the world of REST APIs, that isn’t always the case. Client failures, networking errors, or just poorly written code can all spell trouble for an API call (and your end-user experience). Luckily, idempotency is here to help! It can be a little confusing at first, but once you have a handle on it, you’ll see that it is an important aspect of designing and using mission-critical systems.

Idempotency is an often-used term in computer science. It's meaning to some might not be known, to others, it's very well known. The explanation for idempotency is:

The property of some operations such that no matter how many times you execute then, you achieve the same result.

In the context of a developer working with REST APIs, your application is sending requests and getting back responses with some other service on the internet. When that API is an idempotent guarantee that when you send an identical request you will always get an identical response. What do I mean by identical? The headers, body, authorization, everything needs to be exactly the same.

Not all REST APIs use idempotency, most of the time it is only necessary for requests that influence the state of something, or you really don’t want to accidentally run twice. For many APIs, this is limited to POST or PUT requests, whereas most “state neutral” requests do not add the complexity to their interfaces.

Let's understand that with a simple example:

When Client/End-User wants some information usually the GET method is used. Way change user mistakenly requests 10 times or even millions of times then that information doesn't change in meanwhile.

But, When the user used POST request quite several times, then might that identical requests is stored multiple times in the database.

Originally we as a Developer does not want that going on, which lead to a fatal mistake accidentally. So in my point of view, there is two way we can avoid that error:

1. Suppose we are going to make order in amazon site to buy hard drive in that case amazon put some param in API of order like:

   POST /order/:userId/:productId/

   In that case, the server only checks product and user already make an order or not if not make entries in the database. If the next request is the same then the server regret request and then not make two orders of the same product.

1. Some of the developers using hashing. They hash the body of requests and check hash are present in the database or not, if not then feed in the database.

In my point of understanding view, these are an easy approach to deal with that kind mistake, and maybe more solutions are available than these two.

Essentially, idempotency is the mathematical way of saying “one can apply a certain operation on something many times, without changing the result of the operation after the first time the operation is applied”.

If you want to learn more about this then follows these link: