In today’s interconnected world, everyone is at risk of cyber-attacks. This blog is the perfect introduction to cybersecurity as a profession or as a career. - <a href="https://www.linkedin.com/in/deepak-lingaraju-20013239/">Deepak Gowda</a>, <a href="https://coffeebeans.io/">CoffeeBeans</a>.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v3_qGPKpZMbPXrs5ReTJxg.jpeg"></figure>The best way to begin your career in cyber security
<ul>
<li>Are you interested in Cyber Security as a career?</li>
<li>Are you planning to switch your career toward IT Security? But don’t know how to proceed or where to start?</li>
</ul>
Hopefully, this article will help you gain an understanding of cyberspace and move in the right direction.
In fact, just like any other information technology (IT) domain like programming, Testing, IT security is a huge subject. Becoming an expert hacker in this field takes effort, practice, and time.
IT Security can be mainly divided into two major parts:
<ol><li>Offensive Security</li></ol>
In offensive security, people will perform Ethical Hacking (legal way of hacking the application and get paid for it 😊), Penetration Testing (Measuring the security posture of the application), and other operations to discover problems in IT Infrastructure before a hacker can penetrate and damage it.
2. Defensive Security
In defensive security, people will do everything they can to ensure maximum security. Antivirus Companies, Intrusion Detection System (IDS), Intrusion Prevention System (IPS), Firewalls, Distributed denial of service protection systems (DDoS), and other end-point security mechanisms fall into defensive security.
Whether you are a recent graduate in any degree or an experienced professional who wants to switch to security, I strongly suggest you get the following certifications or gain the knowledge either through online platforms like Udemy.
<ol>
<li>
A+ certification is widely accepted as an industry standard certification used to start careers in the information technology (IT) industry. The A+ certification is issued by CompTIA.</li>
<li>
Network+ certification validates the knowledge and skills needed to troubleshoot, configure and manage wired and wireless networks found in companies around the world. CompTIA Network+ certifies a professional-level understanding of emerging technologies, including cloud and virtualization technologies.</li>
<li>
Security+ certification validates that you have the core skills necessary for a career in IT security. For many aspiring cybersecurity professionals, earning this popular entry-level certification can be the first step toward a rewarding, in-demand career.</li>
</ol>
After that Follow To do the Advance Certification based on your future goals.
<figure><img alt="Certification in cyber security" src="https://cdn-images-1.medium.com/max/688/1*zsJJLJBXuzlZsvU29KmqmA.png"><figcaption>Certification in Cyber security domain</figcaption></figure>It is important to have a good set of certifications that demonstrate knowledge of the IT security field, but continuous learning is what makes you a better IT security professional, not a particular course or certification.
I really hope I have shed light on some important ways to be a part of the IT security community.
Happy Learning !
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=d919dca9309d" width="1" height="1" alt="">

In today’s interconnected world, everyone is at risk of cyber-attacks. This blog is the pe ...

The best way to begin your career in cyber security

Cross Browser Testing using Selenium GRID
One of the challenges that we face while testing the application is testing it on different browsers and environments. We all might have observed that some websites are not properly displayed on some browsers and we just think that the website is broken. But, as soon as you open it on a different browser, the website opens up just fine. Thus, this behavior explains the compatibility of a website with different browsers.
<ul><li>
Kiran HS, <a href="https://www.coffeebeans.io/">CoffeeBeans</a>
</li></ul>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*qY7Nvn18Jot4iLK0GbCd7Q.jpeg"></figure>Each browser interprets the information on the website page differently, so, some browsers may lack the features that your website is trying to show and make your website look broken on that browser.
That being the brief story, I bet you all have figured out the topic of today’s discussion — Cross Browser Testing. So what is cross browser testing?
Cross browser testing is a type of testing that lets you check whether the websites are working as intended when accessed through
<ul>
<li>Different Browser — OS combination</li>
<li>Browsers like — Chrome, Firefox, Safari, Edge, etc</li>
<li>Operating Systems like — Windows, Linux, MAC, etc</li>
</ul>
It’s about shipping releases that are as browser-agnostic as possible, which is key to delivering a uniform user experience on a diverse, ever-growing range of browsers/devices.
As a tester, it is your responsibility to make sure that not only do applications work, but they work for all your users, no matter what browser, device, or additional assistive tools they are using. Now comes the next question -
Why cross browser testing?
<ol>
<li>To check how the website appears on different browsers</li>
<li>To check how the website works on different browsers ( quite obvious )</li>
<li>To ensure that you’re not alienating a significant part of your target audience–simply because your website does not work on their browser OS.</li>
</ol>
The next question which comes to mind is -
How to perform cross browser testing?
This can be done in two (obvious) ways
<ol>
<li>Manual Approach (Manually check the functionality on different browsers and platforms, painful process to follow)</li>
<li>Automation Approach (Write one piece of code and run it on different browsers and platform combinations — sounds cool and easy right?)</li>
</ol>
That being said, let’s dive into the automation approach and see how this can be achieved with Selenium, Selenium GRID, and TestNG
Firstly, you will need to set up a selenium grid to run the tests on different browsers and platforms. For this, you will need a selenium server standalone jar which can be found in the given link — <a href="https://selenium-release.storage.googleapis.com/index.html?path=3.141/">Selenium Server Standalone Jar</a>
Once you have downloaded the jar file, you need to set up the hub and node based on the requirement. For the demonstration purpose, I will create 1 hub and 2 nodes. 1 of the nodes will run firefox as browser-related test cases. The other node will run chrome-related test cases.
Let’s start by creating a hub.
The command to create a node is as follows
java -jar selenium-server-standalone-3.141.59.jar -role hub
Below is the screenshot of the hub looks when it is up and running
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G_mWZ6m7Q0JdPGC4"></figure>Once you have created a hub and have obtained the hub register URL, let’s register a node with chrome browser-related configurations. This can be done in two ways,
<ol>
<li>By passing the arguments in the command line</li>
<li>By creating a JSON file with the required configurations.</li>
</ol>
I will be creating both nodes by passing the arguments from the command line. The configuration goes as follows for creating a node with chrome browser configuration
java -Dwebdriver.chrome.driver=”/Users/macbook/Downloads/chromedriver” -jar selenium-server-standalone-3.141.59.jar -role node -hub <a href="http://localhost:4444/grid/register">http://localhost:4444/grid/register</a>
Below is the screenshot of it looks when it is registered
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q0WAC0s4LgUU164D"></figure>Once you have registered that node, let’s register another node with firefox browser configurations. The command to do so is as follows
java -Dwebdriver.gecko.driver=”/Users/macbook/Downloads/geckodriver” -jar selenium-server-standalone-3.141.59.jar -role node -hub <a href="http://localhost:4444/grid/register">http://localhost:4444/grid/register</a>
Below is the screenshot of it looks when it is registered
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CWb2UdLTXEpKqkQc"></figure>Once both the nodes are registered it can be verified by navigating to the grid console. The same can also be verified on the hub console
Hub Console
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oA_nApXOVaF-rIA1"></figure>Grid console URL is as follows — <a href="http://localhost:4444/grid/console">GRID Console</a>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fOZGNwa3mrtlm72W"></figure>After you have registered both nodes, get the hub URL and append wd/hub at the end. We will use this URL to route the test cases to specific nodes as configured.
Hub Url — <a href="http://localhost:4444/wd/hub/">Hub URL</a>
Now let's create a maven project and testng.xml file so that we can run the tests parallelly.
Let’s add the selenium and testng dependency
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IeJ1q2hDcy8dRTh_"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6uKiJSq_bKiP8hyG"></figure>The next step is to initialize the browser’s drivers based on the requirement. chrome driver if chrome browser is required, firefox driver if firefox browser is required.
Let’s write some basic test cases that are going to print the browser title from both the browsers
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jsHJ65hHx_7ZSKWT"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bBBUErzRNXYoTJ9Y"></figure>Now let's run the test cases parallelly and see if the configurations are working
Command to run the test — mvn clean test
Viola, one single test can now be run on 2 different browsers parallelly. Refer to the console for execution results
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xRAeer4-SBYGvmAD"></figure>For now, the platform in which I am running the test cases is MAC, this can be changed when a different platform is configured like Windows, Linux, etc. TestNG file to run the test cases parallelly is as below.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZRKWiFBK8S87v787"></figure>In the same way, safari and edge can also be configured to run the test cases. It depends on the requirement of how many browsers and platforms need to be covered.
That’s all folks, for now, see you guys in the next exciting blog.
Thank you !!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=342d9f60b1f0" width="1" height="1" alt="">

Cross Browser Testing using Selenium GRIDOne of the challenges that we face while testing  ...

Cross Browser Testing using Selenium GRID

Transfer Learning works on the idea that a pre-trained model trained in one setting can be utilized in a different setting for a specific task. I will be doing sentiment analysis here by using a pre-trained BERT model using Pre-Trained Model Approach and will be further training it on a custom dataset prepared.
<ul><li>
By <a href="https://www.linkedin.com/in/lawa-747151117/">Lakshay Wadhwa</a>, <a href="https://coffeebeans.io/">CoffeeBeans</a>
</li></ul>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/760/1*FCYpeLgCxY7mIkmzV0o5Eg.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*olcrXmbB3FH7X2_Z.png"><figcaption>Source: Educative.io</figcaption></figure>Key Motivation for Transfer Learning- If we look at tasks in our everyday life, we don’t necessarily learn everything from scratch. We essentially try to make our understanding of some new task based on our experiences in the past. It’s also fairly difficult to gather a huge amount of data to train a Deep Learning model from scratch. Transfer learning comes very handy in cases where you don’t have much data to train a new model from scratch.
This article is solely focused on the practical implementation of Transfer Learning by using a pre-trained model and we will further train it according to our requirements.
Let’s walk through the script:
We will start by installing pip, sentencepiece, datasets, and transformers.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-JS5IJ4Qctw7r-xq.png"></figure>Next, we will define a class where we would write the function for encoding data, in our case, it’s tweets.
For more details, you can read about the different attributes of tokenizer.encode_plus in the following <a href="https://huggingface.co/transformers/v2.11.0/glossary.html">link</a>.
Also, you can go through this <a href="https://huggingface.co/docs/transformers/main_classes/tokenizer">link</a> as well.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*p_SesQeHh-ez1GSK.png"></figure>The next steps involve defining hyperparameters as well as the model on which we are going to do training.
There is no strictness regarding the model used here, you can choose your own depending on the problem statement. But it’s always fair to check on its performance before you further train it on your custom data.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RIIZ2NbdWuu28tap.png"></figure>Next, we should define a relabeling function that actually defines the labels of your classification problem. Here I am taking three categories 0,1 and 2.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JjaBh1lHV0gedtjU.png"></figure>Next is converting the data into an appropriate format before we pass it to a trainer.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*g1gBbEvTZfBDhulu.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LtHo6TeA0SgBbXYe.png"></figure>The next step is model training and this is the most crucial step of whole process where we will pass the data to pretrained model trainer.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r2_k9DiGp_7KANyw.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uZsRr_lZw7wQRyku.png"></figure>Please see that I have kept epochs to 10 and the Batch size is 8, my model took approx 3hrs for 1 epoch to train since my dataset was large, you can play around here by keeping epochs less or keeping the dataset small, but if you want to train a good model, my suggestion is to use at least8 to 10 epochs for satisfactory results.
Also, make sure to evaluate your results.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E778b0GgLXoPMgyR.png"></figure><h3>The next concept I want to share is ONNX model format.</h3>
ONNX is an intermediary machine learning framework used to convert different machine learning frameworks. In Short, train your custom model in whatever framework you are comfortable with, like Tensorflow and Pytorch, and just finally convert it to common ONNX format. This provides a lot of flexibility to developers as well. You can also use ONNX models with optimized inference frameworks (Onnx runtime, Ncnn, Tvm etc) to maximize performance.
(I will write a separate blog later for ONNX in detail)
According to official documentation :
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jILR_D1L-6qfsavy.png"><figcaption>Source: <a href="https://github.com/onnx/onnx">https://github.com/onnx/onnx</a></figcaption></figure>Every developer who is working on either tensorflow or Pytorch or using any other DL framework must know ONNX as interoperability is very important to keep production pipelines intact and in case we need to change model or retrain model in different frameworks and use them in production then ONNX would come very handy as you would have a single framework for production instead of various frameworks.
Here I am sharing a code below to convert retrained model using ONNX.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wkIEzJg18rRoq6of.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C-vVDnM2HMyXNaV6.png"></figure>Please note here that defining features is really important as this defines for what specific task we are converting our model to ONNX format. The last step involves converting the model into ONNX format and then checking the export or loading the model and then utilizing it in production or research environment.
Please suggest any changes if some error is there, the error would be rectified immediately.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=d9dff925c984" width="1" height="1" alt="">

Transfer Learning works on the idea that a pre-trained model trained in one setting can be ...

How to use a pre-trained BERT model for classification using Transfer learning

<h3>eBPF — Divulging The Hidden Super Power</h3>
If you are a performance engineer/network engineer or even security engineer, the chance of you encountering eBPF technology in the future is very high. eBPF now has a huge community of users, including big players like Meta, Google, Cloudflare, and Netflix all using this tech in their daily operations.
<ul><li>
<a href="https://www.linkedin.com/in/goutham-krishna31/">Goutham Krishna</a> , <a href="https://coffeebeans.io/">CoffeeBeans Consulting</a>
</li></ul>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PAHzzTuVSwAHRXwIzOFjOw.jpeg"></figure><h3>Prelude</h3>
Let me start the blog with a real story. A year back one of my friends called me to discuss tech (which is a very common thing between us). We share different technical challenges each of us faces at our workplace or by any of our peers and these discussions lead to some informative and creative knowledge-sharing sessions. In such a discussion, he described a specific challenge faced by his cousin, who works for a giant cloud provider. The challenge was to restrict certain IPs dynamically as they provide threats such as a DOS (Denial of service attack), the application developer’s brain in me impetuously replied that these should be handled at a firewall level, or middleware can be written to check the origin of the packet and maintain a blacklist for the malicious senders and ignore the requests (Yes I come from a NodeJS and Go background so the initial solution strikes as a middleware). My friend patiently explained the scale and performance at which this needed to be executed which was way beyond my comprehension. After a noob’s doubt clearing session, we agreed that the scale he wanted could only be achieved at a kernel level. I wished him luck (sarcastically) to write a kernel patch and raise a PR hoping the OS maintainers would include the kernel patch in an upcoming kernel release and he can use this feature when it is released. As a reply to my sarcasm, he shared with me a link to an article that detailed something called “eBPF” (extended Berkeley Packet Filter). I did a basic skimming through the article, and my ignorant mind came to sense that there are amazing inventions in the tech world that I am unaware of.
According to eBPF, you can inject the code directly into the kernel without writing a patch, waiting for it to be approved by the OS maintainer,
“RUN YOUR CUSTOM CODE DIRECTLY IN OS KERNEL” — LIZ RICE
“SUPERPOWERS FOR LINUX”. — BRENDAN GREGGS
<figure><img alt="" src="https://cdn-images-1.medium.com/max/725/0*17I5uYtBRc_AXsy8"></figure>NB: I have added some video and blog links in the reference section please check it out for some amazing sessions and blogs of eBPF.
<h3>History</h3>
The eBPF came to life in 2014, introduced in Linux kernel 3.18, thereby unlocking the God mode of the Linux kernel. The natural doubt anyone reading this blog would have is regarding the name. If this is an “extended berkeley packet filter” then there should be a BPF “berkeley packet filter”. Well, you are right. The BSD packet filter is not a new concept. It was from the 90’s. This gem has been hiding under the radar for years, the Xennails were true innovators. BPF was very basic and its only job was to filter packets at the kernel level hence the name.
NB: I have added the original BPF paper published on December 19, 1992, a very interesting read.
The eBPF has come a long way from BPF, just a packet filtering utility to the consideration of microservices architecture for kernels or as they call it microkernels. All the top tech companies that work at scale nowadays use eBPF on daily basis. CNCF community nowadays breathes and lives on eBPF, if you are a DevOps engineer or sysadmin you would have heard of cilium and Falco both popular in Kubernetes users and production tools that are written on top of eBPF. In 2018 Linux announced it would replace its iptable-based implementation with an eBPF version in the kernel (well replacing iptable with any solution would be better), fall back and disadvantage of using iptables is out of the scope of this article, please go to the reference section and find a well-written article about it. The Kubernetes used iptables for the following use cases mostly
<ul>
<li>Kube-proxy — the component which implements Services and load balancing by DNAT iptables rules</li>
<li>Most CNI plugins are using iptables for Network Policies</li>
</ul>
Cilium has made it more efficient by eliminating the iptable whose performance degrades. You can refer to the details <a href="https://cilium.io/blog/2018/04/17/why-is-the-kernel-community-replacing-iptables">here</a>.
<h3>Program Execution Bozo’s Guide</h3>
To explain the importance of eBPF there needs to be an explanation of how programs are executed in Linux, I will try to explain it from a 1000ft view for everyone.
NB: Windows User? Well why are you even reading this article, you guys do not have all these cool features.
Linux memory is divided into two
<ol>
<li>Kernel space</li>
<li>User space</li>
</ol>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/602/0*ErgxMOK9ov19toqQ"><figcaption>Credits: slideshare</figcaption></figure>The image itself explains the difference between these two. All the programs that you write are just collections of syscalls that are kernel APIs. Just take the example of opening a file through your favorite programming language that just translates into a fileopen syscalls in the kernel.
When your application asks the kernel for something, a chunk of data in kernel space is frequently copied into user space. We must do this because operating systems strictly partition memory regions used by the kernel, making it impossible to simply provide a pointer to some region of kernel memory to a user space program. This is known as “crossing the user/kernel boundary,” Because of the copy operation, operations like these can have significant performance consequences.
While syscalls cover almost all cases, there arise situations where this is not sufficient like when we need kernel-level performance or write a new driver programming, etc. Depending on the OS maintainers to make patches for all these small use cases is a waste of time and an impossible process. This is where ebpf comes into the picture.
eBPF helps you to write programs in the user space which get packaged and injected into the kernel directly, these programs run on VM in the kernel with a limited instruction set thus extending the capability of the base kernel module.
<h3>eBPF Dissected</h3>
eBPF is the provision to run custom code that runs on the kernel for various processes like
<ul>
<li>Observability (tracing)</li>
<li>Debugging</li>
<li>Firewalling</li>
<li>Load Balancing</li>
<li>Network related activity</li>
</ul>
Anyone who has worked in tracing the various programs in the kernel would know its difficulty. The half-baked utilities available in the Linux systems are not enough for profile complex systems or even to extend the perf tooling.
Ebpf is event-driven which means it gets triggered on the following scenarios
<ul>
<li>A system call</li>
<li>Function entry/exit</li>
<li>When a packet enters or leaves</li>
<li>K probes or U probes</li>
</ul>
The programs are written in a language called restricted c which is c with a limited instruction set. The BPF compiler BCC converts this into a bytecode which is loaded into the kernel for execution. A validator is run before compiling to ensure there is no infinite loop or such never-ending I/O operation which could crash the kernel.
<h3>Additional Trick Under Your Sleeve</h3>
The ebpf is indeed a powerful tool that you could have under your sleeve. When working on high-performance projects tweaking the packets or extending the tracing functionality all help you give better observability of what’s happening with the system. Even though encountering the ebpf by an application developer at the present stage is very feeble, if you are a performance engineer/network engineer or even security engineer, the chance of you encountering ebpf in the future is going to shoot up to the sky.
There are some considerations while writing ebpf programs, there have been several privilege escalation attacks that leverage ebpf since it runs in a sudo privilege. The ebpf programs could be used as a powerful aid when leveraging kernel memory vulnerabilities. A detailed writeup of leveraging such a vulnerability was found by Qualys, there is a writeup by them which you can refer to from <a href="https://www.qualys.com/2021/07/20/cve-2021-33909/sequoia-local-privilege-escalation-linux.txt">here</a>.
<h3>Conclusion</h3>
As said in Spiderman movies “Great power comes with great responsibility” when you unlock the God mode of Linux you are on your own, the guards that protected your program from corrupting the whole are not available now. There are specific use cases to use Ebpf, it is not the swiss knife for all your performance issues. The community is pretty huge now including big players like meta, google, Cloudflare, and Netflix all using the tech daily. The tech has loads of potential to grow, recent years have seen separate conf for ebpf enthusiasts.
This blog serves as a small opening to people who are unaware of this cool tech, so please do your research. There are tons of resources available online about ebpf and open source projects being built on top of it. I will be writing a follow-up article detailing how to write a sample ebpf program and execute it.
<h3>Reference</h3>
<ul>
<li>The BPF research paper link was published in the year 1992 — <a href="https://www.tcpdump.org/papers/bpf-usenix93.pdf">https://www.tcpdump.org/papers/bpf-usenix93.pdf</a>
</li>
<li>Brendann Gregg talks about eBPF -</li>
<li><a href="https://www.facebook.com/atscaleevents/videos/1693888610884236/">https://www.facebook.com/atscaleevents/videos/1693888610884236/</a></li>
<li><a href="https://www.youtube.com/watch?v=w8nFRoFJ6EQ">https://www.youtube.com/watch?v=w8nFRoFJ6EQ</a></li>
<li>Ebpf over iptables blog — <a href="https://cilium.io/blog/2018/04/17/why-is-the-kernel-community-replacing-iptables">https://cilium.io/blog/2018/04/17/why-is-the-kernel-community-replacing-iptables</a>
</li>
<li>Qualys vulnerability — <a href="https://www.qualys.com/2021/07/20/cve-2021-33909/sequoia-local-privilege-escalation-linux.txt">https://www.qualys.com/2021/07/20/cve-2021-33909/sequoia-local-privilege-escalation-linux.txt</a>
</li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=181f96291ef7" width="1" height="1" alt="">

eBPF — Divulging The Hidden Super PowerIf you are a performance engineer/network engineer  ...

eBPF — Divulging The Hidden Super Power

<ul><li>By Rahul Kumar, <a href="https://coffeebeans.io/">CoffeeBeans Consulting</a>
</li></ul>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*PqG8vJjrHNrcYfLSwAfI4g.png"></figure>What is a Product Roadmap?
A product roadmap is a document that outlines the steps that will be taken for a product or solution to be developed over time. Roadmaps are used by product owners to specify future product functionality and the timing of the release of new features. When used in agile development, a roadmap gives the team’s daily work critical context and should be adaptable to changes in the market.
Nobody knew what product roadmaps should look like until recently, but we all knew something had to change.
To communicate our product plans at older companies, we used pen and paper and a release planner. They were long, complicated, and detailed — after all, they were designed for developers — and they resulted in a jumbled backlog that was difficult to follow.
Today, road mapping is a divisive topic, but one thing is clear: It is necessary. We all know that no one reads the lengthy piece. We’re also learning how effective a roadmap can be when it’s so well-designed that teams use it to make product decisions and businesses use it to make business decisions.
We’ll look at how a roadmap can help you connect your work with that of others and reclaim control over your product. But what exactly does that road map entail? Let’s dive in to understand it better.
What does a great product roadmap look like?
A good product roadmap must be visually appealing, easily accessible, and clear enough for anyone to scan for answers to the following questions:
· What exactly are we doing?
· Why are we doing it in the first place?
· What does this have to do with our OKRs?
OKRs are defined as Objectives and Key Results that the product is entitled to achieve through the set of features you are building for the product. It encompasses the milestones you will attain in releasing those features.
A theme-based product roadmap is based on this premise, and the benefits are enormous and immediate.
· Reduce the number of meetings you attend — On the roadmap, your priorities (what and why) are clearly stated. You do not need to explain things to different people in different ways.
· Encourage constructive team debates — Your roadmap can serve as a benchmark for team members to hold themselves and one another accountable for linking deliverables to roadmap goals and OKRs.
· Make product choices, everyone understands — you’re no longer the jerk who dismisses ideas. You can actually discuss customer feedback and ideas using your roadmap and priorities, which are visible to everyone
We must abandon the notion that we can enumerate a set of features that will represent what we will do in the future. This is a ridiculous notion. We should communicate how we will make decisions instead of sharing feature lists with the rest of the company.
A theme-based roadmap is made to be adaptable, so your plans can change as your circumstances change, and it can serve as a communication tool.
To begin, make three columns.
A roadmap, which includes release dates, may be familiar to you. A theme-based roadmap substitute with time horizons made up of three columns:
1. Now — Tasks that you are currently working on
2. Next — Tasks that are coming up soon
3. Later — Tasks that you’d like to work on in the future or need to do a bit more research before you move on
It’s worth noting that we’re not displaying any dates. This isn’t a release schedule; rather, it’s a bird’s eye view of your top priorities. Those are always subject to change, especially in the far future, which you can’t plan for today meaningfully.
The idea is to give yourself some ﬂexibility in case things change. You can push something back if it was current but you no longer want it.
Organize Broad Themes
A roadmap, which includes a list of features and their expected completion date, may be familiar to us.
A theme-based map replaces this with themes, which appear as cards on your roadmap.
According to Jared Spool, founder of User Interface Engineering, themes are “a promise to solve problems, not build features.”
Those words come from the realization that almost any product will receive a flood of customer feedback and feature requests that revolve around a single universal problem.
You can either become a slave to those requests or take a step back and address the root of the problem with a single, elegant solution.
Working in themes allows you to think about how you might approach each problem and then decide how to solve it later.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/393/1*fCW9nhdBAAmBTa9mEPdYrw.png"></figure>In user administration in the blue cloud, you can observe it’s considered as them because it consists of certain features that complete that. Sign up for a new account and login for existing users are two basic features that get covered under it. It’s basically a strategic theme to add/login users to an account, not a specific deliverable.
But on a contrary, you can observe that the last one is crossed out. Because you want your cards to be strategic. To be a strategy, “rewriting transactional emails” is far too specific. It’s both an idea and a tactic, and does not belong in the high-level view you’re developing in this step.
It would, however, be more appropriate as an idea within a larger-scale roadmap card.
Inserting Supporting Details
Once you’ve nailed down your themes, you can add more supporting information for anyone who wants to dig deeper. These details help us strengthen what we’re putting on our roadmap, which could include information that’s useful to those who read it:
1. What exactly are we doing?
2. Why are we doing it in the first place?
3. What does this have to do with our OKRs?
OKRs are defined as Objectives and Key Results that the product is entitled to achieve through the set of features you are building for the product. It encompasses the milestones you will attain in releasing those features.
Internally, your team will have access to detailed data that will assist them in preparing for and navigating your workflow. The following are some of the details:
· Ideas — Strategic suggestions for improvement. These concepts respond to a straightforward business question: What problem are you trying to solve?
· Customer feedback — We attach feedback to ideas in Product Board so that it can be linked to potential improvements and we can keep track of what our customers want.
· User stories — For inspiration, consider the following case scenarios: I want to X in order to Y as a user.
Cards in the Future column don’t have to have all of those answers just yet, but they should get a lot more detailed as they get closer to the ‘Current’ term.
Label and Categorize
You can color code and tag your roadmap as you go along to make it easier for the viewer to sort through and filter down based on a specific interest. It’s similar to how you use post-it notes!
Remember, color coding can also help to distinguish certain features based on the parameters you choose like prioritization, efforts, immediate release, customer needs, etc. It simplifies your process of developing features and functionalities for your product.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*AX2f8QEvpegMdAc6howlyA.png"><figcaption>Source: <a href="https://www.smartsheet.com/your-complete-guide-understanding-and-creating-visual-product-roadmaps">https://www.smartsheet.com/your-complete-guide-understanding-and-creating-visual-product-roadmaps</a></figcaption></figure>User Profiles, maps of cuisines, and reviews are something most customers look for before going to any restaurant. Similarly, what needs to be built when and for whom, the prioritization should be customer-centric rather than features-centric.
Similarly, you can find next and later features to be developed and in case you want to make changes, make sure it helps to solve your customers’ pain points.
How’s that for basic usability? This keeps things simple and engaging visually, and everyone will appreciate not having to slog through stacks of cards to find what they came for.
Rather than staring blankly at one large roadmap, your co-workers can concentrate on the ones that are relevant to them.
The Bottom Line: This Roadmap Is Much Larger Than You Think
The idea’s sheer brilliance is how, with a single gesture, understanding everything about customers becomes the most influential factor in developing product strategy. “Look at us,” companies say when they talk about features. Take a look at what we’ve accomplished thus far.” “Take a look at what you’re dealing with,” companies say when they discuss customer problems. Take a look at what we’re planning to do to facilitate.”
And, in a single stroke, you’re empowering everyone at your company to think in this manner. You are not the only one. Can you imagine the impact that would have?
Just stick to this famous quote by Jeff Bezos:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*MdJQ0nOH7cDqiOU6oz1oUA.png"></figure>References
· <a href="https://happyproject.in/stoic-decisions/">https://happyproject.in/stoic-decisions/</a>
· <a href="https://www.quora.com/What-is-the-better-way-to-build-an-effective-product-roadmap-What-makes-a-good-product-roadmap">https://www.quora.com/What-is-the-better-way-to-build-an-effective-product-roadmap-What-makes-a-good-product-roadmap</a>
· <a href="https://www.prodpad.com/resources/roadmap-course/">https://www.prodpad.com/resources/roadmap-course/</a>
· <a href="https://railsware.com/blog/product-roadmap/">https://railsware.com/blog/product-roadmap/</a>
· <a href="https://productschool.com/blog/product-management-2/product-roadmap-templates/">https://productschool.com/blog/product-management-2/product-roadmap-templates/</a>
· <a href="https://www.smartsheet.com/your-complete-guide-understanding-and-creating-visual-product-roadmaps">https://www.smartsheet.com/your-complete-guide-understanding-and-creating-visual-product-roadmaps</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5cc2c86f2487" width="1" height="1" alt="">

By Rahul Kumar,CoffeeBeans ConsultingWhat is a Product Roadmap?A product roadmap is a docu ...

How to Create a Product Roadmap That Everyone Can Understand!

Architecture design is a must while developing a SaaS application to ensure its scalability and optimising infrastructure costs. In this blog, Lets discuss the implementation of one such architecture with Quarkus java framework and Hibernate ORM
By <a href="https://www.linkedin.com/in/vishal-bihani-821146148/">Vishal Bihani</a> , <a href="https://coffeebeans.io/">CoffeeBeans Consulting</a>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d12p7IPbrPHDTNI_YZeFBg.jpeg"></figure>Suppose you have a great product idea, you started working on it and developed a cool SaaS product. You get new <a href="https://en.wikipedia.org/wiki/Multitenancy">tenants</a> to use your product and they liked it. In a nutshell, your product is a hit.
<a href="https://medium.com/media/f023f36390764bb2aa04a5e5e013a738/href">https://medium.com/media/f023f36390764bb2aa04a5e5e013a738/href</a>Everything seems to be going well until you realize you are bleeding money with every increasing tenant. You want to scale up but you are unable to do so because you have already exhausted all your cash.
<a href="https://medium.com/media/86e1f6e01fb558e933c86f78557afe99/href">https://medium.com/media/86e1f6e01fb558e933c86f78557afe99/href</a>You try to figure out what is going wrong and eventually look into your application infrastructure costs.
You understood that every time a new tenant onboards your application you deploy a new server, database, etc. for that tenant. Separate servers and/or databases are only useful for computing or data-intensive applications but yours is neither of that.
In such scenarios, multi-tenant architecture can be very useful in designing applications with shared resources. Multiple combinations are possible some of which are:
1. Separate servers and shared database
2. Shared server and separate databases
3. Shared server and shared database
<h3>How should I decide which resource to keep separate and which to be shared?</h3>
The decision should be made on each resource after looking at its constraints for scaling up. It’s good if each of your resources scales individually based on the utilization rather than complete application scaling up and remaining underutilized.
There are a few things one should keep in mind while deciding.
For servers:
If your business logic is very customized for each tenant then shared servers are not an optimal solution.
OR
If your application is compute-intensive or each tenant is limited by their respective compute then separate servers are a good solution.
For databases:
Generally, it’s a trade-off between data isolation and resource utilization. Development complexity and scaling constraints are also key decision factors.
A separate database provides tenant-specific customization freedom and ease in monitoring per tenant usage and billing them for backup and disaster recovery.
<h3>Multi-tenant database patterns</h3>
There are three types of patterns:
1. Database per tenant
2. Schema per tenant
3. Row per tenant
Database per tenant
Separated databases will be provisioned for each tenant. It achieves maximum data isolation and will give you freedom for high customization and tenant-specific operations to the database.
The development complexity and cost of this approach are high.
Schema per tenant
Separate schemas are created for each tenant. It achieves data isolation at schema level.
High customization and tenant-specific operations like backup, monitoring, and encryption are not supported in many databases.
The development complexity is high but the cost is low.
Row per tenant
In this approach, all the tenants’ data are stored in the same table. Each row is identified by the tenant identifier. Some databases like PostgreSQL support RLS (Row-Level Security) where the rows are implicitly filtered based on the tenant and there is no need to explicitly write the WHERE clause with the tenant identifier.
There is no data isolation and more care has to be put into writing database queries at the application level.
The development complexity and cost are low.
In this blog, we will discuss the implementation of the shared server and schema-based shared database architecture.
<h3>What we will build?</h3>
We will build an app that will store the information of the users of the tenants.
Each tenant will have its separate schema which will store its users’ details. A public schema that will be accessed by every tenant will contain the pricing detail of the product.
Database pattern
<figure><img alt="" src="https://cdn-images-1.medium.com/max/247/0*VF4dTQkulyUgPx7S.png"><figcaption>schema-based multi-tenancy database pattern</figcaption></figure>Tables
<figure><img alt="" src="https://cdn-images-1.medium.com/max/281/0*pxSfBVA6FaifGRS0.png"><figcaption>table details</figcaption></figure><h3>Implementation</h3>
One important factor while approaching this solution is whether or not frameworks or tools are available that support this architecture and pattern.
For the implementation part, we will be using the Quarkus framework to deploy the REST APIs and perform the business logic.
The Quarkus is an open-source java framework developed by Red Hat which empowers the developers to build cloud-native and modern java applications. You can learn more about Quarkus <a href="https://quarkus.io/">here</a>.
PostgreSQL will be used as the database. It is an open-source SQL database.
Hibernate-ORM supports schema-based multi-tenancy.
Let’s start
Go to <a href="https://code.quarkus.io/">https://code.quarkus.io/</a> and fill in the application configuration.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/803/0*YRbAMlWwbZm4coUl.png"><figcaption>Application configuration</figcaption></figure>Add the following extensions
<figure><img alt="" src="https://cdn-images-1.medium.com/max/432/0*lHGNJmSSv7_Ct0Gp.png"><figcaption>Selected extensions</figcaption></figure>Open in an IDE and run the following command from the terminal:
<pre>mvn compile quarkus:dev</pre>
It will download all the dependencies and start the server with the dev profile activated. In dev, profile Quarkus provides the support for live reloading.
After the server has started, perform a GET request to the following URL:
<pre><a href="http://localhost:8080/hello">http://localhost:8080/hello</a></pre>
<blockquote>It should return ‘Hello RESTEasy’</blockquote>
Create entities
Package information is important, all the entities of the public (shared) schema should reside in the same package. Similarly for the tenant schema. We will discuss this in detail later while discussing multiple persistence units.
<a href="https://medium.com/media/ef34cf9db5e75b5fc6c7b508d068bd1e/href">https://medium.com/media/ef34cf9db5e75b5fc6c7b508d068bd1e/href</a>Hibernate does not support database generation (create or update) in the multi-tenant mode so we need to create the databases ourselves.
Create pricing_details table on public schema
<pre>CREATE TABLE public.pricing_details ( id integer, product_name character varying NOT NULL, price integer NOT NULL, created_at date, updated_at date, PRIMARY KEY (id) );</pre>
Create schema for Tenant A (GOOGL) and Tenant B (AAPL)
<pre>CREATE SCHEMA googl AUTHORIZATION postgres; CREATE SCHEMA aapl AUTHORIZATION postgres;</pre>
Create user_details table on both schema
<pre>CREATE TABLE googl.user_details ( id integer, first_name character varying NOT NULL, last_name character varying NOT NULL, created_at date, updated_at date, PRIMARY KEY (id) );</pre>
<pre>CREATE TABLE aapl.user_details ( id integer, first_name character varying NOT NULL, last_name character varying NOT NULL, created_at date, updated_at date, PRIMARY KEY (id) );</pre>
Insert values in the tables.
Create repositories for entities
<a href="https://medium.com/media/b7ad2829e2f9a60984a3d216724202c5/href">https://medium.com/media/b7ad2829e2f9a60984a3d216724202c5/href</a>Configuring application properties
write the following configuration properties in the application.properties
<a href="https://medium.com/media/f8ff107dfcfa6acdebc505b21b946d81/href">https://medium.com/media/f8ff107dfcfa6acdebc505b21b946d81/href</a>Only a single data source is configured because we have only one database to connect to.
<blockquote>
A persistence unit defines a set of all entity classes that are managed by EntityManager instances in an application
</blockquote>
We have separate persistence units for public schema (&lt;default&gt;) and tenant-specific schema (tenant)
The data source is set to &lt;default&gt; so that they connect to the default data source. Multi-tenant mode is set to SCHEMA
But we need to configure which persistence unit to manage which entities. For that, we need to create package-info.java files in the packages containing the entity files of public and tenant-specific files.
<a href="https://medium.com/media/2ee973e87d56c5fec30db9633af8fa78/href">https://medium.com/media/2ee973e87d56c5fec30db9633af8fa78/href</a><a href="https://medium.com/media/89a6ee2e71ad4bb1c359c7e059b38b6b/href">https://medium.com/media/89a6ee2e71ad4bb1c359c7e059b38b6b/href</a>Okay, we configured which persistence should handle which entities but what about schema information?
Each tenant will have its own schema name then how will the persistence unit know which schema to go for. For this, we will create a Tenant Resolver which will resolve the schema name based on the incoming request.
We need to create a Tenant Resolver for all the persistence units.
We will implement the hibernate’s TenantResolver interface which provides a method to resolve schema names.
<a href="https://medium.com/media/c0c771f1f279bde9dc869a368e7883e9/href">https://medium.com/media/c0c771f1f279bde9dc869a368e7883e9/href</a>The @PersistenceUnitExtension takes the name of the persistence unit for which this TenantResolver implementation is.
@PersistenceUnitExtension is for the default persistence unit.
The @RequestScoped is for defining the lifecycle of this bean same to that of the request the application receives (Bean is created when the application receives the request and is destroyed when the request is completed). Once the request is completed it will be destroyed and will be recreated with every incoming request.
what about the below code?
<pre>public String resolveTenantId() { String tenantName = context.request().getHeader("tenant"); return tenantName; }</pre>
To keep the implementation simpler we will pass the tenant identifier as the header in the HTTP request with the key as “tenant” and the value as the identifier. The above code will retrieve that value and return it as the schema name for that tenant.
Now all the configuration is done but where are the APIs for fetching data?
<a href="https://medium.com/media/bb3dc31fe4641c24aefcab1dd47d3b1d/href">https://medium.com/media/bb3dc31fe4641c24aefcab1dd47d3b1d/href</a>‘/pricing/all’ endpoint will fetch the list of pricing details from the public schema and return the list.
‘/user/all’ endpoint requires a tenant identifier as a header and will fetch the data from that schema and will return the list of users.
Let’s insert some data into the tables
<figure><img alt="" src="https://cdn-images-1.medium.com/max/823/0*Z-g0_JpRvYd0I3Cg.png"><figcaption>public schema</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/0*GKVCl0oNHp8gtUe2.png"><figcaption>googl schema</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/0*Ve32K5o0OctpcC7c.png"><figcaption>aapl schema</figcaption></figure>Let’s hit the APIs and see the results
We can use postman to check the APIs
<figure><img alt="" src="https://cdn-images-1.medium.com/max/478/0*W-6OJ-AF2p8lMGbD.png"><figcaption>list of pricing details from public schema</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/0*Ym46lKGPjEKP2tD-.png"><figcaption>list of users from googl schema</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/0*FTUlhar0yuykFvYy.png"><figcaption>list of users from aapl schema</figcaption></figure>Great! we finally achieved schema-based multi-tenancy for our application.
<h3>Important</h3>
For the simplicity of the implementation, we passed the tenant identifier in the header. It should not be passed in the header. A better approach will be to include it in the JWT tokens which can’t be modified and retrieve that by intercepting the HTTP request and storing the identifier in a TenantContext.
Now I hope you will apply this architecture to your SaaS product and save on your infrastructure costs.
<h3>Source code</h3>
You can find the source code <a href="https://github.com/vishalbihani1306/schema-multi-tenancy">here</a>.
<h3>Pros</h3>
<ol>
<li>Efficient use of resources.</li>
<li>A better architecture for multi-tenancy compared to the row per tenant approach in terms of data isolation.</li>
<li>Low infrastructure costs.</li>
<li>Can easily scale.</li>
</ol>
<h3>Cons</h3>
<ol>
<li>Development complexity is high.</li>
<li>High customization per tenant will be difficult.</li>
<li>Data backup for each tenant is not possible.</li>
<li>Monitoring for each tenant may not be supported.</li>
<li>Frameworks supporting this pattern may not be available in all languages.</li>
</ol>
Thanks for reading.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=cffd6e672db0" width="1" height="1" alt="">

Architecture design is a must while developing a SaaS application to ensure its scalabilit ...

Schema-based multi-tenant architecture using Quarkus &amp; Hibernate-ORM

Linear programming is a field of mathematical optimization that has been in use since the 1960s. And yet, not many people know what it truly is or how to solve it, because it’s very technical. This blog will walk you through the entire process of forming a linear program and solving it — step-by-step — with simple formulas at your fingertips.
<ul><li>
By Pratik Patre , <a href="https://coffeebeans.io/">CoffeeBeans Consulting</a>
</li></ul>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d4p4hoFlPbgKrNgViyan4w.jpeg"></figure>What is linear programming?
In simple words, it is a mathematical solution to a complex problem. Believe it or not, we have been using linear programming in everyday life (technically not programming in our minds but the concept). Simple examples would be packing your bag for a trip, managing time for an exam, or buying a variety of chocolates within the set budget. It is basically an optimization problem that we try to solve and by saying that I meant frequentist techniques like Maximum Likelihood (MLE). Mathematically, we usually solve by using some kind of variables and constraints to get the maximum or the minimum of the objective set.
<h3>The process to formulate a Linear Programming problem?</h3>
Let us look at the steps of defining a Linear Programming problem generically:
<ol>
<li>We first decide on the unknowns which act as decision variables</li>
<li>We define the objective function</li>
<li>Identify the constraints i.e. the system of equalities or inequalities representing the restrictions on the decision variables</li>
<li>Non-negativity restriction</li>
</ol>
For a problem to be a linear programming problem, the decision variables, objective function and constraints all have to be linear functions. If all three conditions are satisfied, it is called a Linear Programming Problem.
Linear Programming in action
Ordinary Least Squares Basics
Lets see how linear programming can be clubbed with gradient descent and used in linear regression in machine learning to solve an optimization problem. Let’s start simple, in linear regression we predict a quantitative response y on the basis of a single predictor variable x. It assumes a linear relationship between x and y i.e. y ~ w0 + w1*X. We use the training data to produce model coefficients w0 and w1. We can predict yhat based on X = x i.e. yhat = w0 + w1*x. Using the training data we find a line that most closely represents the data points. There are various ways to measure what it means to closely represent. We may, for instance, minimize the average distance (deviation) of the data points from the line, or minimize the sum of distances, or the sum of squares of distances, or minimize the maximum distance of a datapoint from the line. Here the distance can be either Euclidean distance, or vertical distance, or Manhattan distance (vertical+horizontal), or other.
We choose to minimize the maximum vertical distance of a point from the line. In two dimensional space, a general equation of a line with finite slope has the form y = w0 + w1*x where w0 and w1 are parameters (slope and constant respectively). For a point (p, q), the vertical distance of the point from the line y = w0 + w1*x can be written as |q − w1*p − w0| which is nothing but residual (e1) and if we square it and sum it over n number of points in our data, we get the residual sum of squares i.e. RSS = e1² + e2² ….en².
Let’s Start with an Example
Defining decision variable and objective function
Now consider, we want to predict a house’s price with respect to one variable which is the area of the house. So this is our decision variable which we denote as x. Say for a sample point, g(w) = w0 + w1*x is the expected price of a house based on x area of the house. Now, y = g(w) = w0 + w1*x will be marked as an objective function as we have to optimize this line to best fit the data.
Now I will not go into the proof but if we consider the partial derivative of y with respect to w0 and w1 and represent that in a vector form that’s when we get the gradient of y. So, below would be the mathematical expression.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iLlcLbSzuWt5enzD"></figure>The cost function is the residual sum of squares and the gradients for the RSS with respect to w0 and w1 will be as shown by RSS(w0,w1) above in vector form.
Defining Constraints
So now we can define our constraints, We will have to update the w0 and w1 based on the following equations:
w0 = w0 — Learning rate * partial derivative of RSS function with respect to w0
For simplicity we can write it w0 = w0 + 2N * B…………..(2)
Where B = (sum of errors after prediction over all data points)
w1 = w1 — Learning rate * partial derivative of RSS function with respect to w1
For simplicity we can write it w1 = w1 + 2N * C..…………(3)
Where C = (sum of (errors*x) after prediction over all data points)
We repeat the above two steps until convergence, i.e. until B — C &lt; t (tolerance value)
Now we can rewrite it as B + (-C) &lt; t
Squaring on both sides (B + (-C))² &lt; t²
Subtracting 2*B*C on both sides (B + (-C))² — 2*B*(-C) &lt; t² — 2*B*(-C)
Now a² + b² formula, LHS will turn to be B² + (-C)² i.e. B² + C² &lt; t² + 2*B*C
Taking square root on both the sides we get
Square root(B² + C²) &lt; square root(t² + 2*B*C) ………….(1)
Now technically the convergence is the magnitude of the gradient vector = 0 but in practice, we consider the magnitude of the gradient vector &lt; T
Where T is the tolerance value
Now as per equation (1), the LHS is nothing but the magnitude of the gradient vector and the RHS is the Tolerance value. We can rewrite (1) as follows
Square root(B² + C²) &lt; T ………….(1a)
Defining Non-negativity restriction
The non-negativity restriction i.e. the area of the house will be greater than or equal to zero x &gt;= 0.
So now we have formulated our linear program with the help of gradient descent, lets solve for the optimum line.
Operationalizing Linear Programming
Let’s consider the following data points
X Y
0 1
1 3
2 7
3 13
4 21
We start with assuming intercept = w0 = 0 and slope = w1 = 0 and by setting stepsize or learning rate = 0.025 and tolerance = 0.01
Step 1: We predict and find for yhat based on yhat = w0 + w1*x.
We get the following predictions for the five data points [0,0,0,0,0]
Step 2: We find the errors after prediction by yhat — y
We get the following errors [-1,-3,-7,-13,-21]
Step 3: We update the intercept by summing the errors and inserting it into equation (2) to get
0 + 2*0.025*sum([-1,-3,-7,-13,-21]) = -2.25
Step 4: We update the slope by summing the multiplication of errors and respective area of house as per equation (3). Thus equation 3 will turn to be:
0 + 2*0.025*sum([0, 1, 2, 3, 4] * [-1, -3, -7, -13, -21]) = -7
Step 5: We calculate the magnitude which is LHS from equation (1a):
sqrt(( -45)² + (-140)²) = 147.05
Step 6: We check equation (1a) to see if it converged. Since 147.05 is greater than 0.01 (the tolerance value set by us), we repeat the steps again but this time with the updated w0 and w1.
The purpose of this blog is to see how linear programming can be used in linear regression. Feel free to code this and get the optimum value for w0 and w1.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=8b9a7ae39cb2" width="1" height="1" alt="">

Linear programming is a field of mathematical optimization that has been in use since the  ...

Step by Step Guide to Linear Programming: The Best Way to Break Through the Subject

<h3>What are activation functions and why do we need those?</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n6ZZJWEbyVCFfkU5ZjYMAA.jpeg"></figure><img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=c2e95ab06e7b" width="1" height="1" alt="">

What are activation functions and why do we need those? ...

Activation functions | Deep Learning

From sourcing raw materials from every corner of the world and selling end products across the world, Supply chain management plays a vital role! And technology never failed to do its job! Blockchain has already disrupted the finance industry and the supply chain will be the next
<ul><li>
By Siva Seetharaman, <a href="https://coffeebeans.io/">CoffeeBeans</a> Consulting
</li></ul>
<figure><img alt="Supply chain with Blockchain technology" src="https://cdn-images-1.medium.com/max/1024/1*bIG3LRY-CNqs0qSAUXqvFw.jpeg"></figure>Supply Chain Management is becoming one of the most critical areas for businesses to thrive. Manufacturing companies source raw materials from every corner of the world and finished goods are also moved across borders. As the quantum of imports/exports increases, there is a risk that SCM might become a bottleneck especially if there is a lack of planning.
Technology has indeed played a crucial role in transforming this age-old sector of movement of goods. Large enterprises are deploying sophisticated Enterprise Resource Planning systems, and Transport Management Systems to manage their day-to-day operations. But still the current processes and the systems do have their own deficiencies. These deficiencies reduce the credibility of the whole SCM infrastructure.
Challenges in current Supply Chain Infrastructure:
<ol>
<li>As goods get transported from one corner to another corner of the world, one shipment is handled by multiple stakeholders until it reaches the customer. Practically, there cannot be one single ERP that is implemented by all the players in the chain.</li>
<li>The lack of one system results in lack of transparency in the flow of Inventory and Information among the participants. The participants operate in silos and parties like banks and end customers are also often kept in the dark.</li>
<li>As the Supply Chains involve a lot of cross-border transactions, the possibility of mixing counterfeit products into the chain is very much possible and current systems are not sophisticated to identify this and trace it back to the source.</li>
<li>There are a lot of manual data entries and paperwork to be done in the current setup. This compounds missing information, and erroneous transactions resulting in reputational and monetary losses in many cases.</li>
</ol>
Blockchain Technology:
Blockchain Technology is now the buzzword in the world of technology. Blockchain has already made a huge impact in the finance industry. Although there are proponents and opponents to Bitcoins and other currency tokens, the idea of blockchain that makes this happen is indeed foolproof and niche. Following the Finance sector, other sectors have started to explore possibilities to find answers to their problems from Blockchain.
What is Blockchain?
Blockchain is a decentralized digital ledger system that has the capability to receive and record transactions from multiple parties involved in the system. In a traditional database, data is stored in the form of tables. But in a blockchain, the data is grouped and stored as blocks which are in turn connected to existing blocks thus forming a blockchain. A block is the storage unit in the blockchain where transaction information is stored. Along with transaction information, other details like an encrypted number from the previous block, block header, etc. are also stored. Building the blocks involves multiple people vouching for the credibility of the transactions that happen between two parties. Only after transactions are validated, a block will get added to the existing blockchain. It is nearly impossible as of now to change or delete data that goes into the blockchain. The unique feature of blockchain when compared to the traditional database systems is that the data that enter the blockchain are tamper-proof and are recorded forever.
How can Blockchain disrupt the Supply Chain Industry?
As mentioned earlier, blocks are the basics of a Blockchain. Out of the many advantages of this system, three points stand out clearly as game-changers when it comes to implementation in Supply Chain Management. They are Improved Traceability, Minimized human intervention, and Enhanced coordination between the parties. Before getting into the advantages of a Blockchain system in Supply Chain, it is important to understand how to build a blockchain system in a supply chain scenario.
A Classic Supply Chain scenario:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RMLMhIkn0M8JHU3y"></figure>In the above scenario,
<ol>
<li>A customer places an order with a retailer</li>
<li>To fulfill the requirement, the retailer in turn orders to the distributor</li>
<li>The distributor then places the order to a manufacturer to produce the product</li>
<li>Once the manufacturing is done, the manufacturer fulfills the distributor. The distributor fulfills the retailer</li>
<li>As a final step, the retailer fulfills the customer order.</li>
<li>The retailer or distributor or manufacturer might seek the support of a bank for financial aid.</li>
</ol>
As mentioned above, blockchains can improve the credibility of the system by improving the transparency of flow of information and the traceability of inventory between the parties. But why should a system be transparent? Let’s read the cases below to understand why.
Case 1: Banks should make informed decisions before approving a loan or any other transactions. Let’s assume a case where the manufacturer applies for a loan in the bank. In this case, the bank will have to conduct physical audits of the transactions and documentation before approval. This is a long and error-prone process. In a best-case scenario, if the bank can access all the upstream transactions along with agreements in one place, then it will be easy and foolproof for the bank to approve such requests.
Case 2: Let’s assume the distributor imports finished goods from a manufacturer who is in a different country. At the time of receiving at the port, some counterfeit goods are mixed in the supply chain. When the distributor finds this, he will not be able to figure out who mixed counterfeit into the chain. The recall and reverse logistics will then stand out as new problem statements. To address this problem, the distributor should be part of a system where every single transaction with every single participant is recorded in a single system.
A Blockchain Supply Chain system:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9exw-HhJUf-7PdjU"></figure>For a blockchain system to work as expected, all the parties who are participating in the supply chain should agree to be part of the blockchain. In this case, the assumption is all the parties mentioned in the above diagram are part of the same blockchain. (Reference <a href="https://hbr.org/2020/05/building-a-transparent-supply-chain">https://hbr.org/2020/05/building-a-transparent-supply-chain</a> )
<ul>
<li>The colored bars mentioned in this diagram are the blocks that get created whenever a transaction is done between two participants.</li>
<li>In the first step, the customer orders a product from the retailer and the retailer gives back an order confirmation. These are two separate transactions. So two separate blocks are created. The green block is the customer side and the blue block is the retailer side transaction.</li>
<li>As the flow moves forward, the blocks keep added to the blockchain. So from customer ordering to customer fulfillment, all the blocks are part of this blockchain and anyone participating in this chain will gain the full visibility of the same.</li>
<li>These blocks now form the blockchain. Every transaction is recorded and every participant of the chain can now access the data. This makes the system completely foolproof and also establishes the ultimate transparency.</li>
</ul>
Now that we know how a blockchain system works in a Supply Chain scenario, below are the key aspects of the technology that will transform the sector.
Improved Traceability: Every step of the flow is entrusted and recorded as blocks. This makes it easier for the parties to trace back shipments to the source. This is highly useful in sectors like farming, and fishing where multiple unknown parties are involved at source. Also, in sectors like Pharma, Art, it is possible to trace back and figure out the exact point when and where a counterfeit came into the supply chain.
Minimized human intervention: Airway bills, Invoices, Handling instructions, Bill of Landing, Export License, and Packing list are some of the many documents that are involved in a supply chain. The worrying part is that the maker checker process in documentation is purely manual and it is prone to errors. With Smart Contracts in Blockchain, the complete industry can go paperless and improve the efficiency multifold.
Enhanced coordination between the parties: If all the parties agree to get on a blockchain, then there will be a seamless flow of information to all the participants. This improves the coordination between the parties in the supply chain and the overall visibility of information and inventory flows.
Conclusion:
The implementation of Blockchain in Supply Chain Management has been tested in the real world by a few companies like Walmart Canada, IBM Food Trust. But these are tested on a small scale and the world is yet to see a full-fledged implementation where Blockchain replaces ERP.
Transparency of information flow between parties, Reduction of IT costs, Elimination of manual efforts, and Reduction of losses incurred due to counterfeit products are some of the key advantages of Blockchain technology over traditional technology. There are different ways of implementing a blockchain network. The network can be either public or private. Also, there are various other value adds like smart contracts which reduce the efforts needed for mundane activities in SCM like contract management. Of course, there are course corrections to be done and blockchain is an evolving technology. But it gives a promising ray of hope in the world of Trade, Commerce, and Supply Chain Management.
References:
<ol>
<li><a href="https://hbr.org/2020/05/building-a-transparent-supply-chain">https://hbr.org/2020/05/building-a-transparent-supply-chain</a></li>
<li><a href="https://www.ibm.com/blockchain/supply-chain">https://www.ibm.com/blockchain/supply-chain</a></li>
<li><a href="https://www.mckinsey.com/business-functions/operations/our-insights/blockchain-technology-for-supply-chainsa-must-or-a-maybe">https://www.mckinsey.com/business-functions/operations/our-insights/blockchain-technology-for-supply-chainsa-must-or-a-maybe</a></li>
<li><a href="https://www2.deloitte.com/us/en/pages/operations/articles/blockchain-supply-chain-innovation.html">https://www2.deloitte.com/us/en/pages/operations/articles/blockchain-supply-chain-innovation.html</a></li>
</ol>
Thanks for reading!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=96c85c77ef20" width="1" height="1" alt="">

From sourcing raw materials from every corner of the world and selling end products across ...

Building the next-gen Supply Chain with Blockchain Technology

<ul><li>
By Mokshith Ajalade, <a href="https://coffeebeans.io/">CoffeeBeans Consulting</a>
</li></ul>
<figure><img alt="How to persist custom material UI theme using Redux toolkit and react" src="https://cdn-images-1.medium.com/max/1024/1*MAQrfYuiGWxRrRJqsWB4Jg.jpeg"></figure>Hello there!! I have recently set up a light and dark theme using Material UI in my React project. I am writing this blog with the hope that it will be useful to someone who is trying to use Material UI in their project and setting up custom themes with it.
<h3>What you will learn:</h3>
<ul>
<li>How to set up custom Material UI themes(light and dark)</li>
<li>How to toggle between light and dark theme</li>
<li>How to set up and use the Redux Tool kit</li>
<li>How to store and read data from local storage</li>
</ul>
<h3>In this article, I would assume,</h3>
<ul>
<li>You know basic React</li>
<li>Have a basic understanding of how Redux state management works</li>
<li>Already have an existing React app</li>
<li>Material UI version is v5.4.0</li>
</ul>
<h3>Our Goal</h3>
To persist(continue) the same theme as before even after the page is refreshed or opening the app after closing it.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*cCkzn86NnenvdOEH.gif"></figure><h3>What we will do to achieve our goal,</h3>
<ol>
<li>Install Redux Toolkit, React-redux, and set up a global state for theme toggling</li>
<li>Install Material UI and set up custom theme palettes for light and dark theme</li>
<li>Use components from Material UI to build a basic UI</li>
<li>Use local storage for persisting our theme</li>
</ol>
<h3>1. Install Redux Toolkit, React-Redux, and set up a global state for theme toggling</h3>
Install Redux Toolkit and React Redux
<pre># If you use npm: npm install @reduxjs/toolkit react-redux</pre>
<pre>Or #if you use Yarn: yarn add @reduxjs/toolkit react-redux</pre>
You should also make sure that you have the React and Redux DevTools extensions installed in your browser:
<ul>
<li>React DevTools Extension: - <a href="https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi?hl=en">React DevTools Extension for Chrome</a> - <a href="https://addons.mozilla.org/en-US/firefox/addon/react-devtools/">React DevTools Extension for Firefox</a>
</li>
<li>Redux DevTools Extension: - <a href="https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd?hl=en">Redux DevTools Extension for Chrome</a> - <a href="https://addons.mozilla.org/en-US/firefox/addon/reduxdevtools/">Redux DevTools Extension for Firefox</a>
</li>
</ul>
Now that we have packages and extensions related to Redux in our project, it’s time to create a global “ theme” state. We can do this in three steps,
<ol>
<li>Create a Redux Store and provide it to React</li>
<li>Create a State Slice and add it to the Redux Store</li>
<li>Use Redux State and Actions in the UI to toggle our state(dispatch actions)</li>
</ol>
Create a Redux Store,
Create a file named src/store/store.js. Import the configureStore API from Redux Toolkit. We'll start by creating an empty Redux store, and exporting it:
<a href="https://medium.com/media/187dbbe4862c8e96ceb8fa79ef879fbe/href">https://medium.com/media/187dbbe4862c8e96ceb8fa79ef879fbe/href</a>Provide the Redux Store to React,
Once the store is created, we can make it available to our React components by putting a React-Redux &lt;Provider&gt; around our application in src/index.js. Import the Redux store we just created, put a &lt;Provider&gt; around your &lt;App&gt;, and pass the store as a prop:
<a href="https://medium.com/media/f7b83161b8d5132718adf28679615af9/href">https://medium.com/media/f7b83161b8d5132718adf28679615af9/href</a>Create a Redux State Slice,
Note: A “slice” is a collection of Redux reducer logic and actions for a single feature in your app, typically defined together in a single file. The name comes from splitting up the root Redux state object into multiple “slices” of state.
Add a new file named src/store/reducers/themeSlice.js. In that file, import the createSlice API from Redux Toolkit.
Creating a slice requires a string name to identify the slice, an initial state value, and one or more reducer functions to define how the state can be updated. Once a slice is created, we can export the generated Redux action creators and the reducer function for the whole slice.
Redux requires that <a href="https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow#immutability">we write all state updates immutably, by making copies of data and updating the copies</a>. However, Redux Toolkit’s createSlice and createReducer APIs use <a href="https://immerjs.github.io/immer/">Immer</a> inside to allow us to <a href="https://redux.js.org/tutorials/fundamentals/part-8-modern-redux#immutable-updates-with-immer">write "mutating" update logic that becomes correct immutable updates</a>.
We set our theme global state's initial value to darkMode: false and write a reducer function to toggle our current theme mode when the action is dispatched.
<a href="https://medium.com/media/edcb79307bede7ad7f420ad83659b84c/href">https://medium.com/media/edcb79307bede7ad7f420ad83659b84c/href</a>Add Slice Reducers to the Store,
Next, we need to import the reducer function from the themeSlice and add it to our store. By defining a field inside the reducer parameter, we tell the store to use this slice reducer function to handle all updates to that state.
<a href="https://medium.com/media/1b9a7d71aa01f61977f6d5ba6cd80b15/href">https://medium.com/media/1b9a7d71aa01f61977f6d5ba6cd80b15/href</a>Use Redux State and Actions in React Components
Now we can use the React-Redux hooks to let React components interact with the Redux store. We can read data from the store with useSelector, and dispatch actions using useDispatch. Create a src/components/square/Square.js file with a &lt;Square&gt; component inside, then import that component into App.js and render it inside of &lt;App&gt;.
<a href="https://medium.com/media/e54d46ce50c35cf53b82d7fef392e7f4/href">https://medium.com/media/e54d46ce50c35cf53b82d7fef392e7f4/href</a><a href="https://medium.com/media/5429874cd05b00133aa35c642a77e5bc/href">https://medium.com/media/5429874cd05b00133aa35c642a77e5bc/href</a>Now our UI looks like this
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KRrU6LdBrPTJMw8e.png"></figure>Open up your browser’s DevTools. Then, choose the “Redux” tab in the DevTools, and click the “State” button in the upper-right toolbar. You should see something that looks like this:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*45iy-IpnjYtAex0H.png"></figure>On the right, we can see that our Redux store is starting with an app state theme that looks like this:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/776/1*C_GFUKcQSowruuEXXcglNQ.png"></figure>Now when we click the “Toggle Theme” button:
<ul>
<li>The corresponding Redux action will be dispatched to the store</li>
<li>The theme slice reducer will see the action and update its state</li>
<li>The &lt;Square&gt; component will see the new state value from the store and re-render itself with the new data</li>
</ul>
The below image has been uploaded after clicking on the “Toggle Theme” button.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6jg91DBn1VDAP5O-.png"></figure>We can see three important things here:
<ul>
<li>When we clicked the “Toggle Theme” button, an action with a type of "theme/toggleTheme" was dispatched to the store</li>
<li>When that action was dispatched, the state.theme.darkMode field changed from false to true</li>
<li>And our UI got re-rendered after the global state changed, from Light Theme to Dark Theme
</li>
</ul>
With this, we can confirm that the Redux “theme” global state is working as expected and we can also see that Redux Toolkit is generating “types” for us, so we don’t have to manually create them. Less boilerplate code for us:-)
With that, we can conclude by creating a global state “theme”.
<h3>2. Install Material UI and set up custom theme palettes for light and dark theme</h3>
Install Material UI,
<pre>// with npm npm install @mui/material @emotion/react @emotion/styled</pre>
<pre>// with yarn yarn add @mui/material @emotion/react @emotion/styled</pre>
Set up a custom theme palette using Material UI,
To use custom palettes for light and dark modes, we can create a function that will return the correct palette depending on the selected mode, as shown here:
<a href="https://medium.com/media/c936507f8eb1ab3ae0a2d8579841968f/href">https://medium.com/media/c936507f8eb1ab3ae0a2d8579841968f/href</a>We can see on the above code snippet that there are different colors used based on whether the mode is light or dark. The next step is to use this function when creating the theme.
If we wish to customize the theme, we need to use the ThemeProvider component to inject a theme into our application. We can use the createTheme API from Material UI to create a custom theme based on the options received and pass it as a prop to <a href="https://mui.com/material-ui/customization/theming/#themeprovider">ThemeProvider</a>.
<a href="https://medium.com/media/d2f37480757bd07e5558986cac7c762a/href">https://medium.com/media/d2f37480757bd07e5558986cac7c762a/href</a>In the above code, we are setting the mode(local state) according to the darkMode(global theme state) and passing it as an argument to the getDesignTokens function. getDesignTokens function will return us a theme palette based on the mode parameter that it is receiving. And we will pass this theme object as a prop to the ThemeProvider component.
Note: Make sure ThemeProvider is a parent of the components you are trying to customize.
<h3>3. Use components from Material UI to build a basic UI</h3>
Let’s use an Icon provided by Material UI in our UI, to use it we need to install Material Icons.
To install,
<pre># npm npm install <a href="http://twitter.com/mui/icons-material">@mui/icons-material</a></pre>
<pre>#yarn yarn add <a href="http://twitter.com/mui/icons-material">@mui/icons-material</a></pre>
We can access the theme variables inside our React components using useTheme hook provided by Material UI. Our code for UI will look like this,
<a href="https://medium.com/media/36db24c0228285b75344bc31a34c3b40/href">https://medium.com/media/36db24c0228285b75344bc31a34c3b40/href</a>Note: Here I have used both the global theme state from the Redux store and the themeobject provided by ThemeProvider to show that we can access our current theme mode using any of the two ways.
This is what our current UI looks like,
<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*-BhDpdAvERlrzXAx.gif"></figure>Awesome!! We can successfully toggle between our custom light and dark themes. But now we have one last problem. As you might have observed before refreshing in the end, our app had dark theme =&gt; darkMode: true but after refreshing the page, it went back to the light theme. That's because our app does not persist the theme state. Since the app reloads, the memory is cleared and hence the object is reset to the initial value. If you remember, we set our initial state value in our themeSlice as darkMode: false indicating our initial theme mode as light mode.
<h3>4. Use local storage for persisting our theme</h3>
We will be using local storage to solve the exact problem which we faced in the previous section, i.e., to load the UI with the right theme mode after a refresh or when opening the app after closing it. Mind you, our app was working as expected when toggling the theme after the initial load. The problem was that it did not load with the right theme after the refresh.
Since we are getting our initial state from a plain JS object it always remains the same, but what if we could get our initial state value from a source that is already keeping track of theme mode changes and doesn’t get cleared after a refresh or after closing the app? Enter the local storage !! The localStorage object allows you to save key/value pairs in the browser and doesn't have an expiry date.
So now we need to do two things, i. Load our global theme state’s initial state from local storage
ii. Change the value in local storage every time there is a change in theme mode
We can load our initial state like this,
<pre>const initialState = { darkMode: !!JSON.parse(localStorage.getItem("darkMode")), };</pre>
During the very first time our app loads onto the browser we have not set anything in our local storage. So when we try to read the value of the key darkMode we will get a null value. To convert it to false a Boolean value, we use !!.
Secondly, we can toggle the value in local storage every time the theme mode changes like this
<pre>const isDarkMode = !!JSON.parse(localStorage.getItem("darkMode")); localStorage.setItem("darkMode", !isDarkMode);</pre>
According to the rules of the reducers defined by Redux,
<ul>
<li>Reducers should only calculate the new state value based on the state and action arguments</li>
<li>Reducers are not allowed to modify the existing state. Instead, they must make immutable updates, by copying the existing state and making changes to the copied values.</li>
<li>Reducers must not do any asynchronous logic or other “side effects”</li>
</ul>
So according to the last rule, toggling the local storage must be done outside of the reducer function as it is a side effect. So we use a thunk function for this operation.
A thunk is a specific kind of Redux function that can contain asynchronous logic. Thunks are written using two functions:
<ul>
<li>An inside thunk function, which gets dispatch and getState as arguments</li>
<li>The outside creator function, which creates and returns the thunk function</li>
</ul>
So we will create a thunk action creator in themeSlice and export it:
<a href="https://medium.com/media/1df3f59ffee56822cfe74e139f984ab2/href">https://medium.com/media/1df3f59ffee56822cfe74e139f984ab2/href</a>We can use a thunk function in the same way we use a typical Redux action creator:
<pre>store.dispatch(toggleTheme())</pre>
However, using thunks requires that the redux-thunk middleware (a type of plugin for Redux) be added to the Redux store when it's created. Fortunately, Redux Toolkit's configureStore function already sets that up for us automatically, so we can go ahead and use thunks here.
Here is the updated themeSlice.js
<a href="https://medium.com/media/983a2370df83b28cc23a3a614269a976/href">https://medium.com/media/983a2370df83b28cc23a3a614269a976/href</a>Now, all we need to do is dispatch our thunk function whenever there is a change in the theme mode. And to do this we need to import and use asyncToggleTheme instead of toggleTheme from themeSlice in Square.js.
<a href="https://medium.com/media/15c656875793f56a91815fec2605324d/href">https://medium.com/media/15c656875793f56a91815fec2605324d/href</a>Voila!! Now our React app is persisting the theme even after refreshing.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*nndnn7cTQ53vO0So.gif"></figure>Please feel free to comment down below with your thoughts or any doubts you may have. Also please don’t forget to clap for me if this article added some value to you or if you have learned something new. This will encourage me to write more blogs in the future. Thank You!!
Additionally, you can look at the below links for more understanding of the tools we have used in this article.
<ul>
<li><a href="https://redux-toolkit.js.org/tutorials/quick-start">Quick start on Redux Toolkit</a></li>
<li><a href="https://redux.js.org/tutorials/essentials/part-1-overview-concepts">Get a good understanding of Redux</a></li>
<li><a href="https://mui.com/material-ui/customization/how-to-customize/">How to customize Material UI</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage">More about local storage</a></li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=606bf534ee54" width="1" height="1" alt="">

By Mokshith Ajalade,CoffeeBeans ConsultingHello there!! I have recently set up a light and ...

About

Life at CB

Services

Resources

Careers

Activation functions | Deep Learning

CoffeeBeans_BrewingInnovations

What are activation functions and why do we need those?