<?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 Darío Rodríguez on Medium]]></title>
        <description><![CDATA[Stories by Darío Rodríguez on Medium]]></description>
        <link>https://medium.com/@darode?source=rss-6143e1f35421------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ky2AMPvvWPDEX6OjppVcHA@2x.jpeg</url>
            <title>Stories by Darío Rodríguez on Medium</title>
            <link>https://medium.com/@darode?source=rss-6143e1f35421------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 07:09:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@darode/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[7 tips to improve task estimation]]></title>
            <link>https://levelup.gitconnected.com/7-tips-to-improve-task-estimation-2d3873ebf209?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d3873ebf209</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Mon, 04 Mar 2024 03:00:36 GMT</pubDate>
            <atom:updated>2024-03-04T13:44:26.541Z</atom:updated>
            <content:encoded><![CDATA[<p>Task estimation is one important skill of software developers and improving it will help you grow in your career.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*s393ROilGi9kmhBlqm4Dwg@2x.jpeg" /></figure><p>Guessing how long a task will takes is a big responsibility because it could define the time to market of a specific feature and it could have a big impact on the business.</p><p>This skill is so important that it is one that separates clearly Senior Developers from Junior Developers. Think about it, if you can estimate your development effort with certain accuracy you will be trusted by your manager and stakeholders.</p><p>If you find any problem estimating tasks or projects don’t worry it’s completely normal. Learning how to estimate development effort it’s a complex task and you should practice every day to reach proficiency.</p><p>Here you have seven tips to help you to improve your development effort estimation skills.</p><h3><strong>1.- Read, understand and clarify requirements</strong></h3><p>First goes first, you need to understand all requirements, use cases, etc. of the task you are going to implement.</p><p>So, ensure you read the task requirements carefully and ask for more details if needed. It’s very important to talk about any details, both technical and functional, because any little detail missing could be a huge change in the scope of the tasks</p><p>Is very important to clarify anything that could affect significantly such us:</p><ul><li>the scope of the changes</li><li>side effects in other parts of the system</li><li>dependencies and roadblocks</li></ul><p>All the information you can have in advance and every problem spotted upfront will allow you to get a more accurate estimation.</p><h3>2.- Divide and conquer</h3><p>Yes, you should always try to separate the work to be done in small batches so you can easily estimate the amount of work for all of them.</p><p>For example you should create a login feature you can divide it into several tasks like: create users table, create repository, create endpoint, create frontend page, etc.</p><p>At the beginning is a matter of following the process so you can start separating the task into different steps or parts of the process, even writing down the different strategies to separate and evaluate the effort.</p><p>As you improve your skill in separating and estimating the tasks you can do it on the go.</p><h3>3.- Compare estimation between tasks to adjust</h3><p>Let’s say you estimate all the tasks assigned to you separately so the first step is done. But… you can improve your estimations a little bit if you compare your forecast between tasks.</p><p>At this point the most important thing is to ensure that all the estimations make sense. So it’s time to focus on some mistakes that could be spotted if you pay attention to some tasks with similar characteristics that should have a similar effort estimation:</p><ul><li>similar scope of changes</li><li>a similar number of dependencies</li><li>a similar number of side changes in other systems</li><li>similar technologies involved</li><li>etc.</li></ul><p>If we find two or more tasks that have similarities but a completely different estimation we have a problem. In this situation, we need to adjust the estimations to reflect the real estimation.</p><p>By doing this analysis you can spot some bias and errors by comparing estimations.</p><h3>4.- Create a track record of your estimations</h3><p>As said before, development effort estimation is a skill that could be learned and improved. The only issue with this skill is that explaining theory doesn’t help too much, so you need to learn by doing.</p><p>So, to increase your proficiency in estimating your effort it’s really important to create a historical track record with past estimations and the error to compare your accuracy over time.</p><p>You can use a spreadsheet, a notebook, or whatever you want, but the idea is to write down the data in a table with three columns: task name (or brief description), estimated effort and real effort.</p><p>With all this data you can conduct some analysis and discover a lot of things. For example, if you always need more time than estimated, you are underestimating tasks, maybe in the future, you want to increase estimation for this kind of tasks to be more precise. In the other hand if you systematically finish the tasks using fewer points or hours is because you overestimate the effort for these tasks, etc.</p><h3>5.- Don’t forget to add time related to bureaucracy</h3><p>Yes, I know… you don’t like bureaucratic tasks but let’s face it, sometimes we need to do documentation, prepare a demo, attend a meeting or event give training related to the task you are doing.</p><p>In these cases, my recommendation is to add more time to your tasks or create a different one to assign the effort of this part specifically.</p><p>If you have any doubt about if this is a good practice, let me say something: these bureaucratic tasks belong to the main one because without the main one they will never exist. So it’s completely ok if you increase your estimation of development effort for the main one or if your team decides to create a new one. The main issue here is that you need to show the effort dedicated to this part of your job.</p><h3>6.- Increase your technical and domain knowledge</h3><p>This is easy to explain: the more you know the better will be your estimations.</p><p>So it’s very important to dedicare some time to know more about: business logic, classes, arquitecture, databases, etc related to the system you are developing.</p><p>By doing so, you can make informed decisions and spot side changes and other implications.</p><p>The more you know the more precise your estimations will be.</p><h3>7.- Use analytical techniques</h3><p>Sometimes the main issue is that you don’t know where to start, if this is your case then you try some analytical methods.</p><p>These methods will help you to transform the code changes into some measurable values.</p><p>Following you can find the most well known techniques:</p><p>The first technique is <strong>COCOMO</strong> (Constructive Cost Model). It uses mathematical equations to estimate the effort, time, etc. based on project characteristics such as code size, complexity, and team experience.</p><p>The second one is <strong>Function Point Model</strong>. This technique estimates the functional size of a software system based on the quantity and complexity of the features it provides, which can then be used to estimate the effort and resources required. So complex feature should have higher estimation than easy ones.</p><p>There are other techniques but these two, in my opinion, offer another approach and give you some analytical methods to start estimating</p><p>Disclaimer here, no one it’s better than the other one so try both and use the one that works best for you.</p><h3>Wrapping up</h3><p>Improving task estimation is crucial for software developers, as it directly impacts project timelines and business outcomes.</p><p>So remember to:</p><ul><li>understanding requirements thoroughly</li><li>breaking down tasks</li><li>compare estimations to ensure they make sense at a whole</li><li>maintain a track record for monitoring purposes</li><li>add time to bureaucratic issues in tasks</li><li>increase your technical and domain knowledge</li><li>use any analytical techniques for software estimation</li></ul><p>I hope you can improve this skill by following these tips so you get more valuable as a developer, paving the way for more successful project deliveries and career growth.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d3873ebf209" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/7-tips-to-improve-task-estimation-2d3873ebf209">7 tips to improve task estimation</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Secure development for dummies: basic concepts]]></title>
            <link>https://levelup.gitconnected.com/secure-development-for-dummies-basic-concepts-93baa07dda1a?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/93baa07dda1a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Fri, 13 Oct 2023 01:55:33 GMT</pubDate>
            <atom:updated>2023-12-06T19:46:27.476Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lz9u_ke7193TeTbM_bl-Gg.jpeg" /></figure><p>Creating secure applications should be the goal of every developer because it could make a difference for the company they are working for.</p><p>Nowadays, hacker attacks are increasing so we, as developers, should keep this in mind to increase the security level of our applications. Many factors like social engineering, system configuration, bugs, etc. affect our software security. The good part is that we can increase security exponentially by following some basic principles.</p><p>Because of that, I’m going to create a series of article explaining how to improve security for developers that has no expertise in this area.</p><p>In this first article, I’m going to show how you can increase security in your day-to-day tasks just by following the regular development life cycle and by adding some security concerns.</p><h3>Development life cycle</h3><p>I’m sure most developers are familiar with the development life cycle, but just in case, let me introduce some theory about it.</p><p>A brief definition could be the following: the software development life cycle (SDLC) is a process that enables the production of high-quality and low-cost software in the shortest time possible.</p><p>So, SDLC tries to ensure we can produce high-quality software using low resources in terms of time and future maintenance effort.</p><p>You can find this process divided into different phases but usually, it has six phases: analysis, design, implementation, testing, deploying, and maintenance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/0*Cciptvpd2x07tei0" /></figure><p>Each phase covers part of the tasks performed in developing software:</p><ul><li>Analysis: get all the requirements and features you need to develop</li><li>Design: specify how you are going to create your application and what technologies and programming languages you are going to use</li><li>Implementing: code your application</li><li>Testing: validate that your code works correctly</li><li>Deploy: put your code in the production environment</li><li>Maintenance: correct and enhance your application</li></ul><p>You can apply SDLC in different ways depending on what framework you are following. For example, in Scrum, you will apply it at the task level. Otherwise, if you use a waterfall model you will do it at a project level.</p><p>No matter what framework are you using, you can use SDLC principles to improve security. The idea is to join the software development lifecycle with the main security principles for the software we are going to explain next.</p><h3>Main security principles in software development</h3><p>Before going deeper into each phase and explaining how to apply security best practices to them, we need to know a little bit more about the security principles that apply to software development.</p><p>To say an application is secure it should be:</p><ul><li>Authenticated: the system should know what user is performing what action at anytime</li><li>Confidential: the information should only be accessed by users with the correct rights and access level</li><li>Integral: the information should be modified only by users with the correct rights and the system should ensure the information was not modified without permission</li><li>Available: the system should be up and running for the users that need it</li></ul><p>Essentially these principles try to enforce some logic design best practices when creating software applications.</p><p>The idea behind them is to ensure application and data are accessed properly by the users and that the application guarantees the data integrity between the different user’s actions.</p><p>The availability principle refers to the idea that the most secure application is the one that is not accessed or used by anyone, that’s true but it’s useless so the application should be ready for the users.</p><p>Now that we know about the SDLC and the basic security principles in software development let’s put everything together by applying the principles to each SDLC phase.</p><h3>Analysis phase</h3><p>This is the initial phase, here you are gathering and refining all requirements for your application’s features. In this phase, you usually map or adapt business cases or user stories to tasks.</p><p>To make it more secure you should focus on the following things:</p><ul><li>Working environment</li><li>How users access information</li><li>What kind of information you are going to store</li><li>etc.</li></ul><p>It’s important to know the working environment because you will face different risks depending on whether you are making a web app, a mobile app, or a desktop app.</p><p>Depending on how users access the information, your application could be more secure. For example, by implementing an ACL (access control list) you could enhance security exponentially.</p><p>In the same way, the information your application manages will define some security requirements like encryption, anonymization, and so on.</p><p>It’s very important to introduce security requirements in the first step so you can make decisions in the following phases accordingly.</p><h3>Design phase</h3><p>In the design phase, you start making technical decisions. So it’s essential to think about security concerns in any of these decisions.</p><p>In this phase you can apply some best practices like:</p><ul><li>Using secure communication protocols (HTTPS, TLS encryption, etc)</li><li>Using the latest version of the selected programming language and checking the security recommendations it</li><li>Choosing the latest versions of libraries or frameworks to avoid known security issues</li><li>Using the latest versions of auxiliary software like databases, cache systems, web servers, and so on</li><li>etc</li></ul><p>The best practices highlighted above are, as usual, theory and should serve as a guide. In real life, you will encounter situations where you should use deprecated versions of libraries or languages or insecure protocols to communicate with certain APIs, etc.</p><p>The most important outcomes of this phase, in terms of security, are:</p><ul><li>to define technical specifications to meet the best practices as closely as possible</li><li>to identify the insecure parts as well as countermeasures to avoid security flaws.</li></ul><p>If you can get both things in this phase you are paving your road for the following ones and for sure your software will be more secure.</p><h3>Development phase</h3><p>During the development phase you are coding your application and it’s when you are implementing any security-related feature.</p><p>In this phase is very important to:</p><ul><li>Avoid using deprecated functions or features from the selected libraries or programming languages</li><li>Setup process of code review so the code is checked at least by one other person on the team</li><li>Keep your code as simple as possible avoiding antipatterns</li><li>Centralize your code related to security to reuse it easily</li><li>Use cryptographic secure methods for randoms, UUIDs, and encryptions</li><li>Encrypt sensitive information</li><li>Validate user input and encode it accordingly before storing it in the database or displaying it to the user again</li><li>Control all errors to avoid sending stack-trace information without control</li><li>Created anonymization method and centralize them</li><li>etc.</li></ul><p>As you can see this phase is when things happen. It’s important to take time at this phase to ensure your code and the features you are implementing are secure.</p><p>You can apply the snowball principle here, if you do it well you could increase your application security exponentially, if not you will need tons of hours to review and secure your application later on.</p><h3>Testing phase</h3><p>This phase tries to ensure the software implemented in the previous one works as expected.</p><p>In the testing phase, you will test all issues related to security implemented in the development phase plus ensure the whole application is robust enough.</p><p>This means you should test more than the “happy path” or the common entry values for the method or use cases.</p><p>Some considerations would be:</p><ul><li>Testing security issues spotted during design and development phases</li><li>Testing security-related methods like encryption or anonymization ones</li><li>Testing edge cases for uses cases/methods</li><li>Testing user validation methods</li><li>Testing data encoding methods</li><li>Testing error handling</li><li>etc</li></ul><p>So, the idea is to create a control layer to ensure all security measures are working as expected and that the user cannot break the application easily.</p><h3>Deployment phase</h3><p>At this phase, you have an application or some useful features and it’s time to put it ready for the users.</p><p>In this phase security it’s very important because we are talking about the architecture that is going to support the public access to your application.</p><p>Some security considerations to check are:</p><ul><li>Use the latest operating system versions</li><li>Use the latest versions of databases, web servers, and so on</li><li>Follow the hardening guides for each part of your infrastructure (servers, firewall, etc.)</li><li>Pay special attention to cloud vendor configuration best practices</li><li>Configure a system monitoring for all assets</li><li>Restrict access only to required users to the production environment</li><li>Restrict access using VPN or IPs if possible</li></ul><p>Definitely you should ensure your infrastructure only allows users to access the lowest resources possible to use the application. For example, if you are configuring a firewall for a public web app only allow connections to port 443 close other ports, etc.</p><h3>Maintenance phase</h3><p>Nowadays we are working in an iterative environment and it’s a common practice to launch a minimum viable product and then improve it.</p><p>In this scenario, the maintenance phase has a lot of responsibility because most of the launched features are going to evolve. So, in addition to the changes in business logic or features, we should add some security enhancements during this phase.</p><p>For example:</p><ul><li>Update libraries or programming language versions</li><li>Increment security in specific features (login, payments, etc)</li><li>etc</li></ul><p>I want to highlight something important here, adding security features like 2FA login, email validation, or SMS validation for payments, seems to be features that should be detected and defined during the analysis phase but sometimes is not possible to do it because of technology restrictions or project scope.</p><p>The security world evolves every day so you need to stay tuned and see if some of the new best practices can be used in your application. For example, some time ago we didn’t use 2FA for login and now it’s very common so in that scenario some maintenance would be required to improve login security.</p><h3>Real-life disclaimer</h3><p>At this point, you know all the theory and it’s time to apply it to your projects but you will face the real life…</p><p>Beware that you are going to face a lot of challenges and roadblocks:</p><ul><li>the product manager pushes for business features over security ones</li><li>you run out of time and deadlines aren’t meet</li><li>etc.</li></ul><p>Sounds familiar right? As a result, security “goes later on” and improvements are made in batches. Don’t worry about it, think about secure development as an iterative process, your goal is to improve security so try to put in as many security enhancements as possible.</p><p>Another important thing in real life is that our main security threats are the users. Yes, humans that use our application. Hackers nowadays rely heavily on social engineering to cheat our users using phishing techniques, for example. So, it’s important to remember some users are more familiar with technology than others and in some cases choosing a secure password is a challenging task for them.</p><p>The only way we can protect our users is by creating the most secure application we can, but we can’t make decisions on their behalf, so our application won’t be the most secure one even if we have created the perfect software (which I guarantee you it doesn’t exist)</p><h3>Conclusions</h3><p>Secure development is about common sense, and it doesn’t require you to obtain a specific and expensive professional certificate.</p><p>You should apply security concepts in every phase of the software development life cycle, putting security aspects as a top priority from the beginning of the project.</p><p>It’s very important to ask yourself if the feature you are developing meets the main principles for secure software, it should be: authenticated, confidential, integral, and available.</p><p>And the last thing you should get as a takeaway is that doing secure development is an iterative process like doing software itself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93baa07dda1a" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/secure-development-for-dummies-basic-concepts-93baa07dda1a">Secure development for dummies: basic concepts</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to manage your technical backlog]]></title>
            <link>https://levelup.gitconnected.com/how-to-manage-your-technical-backlog-868415f8eea9?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/868415f8eea9</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Thu, 20 Apr 2023 16:30:56 GMT</pubDate>
            <atom:updated>2023-08-06T08:06:56.497Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gJvc-4rdU_5FmhuoQcbsvA.jpeg" /><figcaption>Picture from <a href="https://unsplash.com/@villxsmil?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Luis Villasmil</a> at <a href="https://unsplash.com/es/fotos/mlVbMbxfWI4?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Before talking about technical backlog we should add some context, so are going to talk about technical debt first.</p><p>Ward Cunningham said that “some problems with code are like financial debt. It’s OK to borrow against the future, as long as you pay it off”. After this metaphor, he coined the term “Technical Debt” to define this situation.</p><p>He wanted to say that it’s completely ok to patch something here and there if you keep in mind you are going to expend time in the near future to refactor and fix it.</p><p>A solution could be to develop every new feature cleanly and perfectly but we know this is impossible. Remember, the saying “every software that is in production is legacy software”.</p><p>In other words, we need to learn how to deal with technical debt regularly to keep debt exposure to a minimum, updating and refactoring our systems. Here is when a technical backlog arises as the perfect tool.</p><h3>How does a technical backlog help?</h3><p>You can use many tools to manage technical debt but one of my favorites to use is the technical backlog.</p><p>The idea is very easy, just apply product backlog management techniques but for technical tasks, let’s see it.</p><p>You, as a tech lead, have some technical tasks (improvements, refactors, etc) that are not related to business needs directly. They add value because they can reduce bugs and improve development performance. So, you need to work on these technical tasks regularly to increase quality.</p><p>Because you have a lot of tasks you need to prioritize, sort, and manage them based on the impact of all tasks to ensure you achieve your goals, and here is where a technical backlog will help you.</p><p>In my experience creating a list of technical tasks and managing them using product backlog management principles it’s a game changer.</p><p>This technique will help you to:</p><ul><li>Evaluate the business impact of pure technical tasks</li><li>Prioritize tasks to add more value early and often</li><li>Align your work with your long-term strategy</li><li>Create a technical roadmap for your team</li></ul><p>In the following sections, I’m going to explain in depth how to prioritize tasks, how to create the backlog with your team, and most important thing how this works with the main product backlog.</p><h3>Ways to prioritize tasks</h3><p>Before going further, I want to say that you will find thousands or millions of ways to prioritize tasks on the internet. Please, feel free to do your research to find what works best for you, there is not one strategy to rule them all.</p><p>Here I bring you the most useful and easy-to-implement techniques to prioritize tasks based on my own experience.</p><p><strong>Value vs. Effort</strong></p><p>Using this strategy, you should assign to each task a value (in our case the benefits or reduction of technical debt) and a measure of effort (here you can put the number of hours or story points to develop this task). You can rank both value and effort from 1 to 5 to make it easier.</p><p>When you have all tasks ranked, you should place them in a matrix in which value is represented in the x-axis and effort is represented in the y-axis like the following image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/0*rYrXZ1f4hbQmj4UK" /><figcaption>Value vs effort matrix example</figcaption></figure><p>If you take a look at the matrix you can see four main areas.</p><p>The first area is the most interesting because the tasks there add so much value with a little effort, they are called “quick wins”. The second area is the one that holds tasks that add low value with a high effort and are called “time sinks”. The area that holds tasks that add low value with low effort is the “so-so” area. And the last one is the area that holds high-value and high-effort tasks that are usually “big projects”.</p><p>Keeping those areas in mind it’s very easy to prioritize tasks. You will want to do “quick wins” first to get the most value sooner. In the same way, you won’t prioritize “time sink” tasks to avoid losing time. The “so-so” tasks could be prioritized from time to time to keep reducing your technical debt. Definitely, you should prioritize the “big projects”, but you should analyze them carefully because in most cases you should break them down into smaller tasks.</p><p><strong>MoSCoW</strong></p><p>This strategy is about sorting your task into buckets to figure out what matters most to your team.</p><p>You should put each task in one of these buckets:</p><ul><li>“must-have”: tasks that should be done right now because add so much value to your team and the business. For example, tasks that will improve your development speed or allow you to fix or reduce bugs.</li><li>“should-have”: tasks that are important, but could be done later on if needed. In this bucket, you can place tasks like fixing minor bugs that cause issues from time to time but don’t affect the production environment.</li><li>“could-have”: tasks that are not important, don’t have a deadline, and don’t have a huge impact. A huge refactor in legacy, but working code just to meet new code standards it’s a good example for this bucket.</li><li>“won’t-have”: tasks that are not important that could be postponed forever if you don’t have resources. For example, small code refactors that are more related to code style than testability, etc.</li></ul><p>With this technique prioritizing is really easy. First of all, you can put into the bottom of your backlog those “won’t have” tasks. Then you can mix and match “must-have” and “should-have” tasks on top of your backlog. You can set a deadline to “could-have” tasks so you won’t ignore them but surely they are not so urgent.</p><p><strong>Cost of delay (CoD)</strong></p><p>Cost of delay is about quantifying the impact as money for a particular task, so you can prioritize them based on the direct impact on the business.</p><p>This technique is particularly good if you can quantify your technical debt in some concepts related to business, for example, the cost of not fixing a bug or the cost of improving a particular system to decrease development time or performance, etc.</p><p>To use the cost of delay you should estimate the value of doing a task in money (how much time you are going to save or how much money you are to save) and the effort in time to develop it. With these two parameters, you can create a Cost of Delay (CoD) ratio by dividing cost by time. You can display all the information in a table like the following one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/0*uzeedn0OkutDvoeB" /><figcaption>Cost of delay table example</figcaption></figure><p>With all the information and the calculated CoD ratio, you can easily prioritize your tasks, just order your tasks by CoD ratio. The higher the ratio the higher the expected outcome for a task and the business.</p><p>Cost of delay and Value vs Effort are pretty similar techniques, the main difference between them is that the former doesn’t set a measure you can translate to business language and is more based on opinions than on facts.</p><h3>Some tips to prioritize tasks</h3><p>Previously we saw some strategies or techniques to prioritize tasks but in real life sometimes it’s not as easy as choosing one of them and using it forever.</p><p>To nail it using your prioritization skills you will need to mix and match all of them.</p><p>The easiest way to start is to use a Value vs Effort, it’s easy and allows you to detect quick wins and prioritize the tasks.</p><p>For some tasks calculating some parameters, especially effort, could be difficult. In this case MoSCoW it’s your solution because you can order your tasks without complicated analysis.</p><p>If you can calculate the cost of a task then do it! Without any doubt Cost of Delay is the most useful technique because you can prioritize your tasks and translate them to business value at the same time.</p><p>The only thing you need to consider is not to compare task priority estimates using different techniques. So don’t compare two tasks, one evaluated using Cost of Delay and another one evaluated using MoSCoW, they are not comparable.</p><p>You can use any technique to evaluate the whole backlog without concerns. Depending on the context it could be easier to use one technique or the other when merging your technical backlog with the product backlog. We are going to comment more on this in the next section.</p><h3>Merging product backlog and technical backlog</h3><p>At this point, you have your technical backlog filled with tasks. The next step is to add the tasks to the main product backlog so you can start working on them on a regular basis based on your project management framework (scrum, kanban, etc.)</p><p>To do this you need to talk with your product manager to create a strategy to add some technical tasks alongside the product ones. Both of you should agree on how to do it because you need to balance business and technical needs.</p><p>A good strategy is to define a specific amount of time or story points to add purely technical tasks, let’s say 20% of the sprint time. By doing so, you will have a slot to keep improving the technical part of your systems without disturbing the pace to release business features.</p><p>Very important! Don’t assign all bug fixes, feature bugs, refactors, etc to this technical slot, those kinds of tasks could be required by business features. For example, let’s say you need to add a new feature that requires a huge refactor in your business logic, this is not a purely technical task. The time needed to do these changes belongs to the time you need to develop this new feature, so this task should be placed in the main product backlog.</p><p>It’s important to keep the product manager involved during the process. You should explain your technical needs in terms of business impact so the product manager can get some insights about the outcomes the team is going to get after all technical work is done.</p><p>To have a healthier relationship between business and technical tasks, in my own experience, it’s important to have regular meetings with your product manager. Once a month could be more than enough if you speak regularly, so you can schedule a meeting specifically to talk about the technical backlog and how you should merge it with the product backlog.</p><h3>Managing the backlog as a team</h3><p>Managing technical backlog alone can work for most tech leads. But, to be honest, it’s an incredible opportunity to empower your team.</p><p>If you encourage your team to add items to the technical backlog and to be responsible to justify what tasks should be prioritized you are increasing your team member’s ownership like never before.</p><p>Sounds challenging but it’s really easy, you just need to add new items as a daily task. You can use scrum events like daily meetings, bug fixing, etc. to create items in the backlog if needed.</p><p>Later on, you can prioritize all items with your team during a specific meeting like technical grooming or similar. In this meeting, everyone on the team should prepare a list of reasons to justify why a specific task has more priority than others. I like to ask my team members to bring arguments for the three tasks they consider more important to explain how they will improve our day-to-day work.</p><p>Of course, you need to guide your team and all tasks should be prioritized following one or more than one of the strategies explained before, but it’s really important to give voice to your team during this process.</p><p>This way, your team will receive a boost of motivation because they will have real action to improve things that they feel like pain points. And you will have a clear vision of how they see the technical priorities of the team and it allow you to do any alignment if needed.</p><h3>Conclusions</h3><p>As you know as tech lead one of your priorities is to fight technical debt. This duty is not easy and a technical backlog can help you out.</p><p>Using a technical backlog you can know how to prioritize purely technical tasks to fight against technical debt and succeed. To do so, you will prioritize your backlog as a tech lead and then merge it with the main product backlog leaving a slot of time for the technical tasks.</p><p>You can use several strategies to manage your technical backlog like Value vs Effort, MoSCoW, and Cost of Delay. Depending on the context, some of them are more suitable than others so you can choose what works best for you.</p><p>The most important thing is that you can and should manage the technical backlog with your team. It’s a great opportunity to motivate the team and increase ownership. It’s one of the best ways to encourage your team to propose improvements and stay aligned with systems priorities.</p><p>Don’t hesitate and create your technical backlog right now!</p><h3>Level Up Coding</h3><p>Thanks for being a part of our community! Before you go:</p><ul><li>👏 Clap for the story and follow the author 👉</li><li>📰 View more content in the <a href="https://levelup.gitconnected.com/?utm_source=pub&amp;utm_medium=post">Level Up Coding publication</a></li><li>💰 Free coding interview course ⇒ <a href="https://skilled.dev/?utm_source=luc&amp;utm_medium=article">View Course</a></li><li>🔔 Follow us: <a href="https://twitter.com/gitconnected">Twitter</a> | <a href="https://www.linkedin.com/company/gitconnected">LinkedIn</a> | <a href="https://newsletter.levelup.dev/">Newsletter</a></li></ul><p>🚀👉 <a href="https://jobs.levelup.dev/talent/welcome?referral=true"><strong>Join the Level Up talent collective and find an amazing job</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=868415f8eea9" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/how-to-manage-your-technical-backlog-868415f8eea9">How to manage your technical backlog</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to manage time like Senior Developers]]></title>
            <link>https://levelup.gitconnected.com/how-to-manage-time-like-senior-developers-d1fe62c4438e?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1fe62c4438e</guid>
            <category><![CDATA[time-management]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Wed, 08 Mar 2023 03:43:55 GMT</pubDate>
            <atom:updated>2023-03-25T06:49:11.634Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uE9VGvwXdtfZy6q9KHiUNQ.jpeg" /></figure><p>It’s widely known that one of the main differences between senior and junior developers resides in soft skills. And one of the most important is time management.</p><p>Time management allows you to improve your performance. If you manage your time wisely you will add value exponentially to the company.</p><p>In other words, you can be the developer with the best technical skills but if you don’t know when to do a quick fix or when to do a big refactor you are losing time and thus money. This is why, in my humble opinion, time management is a game changer for software developers.</p><p>In this article, we will cover some basics of time management, specifically for software developers.</p><h3>Identify important and urgent tasks</h3><p>First thing first, you need to know what tasks are important and what are urgent.</p><p>You can lean on the Eisenhower Matrix to analyze your tasks and evaluate their urgency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*kNSCf3ekdH9rIZNR" /></figure><p>To use this matrix you should sort the task into different quadrants depending on how urgent and important is a particular task. You should put into “Do” quadrant tasks that have a clear deadline or a big impact. Inside the “Decide” quadrant you will put tasks with some impact but not a clear deadline, more focused on long-term success. The “Delete” quadrant will have tasks that are not needed at all. Inside the “Delegate” quadrant you should put tasks that should be done but don’t require a specific team member or set of skills to be done.</p><p>The Eisenhower matrix won’t solve all your problems but it’s a good way to ensure the tasks you are struggling with are worth the effort.</p><p>If you hesitate when you are putting a lot of effort into a particular task you just need to verify if the task is inside the “Do” quadrant, then you are doing great. If it’s inside the “Delete” quadrant, leave it right now because you are wasting your time. If the task is inside the “Delegate” or “Decide” quadrant, just ask your tech lead to verify you are the best team member to develop this task.</p><h3>Plan ahead your tasks</h3><p>When you are beginning a new task you can start coding and expect there won’t be any problems or analyze the task and split it into different steps.</p><p>Just analyze the different strategies to refactor code, implement the task, whatever thing you need. Then create a list with different steps, diagrams and all documentation you need before starting to develop.</p><p>You don’t need to create books and books of documentation or diagrams, it’s more about simulating how you will develop the task to try to spot any major issue upfront.</p><p>As you get more seniority this exercise will be more natural so you don’t need to create any documentation, diagram, or write down every aspect. You will learn how to do it keeping the documentation to a minimum.</p><h3>Avoid multitasking</h3><p>Don’t multitask, never!</p><p>Multitasking is a time sink, I cannot stress it more.</p><p>When people refer to multitasking, they usually think about doing several tasks at the same time like in parallel processing. In real life, it doesn’t work as you may think. Usually, it involves a lot of context switching because you cannot handle several tasks in real parallel at the same time.</p><p>If you know a little about context switching is one of the worst things ever and it reduces your performance exponentially because it comes with a penalty in time. When you switch from one task to another you should remember everything you were doing and to do it you need some time.</p><p>It means you are going to dedicate more time to finishing the task just because you need to do several reminders when changing your focus between tasks.</p><p>Instead of doing several things at the same time, focus your effort on finishing an open task and try to reduce multitasking as much as possible.</p><h3>Use timeboxing for recurrent tasks</h3><p>Another useful tip for recurrent tasks is to use the timeboxing technique.</p><p>The timeboxing technique is about setting a specific amount of time for a particular task. Instead of using an infinite amount of time, you put a restricted amount of time into this task and no more than that.</p><p>This technique’s really useful to avoid wasting time and encourages you to focus on important things because you won’t put more time and effort into a task than is needed.</p><p>You can use timeboxing for recurrent tasks like code review, email responses, training, etc. For example, you can reserve a slot in the first hours of the day to do code reviews, you can use one hour after lunch to answer emails, etc.</p><p>You can choose whatever schedule is the best for you.</p><h3>Learn when to ask for help</h3><p>In this article, we are talking about how to get the most out of our time from a developer perspective. Basically, if you can be sure you are doing your assigned tasks the fastest and better you can I’m sure you are doing great.</p><p>Sometimes you will find some roadblocks or you will have some doubts when developing some tasks. In this case, you have two options: you can try to solve all problems on your own, or you can ask for help from your tech lead or a teammate.</p><p>It might sound obvious but asking for help is not easy for many people so they spent a lot of hours fighting problems that could be solved in a matter of minutes if they had asked for help.</p><p>So, believe me, it’s better to ask for help and show some of your weaknesses but finish your tasks on time than trying to hide your need for help delaying tasks, and not adding all the value you can.</p><h3>Time management techniques</h3><p>Now that you know some tips to improve time management with a focus on your day-to-day as a software developer it’s time to get some info about time management in general.</p><p>All time management techniques focus on two main things: stay focused for a period of time and create habits around this topic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0QByU_wxeoEY_PQZ7cn4oQ.jpeg" /></figure><p>Here you have an intro with some info about some of the most popular time management techniques:</p><ul><li>Pomodoro: take a task and set a timer for 25 minutes to work on it. When the timer rings, take a 5-minute break, then continue working on this task or a new one. After four rounds or “pomodoros” you should take a longer break of about 15–30 minutes.</li><li>Flow time: similar to Pomodoro but without working time restriction. Just pick a task and start working on it and write down the time you begin. When you feel tired or start to procrastinate, just take a break. If working time is under 25 minutes the break time should be 5 minutes, if working time is between 25 and 50 take 8 minutes break, if the working time is between 50 and 90 minutes take a 10 minutes break, and for working time above 90 minutes take 15 minutes break.</li><li>Don’t break the chain (Seinfeld’s) method: this technique it’s about committing to do one thing every day to create a habit. You should mark each day you do things right with a red cross so you will have visual feedback on your progress. The idea is to not break the chain of red crosses for any reason. This technique it’s really good to improve tiny habits so it will help you to apply all the other tips commented above.</li></ul><p>You can choose one of these tasks or another one that works for you. The important thing here is that you know where to start if you want to improve your time management skills.</p><h3>Bonus: Gamification is your bestie</h3><p>I know that changing a way of doing things could be very daunting and overwhelming. Don’t get upset, creating a new habit it’s complicated and takes time.</p><p>If you are like me, sometimes you need some “external” help to stay motivated you can rely on gamification.</p><p>The idea is to use an application to get rewards when you are doing good and reminders or alerts when you don’t.</p><p>You can find a ton of time-tracking apps that include gamification features for web, Android, and iOS like Epicwin, HabitHunter, etc. Just make sure it supports the time tracking or productivity technique you are using.</p><h3>Wrapping up</h3><p>Time management is one of the most essential soft skills to become a senior developer.</p><p>It’s really useful because it allows you to stay focused on tasks that matter the most for the company so you can be sure you are adding a lot of value.</p><p>To improve your time management skills you should:</p><ul><li>Identify important and urgent tasks</li><li>Plan ahead your tasks</li><li>Avoid multitasking</li><li>Rely on time boxing for recurrent tasks</li><li>Ask for help when you are stuck</li></ul><p>In addition to these tips, you can use a more traditional time management technique like Pomodoro or Flowtime to stay focused and control your timing.</p><p>A little bit overwhelming? Don’t worry! If you need some extra motivation you can use a gamification app to help you create your new time management habit.</p><h3>Level Up Coding</h3><p>Thanks for being a part of our community! Before you go:</p><ul><li>👏 Clap for the story and follow the author 👉</li><li>📰 View more content in the <a href="https://levelup.gitconnected.com/?utm_source=pub&amp;utm_medium=post">Level Up Coding publication</a></li><li>💰 Free coding interview course ⇒ <a href="https://skilled.dev/?utm_source=luc&amp;utm_medium=article">View Course</a></li><li>🔔 Follow us: <a href="https://twitter.com/gitconnected">Twitter</a> | <a href="https://www.linkedin.com/company/gitconnected">LinkedIn</a> | <a href="https://newsletter.levelup.dev/">Newsletter</a></li></ul><p>🚀👉 <a href="https://jobs.levelup.dev/talent/welcome?referral=true"><strong>Join the Level Up talent collective and find an amazing job</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1fe62c4438e" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/how-to-manage-time-like-senior-developers-d1fe62c4438e">How to manage time like Senior Developers</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The art of caching for backend applications]]></title>
            <link>https://levelup.gitconnected.com/the-art-of-caching-for-backend-applications-38350f95def6?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/38350f95def6</guid>
            <category><![CDATA[application-performance]]></category>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cache]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Tue, 10 Jan 2023 17:17:37 GMT</pubDate>
            <atom:updated>2023-03-22T17:59:51.629Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*knlyvigzX1TZyhrT4ZPXjQ.jpeg" /></figure><p>Caching is a common technique we use when creating our applications to increase performance by storing frequently-used data in ephemeral but fast storage. A cache can help you to reduce the amount of time that an application takes to access that data, which can improve the overall user experience and make the application more responsive.</p><p>When you have enough experience programming you start learning new things apart from the typical frameworks, libraries, design patterns, etc. One of these is how you can manage your information to improve your application performance, and here it’s where a cache comes in place.</p><p>In this article, we will explore the basics of caching in software development and discuss some of the key considerations when implementing a cache for your application.</p><h3>What is caching?</h3><p>First of all, we need to explain in depth a little bit more about caching.</p><p>As we said, caching is a way to store data in a temporary location so that it can be accessed faster and more scalable by our application.</p><p>This can be useful for reducing the amount of time that an application takes to retrieve data that is used frequently, such as the results of a database query or the contents of a frequently-visited web page. By storing this data in a cache, the application can access it faster the next time it is needed, which can improve the overall performance of the application dramatically.</p><p>This is the main reason why it’s very important for a software developer to master all aspects of caching and use it to make faster and more reliable applications.</p><p>This is the theory but, a lot should be said when you are going to implement a cache.</p><h3>Key features of a cache</h3><p>Before coding anything or installing the new trendy cache engine you need to think about the key aspects of a cache and make a lot of decisions.</p><p>Depending on your use case, the resources you have, the programming language you are using and the way your application is going to use the data, you will choose a different kind of cache and a different configuration for it.</p><p>The main parameters you should pay attention to are the following:</p><ul><li>type of cache: you can choose to store data in a local or distributed cache</li><li>data to store: you can choose between storing data as is or compiling it to save time for future usages in your app</li><li>filling strategy: you can implement a lazy or eager cache depending on your use case the strategy chosen could improve or ruin your performance</li><li>size of cache: you need to know the amount of data you are going to store because it will define the number of cache entries you can store</li><li>keys: you should pay attention to the key or keys you use to store your data so it’s searchable the way you need it</li><li>TTL (time to live): is another essential parameter that defines how long data will be stored in the cache</li><li>eviction policy: this policy decides when a particular key will be removed from the cache to store new data</li></ul><p>I know… there are a lot of parameters to configure and a ton of decisions to be made even before you write a single line of code… that’s why a cache it’s so amazing!</p><p>To make it easier we will review some of the most important in the following sections.</p><h3>Local or distributed cache</h3><p>Essentially we can identify two types of cache: local or distributed.</p><p>A local cache works in the same machine that is going to use the information. In other words, a local cache uses the same machine resources as your application does.</p><p>You can find two approaches to implementing a local cache: memory-based or disk-based</p><p>A memory-based cache stores data in memory that could be inside your application memory or using another process, shared memory, etc. The main advantage of this implementation is that it is the fastest way to access data. On the other hand, it has a particular caveat and it’s that data is only available as long as the cache engine is running.</p><p>A disk-based implementation uses disk storage which is slower than memory but can be persisted even if the application restarts. Another advantage is that usually, disk is cheaper and bigger than memory so you can store more data at lower costs.</p><p>A distributed cache works across a network and multiple machines access it, it’s useful to scale applications and to share data between different servers supporting huge applications. The typical way to implement these caches is to install an instance or a cluster of a specific cache engine server. These systems are meant to scale horizontally so it’s very common for them to have some features like clustering and sharding out of the box.</p><p>Which one is better? It depends on your use case… Because we have thousands of use cases for a cache, you have thousands of options to choose from. I have created the following comparison table to help you choose between a distributed or local cache for your application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/0*liuTUD6Bcd5jir2w" /></figure><p>As you can see local and distributed caches are really different, but both make a lot of sense depending on your use case.</p><p>Let’s say you have data, like for example, weather information for a particular city and you want to cache it. In this example data it’s the same for all requests, doesn’t change so often and it’s small (in size). This use case could use a small local cache in disk or memory so you will avoid scaling a remote cache if you have a lot of requests.</p><p>Another use case that will need a distributed cache could be a requests access control system. These systems, for example, will store a cache with information about the number of requests per minute per API user. So you need to have all the information from all servers in a shared database to count all requests properly. In this use case, you need to use a distributed cache so you can share the information between all servers.</p><p>Important to notice that here we are not speaking about a particular technology. It is because you can implement local or remote cache using the same technology in most cases. For example, you can use a Redis instance for a local or remote cache. Some of you could think it’s a lot of overengineering but makes a lot of sense if you want to change a local cache for a distributed one in the future. In this case, you will be able to use the same technology without changing a single line of code of your application.</p><h3>Choosing the best filling strategy</h3><p>When we talk about the filling strategy we are talking about the way data will be inserted into the cache. Here we have two ways to do it: eager or lazy.</p><p>If you are going to use an eager approach it means you can handle a miss in your cache so you will insert or update data on a regular basis, but it doesn’t matter if some data is missing in your cache. The best way to implement this approach is using a background process that compiles data and loads the data in your cache.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tCgrfQDtOSDHOyII" /></figure><p>The lazy approach assumes that you cannot miss information in your cache so basically, your application should try to fetch data from your cache and if a miss occurs the app will go to a secondary data source (usually a relational database) to fetch the information and then insert it in the cache for future usages. To implement a lazy approach you need to create a logic to access your data in your application to handle missing data and use a fallback. Depending on your programming language or framework you will find different options to do it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xaEU1AO5LzXWVwRL" /></figure><p>Ok but… what about a hybrid approach? Great question! For sure you can combine both strategies and, in most cases, it’s the best option if you want to get the most performance without missing any data.</p><h3>Designing your keys</h3><p>The most important aspect is that the keys should be searchable for your application so you need to pay attention and take your time to make the right decisions here.</p><p>Keeping this in mind, you should adapt your keys to the way your application is going to retrieve data. So, if your application is going to retrieve data based on let’s say “product_id”, you should create a key using this information, for example, a key could have this format:</p><pre>product-info:123</pre><p>If your application needs multiple parameters you can concatenate all necessary parameters to create your key. For example, you would want to store product information with translations per language, like product description, etc. In this case, a valid key could have the following format:</p><pre>product-info:123:en<br>product-info:123:es</pre><p>A common pitfall when choosing keys is storing huge amounts of data inside the same key. Because the cache systems are very fast indexing and managing information it doesn’t mean that they are not affected by network speed. So, if you are using a distributed cache you need to pay attention to the size of the data you store inside each key because it will be transferred through the network.</p><p>To avoid this problem you can split your cache into several keys with specific information depending on how your application will use it.</p><p>In the example we mentioned before, instead of storing all localized information in the same key you can split it in two. In one key you can store generic information like price, rating, packing size, etc. and use another key to store localized information like description, name, etc.</p><p>This way you are going to have two keys, like this:</p><pre>product-info:123<br>product-lang:123:es<br>product-lang:123:en</pre><p>Your application can use whatever is needed while retrieving the least data on each request.</p><h3>Calculating the best TTL value</h3><p>Another important parameter in your cache is TTL (time to live).</p><p>As said before, TTL is like the expiration date of your data and defines when the value of a particular key could be deleted or replaced, so it’s no longer available for your application. Choosing the correct TTL is important to maximize your cache hit ratio without having deprecated data.</p><p>A high TTL value will increase the hit ratio but could turn your cache into an unusable source of information because the data is not up to date. If the TTL value is low your hit ratio will be lower but the information will be refreshed very often.</p><p>You can configure a static TTL value, the same for all keys, or a dynamic one, a different value depending on any key parameter. It’s very useful to define dynamic TTL values so you can improve the hit ratio keeping important keys up to date. For example, you can assign different TTL values for each type of product, language, etc.</p><h3>Configuring the correct eviction policy</h3><p>The last important parameter to configure your cache is the eviction policy. It decides which key will be deleted or replaced to store new information.</p><p>The most common eviction policies are:</p><ul><li>random: removes any key</li><li>LRU (least recently used): removes the key that was not used recently</li><li>LFU (least frequently used): removes the key that was not accessed very often</li><li>TTL-based: removes keys nearly to expire</li></ul><p>Each strategy has pros and cons but as a quick reference, you could use them as follows.</p><p>You can use random eviction policy when you don’t expect a key to be used more than others, and it’s a good default strategy to start caching.</p><p>If your cache has some keys that are accessed very often you should use LRU or LFU eviction policies so you want to ensure to preserve the most popular keys.</p><p>If your cache uses different TTL values for each key a good option is to use a TTL-based eviction policy so you preserve keys with higher TTL which could be more important.</p><p>Choosing an eviction policy sounds a little tricky but in reality, is a matter of trial and error. Usually changing the eviction policy doesn’t break the cache so you can try one and change to another one to see if it’s better for your use case.</p><h3>What is the best technology for my cache?</h3><p>Finally, we should talk a little bit about specific technologies or engines you can use to implement your cache.</p><p>First of all, let’s talk about local caches. You can use your hard drive to implement a cache. Yeah, I know… it’s not a proper engine but, for some use cases of local cache, caching information in a local file it’s more than enough and for sure it’s the easiest way to do it.</p><p>The most used engines are in-memory databases, you can use them for local and remote caches. They are blazing fast and really easy to use because you don’t need to create indices and configure endless parameters. This kind of database could have some problems because some engines will clear all data if the process is restarted. Some examples of this technology are Redis and Memcached.</p><p>Of course, you can use any database engine with more traditional capabilities (indices, expressive queries, etc.) NoSQL databases are very interesting to implement a cache because they support a really huge amount of requests per second. These kinds of databases have one advantage which is that they support data persistence when restarting the process and allow you to query your data (filtering, projections, etc.). In this group, you can find some databases like MongoDB, Elasticsearch or Cassandra.</p><p>In case you decide to use a distributed cache, you need to check the horizontal scalability options the different technologies have and the additional costs. For example, if you deploy a cluster or HA architecture your setup will start with at least three instances, so the costs will at least triple if not quadruple.</p><p>As you can see there is no one technology that is better than the other, but any of them could be a good one for your cache.</p><h3>Conclusions</h3><p>As a brief summary, a cache is a way to store the most used data of your application to increase the performance of your application.</p><p>The most important features of a cache are:</p><ul><li>type (local or distributed)</li><li>the filling strategy</li><li>how do you define the keys</li><li>the TTL you choose to improve the hit ratio</li><li>the eviction policy to delete data</li></ul><p>The most important thing is to ensure you have a proper hit ratio to increase your application performance as much as possible.</p><p>You can use specific technology like Redis or Memcache which are in-memory databases specially designed to create the cache, or you can use other engines like NoSQL databases (MongoDB, Elasticsearch, etc.) which are designed to handle a high number of requests and allow you some advanced features like filtering, etc.</p><p>Implementing a cache for an application it’s easier than it seems and it’s a wonderful experience when you see the increase in performance you get and how configurable these kinds of technologies are.</p><p>Good luck and cache it all!</p><h3>Level Up Coding</h3><p>Thanks for being a part of our community! Before you go:</p><ul><li>👏 Clap for the story and follow the author 👉</li><li>📰 View more content in the <a href="https://levelup.gitconnected.com/?utm_source=pub&amp;utm_medium=post">Level Up Coding publication</a></li><li>🔔 Follow us: <a href="https://twitter.com/gitconnected">Twitter</a> | <a href="https://www.linkedin.com/company/gitconnected">LinkedIn</a> | <a href="https://newsletter.levelup.dev/">Newsletter</a></li></ul><p>🚀👉 <a href="https://jobs.levelup.dev/talent/welcome?referral=true"><strong>Join the Level Up talent collective and find an amazing job</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38350f95def6" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-art-of-caching-for-backend-applications-38350f95def6">The art of caching for backend applications</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[23 software development resources for 2023]]></title>
            <link>https://medium.com/@darode/23-software-development-resources-for-2023-9e93f1fc5952?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e93f1fc5952</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Wed, 28 Dec 2022 21:38:09 GMT</pubDate>
            <atom:updated>2022-12-28T21:38:09.080Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VcF3q6oaQihWdZP-GQ5Emg.jpeg" /></figure><p>This year is coming to an end. It’s time to celebrate, enjoy the holidays and spend time with family and friends. It is also time to wrap up and set goals for the new year so we can improve as developers and stay up to date.</p><p>If you are thinking about climbing a step and evolving as a software developer next year this is the right article! Here is a list of 23 resources to improve in some areas in this new year 2023.</p><p>I’ve curated a list of valuable articles, books and other resources to start learning in the areas I think will be key for software developers next year.</p><p>The topics cover a range from software architecture, to cybersecurity to soft skills all of them with a few sub-topics to dive a little deep into and get curious to keep learning about them.</p><p>No more hassle and dazzle, here is the list.</p><p><strong>Software architecture</strong></p><p>1.- Clean architectures: will help you to create testable and more maintainable code, you can learn more <a href="https://betterprogramming.pub/the-clean-architecture-beginners-guide-e4b7058c1165">here</a>.</p><p>2.- DDD: (domain-driven design) reduces software complexity for huge systems and brings code closer to business, you will find a great article about it <a href="https://medium.com/microtica/the-concept-of-domain-driven-design-explained-3184c0fd7c3f">here</a>.</p><p>3.- Observability: allows you to reach the next level in your application understanding and helps you when debugging changes over time in your code, you can find a great book about it <a href="https://www.oreilly.com/library/view/observability-engineering/9781492076438/">here</a>.</p><p><strong>Testing</strong></p><p>4.- TDD: (test-driven development) it’s a basic approach to creating applications nowadays and every developer should master it, you can begin with <a href="https://www.oreilly.com/library/view/test-driven-development/0321146530/">this book</a>.</p><p>5.- End-to-end testing: testing applications from a user perspective it’s really useful to ensure everything works as expected, if you want to learn more check <a href="https://medium.com/de-bijenkorf-techblog/how-to-use-cypress-for-end-to-end-e2e-testing-beb1aa82696a">this article</a>.</p><p>6.- BDD: (behavior-driven development) allows you to test your application based on business requirements using a common language, you can start learning <a href="https://blog.testlodge.com/what-is-bdd/">here</a>.</p><p><strong>APIs</strong></p><p>7.- graphql: with it you can create flexible APIs and empower your frontend applications, you can find more info <a href="https://graphql.org/learn/">here</a>.</p><p>8.- json schema: it’s a way to validate JSON API and will make easier to enforce the correct usage of your API and improve security, you can learn about it <a href="https://json-schema.org/">here</a>.</p><p>9.- openapi: a well-documented API it’s a must nowadays to improve your team productivity in this new software integration era, you can check some info <a href="https://swagger.io/specification/">here</a>.</p><p><strong>New programming languages</strong></p><p>10.- rust: it’s a relatively new programming language for building cross-platform applications and could be very useful as a second programming language, you can find everything about it <a href="https://www.rust-lang.org/">here</a>.</p><p>11.- typescript: a must for frontend and javascript developers in general to reach the next level, you can start learning <a href="https://www.typescriptlang.org/">here</a>.</p><p>12.- go: one of the best programming languages to create scalable applications easily, to start learning more about it check more info <a href="https://go.dev/">here</a>.</p><p><strong>Data/IA</strong></p><p>13.- machine learning basics: it’s a new way to create algorithms and could be helpful for your project, so learning about it could be very valuable, you can learn the basics <a href="https://www.ibm.com/downloads/cas/GB8ZMQZ3">here</a>.</p><p>14.- data visualization: knowing your data it’s crucial if you need to work with huge amounts of data and creating visualizations it’s the best way, start learning the basics <a href="https://www.tableau.com/learn/articles/data-visualization">here</a>.</p><p>15.- gaan neural networks: if you need to create IA application it’s important to know what’s going on under the hood even if you are going to use a prebuilt library, you can get some basic information <a href="https://www.ibm.com/cloud/learn/neural-networks">here</a>.</p><p><strong>Cybersecurity</strong></p><p>16.- web app security: if you create web applications you need to know about csrf, xxs, sql injection attacks to ensure your application follows a good quality standard, check <a href="https://medium.com/nerd-for-tech/devsecops-basics-where-to-start-aa7babee4ac4">this article</a> to learn the basics.</p><p>17.- digital certificates: it’s a basic building block for secure applications nowadays and learning the basics about them could be very valuable for your projects, you can find more info <a href="https://www.okta.com/identity-101/digital-certificate/#:~:text=Digital%20certificates%2C%20also%20known%20as,internet%20in%20a%20secure%20manner.">here</a>.</p><p><strong>Softskills</strong></p><p>18.- effective communication: improving communication with stakeholders, product managers and other business colleagues it’s crucial to grow as a software developer, you can find some tips to improve your communication skills <a href="https://askcloudarchitech.com/posts/self-improvement/communicate-effectively-web-developer/">here</a>.</p><p>19.- business orientation: the more you understand the business the better your code will be, you can learn more about it in <a href="https://medium.com/@darode/what-makes-a-developer-a-top-performer-fd39433d4aa0">this article</a>.</p><p><strong>Devops/System</strong></p><p>20.- docker: it’s the new standard to package and deliver your applications and it’s definitely a must for every developer, you can learn more about it <a href="https://docs.docker.com/get-started/">here</a>.</p><p>21.- kubernetes: if you work with large systems this is your solution to deploy a flexible architecture in a matter of seconds, you can start <a href="https://kubernetes.io/es/docs/concepts/overview/what-is-kubernetes/">here</a> to learn more about it.</p><p>22.- serverless: it’s a new way to deploy applications without taking care of servers and endless configurations and it’s very easy to scale, you can learn all the basics <a href="https://levelup.gitconnected.com/aws-serverless-architecture-for-dummies-fc9622908c2e">here</a>.</p><p>23.- ci/cd: allows you to ship your applications to production in a reliable and automatic way, you can learn the basics about it <a href="https://www.guru99.com/ci-cd-pipeline.html">here</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Vz3vPUpKnYCmZldn" /></figure><p>That’s all folks! I hope this list helps you on your way to becoming the best developer ever.</p><p>If you miss something or you know a better resource please let me know in the comments.</p><p>I wish you the best for 2023 and … keep coding ;-)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e93f1fc5952" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing a highly scalable e-commerce site for dummies.]]></title>
            <link>https://levelup.gitconnected.com/designing-a-highly-scalable-e-commerce-site-for-dummies-947e0f6665fe?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/947e0f6665fe</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[high-scalability]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Tue, 01 Nov 2022 03:02:24 GMT</pubDate>
            <atom:updated>2022-11-01T03:02:24.739Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aHusJsW-dTKeyv8PX_tpUg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@tranmautritam?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Tran Mau Tri Tam ✪</a> in <a href="https://unsplash.com/es?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>This is the third article of a series on how to create and develop high-scalability backend applications. You can check the <a href="https://levelup.gitconnected.com/scaling-backend-applications-for-dummies-31c713ec04a4">first article</a> about some basic concepts and the <a href="https://levelup.gitconnected.com/high-scalability-patterns-for-dummies-da1f7d2a7873">second one</a> about how to apply high-scalability patterns in your applications.</p><p>In this article, we are going to focus on how to scale a real-world backend application using all knowledge we got from previous articles.</p><p>We are going to pay special attention to changes in architecture to achieve the so-wanted high scalability in our application.</p><p>Disclaimer: This article is intended to be an introduction to this topic so I’m going to skip a lot of things like configuration files, deploy environment configurations, etc. For the same reason, some architectural changes won’t be proposed or explained like a heavy refactor to use microservices extensively. I want to keep the explanation easy to follow for non-experienced developers.</p><p>Let’s move on and get some information about our project!</p><h3>Project definition and initial system architecture</h3><p>First of all, we need to define the project we are dealing with and some initial architecture.</p><p>The website we are going to work with is a regular e-commerce website, something like Amazon, a retail website, Shopify, etc. So basically think about any regular e-commerce website that has bi-directional communication with the user sending emails when a purchase is made, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TFrmd3ilroaK3zw-" /></figure><p>The main use cases for users are the following:</p><ul><li>see offers</li><li>list products</li><li>see product details</li><li>checkout</li><li>send an e-mail to confirm the purchase</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PXS8plupI5Vyi3jy" /></figure><p>Our project is a monolith with all features encapsulated but developed using the same code base. So it could be easy to separate each feature in a different application, but for now, it was not a technical requirement because the technical debt was not so high.</p><p>In the same way, every feature is using a common typical MySQL database to store all information about products, orders, discounts, campaigns, etc.</p><p>In brief, we are in front of a successful MVP application that is going to get bigger and bigger over time. It’s working but it’s near to reaching the point where technical debt starts to be a problem to develop new features and maintain existing ones.</p><p>So… suddenly one day our Product Manager told us that because the company is growing and sales are going well, the marketing team is preparing a huge campaign to increase sales for Black Friday.</p><p>The technical team is really happy because of the good news but, soon all of them start to realize that the application is not prepared for that. A lot of work must be done in order to get good response times and to handle the huge amount of traffic expected.</p><p>Does it sound familiar? Did you face some similar situation?</p><h3>Analyzing and improving</h3><p>After that change in the product roadmap, all the people on the technical team started to think about how they can improve the application to face the huge Black Friday campaign.</p><p>First of all, they need to spot current performance problems and new ones that could arise when the number of requests starts to increase. To do it they set up an observability dashboard with Kibana and Elasticsearch to get some detailed metrics about performance and APM information.</p><p>After that, they started to measure the performance of current customer requests, page load, database slow queries, etc. With all this information they could spot some issues that could seriously affect the Black Friday campaign.</p><p>The main issues found were:</p><ul><li>sometimes sending the purchase confirmation e-mail takes too much time</li><li>offers page performance sinks on peak hours</li><li>product list and product details page performance decreases during peaks and a lot of slow queries related to these features were spotted</li><li>writing checkout information timing metrics have peaked during the busiest hours</li></ul><p>As you see they could identify four different issues that should be resolved before launching this new campaign.</p><p>Each issue could be solved using a different high scalability pattern so in the next sections we are going to make changes in the initial architecture of the e-commerce website to improve it.</p><h3>Scaling horizontally</h3><p>The first thing that the technical team did was to add more servers to increase code execution speed. Yes, they applied horizontal scaling to increase performance.</p><p>The changes in the system were minimum. All servers will execute the same code and will be updated accordingly using the CI/CD tool. A Load Balancer was put in place to distribute the requests to a pool of servers that will execute the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qTWuvxHnfKdT-zB7" /></figure><p>One of the important changes was to modify the database architecture to create a primary-secondary architecture. The primary server will remain common to all servers in the pool and every server in the pool has one secondary copy of the database for read-only purposes. Some changes in the code were needed to adapt repositories to use primary or secondary servers when needed but the changes were minimum because they didn’t change the database engine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pKxHXW-541OM61h2" /></figure><p>These changes improved the performance during peak hours but didn’t solve all problems, so the team kept improving the system.</p><h3>Using background processing</h3><p>The second problem the team solved was that sending the purchase e-mail was really slow sometimes. This problem happens on a particular part of the system and affects a specific feature of it so they explored another solution.</p><p>Sometimes the “sending email” feature was really slow due to problems connecting to the external email server. Because it’s not a critical feature the execution of this code could be deferred to send the email later on so the team solved the issue by applying a background process pattern.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F2Ccxm6Tm6JyZSPn" /></figure><p>The team created a microservice to refactor this feature to run all this business logic. The microservice and the monolith will communicate using an event bus. This way the main code will execute the purchase process and will send an event to the bus to send the email later on.</p><p>An event bus is a method to send messages between microservices or different parts of the system so it’s a really good improvement to defer more actions in the future for other parts of the system.</p><p>Now the application is more prepared, but there are some other things that could be done in order to prepare the application to deal with all requests of the Black Friday campaign.</p><p>Caching data</p><p>The next improvement was focused on the performance of offers, product lists and product detail pages. Previously the team improved performance for the whole system by enabling horizontal scaling but some specific improvements in these pages were needed.</p><p>To improve these pages specifically, the team choose to use caches to get lower response times and to allow these pages to handle more queries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2uDZUgu8gAmgMm0k" /></figure><p>The team chose to use two cache instances with different logic to store and fill their data.</p><p>The first one will store product information and will use a lazy approach to fill in the data. It means the data will be stored in the cache when the business logic gets the results from queries from the main database. This approach has some drawbacks and it’s that when data is not in the cache the performance is not so good. But on the other hand, this cache has lower maintenance because it fills by itself.</p><p>The second cache will store offers information and will use an eager approach to fill in the data. In this case, the team created a process that stores the offers’ data by compiling it from information located in the main database. This approach is really good because it will give the best performance because the system will always retrieve information from the cache. But it has some issues, the system will only be able to use data stored in the cache, so if some data exists in the main database but not in the cache couldn’t be retrieved.</p><p>Sharding main database</p><p>The last problem that the team should fix to get a robust system is the one related to performance on writes into the main database during peak hours.</p><p>To improve write performance one of the best solutions is to use sharding in the database layer. It requires a lot of changes because usually involves changing the database engine which means doing a lot of changes and refactoring in the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5Ll1pJvc5Vg25yAt" /></figure><p>In this case, the team choose to change the main database that uses MySQL to a NoSQL database based on MongoDB. This change as said before required a lot of changes in code to adapt data repository classes to use this new database engine.</p><p>It was really challenging and required a lot of effort, but it allowed the system to handle thousands of write requests and made the system more robust.</p><h3>Conclusions</h3><p>When you are about to improve your application performance your first step should be a deep analysis to know metrics about the performance of different parts of your system.</p><p>The next step is to create a strategy to solve all issues detected in the initial analysis. The most common ways to solve performance issues are horizontal scaling, implementing caches and background processing.</p><p>To improve the performance of your whole system you should mix and match all scalability patterns to increase both performance and the number of handled requests. In this example, you can see that scaling and application is an iterative and incremental process.</p><p>My recommendation is that scaling and performance issues should be resolved as any other bug. So you don’t need to do big refactors as one-off projects but do regular small improvements in your maintaining your system.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=947e0f6665fe" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/designing-a-highly-scalable-e-commerce-site-for-dummies-947e0f6665fe">Designing a highly scalable e-commerce site for dummies.</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[High scalability patterns for dummies]]></title>
            <link>https://levelup.gitconnected.com/high-scalability-patterns-for-dummies-da1f7d2a7873?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/da1f7d2a7873</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[high-scalability]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Mon, 17 Oct 2022 00:42:10 GMT</pubDate>
            <atom:updated>2022-10-17T00:42:10.838Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0KhqTi9CTC3LOC4O" /><figcaption>Photo by <a href="https://unsplash.com/@soberanes?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Uriel Soberanes</a> on <a href="https://unsplash.com/es/s/fotos/martial-art?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>This is the second part of a series of articles where I’m covering the basics of scaling backend applications.</p><p>In <a href="https://levelup.gitconnected.com/scaling-backend-applications-for-dummies-31c713ec04a4">the first article</a>, we talked about some concepts and procedures to ensure that you are scaling when and how it is needed, you can read the full article here.</p><p>In this second part I want to focus on some advanced techniques to scale applications, why you need them and some examples of implementing based on real world problems, let’s go!</p><h3>About scaling patterns</h3><p>Usually when you are scaling your application you start by applying one technique and then another one depending on the problems you are facing. So basically your application starts to be more scalable because of the sum of improvements every pattern gives you.</p><p>There is no specific way to apply this patterns because each application is different, but if I should write down a guide to scale an application applying these patterns would be something like this:</p><ol><li>Ensure you checked the basics (database and code optimization)</li><li>Scale vertically</li><li>Scale horizontally</li><li>Implementing a caching system</li><li>Implement database sharding</li></ol><p>I will apply these patterns in this particular order just because it solves the most common issues you are going to face as your application usage increases.</p><p>When you have some experience developing systems that support a huge load you will skip some patterns because they won’t help you so much. I will explain a little bit more in the next sections but first of all let’s get more information about the patterns themself.</p><h3>About vertical and horizontal scaling</h3><p>At this point I want to talk about the differences between vertical and horizontal scaling and when to use one or the other.</p><p>Vertical scaling is when you add more resources to the same application but using the same amount of servers. For example let’s say we have a website and we use one server to run it. If we want to scale vertically we will change the CPU for a faster one, we will add more RAM, we will change disk for a faster one, etc.</p><p>Horizontal scaling refers to the action to add more resources to run an application but increasing the number of servers. Using the previous example, if we want to scale horizontally our website we will add a second server instead of improving the existing one so we will get twice the power to run the application.</p><p>When you scale to add more resources you increase the costs of running your application, depending on the hardware requirements of your application scaling vertically adding powerful hardware could be as expensive as running another server to scale horizontally.</p><p>Both options have some pros and cons, and some use cases that make one of them the best option. For example, if you are running a stateless application without sessions, scaling horizontally is the best option, because in addition to gaining more power you will get high availability for your application. On the other hand if your application has a strong dependency on local resources inside the server, scaling vertically could be the fastest way to get more performance before doing a big refactor of your application to scale horizontally.</p><p>One important thing is that vertical and horizontal scaling patterns don’t belong to a particular technology, they apply to almost every application from web servers to databases. Usually each application has its own scaling capabilities built in.</p><h3>About caching, sharding and high throughput databases</h3><p>Now it’s time to introduce some scaling concepts related to databases and data usage in general.</p><p>When we say caching we are talking about compiling the information and storing it in a way that is faster to access and requires less resources. With this we can support more requests with low response times. This pattern is applied to improve database access as a first layer before reaching a slow database. We will see how it works in the following sections.</p><p>Sharding is a concept of data distribution and refers to the way we can distribute the information between different database instances in different servers. Usually when we scale databases horizontally we do it to read information but the typical architecture has only one primary server. It has a big problem if your application needs to write a lot of information and it’s where sharding comes to solve this problem. We will talk more about sharding in the following sections.</p><p>If I should define what is a high throughput database I will say that it’s a database that was implemented with horizontal scalability and sharding capabilities out of the box. It means that you just need to install and configure your database to handle millions of requests without touching a line of code.</p><h3>A scaling pattern for every problem</h3><p>As said, every pattern was thought to solve a particular problem or set of problems your application will face when increasing the number of requests to your system. We saw all the details about the patterns and it’s time to see how they can help us.</p><p>Vertical scaling allows you to handle a slight increase in your requests but won’t help you to reach hundreds of millions of them. It’s really useful in the early stages of your application but you will need to start scaling horizontally soon.</p><p>Horizontal scaling will help you handle millions of requests and should be applied to each part of your application. It means that you will need to scale horizontally your application servers, your database servers and so on.</p><p>Caching will help you to increase the number of requests your application can handle by avoiding overloading some parts of your systems like databases. Caching could be used to store the response of your application so basically you can skip even the process of the request itself but it’s really useful to reduce database queries. Sometimes you need a slow but reliable database engine to store the information and caching some information will help you to reduce response time and increase performance.</p><p>Sharding your data will allow you to handle both more read and write requests to your database or application. You can implement your own sharding algorithm, it’s easier than it seems, but I recommend using existings solutions like some database engines that have sharding support built in.</p><p>Using high throughput databases it’s really useful when the bottleneck of your application is the database. Usually it’s about using NoSQL databases like MongoDB, Redis, CouchDB, Cassandra, etc. these databases use a new approach to manage data and most of them implement horizontal scalability and sharding capabilities out of the box.</p><p>We have learned a lot of theory about scaling, its patterns and how they help us to improve our application performance. Now we will see how they work and how we can use them in our systems.</p><h3>How to scale horizontally</h3><p>Usually, you scale horizontally when some part of your application is overloaded. Let’s say your application server or web server is running out of resources (CPU, ram, etc) you can add more servers to deal with it.</p><p>The most common architecture to scale horizontally involves using a Load Balancer. A load balancer is an application that distributes requests, typically HTTP or TCP requests, across a pool of servers. Using a load balancer you can scale your application to the sky by just adding servers to the pool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XgF0_0tG1NtGsubf" /></figure><p>Some applications like databases supports horizontal scaling out of the box. The most common strategy available to do it is the primary-secondary replication. You can have one primary server and multiple secondary or replica servers. Ideally you will make a lot of read requests using secondary servers and use the primary just for write requests. The data would be replicated from primary to secondary automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Tt3_D5NHYvQikkOU" /></figure><p>Scaling horizontally has many implications and sometimes could involve big refactorings and huge infrastructure changes. But despite all of that it’s the only way to add more resources when your application needs to handle more requests effectively.</p><h3>How to implement a caching system</h3><p>One of the basics scaling patterns is caching and it’s about using specific high performance databases to serve data.</p><p>When you implement a cache system you use a two steps process to fetch data. First you will try to use data inside a cache database because it’s faster, if data is not present in cache you will query your, typically, relational database to gather the information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ko8vO8GOzfvGIaMJ" /></figure><p>You can use several kinds of databases like in-memory databases, key-value databases or NoSQL databases, depending on your requirements some are more appropriate than others. For example, if your cache requires complex queries, maybe a NoSQL database it’s more flexible than a simple key-value, but if you need pure speed and performance key-value in memory databases are the best options.</p><p>Besides choosing database type, you need to think about what information you are going to store in cache and how. Knowing what information to store it’s really easy, you need to cache the information for two reasons: it’s widely used in your application or it’s really slow to fetch it from the database.</p><p>Choosing how to store the data could be a little more tricky, the most common way to do it is to store data using structures as close as you will need to use it later on in your code. For example, if you are caching a slow query from a relational database you will cache the result of this query.</p><p>Usually caches are filled in two ways: storing data on the fly or compiling information using background processes. If you cache data on the fly you are storing query results or business logic data treatments results into cache for following requests. If you use background processes to fill your cache you are compiling the information before it’s retrieved in your code. Both approaches are useful and can be used at the same time.</p><p>Another important thing is that you can implement as many caches as you need using different strategies so it’s up to you to get the most of this pattern to improve your application’s performance.</p><p>If you want more information you can check some technologies like: Redis, MongoDB, CouchDB, Cassandra, etc. to know more about high performance databases and caching.</p><h3>Implementing database sharding</h3><p>When talking about horizontal scaling we said that some database engines have built in horizontal scaling, but for read only queries. The most advanced database engines support horizontal scaling for write queries and they usually do it by implementing database sharding.</p><p>Database sharding literally splits your data into several groups of servers called shards. Every shard usually has at least three servers (one primary and two secondaries) to ensure availability and to support write and read for its portion of data. If you have two shards you can handle twice write requests, if you have four shards you can handle four times write requests and so on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EKwyJzPJaim4vDHu" /></figure><p>In my experience database sharding it’s not always a requirement to scale horizontally your application, you just need to use it when you need to scale write requests to your database.</p><p>Depending on the database engine sharding could be very easy to implement (like MongoDB) or could require you to write your own code to manage sharding.</p><p>Anyway, sharding requires advanced configurations and has many implications so you need to be sure before using it to avoid over engineering.</p><h3>Conclusions</h3><p>If your servers are running out of resources, scaling your application will solve your problems. You should select a scaling pattern depending on the problem you are facing.</p><p>The easiest and fastest way to make your system run faster is to implement a cache system. You should take into consideration two things: database engine and data structure. Depending on how you are going to access and store your information, data structure and database engines will differ.</p><p>Without any doubt the best way to have a reliable and scalable system is to scale horizontally every layer of your system, both application and database servers. Depending on the layer and the technologies you are using, scaling horizontally will be a matter of seconds or will require a lot of development hours.</p><p>Scaling your application will add more complexity to it, but it’s the only way you can make it grow. Because of this, when you scale your application you should balance your system complexity and performance improvement and analyze with caution every change. But believe me, there is no other way to handle millions of requests, you need to scale!</p><p>If you feel these concepts are a bit advanced for your knowledge on scaling applications, you can take a look <a href="https://levelup.gitconnected.com/scaling-backend-applications-for-dummies-31c713ec04a4">at the first article of this series</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da1f7d2a7873" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/high-scalability-patterns-for-dummies-da1f7d2a7873">High scalability patterns for dummies</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling backend applications for dummies]]></title>
            <link>https://levelup.gitconnected.com/scaling-backend-applications-for-dummies-31c713ec04a4?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/31c713ec04a4</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[high-scalability]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Wed, 28 Sep 2022 12:29:16 GMT</pubDate>
            <atom:updated>2022-09-28T12:29:16.973Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-3EajvlEWnj2UluSdXLUpA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@sigmund?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sigmund</a> / <a href="https://unsplash.com/es/s/fotos/lego-blocks?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Maybe you, as every developer, have faced a situation when your application starts to slow down and shows poor performance.</p><p>I know, it’s disappointing but it just happens. When you start working in an application and it gets more users and requests, some issues related to overloads, unexpected system failure and service downtime will occur. It’s completely ok, it just means you need to scale up your systems.</p><p>If you have enough experience you may plan for some scenarios upfront based on previous projects and that’s a really good starting point because it means your architecture is, at least at some point, scalable.</p><p>If you are new to this concept don’t worry, I have created a series of articles to introduce some concepts of scaling applications from the basics.</p><h3>Scale… what?</h3><p>Before going further I think it’s time to clarify some concepts.</p><p>When we talk about scaling in software development we refer to the action to add more resources (hardware) to run a particular application.</p><p>But if my program runs perfectly, why do I need to scale?</p><p>Great question! Usually when you develop an application you do it in a certain context and when this context changes your application could be affected.</p><p>Let me explain with an example. You are programming an ecommerce like Shopify. At the beginning you didn’t pay attention to database performance and it’s completely ok, the app has a few users and response times are quite good. Someday the performance drops and you realize that after the marketing campaign now your application has 100k users at the same time. Your application is the same but it doesn’t work as before, so what happened… exactly! the context your application runs on changed.</p><p>These situations tend to happen from time to time. This is why it is so important to take care about the performance and the scalability of your application from the beginning.</p><p>I’m not saying that you should create the next Google or Facebook with data centers around the world from day one, but you need a strategy and tools to scale your application. And that’s why this series of article exists.</p><h3>How can I scale my application?</h3><p>Now that we are on the same page so it’s time to go deeper into scalability concepts.</p><p>First of all I want to depict the typical flow when scaling an application.</p><p>The first part of scaling an application is to know what it’s going on under the hood. In other words, we need to find what makes performance decrease in order to apply a solution to the problem.</p><p>The second part is to apply a solution, obviously. At this point we are really lucky because there are a lot of solutions documented to help us when scaling our applications.</p><p>If you ask me for a brief summary of this process should be something like this:</p><ol><li>Analysis:</li></ol><ul><li>Enable observability tools</li><li>Make a root cause analysis</li></ul><p>2. Improve:</p><ul><li>Optimize code and business logic</li><li>Optimize database usage (e.g. slow queries)</li><li>Use background processing</li><li>Apply advanced scaling patterns</li></ul><p>In this article and the following ones we will cover all these aspects and phases of the process. Let’s start talking about observability.</p><h3>Enable observability tools</h3><p>This sounds really obvious but it is not.</p><p>Before applying any solution to your scaling problem you need to know where the problem is and what is causing it. We should apply different solutions depending on the problem. We are not going to apply the same improvements for slow queries in a database and for an overloaded server that cannot handle more requests.</p><p>So first of all you need to audit your application. In the best case scenario your application has some observability tools in place like Kibana, Grafana, Prometheus or similar. If so, you are lucky because you can check this data to spot the problem. If not, my advice is that you need to implement an observability tool right now.</p><p>Because this article is an introduction to general concepts I’m not going to give you a deeper explanation on how to install and use any of these tools. You have hundreds of articles about it on the internet. But I want to give you some tips on what data you should gather to get a good observability of your application.</p><p>The most important information you want to know about your application is:</p><ul><li>application id: to identify your application in case you have many of them</li><li>request status: true/false or and error code, it’s up to you</li><li>request time: time elapsed from start to finish of request in seconds or milliseconds</li><li>server information: server name/cluster id or similar, helps you to spot specific problems</li><li>profiling information: information about time to run some methods or classes of your application, call to external apis, etc.</li></ul><p>You should gather this information for each request. If your app has a huge amount of requests consider gathering data for at least 10%-20% of requests. You can store this information as logs, but if you use an observability tool to display it you will be more productive because you get all your data at a glance.</p><p>If you want to get your observability to the next level you can take a look at APM libraries. APM allows you to gather low level information like errors and stack traces from your app with a few lines of code using libraries. These libraries are available for most programming languages and frameworks and are compatible with all observability tools.</p><p>In this section we should mention another source of information really useful to deal with performance problems and it’s the classic server monitoring. This information is usually available through specific server monitoring applications like Nagios, Centreon, Zabbix, Pandora FMS or more generic one like observability tools mentioned above.</p><p>This information about usage of resources like CPU, RAM, network, etc. could give you a lot of information about your application performance and help you to analyze the problem. So don’t underestimate this kind of information when conducting a performance analysis of your application.</p><p>With all the insights of what is happening inside our application we can spot performance problems and start making improvements.</p><h3>Make root cause analysis</h3><p>Now, you have all the information available and you need to start searching for the problems.</p><p>I’m my experience the typical problems related to poor application performance are caused usually by:</p><ul><li>requests to external APIs that take too long</li><li>not optimized database queries</li><li>non scalable code</li><li>lack of resources</li></ul><p>Problems with third party requests should be easy to spot because they tend to be consistent. Usually they are caused by a problem in the vendor’s systems and could be temporary or structural. Besides being easier to find, these problems are not so easy to fix, mainly because you cannot control the code of this API. So basically you should contact your vendor and see what they can do. If you are lucky enough and it’s an internal API developed by another team, just grab a coffee and talk with your colleague to see what is happening and how you can help.</p><p>If your problem is related to non optimal queries then the approach is completely different. You should analyze your queries according to your database engine using some “explain” command and look for some improvements. We will cover this topic in the following sections.</p><p>Another typical problem is a non optimal code, this is so general, I know… But in my experience a lot of problems are caused by code that is not optimized in terms of business logic and use of resources. Some examples are: repeated queries during the same request, doing business logic in requests that could be deferred, legacy code not useful but not refactored, and so on…</p><p>A lack of resources problem is sometimes easy to spot if you have correct observability in place. Sometimes even if your code, queries, etc are optimized and perfect you can reach the limit of your database engine, web server, etc. In this case you will see errors with messages like “connection limit reached”. We will explore some options to solve them in the following sections.</p><p>Using the observability information you should be able to identify problems and it’s kind easily. Once you do that the next step is to know how to start solving them.</p><h3>Scaling by improving code performance</h3><p>First of all I want to talk about code performance because in my opinion it is the easiest problem to solve but the last one people address.</p><p>Before optimizing database queries or making major refactors in your code, or improving your hardware you should review your implemented business logic.</p><p>But… What should you look for? Great question! I can give you a list of example:</p><ul><li>repeated execution of code during same request, the result should be cached, don’t repeat again same thing</li><li>legacy code no longer needed but that it’s being executed, remove it immediately</li><li>heavy weight loops or iterating same collection several times, try to loop collections as few as you can and avoid loops of loops when possible</li></ul><p>Those tips are the most common pitfalls but for sure there are plenty of bad practices to avoid. This is an introductory course so, this should be treated as an example to guide you on making a root cause analysis.</p><p>If you improve these issues you can get more performance with a low effort and without making a huge refactor or even expending a lot of money to get more power for your servers.</p><h3>Scaling by improving database performance</h3><p>The second place will go to query performance optimization.</p><p>In my experience one of the most common issues when working with databases is just writing the structure or inserting information without paying attention to performance.</p><p>For example, creating the correct index could make your application x10 times faster.</p><p>So it’s crucial to ensure you have the correct indexes in place and that your queries and data structures are optimal to get the most of your database engine.</p><p>I won’t dive deeper into database optimization because this is an introductory article. You have a lot of resources online for your database engine</p><h3>Scaling by leveraging background processing</h3><p>When your code and database queries are optimized and you still have some part of your process that takes a long time you have the last silver bullet… You can try background processing.</p><p>Some parts of business logic can slow down your application requests like logging, inserting a huge amount of data, etc. Sometimes these actions don’t belong to request’s business logic and you can defer them.</p><p>A very good example is the “create user” request that sends the welcome email inside the same request. In this case the request just needs to insert user information into the database and return OK when done, you can send the email using a background process a few seconds later.</p><p>But.. How can you do it? Ok, it’s easier than it seems.</p><p>You can implement an event bus pattern using any message queue servers available like RabbitMQ, Kafka, AWS SQS, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UBj1E1jOV31hLWOk" /></figure><p>The idea is to send an event informing about some action, for example “user created”, in the main request. Then you will have a separate process, usually a daemon, running in background listening to these events, for example “WelcomeEmailSenderListener” that sends the welcome email.</p><p>Using background processing you can make your requests faster and it allows you to scale each part of your system separately allocating the resources they need.</p><h3>Some advance scaling patterns</h3><p>When you implement all techniques above and your applications continue to perform really badly, then you need to apply some advanced scaling patterns. These patterns will help you out when gaining performances for your applications.</p><p>Some of theses patterns are:</p><ul><li>Implement some caching system</li><li>Scaling servers vertically</li><li>Scaling servers horizontally</li><li>Implement database sharding</li></ul><p>We will cover these patterns in the following articles in depth but to give you a brief introduction all of them are based on improving the usage of the hardware resources you have to run your application.</p><p>In the real world we mix and match to get the best of all of them so you will end up with a more complex infrastructure and applications but on the other hand you will have a more reliable system that allows you to increase the number of requests and users effortlessly.</p><h3>Conclusions</h3><p>Scaling is very important to ensure your application can deal with a huge amount of requests and a lot of users which is a good sign that business is performing well.</p><p>Enabling a good observability to gather performance data from your applications is key to understanding why your application has a low performance.</p><p>It’s a good practice to check your code and database performance before adding more hardware to run your applications. Some easy to fix issues like removing legacy code, doing a refactor in business logic or creating some indexes in the database could improve your app performance ten times.</p><p>You can improve your application performance by using more advanced scaling patterns like: caching, vertical and horizontal scaling, sharding, etc. that allow you to get the most of the hardware you use to run your application.</p><p>This is the first article of a series that will cover some aspects of scaling applications, you will find more information about how to scale your application in the next articles.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31c713ec04a4" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/scaling-backend-applications-for-dummies-31c713ec04a4">Scaling backend applications for dummies</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The benefits of Internal Open Source Philosophy]]></title>
            <link>https://levelup.gitconnected.com/the-benefits-of-internal-open-source-philosophy-be86883d241f?source=rss-6143e1f35421------2</link>
            <guid isPermaLink="false">https://medium.com/p/be86883d241f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Darío Rodríguez]]></dc:creator>
            <pubDate>Thu, 23 Jun 2022 20:20:54 GMT</pubDate>
            <atom:updated>2022-06-23T20:20:54.864Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Benefits of Internal Open Source Philosophy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NCv1CCcDAHPYeyaB3kZ6lg.jpeg" /><figcaption>Picture by <a href="https://unsplash.com/@bamagal?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">“My Life Through A Lens”</a> en <a href="https://unsplash.com/es?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>One of the main responsibilities for tech leads, CTOs, VP Engineering or similar roles is to define a culture that allows business to get the most of technology.</p><p>A culture is defined by several aspects but at the end of the day we are working with code and developers. It means that one of your top priorities should be to improve collaboration between developers to deliver as fast as possible.</p><p>You can encourage collaboration using several strategies, for example:</p><ul><li>defining a specific stack (MEAN,LAMP) so all developers will use the same tools and can learn about them sharing information</li><li>implementing CI/CD pipelines to automate processes and create and standard way for all developer to deploy code</li><li>defining a career paths so developers can get more responsibility and have more impact within the company over time</li><li>and much more…</li></ul><p>These strategies to empower culture are great but sometimes it takes a little bit more to reach the next level.</p><p>If you want your team members to find challenges and to keep learning while you increase your delivery rate you should embrace a different approach and the Internal Open Source model is the solution.</p><p><strong>Internal Open Source Philosophy</strong></p><p>But what do I mean when I say Internal Open Source Philosophy?</p><p>It’s easy, it’s about working with your internal code as if it was an open source project.</p><p>It means that every developer can access and modify all code within the organization and not only the repositories or code closely related to their team or squad. It means that as a developer I’m able to fix a bug that makes my assigned task get stuck because, for example, the API client from another team is making requests to my team’s API the wrong way.</p><p>Ok, but… Do I mean it’s not possible to keep any code secret? Of course not. You can have a private repository if you consider it critical to the company or even because you need to follow some regulations requirements or similar. The idea is the developers need to have access to the majority of code if you want Internal Open Source to work.</p><p>As you notice the idea behind this philosophy it’s nothing new, we want to encourage collaboration between teams and to begin with everyone needs to be on the same page.</p><p>Open Source projects have been working this way for years and they are a bulletproof method to collaborate, create big ideas and deliver a lot of value in a short period of time.</p><p><strong>What should you expect?</strong></p><p>Everything we talked about it’s really great but if you liked the idea you are probably wondering what you should expect if your company works following Internal Open Source philosophy. This question it’s a good one and the answer it’s very easy.</p><p>By applying this philosophy you will:</p><ul><li>Remove roadblocks</li><li>Spread know-how and best practises</li><li>Encourage T-shape knowledge</li><li>Grow a team that could collaborate in transversal projects</li><li>Foster collaboration and communication</li></ul><p>Let’s explain them a little deeper.</p><p><em>Remove roadblocks</em></p><p>Because every developer can take access and modify the code, they can fix any bug related to an issue they are facing.</p><p>Sometimes an issue requires fixes in two different systems, so if the developer can fix the bugs in both of them you are removing bureaucracy and delivering a solution faster.</p><p><em>Spread know-how and best practises</em></p><p>As anyone can see the code of each other, they can see how others solve some problem they are facing and they can copy the idea and adapt to their needs.</p><p>This way the code itself serves as a mentor to other developers teaching best practices and problem solving skills.</p><p><em>Encourage T-shape knowledge</em></p><p>T-shape knowledge stands for a way of professional growth where you get a lot of expertise in a particular area but you are still learning from surrounding ones. For example, let’s say you work in a project developing the product listing of an ecommerce store, for sure you will be an expert in this area but you will learn how the checkout process works a little because those two parts of the business are closely related.</p><p>This philosophy encourages collaboration between teams and the possibility to watch the code of other parts of the system so a developer can learn from squads that work in related areas of the business. So eventually it will happen that the closest interconnected squads will learn something about business logic, code style, etc. from surrounding squads.</p><p><em>Grow a team that could collaborate in transversal projects</em></p><p>Embracing this philosophy you are creating “super developers’’ on the go. Keep in mind that they will have a T-shaped mindset, the knowledge is more accessible to everyone and they know how to debug certain issues in other systems.</p><p>These new skills make your team grow and be more able to deliver projects easily and on time, even those that involve changing code in different systems at the same time and coordinating all efforts effectively.</p><p><em>Foster collaboration and communication</em></p><p>This advantage it’s explained inside the others. If your team is working with an open minded mindset and you encourage collaboration and communication on a daily basis, you are speeding up culture adoption and it highlights the best practices.</p><p><strong>Implementing Internal Open Source</strong></p><p>As far as here we know what Internal Open Source is and what benefits could we expect from it. But… How can we implement Internal Open Source?</p><p>Implementing this philosophy it’s really easy and you can do it following these rules.</p><ol><li>All code should be accessible</li><li>All development processes should be public</li><li>All tasks details should be accessible</li><li>Every change should be supervised by other developers expert in the system</li></ol><p><em>1.- All code should be accessible</em></p><p>This rule is easy, if we are talking about open source the basis is all code should the accessible by every developer and they should be able to make changes.</p><p><em>2.- All development processes should be public</em></p><p>Everything that it’s going on with our code should be treated as a public knowledge base: pull/merge requests, commits, deploy pipeline errors, bugfixes, etc.</p><p>Let’s say every developer inside the company can comment on changes in a pull request, the author could get more feedback and If needed he could request feedback from a colleague which is an expert on the problem related to this pull request. This way any developer could get high quality code easily.</p><p><em>3.- All tasks details should be accessible for everybody</em></p><p>Tasks definition or user stories are a great source of information when you need to change some behavior in a business logic and you don’t remember or don’t know why it works as is.</p><p>The same way could help you to spot problemas and to understand why other teams did that change that breaks the system somehow.</p><p><em>4.- Every change should be supervised by other developers expert in the system</em></p><p>We talked about opening the codebase to all developers but it will end in a chaos of commits out of control here and there. This will make your system unstable.</p><p>To mitigate this problem you should establish a policy so every change should be approved by at least one extra developer that has enough expertise in the system that it’s changing.</p><p>For example, if you are changing some API endpoint from your system another member of the squad will review your changes. If you are modifying some code that belongs to another squad you will need a developer from the squad responsible of this code to review and approve your changes.</p><p><strong>Conclusions</strong></p><p>Internal Open Source it’s about open source your company’s code and making it accessible and modificable to all developers within the company.</p><p>We are talking here about code in the first place but other processes like deploying pipelines, code review and information about tasks details should be treated as public information to ensure everyone has access to all information needed.</p><p>This change in your culture will allow your team to deliver faster because they are capable of removing roadblock and learning faster. Furthermore collaboration will increase so communication will be more effective and things will start to run smoothly.</p><p>If your developers are delivering well and you feel your teams are kind of isolated from each other you should definitely try Internal Open Source, your team will reach the next level.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be86883d241f" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-benefits-of-internal-open-source-philosophy-be86883d241f">The benefits of Internal Open Source Philosophy</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>