<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1JnAdgcSwXYc6lc5JXBbiA.png" /><figcaption>Huawei Mate 20 Pr</figcaption></figure>We are nearing the end of 2024 and the bombardment of nostalgic, holiday-themed Instagram and TikTok videos floods my smartphone screen, not that I mind doomscrolling until the early morning hours, that is. Probably due to some specific Meta algorithm or witchcraft (my money is on witchcraft) I keeping getting these old Nokia, Samsung, early iPhone days, video compilations of some of my favorite devices ever. Legendary and imaginative designs procession-tailored to almost any individual-liking. You want a specific form factor, the manufacturers got you covered. Want a <a href="https://en.wikipedia.org/wiki/N-Gage">taco-shaped</a> handheld game device that occasionally moonlights as a smartphone? Gotcha covered! Want a small clamshell phone that can stream TV signals on a mighty 65536-color TFT display? <a href="https://www.gsmarena.com/nec_e616-533.php">NEC </a>got your back… If you were from South Korea in the early 00’s that is…All this nostalgia scrolling on my 2K OLED Huawei <a href="https://www.gsmarena.com/huawei_mate_20_pro-9343.php">Mate 20 Pro</a> curved display (smooth transition, checked), got me thinking of my current main smartphone driver. My ‘Mate’. My ‘Pro’. I had this device since the late 2018, and to the moment of writing this post it hadn’t skipped a beat. I had a lot of favorite and memorable daily phone/smartphone drivers, starting from the legendary <a href="https://www.gsmarena.com/nokia_6150-10.php">NOKIA 6150</a> (still working with 60% of battery left) up to the <a href="https://www.gsmarena.com/samsung_galaxy_s9-8966.php">Samsung S9</a> before buying this Huawei Mate. All served their purpose, and were faithful until the day they weren’t. Most of them being steamrolled by technology, innovation, and time. The average lifespan of my main drivers was around 2 years as the principal devices of the household. The ‘Mate’ was/is the only device that keeps pushing the limits. The primary reason I’ve bought this device was it’s then-incredible camera system. On average, it was one of the highest scores on <a href="https://www.dxomark.com/huawei-mate-20-pro-camera-review-triple-cam-juggernaut/">DXOMARK</a> at the time. As I was dabbing into DSLR photography myself, that was one of my primarily requirements besides the flagship SOC specifications (future-proof and good for Android development). I can’t count the times I was asked about what device I was using and how the night/day photos turned out to be so good. To this day even. With each year and new Samsung or Apple flagship, I’ve contemplated switching to the most promoted one, and then realized that the minor incremental improvements smartphone manufactures make each year are truly minimal, and usually redundant. So many devices were introduced with my digits, and while one device maybe had the better battery life, it balanced it out maybe with a worse camera or display, and that was the case for quite some time. EONS in the terms of technology improvements.OK, “your requirements changed over the years” — you might say at this point. Yes, but very minimal. The smartphone, to this day, still completes 90% of my requirements. Is it responsive? Yes, it is. To be precise, this is the only device I had for more than 3 months, that never showed it’s age. I can still play new games on it. The battery (4200 mAh Li-Po) lasts at least a day at an average of around 5 hours of screen-on time. The display is fantastic and the high pixel density shows its virtues. The size and weight is perfect for my hands. Toughness,call quality, software? Check, check, and check. Huawei long supported this device with constants software updates and improvements. You see the point I’m trying to make?Speaking of the software, I could be wrong, but this might be the last or at least one of the last Huawei flagship devices that came with Google Play Services and Google application (GMail, Maps, Chrome, etc) support out-of-the box, probably influencing its aftermarket price. This is a story in all by itself, so I’ll just move pass it at this time.Drawbacks? Of course there are some. With an internal storage capacity for 128GB it can be a bit crowded in the space department, especially in 2024 where filesizes of the most basic of cat GIF’s is a gorillion kilobytes of data. After all these years, a lot of memories are accumulated and the need for increased storage slowly creeps in. There’s a memory card slot, so that potential ‘issue’ is addressed there. Support for newer Android versions (Android 12 and up), has halted, and it would be great to have some of the features new Android versions bring with them.Will I replace my “Mate’? Most definitely, yes. I’m in the tech world, and sooner than later a device will fall into my hands that’ll check all the boxes the Mate 20 Pro did that late December evening of 2018 when I bought it. Until that day arrives, I’m glad that I had the chance to be surprised in a positive way with a faithful companion such as the Huawei Mate 20 Pro.I’m interested to hear what device, lets be materialistic here for a bit, has held your imagination or was your go-to device despite its age? No matter the technology. It can be a car, bicycle, smartphone, refrigerator, anything. Comment below.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1484c0cd609" width="1" height="1" alt="">

Huawei Mate 20 Pr
We are nearing the end of 2024 and the bombardment of nostalgic, holiday-themed Instagram and TikTok videos floods my smartphone screen, not that I mind doomscrolling until the early morning hours, that is. Probably due to some specific Meta algorithm or witchcraft (my money is on witchcraft) I keeping getting these old Nokia, Samsung, early iPhone days, video compilations of some of my favorite devices ever. Legendary and imaginative designs procession-tailored to almost any individual-liking. You want a specific form factor, the manufacturers got you covered. Want a taco-shaped handheld game device that occasionally moonlights as a smartphone? Gotcha covered! Want a small clamshell phone that can stream TV signals on a mighty 65536-color TFT display? NEC got your back… If you were from South Korea in the early 00’s that is…
All this nostalgia scrolling on my 2K OLED Huawei Mate 20 Pro curved display (smooth transition, checked), got me thinking of my current main smartphone driver. My ‘Mate’. My ‘Pro’. I had this device since the late 2018, and to the moment of writing this post it hadn’t skipped a beat. I had a lot of favorite and memorable daily phone/smartphone drivers, starting from the legendary NOKIA 6150 (still working with 60% of battery left) up to the Samsung S9 before buying this Huawei Mate. All served their purpose, and were faithful until the day they weren’t. Most of them being steamrolled by technology, innovation, and time. The average lifespan of my main drivers was around 2 years as the principal devices of the household. The ‘Mate’ was/is the only device that keeps pushing the limits. The primary reason I’ve bought this device was it’s then-incredible camera system. On average, it was one of the highest scores on DXOMARK at the time. As I was dabbing into DSLR photography myself, that was one of my primarily requirements besides the flagship SOC specifications (future-proof and good for Android development). I can’t count the times I was asked about what device I was using and how the night/day photos turned out to be so good. To this day even. 
With each year and new Samsung or Apple flagship, I’ve contemplated switching to the most promoted one, and then realized that the minor incremental improvements smartphone manufactures make each year are truly minimal, and usually redundant. So many devices were introduced with my digits, and while one device maybe had the better battery life, it balanced it out maybe with a worse camera or display, and that was the case for quite some time. EONS in the terms of technology improvements.
OK, “your requirements changed over the years” — you might say at this point. Yes, but very minimal. The smartphone, to this day, still completes 90% of my requirements. Is it responsive? Yes, it is. To be precise, this is the only device I had for more than 3 months, that never showed it’s age. I can still play new games on it. The battery (4200 mAh Li-Po) lasts at least a day at an average of around 5 hours of screen-on time. The display is fantastic and the high pixel density shows its virtues. The size and weight is perfect for my hands. Toughness,call quality, software? Check, check, and check. Huawei long supported this device with constants software updates and improvements. You see the point I’m trying to make?
Speaking of the software, I could be wrong, but this might be the last or at least one of the last Huawei flagship devices that came with Google Play Services and Google application (GMail, Maps, Chrome, etc) support out-of-the box, probably influencing its aftermarket price. This is a story in all by itself, so I’ll just move pass it at this time.
Drawbacks? Of course there are some. With an internal storage capacity for 128GB it can be a bit crowded in the space department, especially in 2024 where filesizes of the most basic of cat GIF’s is a gorillion kilobytes of data. After all these years, a lot of memories are accumulated and the need for increased storage slowly creeps in. There’s a memory card slot, so that potential ‘issue’ is addressed there. Support for newer Android versions (Android 12 and up), has halted, and it would be great to have some of the features new Android versions bring with them.
Will I replace my “Mate’? Most definitely, yes. I’m in the tech world, and sooner than later a device will fall into my hands that’ll check all the boxes the Mate 20 Pro did that late December evening of 2018 when I bought it. Until that day arrives, I’m glad that I had the chance to be surprised in a positive way with a faithful companion such as the Huawei Mate 20 Pro.
I’m interested to hear what device, lets be materialistic here for a bit, has held your imagination or was your go-to device despite its age? No matter the technology. It can be a car, bicycle, smartphone, refrigerator, anything. Comment below.

Is The Huawei Mate 20 Pro the ‘Mate’ for Time

Automating an Application Deployment Process<figure><img alt="Srdjan Delić — SDRemthix Android tutorial header image of the official Android logo" src="https://cdn-images-1.medium.com/max/1024/1*kC_-Q4g5W0c1vY2kLZVp9w.png" /></figure>Let’s not waste any time, if you’re an <a href="https://play.google.com/console/signup">Android developer</a> with an <a href="https://www.apple.com/mac/">Apple Mac</a> development machine, and want to automate the build, testing and deployment process using the Fastlane framework, you’re at the right place.This tutorial as an addendum to the existing setup process available at the official Fastlane documentation <a href="https://docs.fastlane.tools/">page</a>. If you’re experiencing issues with your Fastlane setup, you can use this article as a checklist of sorts or go directly to the troubleshooting section of this article for the more common issues when running Fastlane deploy.<h3>Fastlane Setup Prerequisites</h3>First things first, visit the following page and make sure that you’ve obtained and secured the needed *.json API file that is tied to your existing Android Developer account:<a href="https://docs.fastlane.tools/getting-started/android/setup/">https://docs.fastlane.tools/getting-started/android/setup/</a><ul><li>You have already created the project for your app on the <a href="https://play.google.com/console/about/">Google Play Console</a></li><li>You have generated the release signing credentials for your app (keystore *.jks file and password, alias, alias password)</li><li>On a Mac machine, make sure you are in the right shell and that JAVA_HOME is defined (best use the same one as in your<a href="https://developer.android.com/studio"> Android Studio Environment</a>)</li></ul><h3>Android Project Setup</h3><ol><li>Create a new folder in the root directory of your app and call it ‘secure’</li><li>Add the secure folder to .gitignore rules: /secure/*</li><li>Copy your already created *.jks and Google Developer Cloud API *.json (created in the Fastlane setup section ) files into the newly created secure root app directory</li><li>In your local.properties add the Android app-signing information in the key-value format (make sure that the information you enter here is valid):</li></ol>KEYSTORE_PATH=PATH_TO_KEYSTORE_ON_LOCAL_MACHINEKEY_ALIAS=APP_ALIASKEY_PASSWORD=APP_ALIAS_KEY_PASSWORDSTORE_PASSWORD=APP_STORE_PASSWORDWe will create a new release signing configuration. In your app module’s build.gradle file, inside the android closure, add the following code at the beginning:<pre> signingConfigs { release { def keystoreProperties = new Properties() def keystorePropertiesFile = rootProject.file(&#39;local.properties&#39;) if (keystorePropertiesFile.exists()) { keystoreProperties.load(new FileInputStream(keystorePropertiesFile)) } storeFile file(keystoreProperties[&#39;KEYSTORE_PATH&#39;]) keyAlias keystoreProperties[&#39;KEY_ALIAS&#39;] keyPassword keystoreProperties[&#39;KEY_PASSWORD&#39;] storePassword keystoreProperties[&#39;STORE_PASSWORD&#39;] } } </pre>6. Edit the buildTypes closure inside the same android closure block and add the following line inside the release block:<pre>signingConfig signingConfigs.release</pre>7. Initialize Fastlane for the project and follow the setup console prompts to complete the Fastlane project setup. Run the following command inside the root directory of your project:fastlane init8. In the newly created fastlane directory we first need to edit AppFile and provide/validate the information for the json API key file path and app package name:<pre>json_key_file(&quot;./secure/DEV_API.json&quot;) package_name(&quot;your.app.package.name&quot;)</pre>9. Next we define the steps for Fastlane to take when we run the script. For the sake of brevity, I’m going to only showcase the final deployment step for the bundle release deployment:<pre> platform :android do desc &quot;Deploy a new version to the Google Play&quot; lane :deploy do gradle( task: &#39;clean bundle&#39;, build_type: &#39;Release&#39; ) upload_to_play_store # Uploads the AAB built in the gradle step above and releases it to all production users end end</pre>10. Check if Java runtime is exported in the JAVA_HOME environment value (see below for troubleshooting options). You can run the following command in the terminal to validate if Java is installed (double dash):java -version11. Continue with executing the Fastlane deployment. When running the first time, it can take some time until all of the dependencies and metadata information are downloaded and the build and deployment steps commence. This step largely depends on your build machine performance and the speed of your local internet connection<h3>Run Fastlane Deploy</h3>After the steps above have been completed, you can finally run Fastlane deploy with the following command:bundle exec fastlane deployBased on the <a href="https://bundler.io/">Bundler</a> configuration on you machine, you might need sudo privileges. Run this instead:sudo bundle exec fastlane deploy<h3>Troubleshooting</h3><h4>Java Runtime Not Found</h4>In case you’re getting java runtime not found, try these steps in the terminal:/usr/libexec/java_home -V | grep jdkYou should get something like this in the output:<pre>Matching Java Virtual Machines (1): 1.8.301.09 (x86_64) &quot;Oracle Corporation&quot; - &quot;Java&quot; /Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home</pre>Let’s add or update the JAVA_HOME path using <a href="https://www.vim.org/">vim</a> :vim .zshrcProceeding with adding the following information (make sure that the correct Java <a href="https://www.oracle.com/java/technologies/downloads/">JDK</a> path is entered, below is just an example):<pre>export JAVA_HOME=/Users/your_device_account/Library/Java/JavaVirtualMachines/java_version/Contents/Home export PATH=$JAVA_HOME/bin:$PATH</pre>Make sure you replace the JAVA_HOME path with the one identified with which javaDepending on the profile you are using for the shell, it should work for zsh too.To apply the new changes run (or .barshrc, or .zsh, etc.):source .zshrcThis would probably not persists and when you restart the terminal, you’ll face the same problems.<h4>Gradlew Permission Denied</h4>In case if you’re getting permission denied, run the following command to give write permission to gradlew:chmod +x gradlew<h4>Gradle Deprecated or Unrecognized VM Options</h4>In you are experiencing build issues with Gradle, make sure that you are not using deprecated gradle jvmargs or similar:Unrecognized VM option ‘MaxPermSize=512m’Remove or replace the arguments with ones that are supported by the new versions of the build system.<h3>Final Thoughts</h3>The steps provided in this article are not perfect and are simply my own way of getting Fastlane quickly up and running for new and existing projects. I’m sure that most of things described and showcased can be further improved upon and streamlined for an overall better developer experience.If you found this tutorial useful, feel free to leave a comment and feedback.Thank you for reading, and happy coding!<h3>References</h3>Fastlane official documentation: <a href="https://docs.fastlane.tools/">https://docs.fastlane.tools/</a><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8819d3d2d24c" width="1" height="1" alt="">

Automating an Application Deployment Process

Let’s not waste any time, if you’re an Android developer with an Apple Mac development machine, and want to automate the build, testing and deployment process using the Fastlane framework, you’re at the right place.
This tutorial as an addendum to the existing setup process available at the official Fastlane documentation page. If you’re experiencing issues with your Fastlane setup, you can use this article as a checklist of sorts or go directly to the troubleshooting section of this article for the more common issues when running Fastlane deploy.
Fastlane Setup Prerequisites
First things first, visit the following page and make sure that you’ve obtained and secured the needed *.json API file that is tied to your existing Android Developer account:
https://docs.fastlane.tools/getting-started/android/setup/

You have already created the project for your app on the Google Play Console
You have generated the release signing credentials for your app (keystore *.jks file and password, alias, alias password)
On a Mac machine, make sure you are in the right shell and that JAVA_HOME is defined (best use the same one as in your Android Studio Environment)

Android Project Setup

Create a new folder in the root directory of your app and call it ‘secure’
Add the secure folder to .gitignore rules: /secure/*
Copy your already created *.jks and Google Developer Cloud API *.json (created in the Fastlane setup section ) files into the newly created secure root app directory
In your local.properties add the Android app-signing information in the key-value format (make sure that the information you enter here is valid):

KEYSTORE_PATH=PATH_TO_KEYSTORE_ON_LOCAL_MACHINE
KEY_ALIAS=APP_ALIAS
KEY_PASSWORD=APP_ALIAS_KEY_PASSWORD
STORE_PASSWORD=APP_STORE_PASSWORD
We will create a new release signing configuration. In your app module’s build.gradle file, inside the android closure, add the following code at the beginning:

signingConfigs {
        release {
            def keystoreProperties = new Properties()
            def keystorePropertiesFile = rootProject.file('local.properties')
            if (keystorePropertiesFile.exists()) {
                keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
            }
            storeFile file(keystoreProperties['KEYSTORE_PATH'])
            keyAlias keystoreProperties['KEY_ALIAS']
            keyPassword keystoreProperties['KEY_PASSWORD']
            storePassword keystoreProperties['STORE_PASSWORD']
        }
    }

6. Edit the buildTypes closure inside the same android closure block and add the following line inside the release block:
signingConfig signingConfigs.release
7. Initialize Fastlane for the project and follow the setup console prompts to complete the Fastlane project setup. Run the following command inside the root directory of your project:
fastlane init
8. In the newly created fastlane directory we first need to edit AppFile and provide/validate the information for the json API key file path and app package name:
json_key_file("./secure/DEV_API.json")
package_name("your.app.package.name")
9. Next we define the steps for Fastlane to take when we run the script. For the sake of brevity, I’m going to only showcase the final deployment step for the bundle release deployment:

platform :android do
 desc "Deploy a new version to the Google Play"
 lane :deploy do
   gradle(
     task: 'clean bundle',
     build_type: 'Release'
   )
   upload_to_play_store # Uploads the AAB built in the gradle step above and releases it to all production users
 end
end
10. Check if Java runtime is exported in the JAVA_HOME environment value (see below for troubleshooting options). You can run the following command in the terminal to validate if Java is installed (double dash):
java -version
11. Continue with executing the Fastlane deployment. When running the first time, it can take some time until all of the dependencies and metadata information are downloaded and the build and deployment steps commence. This step largely depends on your build machine performance and the speed of your local internet connection
Run Fastlane Deploy
After the steps above have been completed, you can finally run Fastlane deploy with the following command:
bundle exec fastlane deploy
Based on the Bundler configuration on you machine, you might need sudo privileges. Run this instead:
sudo bundle exec fastlane deploy
Troubleshooting
Java Runtime Not Found
In case you’re getting java runtime not found, try these steps in the terminal:
/usr/libexec/java_home -V | grep jdk
You should get something like this in the output:
Matching Java Virtual Machines (1):
1.8.301.09 (x86_64) "Oracle Corporation" - "Java" /Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home
Let’s add or update the JAVA_HOME path using vim :
vim .zshrc
Proceeding with adding the following information (make sure that the correct Java JDK path is entered, below is just an example):
export JAVA_HOME=/Users/your_device_account/Library/Java/JavaVirtualMachines/java_version/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH
Make sure you replace the JAVA_HOME path with the one identified with which java
Depending on the profile you are using for the shell, it should work for zsh too.
To apply the new changes run (or .barshrc, or .zsh, etc.):
source .zshrc
This would probably not persists and when you restart the terminal, you’ll face the same problems.
Gradlew Permission Denied
In case if you’re getting permission denied, run the following command to give write permission to gradlew:
chmod +x gradlew
Gradle Deprecated or Unrecognized VM Options
In you are experiencing build issues with Gradle, make sure that you are not using deprecated gradle jvmargs or similar:
Unrecognized VM option ‘MaxPermSize=512m’
Remove or replace the arguments with ones that are supported by the new versions of the build system.
Final Thoughts
The steps provided in this article are not perfect and are simply my own way of getting Fastlane quickly up and running for new and existing projects. I’m sure that most of things described and showcased can be further improved upon and streamlined for an overall better developer experience.
If you found this tutorial useful, feel free to leave a comment and feedback.
Thank you for reading, and happy coding!
References
Fastlane official documentation: https://docs.fastlane.tools/

Android Fastlane Tutorial

Discovering: MLOps

What is AIaaS?

Programming to an Interface

Branchless programming — Why your CPU will thank you

<h4>Episode 1: The strange case of the Qubit</h4><figure><img alt="Discovering Quantum Computing series photo of the interference pattern using a particle beam light" src="https://cdn-images-1.medium.com/max/1024/1*D7ktT6UlWYV8JOdouRVhOA.jpeg" /></figure><h3>Intro</h3>The Discovering series is a new format I’m experimenting with, the idea for which came from the notion that some subjects require a bit more written content and, by extension, time to cover the basics over other similar articles.For each Discovery subject at least two content ‘episodes’ are planned. The episodes are ordered in an incremental way and released in sequential order which is the same way they are meant to be read through.This article episode also marks the first time I have to credit a co-author for it. In the world of machine learning and AI, there have been made significant strides in the past few years and one particular tool introduced itself to the world at the end of last year (2022) and that is <a href="https://openai.com/blog/chatgpt/">ChatGPT</a>. It would be dishonest of me to not mention that I’ve used this tool during the writing of this article episode. In particular the helping hand of ChatGPT was needed for sorting and picking the right material from my previous notes in order to put more emphasis on terminology and questions that the readers would potentially find more interesting.With the credits out of the way, we can start with the principal topic of this article.The subject of <a href="https://en.wikipedia.org/wiki/Quantum_computing">quantum computing</a> is something I’ve been attempting to tackle for quite some time and tried to write about it for at least half an year now. One would be right in thinking that this isn’t a subject matter that is easy to explain let alone provide some validity and practical use cases for the implementation in this, relatively new industry. To say that what follows is a layman’s interpretation of a very complex subject matter is an understatement, but here goes nothing! Let’s dive into the amazing world of quantum computing.<h3>Basic concepts</h3>To cover the subject of the qubit (quantum bit) and quantum computing as a whole, we should take a few moments and look into quantum mechanics in search for answers.It has always been fascinating to physicists to study the behavior of matter and energy data at an atomic, even more importantly subatomic level. The results of those kind of researches gave us the very foundations of modern technology in the form of transistors and computer memory, not to mention how that data help us in understanding the whole physical world around us. When researching and gathering the needed data, the prospect of general data measurements becomes significantly more difficult at the subatomic level. Two key principles emerge when looking into measuring energy data in quantum mechanics. One is the concept of superposition and the other is the process of collapsing state.<a href="https://en.wikipedia.org/wiki/Quantum_superposition">Superposition</a> comes from the notion that tiny particles such as electrons and protons can indeed exist in multiple states simultaneously! Crazy, right? This means that a particle can occupy spacial matter in two or more locations at the same time. Not only that, at that level, a particle can hold different properties at the same time.The other key principle, measurement of a particle, can lead to something what’s called the <a href="https://en.wikipedia.org/wiki/Observer_effect_(physics)">observer effect</a> when the particle collapses into a single, more “stable” state while being observed (or measured). It’s easy to understand how this complicates any attempt of obtaining tangible and predictable data if a particle is changing its properties every time its being measured.To further complicate things even more, quantum mechanics also introduces the concept of <a href="https://en.wikipedia.org/wiki/Quantum_entanglement">quantum entanglement</a>, an event in which two particles are connected in such a way that one directly depends on the properties of the other one. This directly alludes to the notion that in the process of measuring the state of one particle we can directly affect the state of an another one. What’s the fun part in this? The distance between two particles doesn’t seem to matter! With that we are knocking on the door of <a href="https://en.wikipedia.org/wiki/Quantum_teleportation">quantum teleportation</a>, but that is a subject to be explored more in the future (I’m pushing the limits of my mind enough as it is with this topic).With all said, quantum mechanics provides the very foundations for quantum computing. Quantum computing is nothing more than a new way of ‘computing’ things and solve problems previously perceived as unsolvable, using the principles of quantum mechanics. When performing those computational tasks, quantum computing at its core uses quantum bits or qubits for short instead of the traditional binary (‘1’ and ‘0’) units of measurement in computer science. More on that in just a ‘bit’ (I’m not sorry for the bad pun).It is important to note that although the unquestionable relationship between the two, quantum computing and quantum mechanics are completely two separate fields. The understanding of the principles covered in quantum mechanics are essential in understanding and developing quantum computing algorithms on top of the ‘general’ knowledge of computer science and mathematics<h3>What is a qubit?</h3>In 1935, <a href="https://en.wikipedia.org/wiki/Albert_Einstein">Albert Einstein</a>, <a href="https://en.wikipedia.org/wiki/Boris_Podolsky">Boris Podolsky</a> and <a href="https://en.wikipedia.org/wiki/Nathan_Rosen">Nathan Rosen</a> published a scientific <a href="https://plato.stanford.edu/entries/qt-epr/">paper </a>describing the phenomenon of quantum entanglement mentioned before. Since then the concept of quantum computing and even quantum cryptography has branched from the concepts of quantum mechanics.A qubit represents the basic unit of informational data in a quantum computer and is directly comparable to the traditional ‘bit’ in the classic computer system. The main difference between the qubit and the classic bit is that the qubit can have a lot of states instead of just the two (1 and 0) of the classic bit. This is the concept of superposition that quantum mechanics teaches us. In theory, should help improve the computational speed of certain types of problems a lot. In a quantum computer, each qubit can be both a 0 and a 1 at the same time with a certain probability for each value. This, again in theory, can enable quantum machines to execute certain computational tasks in parallel which leads to reduced computation times.The idea for using quantum mechanics for performing computational tasks is first pioneered by <a href="https://en.wikipedia.org/wiki/Richard_Feynman">Richard Feynman</a> in the early 1980’s. An interesting figure on himself, he introduced the concept of <a href="https://en.wikipedia.org/wiki/Nanotechnology">nanotechnology </a>and more importantly for this topic, the mathematical expressions describing the movements and behaviors of subatomic particles known as <a href="https://en.wikipedia.org/wiki/Feynman_diagram">Feynman diagrams</a>. The first demonstrated examples of quantum computing followed in the 1990’s using nuclear magnetic resonance (NMR) spectroscopy.While the qubit is very difficult to work with by the nature quantum mechanics and simplistic maintenance of their quantum states is challenging to say the least, there is an ongoing effort to research all the potential benefits of it that can provide a promising area of research.At the time of this writing, there&#39;s ongoing work by engineers and physicists to improve the overall robustness and ‘stability’ for practical applications.<h3>Use cases</h3>Quantum computing might seem like the clear winner when it comes to computational speeds against its classic computer rival with some calculations that would take the ‘opponent’ longer than the age of the known universe, a quantum computer would execute in a few seconds, but that’s not the case.Not all calculations can be performed faster on a quantum computer, notably tasks that we take for granted in our daily routines such as media playback, browsing the Internet or typing a new blog article can, on average, take longer to be done on a quantum computer. The technology is still in its early stages of development with news about new funds and faster quantum computers (more qubits) coming out on regular intervals. Where the quantum computer struggles the most is in its practical implementation. Since it’s an emerging technology, many use cases for it have yet to be though of.A few use cases where quantum computing might have a significant impact in today’s technology are the fields of cryptography, machine learning, AI and medicine. The field of cryptography keeps coming up in conversations and articles about quantum computing as something that seems to be the likeliest and easiest to find usage for. Breaking encoded data that was previously thought of as being unbreakable seems like something that would interest potential investors in this technology.Machine learning and AI could see new optimization techniques that could cut-down on the times spent on training new models. This would lead to shorter turnarounds for new models based on new and updated data sources.Simulations and optimized prediction algorithms can be brought into the spotlight with much more accuracy and discoverability of new, previously unthought of solutions. But, these are just some of the use cases that are talked about most in the scientific world, the most impactful use cases are probably waiting for the further development and adaptation of the general quantum computing field.<h3>Getting started with quantum computing</h3>Let’s get this right out of the way, one does not need a quantum computer in order to get into quantum computing. A <a href="https://en.wikipedia.org/wiki/Quantum_simulator">quantum computer simulator</a> would most likely satisfy most use cases developers might have.To start of a journey into the field of quantum computing, developers must firstly cover the basic concepts of quantum mechanics such as quantum entanglement, superposition and <a href="https://en.wikipedia.org/wiki/Quantum_logic_gate">quantum gates</a>. While there are countless resources available on the internet, <a href="https://www.amazon.com/Strange-Story-Quantum-Banesh-Hoffmann/dp/0486205185">The Strange Story of the Quantum</a> (hence the subtitle) might be a good starting point. The book is quite popular in the quantum theory field and should be easily obtainable in paper, e-book or audio-book formats.Learning a quantum computing-specific programming language or frameworks that can be used to experiment on quantum computer simulators should be the next step for anyone interest in this topic. There are a few programming languages specifically designs for quantum computing. The first one is Microsofts own <a href="https://learn.microsoft.com/en-us/azure/quantum/overview-what-is-qsharp-and-qdk">Q#</a>, the documentation for which is quite exhaustive. Familiarity with C# is also recommended if deciding to go the Q# route.While the documentation for the <a href="https://www.mathstat.dal.ca/~selinger/quipper/">Quipper</a> programming language might seem a bit out of date, it can’t be argued that it is at least functional.Like any process of learning a new programming language, experimentation is key. By experimenting and running tests on quantum simulators, one can form a better understanding how abstract concepts can be applied to in the new field. The process can be best described as comparing programming language paradigms such as object-oriented programming and functional programming for example. Both can achieve almost the same results at the end ,but to fully utilize them, one has to understand the way they are meant to be implemented and change their approach to problem solving accordingly.Taking a dedicated course on the topic from one the popular teaching platforms such as <a href="https://www.udemy.com/">Udemy</a> or <a href="https://www.coursera.org/">Coursera </a>can provide a nice structured, step-by-step way to learn more and apply the gathered knowledge on various testing platforms or quizzes.After grasping the basic concepts of quantum mechanics and quantum computing, learning about the various quantum computing algorithms should solidify any gathered knowledge about the topic.Some of the more vocal algorithms in the world quantum computing are:<ul><li>Quantum gates: The basic building blocks for quantum circuits used for performing operations on qubits</li><li>Shor’s Algorithm: An efficient algorithms for factoring large integer values</li><li>Grover’s Algorithm: Used for fast searching through unsorted databases</li><li>QFT: A quantum version of the Fourier transform</li><li>QPE (quantum phase estimation): An algorithm used to estimate the values of scalar values in matrix equations used in many quantum algorithms</li><li>QML (quantum machine learning): A set of algorithms used for performing machine learning tasks such as supervised and unsupervised learning</li></ul><a href="https://qiskit.org/">Qiskit</a>,a popular framework for working with quantum computing, includes implementations of the before mentioned algorithms and many more.Below is an example implementation of the quantum circuit that creates a superposition of two qubits done using the Qiskit framework:<pre>from qiskit import QuantumCircuit, execute, Aer # New circuit with two qubits qc = QuantumCircuit(2) # Apply a Hadamard gate to the first qubit to put it into a superposition qc.h(0) # Apply a controlled-not gate between the first and second qubits qc.cx(0, 1) # Execute the circuit on a Qiskit statevector simulator (CPU &amp; GPU optimized) backend = Aer.get_backend(&#39;statevector_simulator&#39;) job = execute(qc, backend) result = job.result() # Get the final statevector statevector = result.get_statevector() print(statevector)</pre>For those that have significant programming experience, they might have an easier time with picking up a new programming language designed for this topics, but nonetheless, the general path outlined in this section remains almost the same. The basics of quantum mechanics still need to be clear before moving forward with a career in quantum computing.<h3>Carrier opportunities</h3>At the time of writing this, there are significantly less jobs on the market for those seeing a career in quantum computing than there are for more conventional computer science technologies, but like with any emerging technology, this can quickly change and new job openings might be closer than we think.There aren’t many places where quantum computing is being researched and utilized. The general perception is that that only large corporations have in their budgets room for research and development in this field. This is not necessarily true. There are smaller companies that seek to get their foot first into what might be the “next big thing”.For those little job postings that are out there (again, at the time of this writing) there should be a few pieces of advice for those looking for applications. Without learning the principles of quantum mechanics and having a strong foundation in mathematics, especially linear algebra, the chances of landing a position are quite reduced.Writing research papers on the subject and extensive networking are bonuses that can land a person a new career in a exciting new world of the qubit.<h3>Final notes</h3>This concludes a short first episode in what should be a series of article posts dedicated to the subject of quantum computing. Again, this article turnover has been significantly shortened thanks to the amazing tools such as ChatGPT.It is important to note that the principles of quantum computing can potentially be difficult to understand and are often counterintuitive to what we are used to in the more traditional mechanics. The field is constantly growing and those working hard on it,are still trying to understand the full implications of quantum mechanics when applied to the world of computing.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb8b4e53e74d" width="1" height="1" alt="">

Episode 1: The strange case of the Qubit

Intro
The Discovering series is a new format I’m experimenting with, the idea for which came from the notion that some subjects require a bit more written content and, by extension, time to cover the basics over other similar articles.
For each Discovery subject at least two content ‘episodes’ are planned. The episodes are ordered in an incremental way and released in sequential order which is the same way they are meant to be read through.
This article episode also marks the first time I have to credit a co-author for it. In the world of machine learning and AI, there have been made significant strides in the past few years and one particular tool introduced itself to the world at the end of last year (2022) and that is ChatGPT. It would be dishonest of me to not mention that I’ve used this tool during the writing of this article episode. In particular the helping hand of ChatGPT was needed for sorting and picking the right material from my previous notes in order to put more emphasis on terminology and questions that the readers would potentially find more interesting.
With the credits out of the way, we can start with the principal topic of this article.
The subject of quantum computing is something I’ve been attempting to tackle for quite some time and tried to write about it for at least half an year now. One would be right in thinking that this isn’t a subject matter that is easy to explain let alone provide some validity and practical use cases for the implementation in this, relatively new industry. To say that what follows is a layman’s interpretation of a very complex subject matter is an understatement, but here goes nothing! Let’s dive into the amazing world of quantum computing.
Basic concepts
To cover the subject of the qubit (quantum bit) and quantum computing as a whole, we should take a few moments and look into quantum mechanics in search for answers.
It has always been fascinating to physicists to study the behavior of matter and energy data at an atomic, even more importantly subatomic level. The results of those kind of researches gave us the very foundations of modern technology in the form of transistors and computer memory, not to mention how that data help us in understanding the whole physical world around us. When researching and gathering the needed data, the prospect of general data measurements becomes significantly more difficult at the subatomic level. Two key principles emerge when looking into measuring energy data in quantum mechanics. One is the concept of superposition and the other is the process of collapsing state.
Superposition comes from the notion that tiny particles such as electrons and protons can indeed exist in multiple states simultaneously! Crazy, right? This means that a particle can occupy spacial matter in two or more locations at the same time. Not only that, at that level, a particle can hold different properties at the same time.
The other key principle, measurement of a particle, can lead to something what’s called the observer effect when the particle collapses into a single, more “stable” state while being observed (or measured). It’s easy to understand how this complicates any attempt of obtaining tangible and predictable data if a particle is changing its properties every time its being measured.
To further complicate things even more, quantum mechanics also introduces the concept of quantum entanglement, an event in which two particles are connected in such a way that one directly depends on the properties of the other one. This directly alludes to the notion that in the process of measuring the state of one particle we can directly affect the state of an another one. What’s the fun part in this? The distance between two particles doesn’t seem to matter! With that we are knocking on the door of quantum teleportation, but that is a subject to be explored more in the future (I’m pushing the limits of my mind enough as it is with this topic).
With all said, quantum mechanics provides the very foundations for quantum computing. Quantum computing is nothing more than a new way of ‘computing’ things and solve problems previously perceived as unsolvable, using the principles of quantum mechanics. When performing those computational tasks, quantum computing at its core uses quantum bits or qubits for short instead of the traditional binary (‘1’ and ‘0’) units of measurement in computer science. More on that in just a ‘bit’ (I’m not sorry for the bad pun).
It is important to note that although the unquestionable relationship between the two, quantum computing and quantum mechanics are completely two separate fields. The understanding of the principles covered in quantum mechanics are essential in understanding and developing quantum computing algorithms on top of the ‘general’ knowledge of computer science and mathematics
What is a qubit?
In 1935, Albert Einstein, Boris Podolsky and Nathan Rosen published a scientific paper describing the phenomenon of quantum entanglement mentioned before. Since then the concept of quantum computing and even quantum cryptography has branched from the concepts of quantum mechanics.
A qubit represents the basic unit of informational data in a quantum computer and is directly comparable to the traditional ‘bit’ in the classic computer system. The main difference between the qubit and the classic bit is that the qubit can have a lot of states instead of just the two (1 and 0) of the classic bit. This is the concept of superposition that quantum mechanics teaches us. In theory, should help improve the computational speed of certain types of problems a lot. In a quantum computer, each qubit can be both a 0 and a 1 at the same time with a certain probability for each value. This, again in theory, can enable quantum machines to execute certain computational tasks in parallel which leads to reduced computation times.
The idea for using quantum mechanics for performing computational tasks is first pioneered by Richard Feynman in the early 1980’s. An interesting figure on himself, he introduced the concept of nanotechnology and more importantly for this topic, the mathematical expressions describing the movements and behaviors of subatomic particles known as Feynman diagrams. The first demonstrated examples of quantum computing followed in the 1990’s using nuclear magnetic resonance (NMR) spectroscopy.
While the qubit is very difficult to work with by the nature quantum mechanics and simplistic maintenance of their quantum states is challenging to say the least, there is an ongoing effort to research all the potential benefits of it that can provide a promising area of research.
At the time of this writing, there's ongoing work by engineers and physicists to improve the overall robustness and ‘stability’ for practical applications.
Use cases
Quantum computing might seem like the clear winner when it comes to computational speeds against its classic computer rival with some calculations that would take the ‘opponent’ longer than the age of the known universe, a quantum computer would execute in a few seconds, but that’s not the case.
Not all calculations can be performed faster on a quantum computer, notably tasks that we take for granted in our daily routines such as media playback, browsing the Internet or typing a new blog article can, on average, take longer to be done on a quantum computer. The technology is still in its early stages of development with news about new funds and faster quantum computers (more qubits) coming out on regular intervals. Where the quantum computer struggles the most is in its practical implementation. Since it’s an emerging technology, many use cases for it have yet to be though of.
A few use cases where quantum computing might have a significant impact in today’s technology are the fields of cryptography, machine learning, AI and medicine. The field of cryptography keeps coming up in conversations and articles about quantum computing as something that seems to be the likeliest and easiest to find usage for. Breaking encoded data that was previously thought of as being unbreakable seems like something that would interest potential investors in this technology.
Machine learning and AI could see new optimization techniques that could cut-down on the times spent on training new models. This would lead to shorter turnarounds for new models based on new and updated data sources.
Simulations and optimized prediction algorithms can be brought into the spotlight with much more accuracy and discoverability of new, previously unthought of solutions. But, these are just some of the use cases that are talked about most in the scientific world, the most impactful use cases are probably waiting for the further development and adaptation of the general quantum computing field.
Getting started with quantum computing
Let’s get this right out of the way, one does not need a quantum computer in order to get into quantum computing. A quantum computer simulator would most likely satisfy most use cases developers might have.
To start of a journey into the field of quantum computing, developers must firstly cover the basic concepts of quantum mechanics such as quantum entanglement, superposition and quantum gates. While there are countless resources available on the internet, The Strange Story of the Quantum (hence the subtitle) might be a good starting point. The book is quite popular in the quantum theory field and should be easily obtainable in paper, e-book or audio-book formats.
Learning a quantum computing-specific programming language or frameworks that can be used to experiment on quantum computer simulators should be the next step for anyone interest in this topic. There are a few programming languages specifically designs for quantum computing. The first one is Microsofts own Q#, the documentation for which is quite exhaustive. Familiarity with C# is also recommended if deciding to go the Q# route.
While the documentation for the Quipper programming language might seem a bit out of date, it can’t be argued that it is at least functional.
Like any process of learning a new programming language, experimentation is key. By experimenting and running tests on quantum simulators, one can form a better understanding how abstract concepts can be applied to in the new field. The process can be best described as comparing programming language paradigms such as object-oriented programming and functional programming for example. Both can achieve almost the same results at the end ,but to fully utilize them, one has to understand the way they are meant to be implemented and change their approach to problem solving accordingly.
Taking a dedicated course on the topic from one the popular teaching platforms such as Udemy or Coursera can provide a nice structured, step-by-step way to learn more and apply the gathered knowledge on various testing platforms or quizzes.
After grasping the basic concepts of quantum mechanics and quantum computing, learning about the various quantum computing algorithms should solidify any gathered knowledge about the topic.
Some of the more vocal algorithms in the world quantum computing are:

Quantum gates: The basic building blocks for quantum circuits used for performing operations on qubits
Shor’s Algorithm: An efficient algorithms for factoring large integer values
Grover’s Algorithm: Used for fast searching through unsorted databases
QFT: A quantum version of the Fourier transform
QPE (quantum phase estimation): An algorithm used to estimate the values of scalar values in matrix equations used in many quantum algorithms
QML (quantum machine learning): A set of algorithms used for performing machine learning tasks such as supervised and unsupervised learning

Qiskit,a popular framework for working with quantum computing, includes implementations of the before mentioned algorithms and many more.
Below is an example implementation of the quantum circuit that creates a superposition of two qubits done using the Qiskit framework:
from qiskit import QuantumCircuit, execute, Aer
# New circuit with two qubits
qc = QuantumCircuit(2)
# Apply a Hadamard gate to the first qubit to put it into a superposition
qc.h(0)
# Apply a controlled-not gate between the first and second qubits
qc.cx(0, 1)
# Execute the circuit on a Qiskit statevector simulator (CPU & GPU optimized)
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
# Get the final statevector
statevector = result.get_statevector()
print(statevector)
For those that have significant programming experience, they might have an easier time with picking up a new programming language designed for this topics, but nonetheless, the general path outlined in this section remains almost the same. The basics of quantum mechanics still need to be clear before moving forward with a career in quantum computing.
Carrier opportunities
At the time of writing this, there are significantly less jobs on the market for those seeing a career in quantum computing than there are for more conventional computer science technologies, but like with any emerging technology, this can quickly change and new job openings might be closer than we think.
There aren’t many places where quantum computing is being researched and utilized. The general perception is that that only large corporations have in their budgets room for research and development in this field. This is not necessarily true. There are smaller companies that seek to get their foot first into what might be the “next big thing”.
For those little job postings that are out there (again, at the time of this writing) there should be a few pieces of advice for those looking for applications. Without learning the principles of quantum mechanics and having a strong foundation in mathematics, especially linear algebra, the chances of landing a position are quite reduced.
Writing research papers on the subject and extensive networking are bonuses that can land a person a new career in a exciting new world of the qubit.
Final notes
This concludes a short first episode in what should be a series of article posts dedicated to the subject of quantum computing. Again, this article turnover has been significantly shortened thanks to the amazing tools such as ChatGPT.
It is important to note that the principles of quantum computing can potentially be difficult to understand and are often counterintuitive to what we are used to in the more traditional mechanics. The field is constantly growing and those working hard on it,are still trying to understand the full implications of quantum mechanics when applied to the world of computing.

Discovering: Quantum Computing

The Developer Experience (DX)

The importance of having a deadline

the art of being a professional at the endThe average software developer has quite a few projects that they have worked on or are working at the moment, but a time comes to pass on that project to another pair of hands. As true professionals of our craft, it is admirable to make that extra step and solidify a positive work relationship between the two parties, the project sender and the project receiver. As someone who’s been on both ends, I can say that it can be very unprofessional when crucial parts of the project are not disclosed or simply do not exist.Over the years, I’ve gathered some helpful insights, tips and guides on how to make process of handing over a project as painless as possible. So let’s not waste anymore time and just dig into them.<h3>Setup instructions</h3>First things first, providing a clear, step-by-step textual or even a video guide on how to build and run a project (if in a runnable state at the first place). Going the video route is, I admit it, a true stretch, but in this day and age it could be a lot more useful than a instructions manual.Like deciphering a riddle, running the first build and setting everything up upon receiving the source code, can be challenging to say the least. One little dependency version number can make or break a project. I’ve worked on so many projects where just a version mismatch can cause absolute chaos. Even give a false positive when the project successfully builds, but then is covered in runtime crashes and warnings. To save you the headache of countless video calls and messages about the correct procedure to build and run a project, just save yourself the time and provide the minimum instructions and notes required to fulfill that task.Container tools such as<a href="https://www.docker.com/"> Docker</a> provide a great way for drafting a build contract that can be reused just for cases like this. It eliminates the need to disclose concrete version names and codes about the running platforms and dependencies (we will come back to this a bit later).One important thing to mention here is to actually test the guide or container component you are providing on your own, local machine and some other test machine to ensure that the guide is not missing some crucial key or step.<h3>Project documentation</h3>For some reason, this miraculous and crucial piece of the puzzle, tends elude or even evaporate into thin air whenever the reaching hands of another developer come near it or even mention’s it.The least amount of data contained in the documentation should be: what’s the project about, what was the state of the project when you started working on it (if it was a legacy project), what’s the project state at the moment of the handover with even mentioning potential unfinished tasks or goals and finally, what was the original plan for the project to end up to.If there isn’t any documentation, write some. At least some description and the state the project’s currently in. The receiving party should have the least amount knowledge if the project is actually doing something or if it can be scrapped the moment the handover process is complete.If there is existing project documentation, go over it once more. Check is everything is there and fill in if something you think might be important is missing.<h3>Account credentials</h3>Any assigned testing account credentials or parameters should be provided to ensure that the project can be explored by the receiving party as soon as possible.There’s a possibility that some full account credentials for some sensitive services needed to be provided. Be sure to check with a supervisor or, if possible, the security team on how the sensitive data should be provided.If you have shared accounts with other projects, decouple them before the handover. Create new accounts and optionally tailor them to the receiving party.Check your Git history logs for any mentions or exposures for the sensitive data.<h4>Third party service accounts</h4>Clean up any required third party service accounts of any debug data and artifacts. Simply provide a clean slate with setting the last logs to be the snapshot state.If cloud services were used during the development and production process, when providing the project, remove any traces of previous logs and data. Some services might not provide this feature, in which case you might consider creating new accounts and migrate to them before the handover process. Mention this to the other party, maybe they have their own existing accounts that they can use or even create new ones that they can share with you in order to update the project.Be sure that you comply to any GDPR regulations when there’s mention of User data. If possible, check with someone who’s more familiar with the legal procedures for this topic.<h3>API documentation</h3>One would imagine that if a project contains or targets an API service, that some documentation or mention of all the possible calls and endpoints exist, but here we are, no documentation just mysterious calls to some outside source of information. Time to lift up the sleeves and start writing down a rudimentary API document yourself.This might seem to be a lot of unnecessary work, especially for someone that perhaps wasn’t actively engaged in the API development process. Don’t worry, that’s why we are here. There are helpful tools that make generating API documentation a bit easier.<a href="https://www.postman.com/"> Postman</a> can be a good tool to start with or search online for alternatives. If using Postman, be sure to also share the API<a href="https://learning.postman.com/docs/getting-started/creating-the-first-collection/"> collection</a> and<a href="https://learning.postman.com/docs/sending-requests/managing-environments/"> environment</a>.Try to print the network logs and see what data you can extract from that and go from there. Be sure to write down also any error states and network responses.The minimum data to be written around a single API call should be:<ul><li>URL</li><li>Call method</li><li>Request data with potential query or path parameters</li><li>Response data</li></ul><h3>Code clean-up</h3>Just to be clear, you don’t need to rush and complete or fix the code. Nothing like that. What you should do is clear sensitive comments and debug messages. Any trivial references of yourself and/or your company should be checked and double checked. Needles to say, remove any course words and rude/silly comments or property names. Leave only the comments that provide value and information about the code itself.Running a a standardized code formatter on the whole code base, ensures a bit of uniformity in the way the code is presented.Refactor any file, class, method, field and property names to be more reflective of the functionality they provide. Run a global search on the whole project for keywords you deem to be important to remove before the handover.<h3>Source code</h3>Directly tied to the previous segment, source code maybe the most crucial part in the handover process. Chances are that the receiving party is primarily interested in the source code, but as we are seeing in this document this key component can be shadowed by so many missing or incomplete pieces that surround it. Many<a href="https://www.jetbrains.com/help/idea/import-project-or-module-wizard.html"> IDE’s</a> provide a way to export the source code for a project that makes it more easy to unpack and run. Export them and import them again under a different name, just to mimic how someone new to the project might experience that process.If parts or the whole code itself should be copyrighted, make sure that it actually is. Check the wordings and date values. Any proprietary library or module, or something else that is subject to different copyright or licensing, be sure to disclose this to the receiving party.Binaries or working examples and artifacts are a welcomed inclusion as well.<h3>Git clean-up</h3>Oh <a href="https://git-scm.com/">Git</a>, where would we be without the safety harness of this tool. Git knowledge is almost an art form and the more one knows how to use it, the more rewarding it becomes.Git or any other VCS for that matter, provide a unique snapshot look into the various stages of development. All the different branches, commit messages and merge requests aiming towards one single outcome, a better project overall.The more mature and complicated a project is, the more information is stored in the Git<a href="https://git-scm.com/docs/git-log"> Log</a>. There’s quite the possibility of old, temporary or even deprecated branches just sitting there without ever being merged into another branch or simply being marked for removal but never actually meeting that task. Go over the Git tree and make sure that only the necessary branches are left. I will not go into details about merging or re-basing branches, there are a lot more great resources available<a href="https://betterprogramming.pub/differences-between-git-merge-and-rebase-and-why-you-should-care-ae41d96237b6"> online</a> about that topic, but simply put re-basing ends up with a single progression line and is perhaps a bit easier to understand and merge shows the paths each of the merging branches have made.If the Git history contains a lot of sensitive information, one simple thing to do is to just create a new repository from the latest branch and provide that as is. If questioned about the lack of log information, just say it’s outside your pay grade to discuss such things.<h3>Assets</h3>Assets can be any document,note, graphical element, fonts, translations, etc. that aren’t necessarily thought of as being an essential part of documentation, but nonetheless can provide a lot of value to someone just starting out with the project. For example, it can be very useful if we provide the Photoshop templates or settings we have used for the graphical elements in our project.UX Design sketches, color codes, testing strategies and schemes can speed up a lot of tedious tasks around matching the exact specifications provided in some other document. I’m not saying that you should provide absolutely every single little brainstorming doodle, just the assets that might be forgotten in the hectic of handing over a project.<h3>Single repository</h3>I have yet to see a developer that likes when someone shares to them a bunch of links and scattered files and documents all over the place. Create a single asset repository which you can easily link and share to anyone that needs it. By using a single repository you’re creating a single source of truth for the files contained in it. Any writing/editing of the files contained in the repository should be disabled before sharing it with outside sources.An additional step would be in defining a clear window of time when this repository is available to be read/downloaded. No repository should indefinitely be left open to any outside party. After the time window has passed, an internal backup copy should be generated and the repository deleted.<h3>Personal transition guidance</h3>Clearly state in a document and if possible in verbal conversation your availability for providing personal guidance or tutoring to new members of the development team or not. If you are available, make sure to state your time availability and window for when you can be contacted. Be very clear about this, you don’t need early morning calls about a project you’re no longer working on. The time window depends on the size of the project (the bigger the project, the larger the time window), but it should almost never exceed a month from the handover date. After that, it’s just up to your personal feelings if you’re going to be available for discussions about the project or not.There’s also the possibility of you providing paid support, but this can heavily depend on the work contract you’ve signed with the company you were developing the project for or if you’re a freelance contractor.<h3>Snapshot version names (optional)</h3>While we have already mentioned containers and dependency versioning, it’s a good practice to write out also the version names and code of the tools and platforms that you have been working with on your local machine. For example: Visual Studio Code version, extensions used, Linux distro version (if developing on Linux systems), Git version and so on.<h3>Helpful tips (optional)</h3>Like any other optional step, its nice to go a bit beyond and show dedication to a project by sharing some helpful tips. I would usually recommend with sharing tips that you yourself wished you had someone tell you before joining the project. Almost all projects come with their own special “quirks” that are usually omitted when disclosing details. Sometimes a project has some unpredictable states and could cause confusion to the new developers. Write them down and be sure to mention that document to the receiving party, because a lot of developers tend to overlook documents that are not integral to the whole project (eg. API documentation).<h3>Solo developer transition</h3>So what to do when the receiving party is, well You, or better yet, there is no receiving party? Everything mentioned up to this point still stands. If your pausing a project for an unspecified amount of time, make sure that when the time comes for you to jump back in, you’ll do it with ease. So many developers can confirm the notion that they have a bit of a “snag” when they come back to a project after more than 6 months have passed. The truth is that many of them have evolved and transitioned over that period and different approaches and new experiences were made that the older versions of themselves simply didn’t know back then. So, when they open the old project with “fresh” eyes, all sorts of things tend to “pop” and even disorient. That’s when looking at some documentation can really help out.Just as a side note, if they are disoriented by the very code they have written themselves, how do you think a complete newcomer would feel after looking at that code without any guidance?<h3>Sunsetting a project</h3>It’s always something heartbreaking when we have to simply put a project aside indefinitely. Depending on the passion, drive and effort put into a project up to that point, it can be very upsetting and even sad. There’s also a possibility that a project was just sitting and taking up storage space. So that’s why good preparations have to be made and much of the same steps I’ve mentioned before repeated.If you have the sunsetting project listed somewhere (portfolio perhaps), be sure to update its status with a final note. Check for any links leading to the project and remove them. If the project was hosted on a third party service, look for a the option of first closing the project and then finally removing it. Export the source code files, assets, build scripts,zip them up and archive them.There’s solid digital asset organization system called the<a href="https://fortelabs.co/blog/para/"> P.A.R.A.</a> method. The para stands for Project, Areas, Resources and Archive. Its a great way for putting every project into perspective and defining, for example common attributes for different projects. If following this method, when sunsetting a project, one just needs to move the project from the ‘Projects’ category to the ‘Archive’ one and that would be it with that.I wouldn’t recommend outright deleting the repositories and files regarding a project. Although chances are very slim in revising that project again for some reason, one can never know. Maybe there’s just that one asset that is needed one more.<h3>Bad examples</h3>We have seen it in the industry happen all the time. Companies buying other companies and later learning about the issues with a product. Developers and other employees quitting when the start product changes hands.Being possessive around code is very common and it’s a factor that should always be calculated in when transitioning personnel around a project (not just developers, the whole team).Painting a wrongful picture of the current state of the project and “masking out” some problematic aspects of it, can cause devastating effects for the new team members. “Do a code review or demo before the handover.”- you might suggest, but here’s the thing, large projects have the “luxury” of being very difficult to analyze, by the sheer prospect of the time it takes to look over every single detail. The buyer, for example, is only interested in a single functionality of the buying product and doesn’t care about everything surrounding that single feature. This leads to acquisitions being made beforehand with the teams being among the last to be given the notice of it. Needless to say, the time and enthusiasm to prepare everything for the handover is very low at that point.If you ever heard the answer: ”The code is the documentation”, on your inquiry about any missing documentation, you rightfully should be displeased. The documentation is the documentation, everything else is extra. Sadly, this is a very common scenario and we should aim to reduce it as much as possible at least by setting an example for ourselves. Since you’re already here, reading this article, you’ve made the first step to being better professionals than the person giving the answer mentioned at the beginning of this paragraph. Good job!<h3>Final notes</h3>Do yourself and others a huge favor and take the extra mile and ensure that you have done everything in your power to make a transition process go as planned.Do you have any examples of good and bad project handovers? I’m looking forward to hearing about them and also about your thoughts on the subject matter. Be sure to comment and to share this post if you find it interesting.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=caec9673b02b" width="1" height="1" alt="">

the art of being a professional at the end
The average software developer has quite a few projects that they have worked on or are working at the moment, but a time comes to pass on that project to another pair of hands. As true professionals of our craft, it is admirable to make that extra step and solidify a positive work relationship between the two parties, the project sender and the project receiver. As someone who’s been on both ends, I can say that it can be very unprofessional when crucial parts of the project are not disclosed or simply do not exist.
Over the years, I’ve gathered some helpful insights, tips and guides on how to make process of handing over a project as painless as possible. So let’s not waste anymore time and just dig into them.
Setup instructions
First things first, providing a clear, step-by-step textual or even a video guide on how to build and run a project (if in a runnable state at the first place). Going the video route is, I admit it, a true stretch, but in this day and age it could be a lot more useful than a instructions manual.
Like deciphering a riddle, running the first build and setting everything up upon receiving the source code, can be challenging to say the least. One little dependency version number can make or break a project. I’ve worked on so many projects where just a version mismatch can cause absolute chaos. Even give a false positive when the project successfully builds, but then is covered in runtime crashes and warnings. To save you the headache of countless video calls and messages about the correct procedure to build and run a project, just save yourself the time and provide the minimum instructions and notes required to fulfill that task.
Container tools such as Docker provide a great way for drafting a build contract that can be reused just for cases like this. It eliminates the need to disclose concrete version names and codes about the running platforms and dependencies (we will come back to this a bit later).
One important thing to mention here is to actually test the guide or container component you are providing on your own, local machine and some other test machine to ensure that the guide is not missing some crucial key or step.
Project documentation
For some reason, this miraculous and crucial piece of the puzzle, tends elude or even evaporate into thin air whenever the reaching hands of another developer come near it or even mention’s it.
The least amount of data contained in the documentation should be: what’s the project about, what was the state of the project when you started working on it (if it was a legacy project), what’s the project state at the moment of the handover with even mentioning potential unfinished tasks or goals and finally, what was the original plan for the project to end up to.
If there isn’t any documentation, write some. At least some description and the state the project’s currently in. The receiving party should have the least amount knowledge if the project is actually doing something or if it can be scrapped the moment the handover process is complete.
If there is existing project documentation, go over it once more. Check is everything is there and fill in if something you think might be important is missing.
Account credentials
Any assigned testing account credentials or parameters should be provided to ensure that the project can be explored by the receiving party as soon as possible.
There’s a possibility that some full account credentials for some sensitive services needed to be provided. Be sure to check with a supervisor or, if possible, the security team on how the sensitive data should be provided.
If you have shared accounts with other projects, decouple them before the handover. Create new accounts and optionally tailor them to the receiving party.
Check your Git history logs for any mentions or exposures for the sensitive data.
Third party service accounts
Clean up any required third party service accounts of any debug data and artifacts. Simply provide a clean slate with setting the last logs to be the snapshot state.
If cloud services were used during the development and production process, when providing the project, remove any traces of previous logs and data. Some services might not provide this feature, in which case you might consider creating new accounts and migrate to them before the handover process. Mention this to the other party, maybe they have their own existing accounts that they can use or even create new ones that they can share with you in order to update the project.
Be sure that you comply to any GDPR regulations when there’s mention of User data. If possible, check with someone who’s more familiar with the legal procedures for this topic.
API documentation
One would imagine that if a project contains or targets an API service, that some documentation or mention of all the possible calls and endpoints exist, but here we are, no documentation just mysterious calls to some outside source of information. Time to lift up the sleeves and start writing down a rudimentary API document yourself.
This might seem to be a lot of unnecessary work, especially for someone that perhaps wasn’t actively engaged in the API development process. Don’t worry, that’s why we are here. There are helpful tools that make generating API documentation a bit easier. Postman can be a good tool to start with or search online for alternatives. If using Postman, be sure to also share the API collection and environment.
Try to print the network logs and see what data you can extract from that and go from there. Be sure to write down also any error states and network responses.
The minimum data to be written around a single API call should be:

URL
Call method
Request data with potential query or path parameters
Response data

Code clean-up
Just to be clear, you don’t need to rush and complete or fix the code. Nothing like that. What you should do is clear sensitive comments and debug messages. Any trivial references of yourself and/or your company should be checked and double checked. Needles to say, remove any course words and rude/silly comments or property names. Leave only the comments that provide value and information about the code itself.
Running a a standardized code formatter on the whole code base, ensures a bit of uniformity in the way the code is presented.
Refactor any file, class, method, field and property names to be more reflective of the functionality they provide. Run a global search on the whole project for keywords you deem to be important to remove before the handover.
Source code
Directly tied to the previous segment, source code maybe the most crucial part in the handover process. Chances are that the receiving party is primarily interested in the source code, but as we are seeing in this document this key component can be shadowed by so many missing or incomplete pieces that surround it. Many IDE’s provide a way to export the source code for a project that makes it more easy to unpack and run. Export them and import them again under a different name, just to mimic how someone new to the project might experience that process.
If parts or the whole code itself should be copyrighted, make sure that it actually is. Check the wordings and date values. Any proprietary library or module, or something else that is subject to different copyright or licensing, be sure to disclose this to the receiving party.
Binaries or working examples and artifacts are a welcomed inclusion as well.
Git clean-up
Oh Git, where would we be without the safety harness of this tool. Git knowledge is almost an art form and the more one knows how to use it, the more rewarding it becomes.
Git or any other VCS for that matter, provide a unique snapshot look into the various stages of development. All the different branches, commit messages and merge requests aiming towards one single outcome, a better project overall.
The more mature and complicated a project is, the more information is stored in the Git Log. There’s quite the possibility of old, temporary or even deprecated branches just sitting there without ever being merged into another branch or simply being marked for removal but never actually meeting that task. Go over the Git tree and make sure that only the necessary branches are left. I will not go into details about merging or re-basing branches, there are a lot more great resources available online about that topic, but simply put re-basing ends up with a single progression line and is perhaps a bit easier to understand and merge shows the paths each of the merging branches have made.
If the Git history contains a lot of sensitive information, one simple thing to do is to just create a new repository from the latest branch and provide that as is. If questioned about the lack of log information, just say it’s outside your pay grade to discuss such things.
Assets
Assets can be any document,note, graphical element, fonts, translations, etc. that aren’t necessarily thought of as being an essential part of documentation, but nonetheless can provide a lot of value to someone just starting out with the project. For example, it can be very useful if we provide the Photoshop templates or settings we have used for the graphical elements in our project.
UX Design sketches, color codes, testing strategies and schemes can speed up a lot of tedious tasks around matching the exact specifications provided in some other document. I’m not saying that you should provide absolutely every single little brainstorming doodle, just the assets that might be forgotten in the hectic of handing over a project.
Single repository
I have yet to see a developer that likes when someone shares to them a bunch of links and scattered files and documents all over the place. Create a single asset repository which you can easily link and share to anyone that needs it. By using a single repository you’re creating a single source of truth for the files contained in it. Any writing/editing of the files contained in the repository should be disabled before sharing it with outside sources.
An additional step would be in defining a clear window of time when this repository is available to be read/downloaded. No repository should indefinitely be left open to any outside party. After the time window has passed, an internal backup copy should be generated and the repository deleted.
Personal transition guidance
Clearly state in a document and if possible in verbal conversation your availability for providing personal guidance or tutoring to new members of the development team or not. If you are available, make sure to state your time availability and window for when you can be contacted. Be very clear about this, you don’t need early morning calls about a project you’re no longer working on. The time window depends on the size of the project (the bigger the project, the larger the time window), but it should almost never exceed a month from the handover date. After that, it’s just up to your personal feelings if you’re going to be available for discussions about the project or not.
There’s also the possibility of you providing paid support, but this can heavily depend on the work contract you’ve signed with the company you were developing the project for or if you’re a freelance contractor.
Snapshot version names (optional)
While we have already mentioned containers and dependency versioning, it’s a good practice to write out also the version names and code of the tools and platforms that you have been working with on your local machine. For example: Visual Studio Code version, extensions used, Linux distro version (if developing on Linux systems), Git version and so on.
Helpful tips (optional)
Like any other optional step, its nice to go a bit beyond and show dedication to a project by sharing some helpful tips. I would usually recommend with sharing tips that you yourself wished you had someone tell you before joining the project. Almost all projects come with their own special “quirks” that are usually omitted when disclosing details. Sometimes a project has some unpredictable states and could cause confusion to the new developers. Write them down and be sure to mention that document to the receiving party, because a lot of developers tend to overlook documents that are not integral to the whole project (eg. API documentation).
Solo developer transition
So what to do when the receiving party is, well You, or better yet, there is no receiving party? Everything mentioned up to this point still stands. If your pausing a project for an unspecified amount of time, make sure that when the time comes for you to jump back in, you’ll do it with ease. So many developers can confirm the notion that they have a bit of a “snag” when they come back to a project after more than 6 months have passed. The truth is that many of them have evolved and transitioned over that period and different approaches and new experiences were made that the older versions of themselves simply didn’t know back then. So, when they open the old project with “fresh” eyes, all sorts of things tend to “pop” and even disorient. That’s when looking at some documentation can really help out.
Just as a side note, if they are disoriented by the very code they have written themselves, how do you think a complete newcomer would feel after looking at that code without any guidance?
Sunsetting a project
It’s always something heartbreaking when we have to simply put a project aside indefinitely. Depending on the passion, drive and effort put into a project up to that point, it can be very upsetting and even sad. There’s also a possibility that a project was just sitting and taking up storage space. So that’s why good preparations have to be made and much of the same steps I’ve mentioned before repeated.
If you have the sunsetting project listed somewhere (portfolio perhaps), be sure to update its status with a final note. Check for any links leading to the project and remove them. If the project was hosted on a third party service, look for a the option of first closing the project and then finally removing it. Export the source code files, assets, build scripts,zip them up and archive them.
There’s solid digital asset organization system called the P.A.R.A. method. The para stands for Project, Areas, Resources and Archive. Its a great way for putting every project into perspective and defining, for example common attributes for different projects. If following this method, when sunsetting a project, one just needs to move the project from the ‘Projects’ category to the ‘Archive’ one and that would be it with that.
I wouldn’t recommend outright deleting the repositories and files regarding a project. Although chances are very slim in revising that project again for some reason, one can never know. Maybe there’s just that one asset that is needed one more.
Bad examples
We have seen it in the industry happen all the time. Companies buying other companies and later learning about the issues with a product. Developers and other employees quitting when the start product changes hands.
Being possessive around code is very common and it’s a factor that should always be calculated in when transitioning personnel around a project (not just developers, the whole team).
Painting a wrongful picture of the current state of the project and “masking out” some problematic aspects of it, can cause devastating effects for the new team members. “Do a code review or demo before the handover.”- you might suggest, but here’s the thing, large projects have the “luxury” of being very difficult to analyze, by the sheer prospect of the time it takes to look over every single detail. The buyer, for example, is only interested in a single functionality of the buying product and doesn’t care about everything surrounding that single feature. This leads to acquisitions being made beforehand with the teams being among the last to be given the notice of it. Needless to say, the time and enthusiasm to prepare everything for the handover is very low at that point.
If you ever heard the answer: ”The code is the documentation”, on your inquiry about any missing documentation, you rightfully should be displeased. The documentation is the documentation, everything else is extra. Sadly, this is a very common scenario and we should aim to reduce it as much as possible at least by setting an example for ourselves. Since you’re already here, reading this article, you’ve made the first step to being better professionals than the person giving the answer mentioned at the beginning of this paragraph. Good job!
Final notes
Do yourself and others a huge favor and take the extra mile and ensure that you have done everything in your power to make a transition process go as planned.
Do you have any examples of good and bad project handovers? I’m looking forward to hearing about them and also about your thoughts on the subject matter. Be sure to comment and to share this post if you find it interesting.

Srdjan Delić, Mobile Product Owner & Product Engineer

Tech Articles