How I prepared my first online course

Since long I didn't publish anything here. It's because I was busy with some other topics, but now it's time to share the results with you.

 In the previous years I published several articles about different aspects of software development on different platforms. From all of them that ones were the most popular which were about version control with git, so at one point I decided to write a book, about this topic (https://www.amazon.com/dp/B095QK1MTN,

https://www.amazon.com/dp/B099C3GKL1).

Once the book was done I started to thing about how bring this topic on a higher level and I decided prepare some tutorial videos and upload them to youtube.

This was an activity which pointed out of my comfort zone. I'm feeling comfortable with doing the technical work and to write about it. I have also nothing against talking about it face to face. But to record it and publish it, so that people can replay it any time, so that people can find all mistakes I made later. They realize my English mistakes, my wrong pronunciation and my voice. And then they can leave feedbacks and comments. That was more than uncomfortable for me.

Finally somehow I managed to get over all these fears and I prepared my first tutorial video about "How can git support you in debugging your code" (https://www.youtube.com/watch?v=kNlnUaEcoLQ). I was really afraid when I first published it. And surprisingly I got really good feedbacks, both from friends and from people, who I don't know. One friend proposed me to prepare a whole online course. I still didn't feel comfortable with that, but after considering it two months long I started to prepare it.

I had to learn a lot: I read a lot and watched some online tutorial about how to build up an online course, what's to be taken care while working on the videos. I learned for example that the first 10 minutes are the most important, because after that time to listener decides if they want to continue the course or not. I also had to make sure if the sound quality is good enough. And I had to decide what I want to share in the videos: do I want to video myself, show some pre-prepared slides or my share my desktop while working on different scenarios? Finally I decided to do a mixture of slides and screen records, while solving real scenarios. I wanted to do my courses in a really practice-based manner.

And finally, despite all my personal fears I decided to add a short introduction video, where I record myself in my personal room. This was really something out of my comfort zone, but I managed to do it.

I learned how to record the screen and edit the video properly. I set up the environment and tried to configure it in a way, that it's well-readable in the videos. I created the skeleton of the course, collected the topics I want to share and figured out the best way to present them. I was thinking about the examples long hours long and I prepared some practical exercises. Then I recorded all the videos, which was pretty time consuming, but it also made fun. Finally I had to find a platform, where I can share the course and finally I decided to use Udemy for this purpose.

So I uploaded and filled everything on Udemy and finally I managed to publish my course.

It has two parts. The first part of for free for everyone and it's called "GIT for beginners" course (https://www.udemy.com/course/git-for-beginners1/?referralCode=2661870CB856A3BDB49C).

The second part (the follow-up of this course) is called "Advanced GIT course - Become a GIT expert" and it presents advanced tricks of GIT. Normally it's not for free, but in the next day by using this link you can get it for free:

https://www.udemy.com/course/advanced-git-course/?couponCode=7402FFF253AB9D0D86F5

I hope you will enjoy it, the only request is that please give me some valuable feedback, so that I can improve the course further.

Creating my first only course made me a lot of fun, I learned a lot, both technically and personally. In the meanwhile I received the first feedbacks and fortunately they are also mostly positive. I hope I managed to create a valuable content which will help a lot of developers.

Find the commit which broke the test in git

Scenario

Find the first broken git commit.

Scenario in details

However the main purpose of git is version control, it can be also useful for debugging.

You found a bug in the system, your first two questions are of course: who did it and when?

Let git help you to figure it out in a fast way.

Detailed description of the solution

Case 1 - Manual verification of commits

If you don’t have an automated way to verify if a commit contains the bug or not, then follow case 1.

The solution will be git bisect. You can enter bisect mode with the command git bisect start.

Then you have to mark your current commit bad, as it contains the bug. Type the git bisect bad command. As the next step you have to mark the last known good commit, so a commit where the bug was still not present. For that you may have to try out several commits. But if you remember that it was still working 2 days ago, then just pick a commit from that day. You can checkout each commit to test. Once you found a good commit use the command git bisect good hash_of_the_good_commit. If the current head is the good commit you can skip the hash from the end of the command.

Now git bisect will checkout some commits. Determine for each if they contain the bug or not and mark them with git bisect good or git bisect bad. After several steps Git bisect will tell you the first good commit. If you think you made a mistake you can restart the bisect process anytime, just type git bisect reset.

Case 2 - Automated verification of commits

You can make this process faster if you have a script or any executable which can determine if the bug is present or not. You can even use a test framework. The point is only that the executable shall return 0 if the bug is not present and anything else if the bug is present.

Similarly to case 1 enter bisect mode with the command git bisect start.

Then you have to mark your current commit bad, as it contains the bug. Type the git bisect bad command. As the next step you have to mark the last known good commit, so a commit where the bug was still not present.

Once you marked one good and one bad commit just use the command git bisect run path_to_your_executable. Here the executable is either a standalone script, but it can be even a call to your test framework with some parameters.

After this step git bisect shows you the first bad commit.

Step-by-step guideline

Case 1 - Manual verification of commits

1. Type git bisect start - It starts the bisect process

2. Type git bisect bad - It marks the current commit as “bad”

3. Type git bisect good hash_of_the_last_working_commit - Mark “good” the last commit where you are sure the bug was not present

4. Now git bisect will checkout a commit which is between the current and the last good commit. Compile it and test it. If the bug is present type git bisect bad, otherwise git bisect good.

5. Repeat step 4 until you can’t find the commit

Case 2 - Automated verification of commits

1. Implement a test which returns 0, if the bug is not present and non zero if the bug is present (most of the test frameworks already works in this way, so it is enough to implement some simple unit test in most of the cases)

2. Type git bisect start

3. Type git bisect bad

4. Type git bisect good hash_of_last_working_commit

5. Type git bisect run your_test

Test your knowledge

You can test your knowledge here:

https://github.com/lmarcell/git_practical_exercises_bisect

Additional git material

You can find more useful information related to git in the following ebook:

https://leanpub.com/practicalguidetoversioncontrolwithgit/

What did I learn from Artificial intelligence for robotics course by Udacity

Introduction

During the last months I did not publish any blog posts. The reason is simple. I was busy with some other topics.

One hand I’m a lucky guy, who did not lose his job due to the current situation, I even had a bit more tasks to be done.

On the other hand, thanks to the flexibility of home office I managed to attend some online courses. Furthermore I’m preparing a material which is giving a great overview on the topic of version control with GIT, you will get more information about this project soon. And of course I occupied myself with non profession related activities.

Now the time is here to become active again on blogging.

During last spring there was an offer from Udacity for taking their “Artificial Intelligence for Robotics” course for free.

Since I have a stronger background of software development, but less experience with robotics algorithms I decided to take it. Let me write some paragraphs about my experience.

How about Udacity

I had no previous experience with Udacity, but I already took several courses from Udemy, which is one of their concurrents, so that’s a good base to compare.

Since I took that time the free version of the Udacity course the service was also limited: I did not have project review and mentorship to the project and I also did not get a certificate in the end. Later on I attended the Self Driving Cars nanodegree program as well, so I also have experience with the commercial Udacity courses, but let’s discuss it in a later post.

While doing the Udemy courses I often found myself bored and lost my attention. In the case of Udacity it was not the case at all.

The material is splitted into lessons, each lesson takes between 1 and 2 hours. During the lessons videos, written materials and quizzes are changing each other. The videos are following a friendly and natural style, while they are explaining well the problem and the solution. The written materials are giving a great summary on the theoretical part of the topics, sometimes even links are attached for some additional materials. The quizzes are either questions with some selectable options or coding tasks where you have to write a small piece of code or extend a given one. All your solutions are evaluated automatically. This is the way how you are making your attention alive and how they are forcing you to really understand the material.

After each session there was a section called “Problem Set”, which contained some tasks which covered the topic of the previous lesson and a “Q&A” session where the most frequent questions are discussed.

In the end of the course there was a practical exam with a list of practical tasks covering the whole material and a final project, called “Runaway Robot” to be solved. It was a real challenge, but it made me learn a lot.

It was a nice experience.

The content of the course

The course itself introduced the most important problems of robotics and their possible solutions. I prepared a very brief summary of these topics.

Since you find a lot of material about these concepts online, I won’t go into details this time, I’m rather just giving an overview.

Localization

The first chapter was about robot localization. The problem to be solved is to decide where the robot is located based on its motion and it’s senses.

Back to the university we learned a lot about distributions and probabilities. That time I did not really understand why we have to learn it, it was pure theory, so I did suffer a lot while learning it.

This chapter brought me at least one purpose, why I had to learn it that time and it also gave a great fresh up of the topic.

Furthermore it introduced me to some robot motion models.

All things considered it gave me a nice overview on the problem of localization.

Kalman filters

Kalman filters are great tools for making some predictions based on historical data. They are based on gaussians, which are functions to represent values with their probability.

So that if there’s a series of measurements with a given probability (for example about the position of the robot or of another object), Kalman filters can update the gaussian after each measurement based on the new measurement values and tell the most possible position of the tracked robot or object. One of its most useful applications in the world of robots and self-driving cars is sensor fusion, where it combines the measurements of several different sensors.

Another fact I have to mention, that it’s named after Rudolf Emil Kalman, who was Hungarian, similarly to me.

As part Udacity Self Driving Cars course I managed to implement an extended Kalman-filter, feel free to take a look: https://github.com/lmarcell/CarND-Extended-Kalman-Filter-Project

Particle filters

The idea of particle filters provides an efficient filtering method, which is really easy to program and which can be used for example for localization. 

The main idea is to randomly create a large amount of particles, which are basically guesses where the robot is located at the moment. Then a weight shall be assigned to each of the particles. After each movement of the robot these weights shall be updated. High weight means that it’s very likely that the robot is around, small weight means that there’s only a small chance for that. By following this method after several movements it will be visible what is it’s most probable position.

Path planning

To find an optimal path between two points in a huge space is a challenging task. However this is a very important topic when we are talking about robots.

In an ideal case we already have a map of the space, but since this space is huge the classical path search algorithms, like breadth-first-search or depth-first-search are not efficient enough to find the most optimal path.

During the course two more efficient solutions have been presented. The first one is the A* algorithm, which is a kind of extension of the classical Dijkstra algorithm. The main idea is to introduce a heuristic function which provides an optimistic guess for the distance from a position to the goal position. So that takes the way where we expect the smallest distance based on the heuristic function.

The main challenge is to find a good heuristic function, since using the wrong heuristic function makes this algorithm really inefficient.

Next to A* algorithm the main concept of dynamic programming was also presented in the course.

PID Control

You have already planned the expected path of the robot, the next step is to let the robot follow this path. This may sound like a trivial problem, but it isn't. Just imagine: your robot is moving with a permanent velocity and you can only tell it if it should turn right or left. And you have the reference path, which should be followed. The most trivial idea is that if the robot is left from the reference path then let it turn a bit right. If it is right from the reference path let it turn left. In this case it will more or less follow the reference path, but it will always overshoot, so cross the reference path and this will result in a very strange and uncomfortable moving for the robot. A PID controller introduces a so-called differential and an integral component as well. If you find the right weight for the different components then you can reach a quite smooth and comfortable moving of the robot.

To find the optimal weight is also not trivial, but fortunately there’s a great algorithm called twiddle, which can help you.

As part Udacity Self Driving Cars course I managed to implement my own PID controller, feel free to take a look: https://github.com/lmarcell/CarND-PID-Control-Project

SLAM

SLAM stands for simultaneous localization and mapping. This can be used in the case when you don’t have a map of the environment of the robot. For example you have a vacuum cleaner robot and you want it first to move around the room and create a map of that, so that later it can find the most optimal path for cleaning it.

This is the problem of SLAM. This problem and one basic possible solution have also been presented as part of the course.

Summary

All things considered I learnt a lot from this course, it let me understand some main concepts of robotics which I could reuse as part of my daily job, while working on autonomous driving.

The course doesn’t go deep into the details, but it teaches and presents the main ideas in a very efficient way. This brought me to the decision to do the Udacity Self Driving Cars course, but let me tell you more about that course later.

Software development in automotive sector

Introduction

The automotive business changed a lot during the last decades. Earlier a car was built up from poor hardware, without any software. During the last time there was a huge change: nowadays software is much more important in a car, than the hardware. All big companies are looking for software solutions on challenges, such as autonomous driving or environment friendly driving (E-cars, better engine controllers etc.). And to resolve these problems, there's a huge need for good and efficient software.

I've been working for more than 5 years in the automotive business and I still think that it is a really challenging and innovative area for software developers. Let me give you a better overview.

Software related areas in automotive

There are several areas in the automotive business, where software has a high focus. I will introduce them below, however there are other areas where software is involved and I’m not mentioning them.

ADAS

ADAS is an abbreviation of Advanced Driving Assistant Systems. This involves basically everything which brings the classical, human-based driving in the direction of autonomous driving. Several systems are already available in serial models, like: adaptive cruise control, lane keeping assistance, park assistant systems etc. But additional solutions are expected within the next few years which will enable autonomous driving in different environments (highway, country road, city).

From a software developer perspective these tasks are strongly related to robotics. Based on the inputs of sensors, like radar, lidar, cameras and ultrasonic sensors, by using additional inputs from the map and about the state of the car (current velocity, steering wheel angle etc.) it should be calculated what is the right reaction of the car.

Of course this process is split into several substeps, like sensor information preprocessing, sensor fusion, object prediction, trajectory planning etc.

Usually a lot of mathematics is involved in this area using technologies of signal processing, computer vision or artificial intelligence.

I think this area is maybe the most challenging area of automotive software development.

Engine control

Controlling the engine is done by software, which can be really challenging in the days when saving the environment is in focus and the related standards are very strict. To be able to achieve them very good software solutions are needed.

There’s even a trend of electrical cars. Their engine also needs strong software support to achieve an efficient energy consumption.

Brake control

Nowadays every new has an ABS (Anti-lock Braking System), which is a great software based support to achieve safe braking even in case of high speed or slippery road surface.

Next to that cars have several additional brake assistant systems, like differential scanning calorimetry (DSC) electrical stability control (ESC) etc. These are mostly software based systems, sometimes even with pretty complicated calculations in the background.

Automatic Gears

Automatic gear is also working in a software based manner nowadays. 

Active and passive safety

Another big area is active and passive safety. Let's see what is included here.

Passive safety contains the classical safety features, like seat belts and airbags and pedestrian safety systems as well. Some software is already involved here, but that’s not really the focus here.

Passive safety is more interesting from a software point of view, however it is overlapping with other categories, like ADAS and brake control. It contains all the systems which can help to avoid an accident or just lowering the risks by lowering the velocity before an accident. That involves emergency brake systems, blind spot detection, adaptive cruise control, ABS, ESC, driver monitoring and lane departure warning. These systems require strong software support.

And I think it is really a good goal to work for decreasing the number of accidents on the roads.

Lighting

Modern cars have a proper system to control their lightning to light always with the right intensity to the right direction. To be able to do it some software support is needed, like detection of other light etc.

Infotainment

Classically infotainment contains everything that stands for the communication between the car and the driver, it involves all screens and touch screens, voice recognition, buttons on the cockpit and on the steering wheel etc. It always includes more and more functionalities, like multimedia, navigation, mobile communication etc. Of course these all require great software based solutions.

Navigation

It is a subpart of infotainment, but it is complex enough to mention it separately. Nowaday navigation requires next to great visualization and audio instructions. Also very good localization and path planning based on several inputs. There are challenging cases, like navigation in a tunnel or navigation in complicated, multi-leveled junctions.

Car2car communication

This topic is really pointing into the future, to the world of self-driving cars, but it is already part of our present. In such a system that’s a huge advantage if the cars can communicate with each other, share their planned movements, share what they can see or share their route. Additionally, cars can also communicate with the infrastructure: traffic lights etc. There are already solutions where the traffic light is changing if a bus arrives.

Additionally we can not rely on the internet, since there’s no signal for example in tunnels, so there’s a lot of challenge on the communication layer as well.

As more and more traffic participants start to communicate more and more information it will become a really interesting domain for both big data and wireless network solutions.

Tooling and simulation

Last but not least a huge area in tooling and simulation which is about developing small (and sometimes even complex) programs which can support the developers in activities like testing, simulation, visualization, parameter adjusting etc. At first it can sound easy but in reality it can also be pretty complex, especially if we are talking about traffic and car simulation.

Used technologies in automotive

The software development in the automotive sector is mostly embedded development, except tooling, that’s pure desktop development. Nowadays mobile application development is also part of automotive, since there are more and more situations when our mobile phone communicates with our car.

The core development used to be based on embedded C, but nowadays most companies are changing to use modern C++.

The tool development is mostly done in Python, in some cases in C++ or Java.

Popular frameworks are also used, like OpenCV, OpenCL, ROS etc.

THe model based approaches are also popular, so UML or Simulink is often used in the automotive sector.

Other than that all classical testing methodology is used, like unit testing mocking, higher level testing, software in loop, hardware in loop.

From the domain perspective all knowledge of robotics, computer vision, artificial intelligence or network programming  is welcomed.

Of course up to the project and company this stack may change.

Development process in automotive

The development of the software of a car is done in multiple sections. First usually it starts as a research project. Its goal is to find the right technical solutions. The next step is a pre-serial development, it is still not dedicated for a model, it is a kind of overall solution. And the last step is the serial development, which has the goal to develop a proper software for dedicated models.

However more and more automotive companies are changing to work in a more agile approach, automotive software development is traditionally convervative and strict.

There’s a framework called Automotive Spice which should follow at most of the serial development projects. This framework is very strict and it requires you to document the requirements clearly, link the software design and related code. As well as the test should be properly documented and linked to software requirements and code.

Biggest challenges of automotive software development

Finally I’d like to point out some domain specific challenges.

No bugs in serial software allowed

As the development of the software is done it will be flashed on thousands of microcontrollers (ECUs). Currently most of the OEMs are flashing them manually one by one and there’s no opportunity for remote flashing. That means that to change the software on an already released car requires bringing it to the workshop and reflashing its software. It is of course inconvenient for the customer and costly for the company.

That’s why finding the major bug after the final release is really painful and should be avoided. In order to avoid such situations the testing of the software needs to be done in a really proper way.

Real Time communication network

In a modern car there are really a lot of microcontrollers (ECUs) and several sensors which are communicating with them (cameras, radar, lidar, ultrasonic sensors, wheel impulse counter sensor, rain sensor etc.) The communication between these sensors and ECUs should be really fast in order to avoid shortages which may lead to accidents. Package loss or communication errors are also risky because of the same reason.

Small capacity of processor and memory

The software needs to be written only once, but from the hardware thousands of units need to be produced. It absolutely makes sense to save money on the hardware by using a cheaper processor or a small memory.

On the other hand the software needs to be developed in a way that it is fitting well with this smaller capacity hardware, which can be challenging for the software development team.

Functional Safety

We all know that in a complex system a lot of things can go wrong: sensor failure, communication failures, unknown software bugs, memory failures etc. A car should be able to handle these situations in the right way. It should be able to detect and handle such situations in a safe manner to avoid or reduce such risks as much as possible. In order to do that a standard called ISO26262 should be followed during the whole development process. It provides a methodology to identify and classify the possible failures and to prepare the software to react on them in the best possible way.

Technically these solutions can be based on checking inconsistent inputs and outputs, on using multiple sensors to receive the same input and in certain cases to do the same computation parallel on multiple controllers with different algorithms.

Security

Since the goal of functional safety is to prevent risks caused by the failure of our own system, the goal of security is to prevent risks caused by externals. In the century of computer viruses and hackers it is very important to have a proper mechanism to guard the system from possible manipulations coming from outside, since they could cause serious accidents. This is a new area in automotive which has a really high focus and which involves huge challenges.

Summary

After more than 5 years as a software developer in the automotive business I see this area as a really challenging area, which needs more and more software developers. If you are considering changing your domain don’t forget about automotive.

Advanced GIT Tutorial - How to debug your code with GIT?

Introduction

Unfortunately every software developer knows that things are often going wrong. Something breaks the build, something else breaks the tests. Someone makes changes which don’t fit with the coding guidelines etc.

It can be pretty difficult in such cases to figure out what went wrong, long long hours and days of debugging is needed sometimes.

Fortunately git can also help in such situations. Let’s see some builtin git commands which can make your life easier if something went wrong in your project.

Figure Out, Who Introduced The Guilty Line

You are reading a code and you find a line. “Who the hell did it?” - this is your first question. Maybe you don’t understand the purpose of the line or it is not following the coding guidelines or it is the root cause of a bug. The first thing that you can do is to check the git log for that file and figure out which commit contains the relevant change. It can be time consuming, especially if there’s a long history of the file and the relevant change happened long back in the time.

There’s another, more efficient solution: git blame.

Just type git blame filename. It will show you for each line, which commit was the last one that modified it.

This way it is pretty easy to figure out who did the change and what was its purpose.

Find The First Broken Commit

You found a bug in the code. You know that a week ago it was still not present and you don’t know the exact root cause yet. It would help a lot if you knew which commit introduced the bug, you could save a lot of debugging-time.

Git bisect is the best solution in this situation. Git bisect is a binary search method in your commit history. It can even handle the merge commits. Let’s see how it works:

1. Type git bisect start - It starts the bisect process
2. Type git bisect bad - It marks the current commit as “bad”
3. Type git bisect good hash_of_the_last_working_commit - Mark “good” the last commit where you are sure the bug was not present
4. Now git bisect will checkout a commit which is between the current and the last good commit. Compile it and test it. If the bug is present type git bisect bad, otherwise git bisect good.
5. Repeat step 4 until you can’t find the commit

Thanks for the power of binary search, it is a pretty fast method to find the guilty commit.

It can cause issues with this method if the bug is not consistent, it randomly appears in some commits.

Automatize The Search Process

It can be time consuming to test the commits manually.

Fortunately it can be automated. Git bisect also supports running automated tests.

1. Implement a test which return 0 if the bug is not present and non zero if the bug is present (most of the test frameworks already works in this way, so it is enough to implement some simple unit test in most of the cases)
2. Type git bisect start
3. Type git bisect bad
4. Type git bisect good hash_of_last_working_commit
5. Type git bisect run your_test

This method will find the first commit where your bug is present.

Summary

Both git blame and git guilty can be very useful in situations when you have to figure out what is the root cause of a bug. It can be much faster than using a classical debugging approach, given that you committed frequently enough.

How can COVID change the life of programmers?

During the last months the whole world changed a lot. Something happened that was not expected at all. The schools closed in most of the countries and a lot of courses have been started. Most of the companies changed to home office mode or closed down. Anyway, digital solutions have a high role in the current situation. The companies with a good digital background can survive, the rest can easily fail.

Fortunately most of the software companies have a good digital background. But how will this situation influence the life of programmers in the long term?

Finally we can do home office

At most of the companies the opportunity of home office is a big ghost since years. Even if there are no technical obstacles or they could be removed by a simple IT solution (like setting up a VPN bridge etc.), a lot of companies still had a policy of no home office or very restricted rules for home office (like only once a month etc.). In most of the cases they had the impression that working from home is not efficient. Or they just wanted to track their employees more strictly and easier.

At most of these companies it changed now and they changed to an almost 100% home office mode. Which means most of their employees in most of their time are working from home.

I’m sure that on one hand there are companies and projects who are more successful on this change, on the other hand some companies may fail this change.

The reason for failing can be the lack of trust from management point of view, wrong leading strategies in the company, pure technical infrastructure, lack of experience or lack of motivation from the developer side.

But based on what I’m experiencing and what I heard from others at most companies this change was more or less successful, the teams are working from home with similar efficiency as they had before.

From the developer side there are also different opinions. There are ones who hate working from home. For some of them the conditions are not fulfilled at home properly, others are just too social to do it on a daily basis.

But, at least from the ones I know, most of the developers like this situation from a work perspective. I personally also like it, but I would prefer to work from the office once or twice a week.

The other point I often heard is that some of the developers have difficulties to find the work-life balance at home and they are working much longer than normally. You have to be strict with yourself to manage it properly.

What will happen to our projects?

Another perspective is the perspective of the customers. Since a lot of businesses stopped working during the last weeks, for sure there will be a lot of projects cancelled by the customers. On the other hand there are fields where there's a huge need for software developers: online communication and education solutions, digital solutions for shops and services etc.

So I also expect a lot of new projects coming in the near future. However all of us need to be flexible, it can happen that we have to change our profile a bit and to change domain or technology in the future.

What comes after Corona?

As for now most of the well-paying developer jobs are placed in big and expensive cities and expensive countries.

At these places even if you have a good salary you don’t have a huge chance to have your own house in a calm circumstance with a nice garden, these places are mostly too crowded for that and the prices are too high. Furthermore a lot of developers are working far from their home, just to have a proper job.

In the current situation there’s a good chance that companies will realize that home office work can still be efficient and they can save a lot of costs on that (like renting office space etc.), so they are changing fully or partially to this mode in the future.

I already heard some nice visions from programmers about moving to the countryside or back to their hometown and doing the same job for the same salary remotely.

It sounds great, but I doubt if it could work so easily.

If you take a look at how most big companies are working nowadays: they have headquarters and offices in more expensive countries, near to their customers and they have offices in so-called best cost countries (like India, eastern-European countries etc.). The reason is that it is enough to pay much less (sometimes even around 25%) in the best cost countries, than in the expensive ones (US, UK, Germany etc.). But they still want to have a certain amount of employees who are there in place, who can meet any time with the customer, who can be tracked better, who are near to the fire.

So if you are working now at an expensive and well-playing place and you are changing to 100% home office mode and moving to some nice, preferred place your advantage over the colleagues working in the so called best cost countries will be strongly reduced. So that it isn't worth it for your company to pay you 3-4 times more than for your colleagues working in the low cost offices. So most likely they won’t do it in the long term.

On the other hand the disadvantage of being far away from the headquarter will be also reduced if more and more work is done remotely. It makes no big difference if you are working from home in the next street or 2000 kilometers away.

That means if the home office model will become more and more popular I expect the differences of salaries between the different countries to be reduced in the long term.

How to make the most benefits from the situation?

How can we handle this situation?

First of all I have to remark, that we are very lucky compared to other professions, since our job can be easily done from home, so we are not stuck without incoming for weeks or months. On the contrary, we can save some time by not having to commute to work everyday.

One hand we have to do our best for our current work and current project to show that we are efficient developers even from home office.

In order to do that you have to have a strict daily routine and you may have to try out new tools or new ways of working. For example we started to do only mob-programming sessions and I think they are really useful.

On the other hand in your free time you have to learn something new, so that you will be flexible enough to change if it is required in the future. Take a look at the trending technologies and domains. There are now a lot of online courses available for free or for a discounted price. Do them, it makes you really powerful in the long term!