<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Yaniv Beaudoin on Medium]]></title>
        <description><![CDATA[Stories by Yaniv Beaudoin on Medium]]></description>
        <link>https://medium.com/@yaniv-beaudoin?source=rss-43a13f295fbf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nNRq-gVP_eCpnbBNZM_nsA.jpeg</url>
            <title>Stories by Yaniv Beaudoin on Medium</title>
            <link>https://medium.com/@yaniv-beaudoin?source=rss-43a13f295fbf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 14:14:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yaniv-beaudoin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Figma Variables— Getting started ✌️]]></title>
            <link>https://medium.com/design-bootcamp/figma-variables-getting-started-%EF%B8%8F-36b8afdddec9?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/36b8afdddec9</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[demo]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Sat, 01 Jul 2023 10:10:20 GMT</pubDate>
            <atom:updated>2023-07-04T08:23:17.261Z</atom:updated>
            <content:encoded><![CDATA[<p>Figma variables are a great new feature from Figma that helps you to take your prototype to the next level.</p><p>It’s pretty intuitive once after doing it once — Check out my simple explanation of how to add color variables to your prototypes and how to change component’s colors based on user interactions 🤠</p><p>Check out the following simple step-by-step example to get started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D6bu07WtX4tE3uuf5lZ3lQ.jpeg" /></figure><p>First lets create a button and a square:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JSDMzTnHA8th9EzHMhK6qA.jpeg" /></figure><p>Second, let’s create a local color variable. To do so, click on the background of the canvas and choose local variables:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b77sgNMYFcvc8zQphyE51Q.png" /></figure><p>Let’s call our new variable “square-color” and choose an initial color we like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Girx7NZIqrJBJd4c6r4a8g.png" /></figure><p>Next, let’s set our squares’ color to our new variable from within the “Libraries” menu:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y5mv3NoBzNceLZQoX1YtDw.png" /></figure><p>Now go to the prototype section on the right and click on our button -&gt; interactions -&gt; on-click -&gt; Set variable:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hqpDW2ZxE2sZ9eCVwXs1yA.png" /></figure><p>When we change the variable color during the prototype, the square color will update it self.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNMA1_DtoGtHuRFky43iuA.png" /></figure><p>That’s it! Good job 🥳🥳 Press the demo play button and see the result:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*4KXlpp_gOuTdsS0BDGHlJQ.gif" /></figure><p>Color is only one element you can control in your prototypes. You can also set boolean, string, and number variables and tie them together easily to form more advanced interactions. Changing a color is just the first step, now that you understand how to get it right it will be much easier to understand more complicated features.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=36b8afdddec9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/figma-variables-getting-started-%EF%B8%8F-36b8afdddec9">Figma Variables— Getting started ✌️😁</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Critics On AWS Costs]]></title>
            <link>https://yaniv-beaudoin.medium.com/critics-on-aws-costs-6fc9793f334?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/6fc9793f334</guid>
            <category><![CDATA[aws-cost-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[aws-cost-optimization]]></category>
            <category><![CDATA[aws-ec2]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Mon, 27 Jun 2022 06:18:33 GMT</pubDate>
            <atom:updated>2022-06-27T06:18:33.597Z</atom:updated>
            <content:encoded><![CDATA[<p>Public cloud providers are marketing geniuses. They convinced us that using cloud environment is cheap. It’s not. It has many benefits but low price is not one of them. When you run on their infrastructure at small scale it’s just fine. When you scale up, you find out that cloud costs can sum up to crazy amounts. You will usually learn it the hard way, when receiving the first AWS bill after scaling up. They tell us that we save money because they take care of the infrastructure. Well, it saves money and it very convenient as well, but(!), after building your systems on their infrastructure and users start to use it, you find out that not everything that shines is gold.</p><h3>Scaling Up In Public Cloud Providers Is Expensive.</h3><p>Spinning up machines when running on AWS for example is incredibly easy. Three clicks and you have a new virtual machine up and running. That’s great for velocity and for AWS bank account. I admire AWS for their ability to scale up computing infrastructure, but they can be more fair when it comes to using their infrastructure cost efficiently.</p><h3>Why Do They Hide Prices??</h3><p>Can you imagine buying products at an e-commerce website that doesn’t state pricing next to product itself? That’s what happens at AWS. The prices are not presented next to the service you use. AWS only shows them in a different page, that you have to look for specifically, and when you find it, it is super complicated to understand the pricing. In my opinion it is not fair.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*ORlOx9zaNLxYsiKt7n4Zbg.png" /><figcaption>RDS Instance Size Selection</figcaption></figure><h3>Why Do They Hide Our Usage??</h3><p>Analyzing what you pay for is extremely difficult. They do offer a few basic metrics and cost break down, but they are really insufficient. The granularity they offer is at the service level. It is fine when you run on a small scale. It becomes a nightmare when running at scale. Following up after your costs when you run 300 EC2, a few k8s clusters, 50 RDSs and 1000 s3 buckets is difficult. You have work arounds but in my opinion it should be much easer to understand what you are paying for.</p><h3>AWS Should Automate Costs Savings For Us</h3><p>I think that AWS should offer better automated cost saving options to help us control our costs. Here are just a few things that they can automate — Right size EC2 Instances, turn off ideal machines and k8s clusters, delete old backups (Or at least notify about them) and right size EBSs... It would be so much nicer if AWS could just make those things work. Wouldn’t it?</p><h3>Why Is AWS Trusted Advisor So Limited?</h3><p>Aws offer a service named AWS Trusted advisor that recommends potential cost savings. It seems good at first glance, but it is very limited:</p><ul><li>Costly — You need to pay for it (100$ for small businesses and starting at 15,000$ for enterprises)</li><li>Limited — The recommendations are very limited</li><li>Report based — It doesn’t alert you when things change</li><li>Manual — It won’t automate saving for you</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NgFhXMhoM2lo1tsKz8Ldvg.png" /></figure><h3>AWS Should Be More Fair When It Comes To Costs</h3><p>Amazon (And AWS) is one of the richest companies in the world. I think that they really deserve it because they changed our lives for the better. I 100% believe in their rights to earn good money for the amazing services they offer. Yet, they should help us to understand, control, and optimize our cloud costs. Their revenues are enormous (62 Billion/a year, as of today), they don’t have to make it so hard for us to manage cloud costs.</p><h3>Lets Talk</h3><p>Please reach out or leave a comment below, I would love to hear your opinion and experience on the topic! Do you share the same feelings as I do? Do you think I am exaggerating? Or have I only scratched the surface of the topic?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6fc9793f334" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Develop Something Personal]]></title>
            <link>https://medium.com/swlh/develop-something-personal-68699015d729?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/68699015d729</guid>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[personal]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Sun, 04 Jul 2021 05:59:05 GMT</pubDate>
            <atom:updated>2021-07-08T06:03:47.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*tUxXgTzWMk7U1ZhsmoPM7Q.jpeg" /></figure><h3>Our Wedding App</h3><p>Developers, I encourage you to develop something personal.</p><p>It is not easy to find time to develop a personal project when you work as a full-time employee. At your job, you have goals to achieve and features that have to see the light of day. Obviously, this dictates what needs to be done, and what shouldn’t be done. This leaves you no time to develop things <strong>you want</strong> to develop. In my opinion, it is a shame. Developing things you want is fun, you get to be creative, discover new technologies and it is super satisfying to get something fully running on your own.</p><p>Find something you think people will like, that someone will find cool or that can make a tedious activity in your life easier, and create it.</p><p>Here, I will share with you a small project I worked on, and provide several tips on how to complete a personal project of your own.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*kUxntC_ZlSg4yxzzX0Og5Q.jpeg" /></figure><h4>Our Wedding App</h4><p>Tali and I got married two weeks ago. It was awesome. A culmination after 6 months of preparations. We prepared a lot and wanted to have the best day of our lives. In addition to the usual things like having a nice venue and a good DJ, we wanted to do something more. This is when we thought that it would be nice if we had an app for our wedding. A great opportunity to develop something of my own!</p><p>We didn’t have a lot of time for development. Yet, we wanted an app that would make the wedding more fun and engage the guests.</p><p>The venue where we got married has a huge LCD screen so we thought it would be nice to use it. The idea was simple, to display on the big screen a grid of pictures that people take during the wedding.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*gUv96l6KGteu_oeJ0D_ctA.jpeg" /></figure><p>The app is served as a browser web app with two simple screens. One screen that shows the photos (as shown above), and a second screen to take photos. Each time someone takes a photo it is immediately uploaded to our servers and replaces the oldest picture on the screen. To show the grid of pictures, we just had to put the browser on full-screen mode and cast it to the screen.</p><p>In order to take a picture, all you have to do is to enter our URL into your phone’s browser, and you are presented with a camera-like screen with two simple buttons — Take a photo and switch between the front and back cameras. Pretty simple.</p><p>We had everything we needed; easily take a picture and instantly see it broadcasted on the big screen.</p><p><strong>Completing</strong> a personal project is not easy to do. Here are a few tips that helped me out.</p><h4>Develop Together</h4><p>After Tali, my wife, and I had thought of the idea, we were not sure whether we should implement it or not. There wasn’t a lot of time before the wedding and many things still had to be done. Then I told my friend Chita about the idea. Chita is a cool dude with a “let’s make it happen” attitude, the right guy to talk to in that situation (Thanks for the help!). Less than an hour later we already started to develop. It was so much fun. I was in charge of the camera screen and Chita on the pictures grid. It was a great experience to work on a personal project together with a friend. Together we were more motivated to accomplish the project and helped each other when we got stuck. So, if you want to start working on something and don’t find the time for it, maybe you should find a partner for it.</p><h4>Achieve Small victories</h4><p>Develop something you will be able to finish in a reasonable timeframe. Otherwise, you might not finish it at all. It is not smart to plan something you can’t achieve. Even if you are very motivated at the beginning of the process you should aspire to achieve small victories. Each victory will increase your motivation and improve your chance of completing your project. Releasing something in small batches will also achieve a very important goal — to understand if what you develop really brings you value (Check out the chapter about small batches at “The lean startup” by Eric Ries).</p><h4>Keep It Simple</h4><p>Every time we had to choose between a more complicated feature and a simpler one we chose the simple option. For example, we chose to develop a web app because it is much faster to develop in comparison to a native application (which may provide a better user experience). Another example is the simplicity of the camera screen — Only two buttons, and no photo editing screen. Complicated features tend to diverge, and they are often more time-consuming than initially anticipated. So try to plan your project as lean as possible, so you can actually finish it.</p><p>A few days before the wedding we went to test the app at the venue. Then we understood that it might have unexpected effects on the wedding. We were afraid that the guests would be too focused on the app and not on the actual party, that people won’t understand how to use it, and that their pictures won’t be of good quality. So, after all, we choose not to use it. It’s disappointing, but the smart thing to do. We simply didn’t want to try this new app for the first time at our wedding, which is stressful enough as it is.</p><p>Even after we chose not to use the app, I am very happy we developed it. It was great to initiate the idea, design it, and implement it. Completing a personal project is a great feeling and taught me a lot. To sum up, choose something you are excited about, find a friend to work with, plan something simple with achievable goals and go for it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68699015d729" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/develop-something-personal-68699015d729">Develop Something Personal</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Scientific Method for Hiring the Ideal Software Developer]]></title>
            <link>https://medium.com/swlh/a-scientific-method-for-hiring-the-ideal-software-developer-fabc403ae60f?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/fabc403ae60f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[job-interview]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Mon, 23 Nov 2020 13:46:53 GMT</pubDate>
            <atom:updated>2020-11-23T22:03:37.084Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*U7oWA8FYQpAbsDhNpb02Ew.jpeg" /></figure><p>In chapter 21 of his book “Thinking, Fast and Slow”, Nobel prize winner, professor Daniel Kahneman describes a method he developed for interviewing employees. I highly recommend reading this chapter, which will also explain the theoretical reasoning behind the method I am going to discuss here. Based on his writings and our own observations, we developed a useful method to help us understand which software developers we should hire. It is nothing new, but rather basic principles put together. The idea is simple, we created a formula with a few factors to grade our candidates. To check if a candidate is qualified, all we need to do is to check the grade of the formula.</p><h3>Motivation</h3><p>As a startup at the begging of its journey, the price of hiring unqualified workers is very high. It takes time to understand that a new worker doesn’t suit the job, they slow down the whole team, you don’t want to fire them right away so you give them a few chances before firing, and then the firing process is not a positive process for anyone involved. We can’t afford to do hiring mistakes, it is just too expensive and disruptive.</p><p>Before this method, we had no constructed way to know if one is qualified or not. Of course, we had an interviewing process but it was mainly based on intuition. You can claim that intuition is very strong but we wanted a more scientific method. Every time we had to check a candidate&#39;s qualification we had to rethink what parameters we care about. We told ourselves stories about the candidates’ strong and weak aspects and tried to project these stories to the candidates’ success or failure in his future work in the company.</p><h3>The Method</h3><p>We chose three parameters which are required for the success of a software developer at our company. We designed every step of the interview process to help us grade these parameters. Every time we interact with the candidate we are focused on only one parameter. This way, we break the big problem of understanding if a candidate suits us into several smaller questions we can better estimate.</p><p>In addition to the four parameters, we add one special parameter — Intuition. We close our eyes and try to guess if the candidate will be a good fit for our work environment. Before this method, intuition was our main tool to recruit so we didn’t want to entirely abandon it, so we added it as the fourth parameter to our formula.</p><h3>Our Parameters</h3><p>Each of the parameters receives a score between one to five. The highest score is five and the lowest is one.</p><p>These are our parameters:</p><ul><li>Technological intelligence (See what it means bellow)</li><li>Specific knowledge in what we need them to do</li><li>A good fit for our company culture</li><li>Our intuition</li></ul><p>To qualify, a candidate has to score at least 16.</p><blockquote>For certain positions, we put more weight on one of the parameters than the others. For example, if we are looking for UI expert or a low level specialist, we will put more weight to the parameter of “specific knowledge”, as listed above. This is because we think that these positions demand more specific experties.</blockquote><h4>Technological Intelligence</h4><p>We say that someone has a high technological intelligence if they:</p><ul><li>Easily jump between different technologies</li><li>Can meet our high code standards</li><li>Can create good software architecture</li><li>Have in-depth knowledge in the computer science world — Data structures, algorithms, etc.</li><li>Have in-depth knowledge of modern software — Familiar with modern frameworks and have experience working in different software environments, etc</li><li>Can articulate their work and communicate their challenges</li></ul><h4>Specific Knowledge</h4><p>Each technological environment is different and reveals its own challenges. We are looking for people that have experienced the challenges that we are going to face. Someone with high technological intelligence will eventually be able to solve every problem but we want to skip as many challenges as we can.</p><p>If someone has good specific knowledge it means that they:</p><ul><li>Have significant experience in the specific technology (Measured in years)</li><li>Are able to quickly solve complicated questions in that specific area</li><li>Have led a significant development in this area</li><li>Faced and solved challenges in this field</li></ul><h4>Good Fit For Our Company Culture</h4><p>We need our workers to have a good fit for our company culture. It won’t work if someone is very skilled but doesn’t share the same work ethics as us. We are looking for people that:</p><ul><li>We can trust and rely on</li><li>Value teamwork</li><li>Respect other people</li><li>Will make an effort to be successful</li><li>Will want the best for the company</li><li>Will take full ownership of their work</li><li>Will aim to see the big picture</li></ul><h4>Intuition</h4><p>As mentioned above, we don’t want to ignore our instincts. There are things our mind catches which we can’t always put down to words. At the end of the interviewing process, we imagine the employee working in our company. If our gut feeling tells us that we will be happy about the recruitment, then we give a high rank to this parameter.</p><h3>Being Parameter Focused</h3><p>Grading each of the parameters is challenging. We can’t afford a long process with each candidate but we still have to be as accurate as possible. This is another place where the method shines. Instead of wasting time, we use every interaction that we have with the candidate for grading a specific parameter. <strong>If an interaction doesn’t help us to grade a parameter, then we should avoid it.</strong></p><blockquote>There is an exception to the point mentioned above: Interactions that are meant to show case the company and highlight its strengths. We use these interactions to impress the candadite.</blockquote><h3>Grading The Parameters</h3><p>Here are some of the tools we use to measure our candidates:</p><ul><li>General knowledge questions</li><li>Problem-solving questions</li><li>Programming home assignments</li><li>Review the CV together with the candidate — This gives the candidate the opportunity to explain how significant each of their past positions was.</li><li>Talk to recommenders, people that worked with the candidate in the past and can help grade the parameters.</li></ul><h3>Using The Method</h3><p>In this article, I focus on hiring software developers but you can apply this method to other positions as well. The parameters and the grading method might be different but the idea is the same; Choose a small number of simple parameters (3–5), write down what these parameters mean and how you can measure them. Then, make sure that every interaction with the candidate is designed to measure your parameters.</p><h3>Wrapping up</h3><p>I hope that you find this method useful as we do. After we started to use this method our whole recruitment has changed and became more parameters oriented. It takes time and effort to get to ideal parameters for you and to implement this method but it is totally worth it.</p><p><strong>Please let me know if you have any new insights after reading this article!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fabc403ae60f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/a-scientific-method-for-hiring-the-ideal-software-developer-fabc403ae60f">A Scientific Method for Hiring the Ideal Software Developer</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[First Steps In React-Recoil]]></title>
            <link>https://yaniv-beaudoin.medium.com/first-steps-in-react-recoil-4e1ddf912e37?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e1ddf912e37</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Fri, 25 Sep 2020 16:18:41 GMT</pubDate>
            <atom:updated>2024-09-08T14:25:59.473Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to use React-Recoil’s Atom</h3><p><a href="https://github.com/facebookexperimental/Recoil">React recoil</a> is aspiring to be the next big state management library for React. As of September 2020, it is still under the experimental stage but already has more than 9.5k starts. It is supposed to smoothly integrate with react’s newest features while allowing advanced state management. This article discusses the concept called <strong>atom</strong> which is the first concept you should learn when starting to use react-recoil.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*jlvx06yyKE6Z8PUga81QQA.gif" /></figure><h3>Share State Between Components</h3><p>An atom in react-recoil is a piece of state that we can share between components. To define an atom we need a unique key and a default value. After the definition, we can use this atom to share state in every component we want across our app.</p><pre>const circleColorState = <strong><em>atom</em></strong>({<br>    key: &quot;circleColor&quot;,<br>    default: &#39;blue&#39;<br>})</pre><p>To use the value of the atom we will use the <strong><em>useRecoilState</em></strong> hook and to set the value we will use the <strong><em>useSetRecoilState</em> </strong>hook<strong>. </strong>The component that uses useRecoilState will re-render every time the atom state changes.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62c990b25791166f6a70a73562d13cb4/href">https://medium.com/media/62c990b25791166f6a70a73562d13cb4/href</a></iframe><p>Although the example above is very simple, it explains the concepts of an atom very nicely. We define it independently of the react rendering tree and then connect it where it is needed. Just throw in an atom and that’s it. ColoredCircle and ColorChangingButton are not aware of each other, yet they can share state. Nothing too fancy but very useful. Even if you don’t use the more advanced features, this simple feature is already very useful.</p><blockquote>If you want to share a state between components then just throw in an atom</blockquote><h3>Atom Family</h3><p>The Atom family function enables us to use the same atom to manage different states with the same behavior.</p><pre>const circleColorState = <strong><em>atomFamily</em></strong>({<br>    key: &quot;circleColor&quot;,<br>    default: &#39;blue&#39;<br>})</pre><p>With just a few changes to the previous example, we can use atoms to manage three different states:</p><ul><li>Line 4: Calling <strong><em>atomFamliy</em></strong> instead of <strong><em>atom</em></strong></li><li>Line 10 and 18: Adding <strong><em>id</em> </strong>when calling to circleColorState.</li><li>Lines 28–33: Passing the same id to <strong><em>ColorChangingButton</em></strong> and <strong><em>ColoredCircle</em></strong> so they will both use the same atom.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/85581d3d6024644d343dfd0bbd31f9b0/href">https://medium.com/media/85581d3d6024644d343dfd0bbd31f9b0/href</a></iframe><p>Here is the result:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*DlfUHfDLm1ukVK_9V_0k8g.gif" /></figure><h3>Conclusion</h3><p>React-recoil’s atom offers a clean API to share pieces of state across react components. This simple API allows us to build independent sharable pieces of state without having to think of the big picture every time we need to share state between components. When you need to share state between components, just throw in an atom. Of course, there is a lot more to know about the atom API and a lot more about react-recoil but, understanding what is an atom already gives you useful functionality.</p><p>Looking for a job?</p><p>Checkout my latest project: <a href="http://secrethunter.io/">secrethunter.io</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e1ddf912e37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Project Management 101]]></title>
            <link>https://medium.com/swlh/software-project-management-101-3035ef521d47?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/3035ef521d47</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Tue, 08 Sep 2020 19:47:44 GMT</pubDate>
            <atom:updated>2024-09-08T14:23:44.756Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BjZJchkTeSv52-IWrZRtGA.png" /><figcaption>Project Management Metrics</figcaption></figure><p>The statistics presented in the graph above are based on a survey of 5500 project management professionals. The survey was conducted as part of a <a href="https://www.pmi.org/-/media/pmi/documents/public/pdf/learning/thought-leadership/pulse/pulse-of-the-profession-2018.pdf">report</a> made by <a href="https://www.pmi.org/">PMI</a>. To understand the graph, let’s look at the topmost line which reflects the number of software projects between 2011 to 2018 that meet the project&#39;s original goals. In 2018, 70% of the projects succeeded to meet the business intent. Or from a different perspective, in 2018, around 30% of projects ended and didn’t provide a solution to the business needs. A huge percentage in my opinion. We can further see that more than 40% didn’t complete in the original budget and more than 45% didn’t complete on time. In this article, I give a few insights that I collected over time that will help you avoid falling into these statistics.</p><h3>Develop Something Relevant</h3><p>One of the biggest wastes of resources in software development is developing products, features, or software infrastructure that nobody needs. Ask any programmer how many times they work on something that nobody used and you will be amazed. We develop things that no one needs very often. Some of it is due to an objective uncertainty of product development, but a big portion of this waste can be avoided.</p><h4>Listen To Your Potential Client</h4><p>Make sure you know who will use what you are going to work on before you start the actual programming. It doesn’t matter if it’s a client outside the company or someone within your company, you should make sure that they are going to use the product once you finished working on it. Here are a few questions to help you do that:</p><ul><li>How are they currently solving the problem? If they already have a different solution to the problem you are trying to solve then they will most likely not need your assistance.</li><li>When will they start using this solution and how often? If they are not eager to start using the product then you should suspect that they might not really want it.</li><li>How many urgent or important issues are they dealing with apart from the current issue at hand? If they have a lot more urgent or important issues then they will most likely not use your product when the time comes.</li></ul><p>The questions mentioned above, focus on the potential client&#39;s needs instead of the solution you are offering. <strong>Try to listen to what they have to say</strong>. Don&#39;t try to convince them that the problem you are trying to solve is important or that your solution is great. Check out <a href="https://en.wikipedia.org/wiki/The_Lean_Startup">the lean startup</a> or <a href="http://momtestbook.com/">the mom’s test</a> for a much deeper understanding of this topic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZUoSD0WckaB4g9bL_rYUQ.png" /></figure><h4>Communicate</h4><p>Developing relevant software is all about communication. Communication between the team to clients, between the company’s management to the product management, and between the programmers to the product manager. Behind each feature, there is a programer that codes it. Usually, this programmer doesn’t communicate with the feature’s client regularly. To make sure that he or she doesn&#39;t work on something that no one needs, we need to constantly communicate with them and let them know what is the most relevant thing they should do. The following are some practical suggestions to implement:</p><ul><li>Schedule periodic events to synchronize between the different roles of the organization. I think that 2 weekly meetings of half an hour with the developers will work for most cases.</li><li>Build a workflow where a task is not considered done until the project/product manager approves it.</li><li>Don’t let programmers be the final call on what to develop next. Programers are busy solving technical challenges. Hence, they don’t have a lot of time to understand what are the most needed features.</li><li>A good project/product manager should take part in the management program. They should be able to open it and understand what are the upcoming tasks. In my opinion, not having a project manager that constantly looks on the team tasks is a great recipe to develop something that no one needs.</li></ul><h3>Complete Development On Time</h3><p>Software development inherently has a lot of uncertainty. It is hard to estimate how much time a task will take, what tasks we don’t know about, and how future findings will change the requirements. Yet, we don’t build our product in a void, which means we have to give time estimations to our management or to our clients. How can we improve our time estimations? We need to put more time into it, but not too much time. We need to find cheap mechanisms that will allow us to better predict how much time our development will take.</p><h4>Be Realistic</h4><p>When asked to give time estimation, programmers often give overly optimistic estimations. Here are a few reasons why:</p><ul><li>Wanting to look good — Saying a task will take a long time in front of other teammates or in front of the managers can be perceived as weakness or inability to deliver.</li><li>Programers are under pressure to give an unrealistic estimation. The managers often don’t believe them. When programmers say that something will take a significant amount of time they know what they are talking about. Don’t push them to say unrealistic estimations because this is what you want to hear.</li><li>We are not always at our best. When programmers try to estimate the time a task will take they usually think of times where they were at there best performance.</li><li>Take into consideration leave days, vacation days, training, and sick days, etc. Programmers won&#39;t do it for you so help them to think of those factors.</li></ul><p>Except for the obvious solutions of considering all of the above, I want to give a rule of thumb. Multiply the time estimation by a constant number. The number changes between people but I would say to add at least 50% to the time estimation. If you don’t trust me, ask programmers in your surroundings what should be the magic number and you will be surprised by the answers.</p><h3>Meet The Required Quality</h3><p>Low-quality software is expensive. It creates endless problems, from system downtime, unworking features to a bad reputation, and much more. Creating high-quality software is challenging. It requires a lot of knowledge, time, and budget which is often limited. Sometimes it is fine to sacrifice our product quality to save time or money but we need to be very cautious about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/0*kDHOMkCi5zRu68sN" /><figcaption>The Tradeoff Triangle — One Can’t Have Them All</figcaption></figure><h3>The Filter Method</h3><p>The filter method is a name I use for a basic concept — Our workflow should contain stages to improve our software quality. Each one of the stages is like a filter that prevents low-quality software from moving to the next stages of our workflow. There are many mechanisms that we can use as a “filter”, here are some:</p><ul><li>Code Review — Letting different people in the team review the same code.</li><li>Define tests — Whether automatic or manual, we should test our code before releasing it to clients.</li><li>Penetrebility test — Defining the test we make to be sure that our project meets the security standards.</li><li>Gradual releasing — First release the product inhouse, then to beta testers and only then to the clients.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*LbmFo_okj1cBj1-D" /></figure><p>The list I gave above is partial, but the idea is clear. We should define what our quality standards are and how we are going to meet them. Once we put our strategy on paper, then it is much easier to make sure it happens.</p><h4>Find Problems Early</h4><p>Another important concept is that you should catch your defects as soon as possible. Whether it be design problems or bugs, you want to become aware of it as soon as possible. The chart below, which was created by IBM System Sciences Institute, demonstrates this nicely:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*8CYe1VJFPKDU3hOzOS1Stg.png" /><figcaption>The Cost Of Fixing Bugs Depending On Discovery Stage</figcaption></figure><p>According to their research, solving problems after releasing the product costs 100 times more! The message is loud and clear. Your quality strategy should focus on the early stages of the development process when it is cheap and easy to fix them.</p><h3>Wrapping up</h3><p>I discussed three of the main pillars of software project management — developing something relevant, doing it on time, and with high-quality. Each one of them is a whole world and I covered just a fraction of them. Yet, implementing even one of the principles I went over will improve your chances to have a successful software project. It takes time and effort to apply them, but it will be totally worth it.</p><p>Looking for a job?</p><p>Check out my latest project: <a href="http://secrethunter.io/">secrethunter.io</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3035ef521d47" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/software-project-management-101-3035ef521d47">Software Project Management 101</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Validating React Forms With React-Hook-Form]]></title>
            <link>https://medium.com/swlh/validating-react-forms-with-react-hook-form-b30d6b2b111e?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/b30d6b2b111e</guid>
            <category><![CDATA[html-form]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-hook-form]]></category>
            <category><![CDATA[react-hook]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Fri, 21 Aug 2020 11:14:34 GMT</pubDate>
            <atom:updated>2020-09-04T22:18:20.006Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*coYN8H4IY0vNckRzuczyuw.png" /></figure><h3>Validating React InputsWith React Hook Form</h3><p>Validating inputs is very often required. For example, when you want to make sure two passwords inputs are the same, an email input should in fact be an email or that the input is not too long. This is can be easily done using <a href="https://react-hook-form.com/api#register">React Hook From</a>. In this article, I will show you how.</p><h3>Required Fields</h3><p>The most simple, yet very common, validation is to make sure that an input component contains input from the user. React Hook Form basic concept is to register input tags to the form by passing register() to the tag’s ref attribute. As we can see here:</p><pre>&lt;input name=&quot;input1&quot; ref={register()}/&gt;</pre><p>In this simple example, we register the input to the form using the name input1. This way react hook form knows to observe changes of the input’s value.</p><p>Now, when we want to validate a required input, we simply add <em>{ required: true }</em> to the ref register call.</p><pre>&lt;input name=&quot;input1&quot; ref={register({required: true)}/&gt;</pre><p>The following is a working code example with basic “required” validation:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e034500362e906331e7f4fdefbf3d575/href">https://medium.com/media/e034500362e906331e7f4fdefbf3d575/href</a></iframe><h3>How it works</h3><ol><li>Calling useForm at line 5 returns a register function to register inputs to the form, handleSubmit function which is used to publish the form and errors which is an object that contains all the errors in the form.</li><li><strong>At line 16 we register the input to the form and mark it as required.</strong></li><li>Before submitting the form, the react hook form validates that the user really typed something.</li><li>If the user did enter input, the onSubmit function at line 12 is called.</li><li>If the user didn’t enter any input then the onSubmit function won’t be called. Instead, the whole function will rerender and the errors object will hold the error.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VbDY7X42Yb2zb9PbXR07Fg.png" /><figcaption>Pressing enter when the input field is empty</figcaption></figure><h3>Maximum Length</h3><p>Getting the basic concept of the library might be a bit challenging but it is totally worth it. Once you understand the previous example, you can create many more validations using only small tweaks. Let’s see another validation example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1dec23a790b809429149bf68cebc50b9/href">https://medium.com/media/1dec23a790b809429149bf68cebc50b9/href</a></iframe><p>The trick is in line 17. When registering the input to the form we enter the maximum allowed length. Another cool feature here that you might notice, is that there is an error message in case the validation fails. This feature is useful when we have more than one validation, as we can see in the following section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*x2BWOS1Y-fDdOmxSM4rgoQ.gif" /></figure><h3>Multiple Validations</h3><p>You can also write multiple validations for the same input. In the following example, we see 3 validations for the same input. The maxLentgh and the pattern validations are built in validations. The isEmail validation is a custom validation that I created using the js validator library.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a926b7cb788f9863ca2134dd2905cfc2/href">https://medium.com/media/a926b7cb788f9863ca2134dd2905cfc2/href</a></iframe><h3>Conclusion</h3><p>The initial use might be a bit challenging but learning how to use the library is totally worth it. Especially if you are using onChange callbacks or refs to extract input values. Not only that the library gives you easy control over the form, it also provides you with great validation capabilities. Most basic validations can be accomplished using the built in validations. Yet, building your own custom validations is smooth and will fill the uncovered cases. Here is the <a href="https://react-hook-form.com/api#register">official documentation</a>. Give it a try!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b30d6b2b111e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/validating-react-forms-with-react-hook-form-b30d6b2b111e">Validating React Forms With React-Hook-Form</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Watching form changes using react-hook-form]]></title>
            <link>https://yaniv-beaudoin.medium.com/watching-form-changes-using-react-hook-form-3ca56d6ac075?source=rss-43a13f295fbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ca56d6ac075</guid>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-forms]]></category>
            <category><![CDATA[html-form]]></category>
            <dc:creator><![CDATA[Yaniv Beaudoin]]></dc:creator>
            <pubDate>Wed, 19 Aug 2020 07:12:32 GMT</pubDate>
            <atom:updated>2024-09-08T14:20:56.339Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1r1zAyI9qE2tkSLbLj4DnA.png" /></figure><p>A super helpful react package I am working with is called <a href="https://react-hook-form.com/">react-hook-form</a>. It allows you to easily build and validate forms. It is pretty useful. Here I focus on a feature called watch, which is usually not the first thing you would use when starting to use react-hook-form.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*rz__TQRE3FDGn9C5RVYUpQ.gif" /><figcaption>Watching input using react-hook-form</figcaption></figure><h3>Watch</h3><p>Watch allows you to observe form changes (🤯). It will notify you whenever an input changes. This way you don’t have to wait for the user to submit the form in order to do something.</p><pre>import React from ‘react’;</pre><pre>import { useForm } from “react-hook-form”;</pre><pre>const UseFormWatchExample = () =&gt; {</pre><pre>  const { register, watch } = useForm();</pre><pre>  const title = watch(‘title’)</pre><pre>  return (</pre><pre>    &lt;form&gt;</pre><pre>      &lt;input name=’title’ ref={register()}/&gt;</pre><pre>      &lt;h1&gt;{title}&lt;/h1&gt;</pre><pre>    &lt;/form&gt;</pre><pre>  );</pre><pre>};</pre><pre>export default UseFormWatchExample</pre><h3>How Does it work</h3><ul><li>First, we name our input “title” and register it to the form.</li><li>We then watch input changes using the watch(“title”) statement.</li><li>The title changes every time the user types a letter and then it is displayed inside the h1 tag</li></ul><h3>Watch API</h3><p>You can use watch on a single form field (Like I showed in the example), an array of field names or to watch all fields by not passing any parameter to the function. Check out the <a href="https://react-hook-form.com/api#watch">official documentation</a> for more details.</p><p>Liked my article? Looking for a job?</p><p>Check out my latest project: <a href="http://secrethunter.io/">secrethunter.io</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ca56d6ac075" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>