<?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[BigPicture by Appfire - Medium]]></title>
        <description><![CDATA[BigPicture is the leading suite of Portfolio, Product, and Project Management apps. - Medium]]></description>
        <link>https://medium.com/appfire?source=rss----8ca13cfaa92---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>BigPicture by Appfire - Medium</title>
            <link>https://medium.com/appfire?source=rss----8ca13cfaa92---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 11:54:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/appfire" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Multi-tenant architecture based on BigPicture software products]]></title>
            <link>https://medium.com/appfire/multi-tenant-architecture-based-on-bigpicture-software-products-380213ff1dd3?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/380213ff1dd3</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[multitenancy]]></category>
            <dc:creator><![CDATA[Weronika W]]></dc:creator>
            <pubDate>Mon, 21 Aug 2023 19:02:10 GMT</pubDate>
            <atom:updated>2023-08-21T19:01:53.932Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fxfzuvtYBT5LKBHtwmSA_A.jpeg" /></figure><p>To understand the mechanism of multi-tenant architecture, it is necessary to start by understanding the differences between the single-tenant and multi-tenant software distribution models. In both cases, the recipient of the service is the so-called ‘tenant.’ In practice, this word is most often used to describe all employees of the same company that has purchased access to the application.</p><p><strong>The single-tenant model</strong> can be categorized based on its two main ways of distribution:</p><ul><li><strong>On Premises</strong>, where a dedicated instance is created for each client with a separate database and a separate system. The software is installed on the client’s infrastructure, which remains its property. The client is responsible for the maintenance of the necessary equipment, including costs related to its upgrade.</li><li><strong>SaaS</strong>, where the software is installed on the manufacturer’s infrastructure. The manufacturer is responsible for maintaining it, as it remains his property. Tenants have access to the purchased application through cloud systems. For this reason, this solution is often confused with the multi-tenant distribution. However, it should be remembered that in the SaaS model, a separate instance is still created for each tenant on a dedicated server.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x749p_wiUy9sERR8C4Wj0A.jpeg" /><figcaption>Single-tenant application distribution model</figcaption></figure><p>The advantage of the single-tenant model is data security. Since a dedicated instance is created for each tenant, there is no possibility of data leakage between different clients. However, when designing an application, it should be taken into account that the tenant may need to have different permissions for individual users within its organization and that one group of users should not see the data of other users. Since these are restrictions within a single company, this does not pose a significant challenge in the process of designing, developing, or installing an application.</p><p>Despite this benefit, the single-tenant solution has its fundamental limitations, which mostly boil down to high costs and system scalability problems. It is expensive to run an application that, depending on its complexity and number of users, will occupy a specific space on the server. Also, in the single-tenant model, the server base performance must be able to maintain not only the system itself but also the maximum load resulting from use. In other words: each machine must be as good as the maximum load that can be generated by its tenant. It should be remembered that from the moment of implementation, the system will require appropriate maintenance, regardless of whether the tenant actively uses the application or not.<br>Moreover, in the single-tenant model, system scaling is always horizontal. This means that adding another tenant requires the purchase of another machine to handle it. This absorbs vast amounts of resources and generates high costs. It’s particularly unprofitable in the case of solutions dedicated to a broad group of customers, which should cost them no more than a few dollars per user per month.</p><p>The alternative is to design and implement applications based on <strong>the multi-tenant model</strong>. In this model, one instance of the application can support multiple tenants. It’s possible because the application is aware of the existence of different recipients. This solution requires significantly more sophisticated architecture than in the single-tenant model. Since the tenants are supported by the same server and use the same database, it must be guaranteed that data between organizations will not be visible.<br>Moreover, the system should only be aware of the multi-tenancy at the stage of identifying the tenant. At the request handling stage, the application should already work as in the single-tenant model. It is due to the principles of clean code design, where the so-called cross-cutting concerns (such as security, transactions, logging, auditing, and multi-tenancy) should not interfere with business logic. This approach provides much higher readability of the code, which directly results in cheaper development and maintenance.<br>The system in the multi-tenant model allows more flexibility in the area of scaling, thanks to the possibility to apply both horizontal and vertical scaling according to needs. It means that with an increasing number of tenants, the manufacturer can, but does not have to, purchase new machines. Instead, the manufacturer can expand those already owned, by increasing the amount of RAM, CPU, or by replacing processors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5FP0SzMTmtaur_xsMAIMbw.jpeg" /><figcaption>Multi-tenant application distribution model</figcaption></figure><h3>How to develop solutions in the multi-tenant model</h3><p>According to the rules of writing good code, the art of creating solutions in the multi-tenant model comes down primarily to creating these solutions in an orthogonal way to functionality in the system. It means that the non-functional aspect, which has an impact on system maintenance, costs, and future development of system scalability, should not intersect or interfere in any way with system functionality. Moreover, these solutions should be implemented in a declarative way, and this requires designing them as an aspect of the system and not its innate part.<br>If these elements are taken care of from the very beginning, the logic associated with multi-tenant applications will not permeate the business logic and thus will not permeate the code itself. Then, understanding the system and its development will be easier for the developer.</p><p>However, the importance of ensuring that multitasking is separated from the business logic does not result only from being mindful of the code quality. It is also an extremely significant aspect of security. Incorrect implementation of this solution may cause the data to start leaking, and as a result, tenants will have access to each other’s data.</p><h3>Security in multi-tenant solutions</h3><p>In the multi-tenant solution, data is grouped so that it is easy to identify to which tenant it belongs. Each tenant’s data can be divided into three main mechanisms:</p><ol><li>databases;</li><li>cache, i.e., a mechanism allowing quick access to data from a database or other resources. It is worth mentioning that none of the mechanisms of caching libraries in Java support natively multi-tenant architectures;</li><li>Data asynchronicity, which should bring with it the context of the tenant. The work ordered asynchronously is called a ‘JOB’.</li></ol><p>For our solution to support multi-tenancy, the above mechanisms must be aware of the existence of different recipients. However, it is essential that the APIs that these mechanisms make available for business logic no longer have multi-tenant aspects.</p><p>Another essential element, significantly increasing the security of applications in the multi-tenant model, is the tight protection of the entire system with functionality supporting the correct flow of requests from users. With each user request, for the duration of the request, the system should switch to the environment of a given tenant. What does this mean? The application should see the data of the tenant sending the request and not see the data of other tenants. At the same time, before such a request enters the business logic (i.e. before it is handled), it should be passed through a mechanism that will set the appropriate lease context for the cache, database connections, and asynchronicity.</p><p>For this purpose, the application path should be designed in the following five steps:</p><ol><li>User request</li><li>System endpoint</li><li>Executing business logic</li><li>Removing tenant context</li><li>Returning response to user</li></ol><p>From a multi-tenant perspective, the most significant and complex are points 2 and 4, i.e., the endpoint system and the clearing of the tenant context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*05kG5lUNFYEft7hRxtocSA.jpeg" /><figcaption>T1, T2, T3, T4 — grouped data for each tenant</figcaption></figure><h3>System endpoint in multi-tenant architecture</h3><p>The endpoint system is a layer that consists of all entry points to the system. It is essential that this layer is designed tightly to ensure that all incoming requests from outside the system must pass through it. The role of the endpoint system is the aforementioned configuration of the tenant environment, even before the request is directed deeper. The configuration is carried out in three stages:</p><p><strong>1. Identification of the tenant by an incoming request</strong>. In this step, two primary methods are distinguished:</p><ul><li>Basic Authentication</li><li>Bearer Authentication</li></ul><p>The most popular methods are those of Bearer Authentication, where a token identifies the tenant. A token can provide data directly, e.g., in JWT technology, or indirectly in solutions-based, e.g., on OAuth 2.0.</p><p><strong>2. Performing user authentication and authorization. </strong>It is worth remembering that authentication is the verification of the user’s identity, and authorization is the verification of the rights of the user with the provided identity.</p><p><strong>3. Configuration of the application context based on the tenant ID</strong>, i.e. correct setting of the tenant environment:</p><ul><li>DB.setTenant(TenantID)</li><li>CACHE.setTenant(TenantID)</li><li>JOB.setTenant(TenantID)</li></ul><p>After all these three steps have been completed, the environment is set up for a particular tenant, and the user can go on to execute the business logic.</p><p>For the security of the client’s data, when leaving the system, it is necessary to carry out the fourth step from the application path, i.e. to clear the tenant’s context:</p><ul><li>DB.clearTenantContext(TenantID)</li><li>CACHE.clearTenantContext(TenantID)</li><li>JOB.clearTenantContext(TenantID)</li></ul><p>The proper functioning of the endpoint system layer is critical for the operation of applications in the multi-tenant model. The layer should be applied:</p><ul><li>onto any Java API exposed to the system, and</li><li>at the level of all REST services. A JAX-RS engine or similar to aspect-fastening mechanism is helpful.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=380213ff1dd3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/multi-tenant-architecture-based-on-bigpicture-software-products-380213ff1dd3">Multi-tenant architecture based on BigPicture software products</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Writing custom TypeScript Eslint rules with unit tests for Angular project.]]></title>
            <link>https://medium.com/appfire/writing-custom-typescript-eslint-rules-with-unit-tests-for-angular-project-f004482551db?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/f004482551db</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[eslint]]></category>
            <dc:creator><![CDATA[Michal Szpak]]></dc:creator>
            <pubDate>Fri, 12 Nov 2021 07:22:40 GMT</pubDate>
            <atom:updated>2021-11-12T07:22:40.751Z</atom:updated>
            <content:encoded><![CDATA[<h3>Writing custom TypeScript Eslint rules with unit tests for Angular project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VYqaYdcdLehYmTjbY-SUCA.png" /></figure><p>After reading this article you will know how to create a custom Eslint rule in Typescript for Angular project and how to test it using Jest.</p><p>We are going to work on a clean Angular project so all you need to have is <strong>node</strong> and <strong>Angular CLI </strong>installed on your device and I’m using <strong>yarn</strong> to add dependencies and run scripts but you can, of course, use a different tool like <strong>npm.</strong></p><h3>First steps</h3><p>First, let&#39;s start with creating a new project. Let’s use Angular CLI to generate a clean project:</p><pre>ng new custom-eslint-rules --style=scss --skip-tests=true --routing=false --minimal=true</pre><p>then we go on to add Eslint:</p><pre>yarn add eslint --dev</pre><p>and initialize it:</p><pre>yarn run eslint --init</pre><p>After the configuration steps:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*3pbsoPvXiRsJ0XNtTXnZ5Q.png" /></figure><p><strong>.eslintrc.json</strong> should appear in the root directory with the following configuration:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6ec4372d1b9b883ccc2258692f289e7b/href">https://medium.com/media/6ec4372d1b9b883ccc2258692f289e7b/href</a></iframe><p>Now in <strong>package.json,</strong> we are going to add a custom script to run eslint with predefined rules for typescript files. The eslint script will be invoked for the “src” directory and all its subdirectories:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/474/1*xvSBDvcwZsR_2TCCQ1MTCQ.png" /></figure><p>to run this script we use:</p><pre>yarn lint</pre><p>after running this command, you should see fixable errors in the console. This is because by default eslint adds some predefined rules in the<strong> .eslintrs.json</strong> file. One of the rules is indent: tab, which causes the errors shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*Rj7GZjfyi9tpockqVtoZxw.png" /></figure><p>Speaking of fixable rules. Eslint provides a flag to fix broken rules. We’ll take a closer look at this later in this article, but for now, just to try it out, you can run the script below, but keep in mind that eslint will change your files as a result. I suggest you run this script on a repository without any local changes so if you have any problems later, you can easily roll back the changes made by the script.</p><pre>yarn lint --fix</pre><h3>AST Tree</h3><p>Before we start writing our first rule we need to understand how ESLint works. Under the hood, Eslint searches <strong>AST </strong>(Abstract Syntax Tree) which is an abstract tree that represents your code.</p><p>To imagine how it works and what <strong>AST </strong>exactly is we will use one of the online tools: <a href="https://astexplorer.net/">https://astexplorer.net/</a>.</p><p>I’ve changed our <strong>AppComponent</strong> a little bit to look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8a399a9aefc238ad6be4bebf2c32d5e/href">https://medium.com/media/b8a399a9aefc238ad6be4bebf2c32d5e/href</a></iframe><p>and copied it to <a href="https://astexplorer.net/">https://astexplorer.net/</a>, then selected <strong>JavaScript</strong> language and @<strong>typescript-elsint/parser</strong> which is also selected in our .<strong>eslintrc.json </strong>file. It should look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xUwJYlkkC7-oMawejOGSlw.png" /></figure><p>You can play around and discover how your code is represented in <strong>AST </strong>and if that’s not enough for you and you want to know more about what <strong>AST</strong> is and how it works, I recommend this article: <a href="https://www.twilio.com/blog/abstract-syntax-trees">https://www.twilio.com/blog/abstract-syntax-trees</a></p><h3><strong>Custom Rule</strong></h3><p>Let’s jump back to the code and clean our <strong>.eslintrc.json, </strong>by removing default <strong>rules</strong>, <strong>plugins</strong> and <strong>extends</strong>, fixing the <strong>parserOptions:</strong> <strong>emcaVersion</strong> to <strong>2021 </strong>and setting <strong>root</strong> to <strong>true</strong>. After all those operations <strong>.eslintrs.json </strong>should look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f198cec75a92f85e527a41f824b5907/href">https://medium.com/media/9f198cec75a92f85e527a41f824b5907/href</a></iframe><p>I left <strong>plugins </strong>and <strong>rules</strong> empty on purpose because it’s the place where we are going to put our custom plugin and rules.</p><p>Now the tricky part comes in. To add a custom rule, you need to add a plugin that has this rule and the plugin needs to be set as a dependency of your project in <strong>package.json </strong>and should be a part of the <strong>node_modules</strong>.</p><p>…at least that’s what the official Eslint documentation says as seen below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iHoucK88vPT9VAL4-6hx7A.png" /></figure><p>But maybe you don&#39;t want to share your custom plugin and you want to keep it locally as part of your application for better maintenance and accessibility. (as I did at my company) In the next chapter, we will go through the whole process of setting up the local plugin.</p><h3>Local plugin</h3><p>First, we need to create a directory and then initialize the npm project. To do it we use</p><pre>npm init</pre><p>and after the configuration steps:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i2ZGZv-gQNBxS-FihbI7Vg.png" /></figure><p>the file should appear in <strong>custom-eslint-rules/eslint/package.json </strong>and it should include the following text:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16793eac02595cc9a2080c6c75bb71f9/href">https://medium.com/media/16793eac02595cc9a2080c6c75bb71f9/href</a></iframe><p>now we need to add some necessary dependencies:</p><ul><li><strong>typescript </strong>for typescript,<strong> </strong>obviously</li><li><strong>jest</strong> with <strong>types</strong> for testing purposes</li><li>and finally <strong>eslint parser</strong> with <strong>experimental utils</strong></li></ul><p><strong>eslint/package.json</strong> should look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d82fdae6d0812cb160d49f42442a7da6/href">https://medium.com/media/d82fdae6d0812cb160d49f42442a7da6/href</a></iframe><p>let&#39;s run the install script inside the eslint directory:</p><pre>yarn install</pre><p>and then generate <strong>tsconfig.json </strong>file by running this script:</p><pre>yarn tsc --init</pre><p>Now add some directories and <strong>index.js </strong>to keep our plugin’s structure clean:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KWb1wfKgjaHXGYUzxu6Lxw.png" /></figure><p>notice that I&#39;ve added <strong>src/rules </strong>for keeping custom rules and <strong>tests/rules </strong>directory for keeping unit tests.</p><p>The next step is to clean up <strong>tsconfig.json. </strong>You can choose your own typescript settings although I recommend you set <strong>outDir</strong> to <strong>dist</strong>. Here is how my <strong>tsconifg.json</strong> look’s like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e7bf9c56db2a7557c333c6743f03152b/href">https://medium.com/media/e7bf9c56db2a7557c333c6743f03152b/href</a></iframe><p>last but not least we configure <strong>jest </strong>and to do that simply run this script:</p><pre>yarn jest --init</pre><p>and after the configuration steps:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QqxQCQ3DE73vuy0bQ-Kmqg.png" /></figure><p><strong>jest.config.js</strong> should appear in the eslint directory. Now you can also configure it on your own but remember to set <strong>transform</strong> property to <strong>ts-jest. </strong>Here is how my <strong>jest.config.js </strong>look’s like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ff59a9dc2b5e2d0bcf35b0455b148dd0/href">https://medium.com/media/ff59a9dc2b5e2d0bcf35b0455b148dd0/href</a></iframe><p>At the end of this chapter, let&#39;s jump into <strong>eslint/src/index.js </strong>and export all the rules from the <strong>src/rules</strong> that we’ll be adding there later:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/097d282e5de78bb66c915c99c0553181/href">https://medium.com/media/097d282e5de78bb66c915c99c0553181/href</a></iframe><p>Let me explain what happened: we took all the rules from <strong>src/rules </strong>iterated through them and exported them as their file names. So notice that your rule file name is actually your rule name that will appear later in <strong>.eslintrc.json.</strong></p><h3>Writing First Rule</h3><p>In Angular, we have the possibility to use a technique called dependency injection. We all use it to inject needed dependencies into <strong>components</strong>, <strong>pipes</strong>, <strong>directives</strong>, <strong>modules </strong>and <strong>services</strong>.</p><p>The injected dependency is usually created as a singleton and overwriting it breaks the whole concept of dependency injection pattern.</p><p>So knowing this we want to write a rule that forces the programmer to precede each injected dependency with the word <strong>readonly</strong>, as they should not be overwritten. For this reason, let’s assume that this is a wrong injection of AppService</p><pre>constructor(private appService: AppService) {<br>}</pre><p>and this is correct:</p><pre>constructor(private <strong>readonly</strong> appService: AppService) {<br>}</pre><p>Now let’s create some files:</p><ul><li><strong>readonly-injectables.ts</strong> inside <strong>eslint/src/rules</strong></li><li><strong>readonly-injectables.test.ts </strong>inside <strong>eslint/src/tests/rules.</strong></li><li><strong>create-eslint-rule.ts</strong> inside <strong>eslint/src/utils</strong></li><li><strong>utils.ts</strong> inside <strong>eslint/src/utils</strong></li><li><strong>selectors.ts</strong> inside <strong>eslint/src/utils</strong></li></ul><p>It should look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2squvtAZxp_BD09MsgCTdw.png" /></figure><p>In <strong>create-eslint-rule.ts </strong>we will write a util function that will help us create custom eslint rules and for this, we will use <strong>RuleCreator</strong> from <strong>@typescript-eslint/experimental-utils</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9c4ea3f87c798e63a741fbae2869cf63/href">https://medium.com/media/9c4ea3f87c798e63a741fbae2869cf63/href</a></iframe><p>Then we should export and define the following variables in <strong>readonly-injectables.ts</strong>:</p><ul><li><strong>RULE_NAME</strong> — the name of our rule, that will be also used in tests</li><li><strong>MessageIds</strong> — this field will hold our error message in the future configuration</li><li><strong>Options</strong> — this field is to further configure our rule in <strong>.eslintrc.json </strong>but in our case, we will not use it</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/10e6d200cddd33137ed6b2e37227e909/href">https://medium.com/media/10e6d200cddd33137ed6b2e37227e909/href</a></iframe><p>Now let’s jump into <strong>selectors.ts</strong> and write a selector that will take all Angular classes in which we can inject services.</p><p>For that let’s go to the <a href="https://astexplorer.net/">https://astexplorer.net/</a> and pass our component here. As you can see on the screenshot below we are looking for a class that has one of these decorators: <strong>@Component</strong>, <strong>@Directive</strong>, <strong>@Pipe</strong>, <strong>@Injectable</strong>, <strong>@NgModule</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n2kV9hs-jVQC16n8g3XrRA.png" /></figure><p>So the correct selector for this should look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8754542481969f86514bbbc636ebe3ad/href">https://medium.com/media/8754542481969f86514bbbc636ebe3ad/href</a></iframe><p>Now when we have a selector, we can go back to our <strong>readonly-injectables.ts </strong>file<strong> </strong>and configure our rule and to do that we need to use the previously written <strong>createEslintRule </strong>method<strong>.</strong></p><p>You can configure it according to your own needs and it should not be difficult because in <strong>WebStorm </strong>you can always<strong> command + right-click</strong> inside any field and check the documentation and if your IDE does not provide such a possibility I recommend you take a look <a href="https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/experimental-utils/src/ts-eslint/Rule.ts"><strong>here</strong></a><strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bfCZBJxbGig9SQ6seOJOA.gif" /></figure><p>So here is my <strong>readonly-injectables.ts </strong>after configuration:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1bbcc9f57695ef01eb39561c35c9b329/href">https://medium.com/media/1bbcc9f57695ef01eb39561c35c9b329/href</a></iframe><p>please notice that the utils are imported using relative paths.</p><h3>Unit Tests</h3><p>It is very difficult to write an eslint rule without first writing a unit test for it because without a test you would have to deploy not finished rule and test your application code with it which you don’t want to do 🙂. It is also good practice according to <strong>TTD</strong> to write a test before a rule so let’s do so.</p><p>We are going to import <strong>RuleTester </strong>from <strong>@typescript-eslint/experimental-utils/dist/ts-eslint </strong>into <strong>readonly-injectables.test.ts </strong>and provide the correct parser:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4dcadbb7d7a622820024753f15700af4/href">https://medium.com/media/4dcadbb7d7a622820024753f15700af4/href</a></iframe><p>then we will write some valid and invalid statements for which we want to test our rule. So here is an array of valid statements:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d302fe80f49ae351e971e4f7c4d09b30/href">https://medium.com/media/d302fe80f49ae351e971e4f7c4d09b30/href</a></iframe><p>Note that the last two are also valid because there is no <strong>decorator</strong> for the class and there is no accessibility property (<strong>public</strong>/<strong>protected</strong>/<strong>private</strong>).</p><p>We also declared three invalid statements:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f24cd05968710287f03576996054fb4d/href">https://medium.com/media/f24cd05968710287f03576996054fb4d/href</a></iframe><p>Now, all we need to do is import <strong>rule</strong>, <strong>RULE_NAME </strong>and <strong>MessageIds </strong>from<strong> readonly-injectables.ts</strong> as shown below:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0a95912f7ee3e78e735bc8718fb82b83/href">https://medium.com/media/0a95912f7ee3e78e735bc8718fb82b83/href</a></iframe><p>and write our test using <strong>ruleTester</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e6b7a930254661512f2ad1a05e1553bb/href">https://medium.com/media/e6b7a930254661512f2ad1a05e1553bb/href</a></iframe><p>The <strong>run</strong> method requires 3 parameters as it is well described in the documentation:</p><ol><li><strong>ruleName</strong> — the name of the rule to run</li><li><strong>rule</strong> — the rule to test</li><li><strong>tests</strong> — the collection of tests to run</li></ol><p>The whole file should look like this: <a href="https://github.com/shpaq23/custom-eslint-rules/blob/bf51bad38609243c7a556ff5bee484fd000c3967/eslint/tests/rules/readonly-injectables.test.ts"><strong>link</strong></a></p><p>To run the test we simply need to execute the script below:</p><pre>yarn test</pre><p>and as expected we got <strong>3 failed</strong> tests and <strong>5 passed</strong> because our rule body is empty and if the rule doesn’t report anything then the testing code is considered correct.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/1*Kt9ubwNwdKe8wz03prqO-A.png" /></figure><p>Now that we have the unit tests, we can start implementing the rule and we will know that it works when all the tests passed.</p><h3>Utility functions</h3><p>All we have to do now is fix the tests that aren’t working. To do this, let’s figure out how we should write our rule and <a href="https://astexplorer.net/">https://astexplorer.net/</a> will help us with that.</p><p>Let’s paste one of the rules from valid statements in there as shown in the screenshot below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WCDAanRiN43UiCQ30za8Ag.png" /></figure><p>Now let’s prepare a plan of action, remembering that the selector we have prepared will select the class decorator and we want to take all the constructor parameters from this class to check if they are preceded by the <strong>readonly</strong> keyword.</p><p>So first we want to get the <strong>class declaration</strong> from the <strong>class decorator</strong> because it is where the constructor is. Then we want to get the <strong>constructor</strong> of this <strong>class </strong>and at the end, we want to get all constructor <strong>parameters</strong> and check if they are preceded by the <strong>readonly</strong> keyword.</p><p>Sounds good, now we will write utility functions that will help us to achieve this goal and to do so let&#39;s go to the <strong>utils.ts</strong>.</p><p>First, we will write some functions that will help us keep good typings:</p><ul><li><strong>isClassDeclaration </strong>— check if <strong>node</strong> is <strong>ClassDeclaration</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/863f6dde0344875b083aa15da3aaee12/href">https://medium.com/media/863f6dde0344875b083aa15da3aaee12/href</a></iframe><ul><li><strong>isMethodDefinition</strong> — check if <strong>node</strong> is<strong> MethodDefinition</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69cce51faaac6d0a9aa4ad48a01c5196/href">https://medium.com/media/69cce51faaac6d0a9aa4ad48a01c5196/href</a></iframe><ul><li><strong>isFunctionExpression</strong> — check if <strong>node</strong> is<strong> FunctionExpression</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bdce6a1ca072618314b9df9300627309/href">https://medium.com/media/bdce6a1ca072618314b9df9300627309/href</a></iframe><ul><li><strong>isParameterProperty </strong>— check if <strong>node</strong> is<strong> ParameterProperty</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a4d546f98dbafd5bcd6e693972f5f398/href">https://medium.com/media/a4d546f98dbafd5bcd6e693972f5f398/href</a></iframe><p>then we add functions that actually help us achieve the goal:</p><ul><li><strong>getClassDeclarationFromDecorator</strong> — for getting <strong>ClassDeclaration</strong> from <strong>Decorator</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/618f37f5e362fc7ae5089dbf2dcb1a94/href">https://medium.com/media/618f37f5e362fc7ae5089dbf2dcb1a94/href</a></iframe><ul><li><strong>getConstructorFromClassDeclaration</strong> — for getting constructor which is typed as <strong>MethodDefinition</strong> in <strong>TSESTree</strong> from <strong>ClassDeclaration</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b62cb0b6eb47c2adcd8e88c8770859e/href">https://medium.com/media/8b62cb0b6eb47c2adcd8e88c8770859e/href</a></iframe><ul><li><strong>getParameterPropertiesFromMethodDefinition</strong> — for getting <strong>MethodDefinition</strong> <strong>ParameterProperties</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/78aa95f62099c7462ef984baed3feff5/href">https://medium.com/media/78aa95f62099c7462ef984baed3feff5/href</a></iframe><ul><li><strong>isParameterPropertyAccessibilityNamed</strong>— for checking the accessibility of our dependencies</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f1b881806d34b86783d8877b89ed5d2/href">https://medium.com/media/1f1b881806d34b86783d8877b89ed5d2/href</a></iframe><ul><li><strong>isParameterPropertyReadonly</strong> — for checking if our dependency isn’t already preceded by keyword <strong>readonly</strong></li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/774c21d30cb7b8f60a2f81cc3f9aacd2/href">https://medium.com/media/774c21d30cb7b8f60a2f81cc3f9aacd2/href</a></iframe><p>the whole file should look like this: <a href="https://github.com/shpaq23/custom-eslint-rules/blob/bf51bad38609243c7a556ff5bee484fd000c3967/eslint/src/utils/utils.ts"><strong>link</strong></a></p><p>Does it look difficult? Maybe at first, but if you slowly analyze the code and the <strong>AST</strong> you have at <a href="https://astexplorer.net/"><strong>https://astexplorer.net/</strong></a> you should quickly catch on and see that it is not that hard 🙂</p><h3><strong>Back to the rule</strong></h3><p>Everything has been prepared, now all we have to do is finish writing the rule. Let’s jump into <strong>readonly-injectables.ts </strong>and import all of the functions from our<strong> util.ts</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/20ecddf663a2483400571fcb7d2bdc24/href">https://medium.com/media/20ecddf663a2483400571fcb7d2bdc24/href</a></iframe><p>according to our action plan let’s get <strong>ClassDeclaration </strong>from <strong>Decorator </strong>and then constructor from <strong>ClassDeclaration</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/680e7aec527b8e6fb2992fcf2ae5a1d8/href">https://medium.com/media/680e7aec527b8e6fb2992fcf2ae5a1d8/href</a></iframe><p>Remember that when searching an <strong>AST</strong> you always have to be careful that you may get <strong>undefined </strong>and the same in this case, if the class does not contain a constructor then we report nothing and stop the rule from executing. And according to what I wrote above, if the rule does not report anything then it is considered valid. So we add something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/70ee7681dfb70423cb4f372b05812bfa/href">https://medium.com/media/70ee7681dfb70423cb4f372b05812bfa/href</a></iframe><p>now we have a class constructor and we know it exists, we extract the constructor’s parameters and in the same way, if the constructor has no parameters, we are stopping the execution of the rule and it is considered valid:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee50259d20c8b3798f078cf04ce65eb8/href">https://medium.com/media/ee50259d20c8b3798f078cf04ce65eb8/href</a></iframe><p>at this point, we know that our class has a constructor and at least one parameter in it so let’s now prepare a local function that will check if a parameter meets the requirements we specified earlier.</p><p>First, we need to check the accessibility of the parameter and if it is not one of the following: <strong>public</strong>/<strong>protected</strong>/<strong>private </strong>then we stop the rule execution. Then, we check if it is not preceded by the <strong>readonly</strong> keyword and if it is, we also stop the rule execution:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e4408e73bee91fff51cc13655d68bf54/href">https://medium.com/media/e4408e73bee91fff51cc13655d68bf54/href</a></iframe><p>We have considered all cases where the injected dependency is <strong>valid</strong>, so now we can finally report and mark the injected dependency as <strong>invalid </strong>and to do that we use <strong>context.report</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a33679c272266e1f7225d355b30efb0/href">https://medium.com/media/3a33679c272266e1f7225d355b30efb0/href</a></iframe><p>Now when our local function <strong>resolveParameter </strong>is finished we execute it for each parameter:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b337b60125b21f721cfceca39cc546e/href">https://medium.com/media/1b337b60125b21f721cfceca39cc546e/href</a></iframe><p>At the end your <strong>readonly-injectables.ts</strong> should look like this: <a href="https://github.com/shpaq23/custom-eslint-rules/blob/bf51bad38609243c7a556ff5bee484fd000c3967/eslint/src/rules/readonly-injectables.ts"><strong>link</strong></a></p><p>Time to run the tests and see if it works:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/313/1*PSwTlfF_tdJAYN2c_HVPKQ.png" /></figure><p>and as you can see, it works 😄</p><h3>Rule Fixer*</h3><p>This chapter will focus on creating a fix for a previously written rule.</p><p>It’s not mandatory, but it’s worth knowing that eslint also provides mechanisms to automatically fix a rule, just like we did at the beginning with the predefined tabs rule.</p><p>When you make a new rule in your team and plug it into CI it will mean that any commit that breaks this rule will be blocked, which is pretty cool.</p><p>But what about the code which is already in your repository and which breaks the rule? This is where Rule Fixer comes to the rescue. It’s a great refactoring tool, but it should be used consciously and in my opinion not automatically, i.e. you should call the fix command by yourself and check later if it didn’t do any harm to your code and always on a clean repository, because later if something goes wrong you can easily rollback all the changes.</p><p>Okay, enough of this theoretical talk, let’s jump into the code. In <strong>readonly-injectables.ts </strong>in rule configuration we should add <strong>fixable: ‘code’</strong> as we can see in the screenshot below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/708/1*9ALl7AU0xpO9zBphfb0hjA.png" /></figure><p>Then in <strong>context.report</strong> we need to provide the <strong>fix </strong>function which gives us access to <strong>RuleFixer </strong>object which has the following capabilities:</p><ul><li><strong>insertTextAfter </strong>— used for inserting text after the given node</li><li><strong>insertTextAfterRange </strong>— used for inserting text after the given range</li><li><strong>insertTextBefore </strong>—<strong> </strong>used for inserting text before the given node</li><li><strong>insertTextBeforeRange </strong>—<strong> </strong>used for inserting text before the given range</li><li><strong>remove </strong>—<strong> </strong>used for removing the given node</li><li><strong>removeRange </strong>—<strong> </strong>used for removing from the given range</li><li><strong>replaceText</strong> —<strong> </strong>used for replacing the whole text of the given node</li><li><strong>ReplaceTextRange </strong>—<strong> </strong>used for replacing whole text in the given range</li></ul><p>we’ll use <strong>insertTextBefore</strong> so all we need to do now is find a node in the <strong>AST</strong> before which we can put the <strong>readonly</strong> keyword to do this let’s take a look at <a href="https://astexplorer.net/">https://astexplorer.net/</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wbIsOUL7bP_wJG1-FuF2Lg.png" /></figure><p>now we can see that we are looking for the <strong>parameter</strong> of our <strong>ParameterProperty </strong>which is the name of our service, so in our <strong>context.report </strong>we simple do as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f49066a7480c3401b31a4f33235ab6d/href">https://medium.com/media/0f49066a7480c3401b31a4f33235ab6d/href</a></iframe><p>Finally, we need to fix the tests, because if the rule has a fix, the test will automatically apply the fix and expect us to indicate what it should look like after the fix so in <strong>readonly.injectables.test.ts </strong>we will add <strong>output</strong> property in <strong>ruleTester</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c86a90e34bfdf2efa46b2512ef922924/href">https://medium.com/media/c86a90e34bfdf2efa46b2512ef922924/href</a></iframe><p>let’s see if it works by running a test</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/348/1*mwXAB6ytSAlvF1f24kefpQ.png" /></figure><p>everything ended as expected, let’s jump into the next chapter 🙂</p><h3>Adding the rule</h3><p>We got this far, so now all we have to do is add the custom rule to our main project and see how it works. To do this we first need to build it, so let’s go to <strong>eslint/package.json</strong> and add the following script:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*A9W-6ynkFMEoMq7AyoUP4Q.png" /></figure><p>After running the script you should see the following directory structure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*243gyEO68dJ89lQ2QMcMTg.png" /></figure><p>Now let’s add our local plugin to the main project, to do this go to <strong>package.json </strong>and add new<strong> </strong>devDependencies:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*IoiA705l7s2MJ8I7FGjybw.png" /></figure><p>and after running <strong>npm install</strong> your custom plugin should appear in <strong>node_moduls</strong> in the main project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/310/1*jkVohZYk0NjDeOr8aACUZQ.png" /></figure><p>then go to the .<strong>eslintrc.json</strong> and add your rule:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/506/1*ziA9HRTJJLqSKkdbvhcngw.png" /></figure><p>To test if everything works, let’s go into <strong>app.component.ts</strong> and incorrectly inject a dependency like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*FB2_8xwVU-gRMp1-vA7vLQ.png" /></figure><p>next go to the console and run <strong>yarn lint</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VLneaFSiwbRbPBvlnDRvbQ.png" /></figure><p>you can also run the script with — fix flag to automatically fix errors, but as I warned you before, it’s best to do it on a clean repository 🙂</p><p>At the end of the job, let’s clean up after ourselves so we can freely commit our changes. Let’s go to the <strong>.gitignore</strong> for a moment and add following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*gnPj5HsVpgYleFtDlrVcnw.png" /></figure><p>Then to make it easy for our teammates to add a local rule to their environment after your changes have been merged, let’s add some scripts in the main <strong>package.json</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/1*tZKf6xRJrgcyj-8iIFrjwA.png" /></figure><p>That way after merging your commit, all they have to do is <strong>yarn lint:build-rules</strong> and <strong>npm install</strong>.</p><h3>IDE</h3><p>To get the most benefit from eslint, it is recommended to configure it with your IDE. Most popular IDEs provide the possibility to configure eslint. It is very convenient and recommended to have the IDE show you the errors in realtime and give you the fixes.</p><p>If you are using <strong>WebStorm</strong> like me, I will show you how to configure it, but if you are using another IDE, I recommend you to google how to configure eslint in it.</p><p>So in <strong>WebStorm</strong> go to the <strong>preferences</strong> and type “<strong>eslint</strong>” then set <strong>Automatic ESLint configuration</strong>, <strong>apply</strong> changes and click <strong>ok</strong> as in the screenshot below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*AxJ90RKXwMxI43rxjvpnwg.png" /></figure><p>and that&#39;s it 🙂.</p><p>Now let’s go to <strong>app.component.ts</strong> and see how it works:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*md7tBIFsDK7jAQ_Lcbuhyw.gif" /></figure><h3>Conclusion</h3><p>Eslint is a very powerful tool. When the project grows and we introduce new conventions on how to write code it is always good to write eslint rule for it. We are all human beings and we don’t like to adapt to new things and eslint is a tool that helps us adapt to them. And even more, if we set a new rule on error, we are forced to follow it.</p><p>Now, you know how to write a custom rule, so nothing stands in the way of implementing new conventions in your project 🙂</p><p>In the end, I give you a <a href="https://github.com/shpaq23/custom-eslint-rules"><strong>link to the repo</strong></a> with what we did and I encourage you to write comments because this is my first article and I am curious about feedback 🙂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f004482551db" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/writing-custom-typescript-eslint-rules-with-unit-tests-for-angular-project-f004482551db">Writing custom TypeScript Eslint rules with unit tests for Angular project.</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</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 handle complexity in complex applications?]]></title>
            <link>https://medium.com/appfire/how-to-handle-complexity-in-complex-applications-5220d0a6c82e?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/5220d0a6c82e</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[complexity]]></category>
            <category><![CDATA[application]]></category>
            <dc:creator><![CDATA[Marta Mazurkiewicz]]></dc:creator>
            <pubDate>Mon, 30 Nov 2020 11:53:09 GMT</pubDate>
            <atom:updated>2020-11-30T11:53:08.888Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NqQ77x_ScS5jZP3g" /></figure><p>After joining <a href="https://softwareplant.com/">my current company</a>, I’ve had a small crisis. The UX I had to work with was different than anything I’ve read about on Medium. We work on <a href="https://softwareplant.com/bigpicture/">BigPicture</a>, an app dedicated to Project Portfolio Managers. To say “at first sight, it’s pretty complicated” is a gross understatement. The system has its jargon, popular only among managers, and I didn’t understand most of the vocabulary.</p><p>Moreover, I’ve heard subject research would be difficult because we have so many different users — each of them with different needs, a different position in a company, a wide variety of duties, working in multiple industries, and using diverse methodologies. How can we provide good UX to such a heterogeneous audience? I felt it’s just an impossible task…</p><p>And then, I discovered the <a href="https://www.nngroup.com/articles/complex-application-design-framework/">article on the NN group website about complex applications</a>. What makes them different? I will explain it with BigPicture as an example.</p><h3>Complex Apps</h3><p>Complex apps are characterized by a lack of one specific user path — users not only have multiple ways available; they often try to achieve widely divergent goals. User flow isn’t linear here, like in most mobile apps or websites. Think about Figma, Photoshop, Excel, or other similar tools. These programs support some main aims but without step by step instructions. In BigPicture, the general goal is to manage projects or project portfolios. We can try to split it into different aspects like task schedule, resources, or risk management. Still, even though it is all about administration and management, the desired outcome might be entirely different for each user.</p><p>It follows that users need to know about Project Portfolio Management, or at least Project Management, to navigate our application. Moreover, our users usually work with large, complex sets of data — this should allow them to make the best decisions. Still, in reality, it’s only as useful as the design of the application allows it. In BigPicture, this data comes from projects’ scope, defined based on connections with other platforms like Jira or Trello. These connections lead us to the next characteristic — a collaboration among multiple tools and platforms. Finally, security is crucial<strong> </strong>because, in a complex system, it is necessary to have clearly defined permissions and roles.</p><h3>5-layer framework</h3><p>How to handle complexity in the application? The NN group answers with a 5-layer framework which are:</p><ul><li>integration complexity,</li><li>information complexity,</li><li>intention complexity,</li><li>environment complexity,</li><li>institution complexity,</li></ul><p>and explains the challenges of each of them.</p><h4><strong>Integration</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rQhpQ4ipSZ7kXiV7" /></figure><p>Integration refers to the connection between application, server, databases, and other systems. In BigPicture, this has always been one of our primary concerns, as we have tried to facilitate a more straightforward use of multiple tools. Integration was still the name of the game.</p><p>Synchronizing data between various external tools and platforms posed quite a challenge. All this connectivity required us to develop a generic approach that will be compatible with each platform. It sounds impossible, especially taking clarity and usability into account, but we try hard to keep things as simple and straightforward as possible for our users.</p><p>Moreover, each data flow takes time, which may slow down the system. Remember, data is stored both on the frontend and partially on the backend, leading to different interface requirements. For example, when it’s on the front, data validation can be performed with no delay. However, if data is kept in backend databases, a user has to perform an action that serves as a trigger. Next, the app has to ask the server for status. And wait for a response. Understandably, at this level of complexity, developers usually say, “it’s impossible,” “no, we can’t do that,” “sure, but…”. It’s not just a matter of making things work — they have to work well. All the while, we must also always keep in mind that one tiny change may have a massive impact in many other areas.</p><p>What can you do? It’s good to know some essential technical words, to understand your application’s complexity and, more or less, how the system works. Talk with developers, ask them for explanations and suggestions. You don’t have to know everything, but you should have a rough understanding of the app’s technical aspects.</p><h4><strong>Information</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cMUyzKepvY4C9-zf" /></figure><p>This layer is all about data and actions such as sorting, grouping, filtering, etc. The biggest challenge lies in creating a straightforward and easy to navigate Information Architecture. Applications must present data in a cohesive and readable form, so data visualization is critical. In complex apps, we quite often see tables — not very sexy, but useful. Our users have extensive data structures with many nodes and connections. We often ask ourselves how many elements we should display on the screen to provide the most value and not muddle things up.</p><p>We usually approach this layer with a lot of research. The competitive analysis gives us answers regarding what already exists. We are not trying to reinvent the wheel just to be different; our application doesn’t exist in a vacuum — existing solutions have a massive impact on user expectations and experience. This approach is relatively cheap and quick. We also talk to our users and ask what they need to accomplish. Based on that, we form requirements for the screens. Then we add appropriate tooltips and descriptions. Finally, we track users’ clicks to find the most popular options.</p><h4><strong>Intention</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iraT8VrvoBRS4T6Y" /></figure><p>The NN Group says that intention complexity is about an unstructured way to achieve goals and the broad possibility of actions. Many app scenarios are usually left unmapped by us, making design challenges. How can we, at the same time, facilitate people’s work from healthcare, automotive, and the military industries? Or how can the same tool support both agile and waterfall methodologies? It is impossible to take all scenarios into account.</p><p>On the other hand, it’s compelling that there are almost no limits for the customers. It’s our goal to facilitate a flexible workflow. At the beginning of my work on BigPicture, I often heard there is no happy path in our tool. I was pretty frustrated, convinced it must exist, and determined we would discover it. I failed almost immediately and started doing the opposite thing — adding more actions to the right-click menus to support many ways of achieving user goals. The last thing on this layer is to consider all corner cases, design the worst possible ones with <em>dirty data, </em>and check what a user will see under those circumstances.</p><h4><strong>Environment</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QaqfgUdkKeQfLpkP" /></figure><p>Quite often, we repeat: “it depends.” Users interact with the applications in their own, unique, usually complicated way. They use multiple tools, and they are dependent on their coworkers. They want to synthesize collected data to support better decision making. In BigPicture, we have to understand how project management functions and get to know different methodologies. Also, essential for us is the knowledge about users’ position in the company. We differentiate between types of users and the resulting needs. We must understand all factors that bombard them every day, all the connections between them and coworkers. That’s not easy.</p><p>The NN Group recommends field studies to see the users’ environment with your own eyes. It’s crucial to conduct IDIs (Individual Depth Interviews) to ask direct questions. You can do it in person or using remote tools. If push comes to shove, you can still extract some value from small, more limited tools like <a href="https://medium.com/bigpicture-one/the-survey-is-back-why-is-a-questionnaire-an-excellent-tool-for-remote-ux-research-8cc839774755">surveys</a>. Ask users to describe their background, daily tasks, tools they use and understand their reasons behind it all. I also check articles, forums, and groups dedicated to project managers, and I try to discover as much as I can about them and their work.</p><h4><strong>Institution</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*y548N1uHXwSps9ff" /></figure><p>This part is about us, practitioners, and the formal and informal culture of our organizations. We navigate between many limitations, trying to provide the user with the best possible experience. That’s challenging. Quite often, organizations work using old models and are afraid of change. Sometimes you can hear, “why should we modify something if it works?”.</p><p>How can you change it? Be a UX evangelist, describe good patterns, and show your competition as an example. Present data. Nothing works like numbers! If you build awareness in your colleagues, changes will be met with less resistance. And the last thing — create a team you love to work with that will support you when you want to give up :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SUQ-6-z4VCYt94y0KWq1Ag.png" /><figcaption>My favorite team!</figcaption></figure><p>So next time, don’t think you’re doing something wrong! Complex apps are challenging by definition, and designing them is even more challenging. However, as I tried to show you, it’s not impossible to do it. The path is demanding but satisfying in the end.</p><p>I want to thank Anna Ciepłota for polishing this article and Anna Piwońska for the beautiful illustrations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5220d0a6c82e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/how-to-handle-complexity-in-complex-applications-5220d0a6c82e">How to handle complexity in complex applications?</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redesigning a Gantt app: the Challenge, the Process, the Result]]></title>
            <link>https://medium.com/appfire/redesigning-a-gantt-app-the-challenge-the-process-the-result-a2b00ee435c9?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/a2b00ee435c9</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[gantt-chart]]></category>
            <category><![CDATA[redesign]]></category>
            <category><![CDATA[big-picture]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Marta Mazurkiewicz]]></dc:creator>
            <pubDate>Fri, 24 Apr 2020 06:47:02 GMT</pubDate>
            <atom:updated>2020-04-24T10:53:56.302Z</atom:updated>
            <content:encoded><![CDATA[<h3>Redesigning Gantt: the Challenge, the Process, the Result</h3><h4>Five years ago, when SoftwarePlant was a small start-up, the company decided to create a Gantt chart as an extension for Jira. It would help to visualize issues on the timeline and, over time, turned into a complete solution for Project Portfolio Management. Two months ago, we launched a completely new version of Gantt.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a8ebJEYjs_Vp8uqabeydGQ.png" /></figure><p><strong>Redesign reasons</strong></p><p>When SoftwarePlant started, the most popular 3rd party Gantt chart library (and probably now) was <a href="https://dhtmlx.com/">DHTMLX</a>, which offers a lot of possibilities and features. Still, it has some limitations, which didn’t allow us to implement the critical changes expected by customers. Over a year ago, during one of our internal hackathons, a group of developers wrote a component for Gantt using Angular technology, and the new development era started. Our Product Management almost immediately made corrections to the product roadmap and recommended continuing work on the Angular Gantt. Angular opened a way for us to implement new features that we were not able to add before.</p><p><strong>My role</strong></p><p>After that, my team leader approached me to ask if I could support the development team and be responsible for UX research and design of the new Gantt chart. I was both scared and excited because I’d never been responsible for such a big project before. But it was an excellent opportunity for me to grow as a UX designer, so finally, I said <em>yes</em>. Invaluable help during this journey came from the people on my team, Ola and Marcin — big thank you for your support and ideas! I also work alongside a Product Owner and developers, taking part in their daily stand-ups. So let’s have a look at the redesign process!</p><p><strong>Redesign goals</strong></p><p>We defined three main redesign objectives:</p><ol><li>Replacing and improving old features;</li><li>Improving management processes on the Gantt chart by enabling new features;</li><li>Refreshing the look to match the rest of the app.</li></ol><p><strong>Users’ pain points</strong></p><p>The first two objectives were related to users’ pain points, so they were our priority. Our primary source of knowledge about users’ problems is the Support Team. They are the first front line when it comes to complaints and customers’ needs. Second of all, we went to a team of consultants who help customers to implement BigPicture and BigGantt. The definitive source of information about the users is <a href="https://www.hotjar.com/">hotjar</a>. We viewed hours of recordings where users tried clicking on different spots, which are not clickable at all and expected some specific results. Direct observation provides qualitative data, which we wouldn’t get if we only looked through Google Analytics. Based on that, we created a list of the most urgent changes that we needed to make to the Gantt module.</p><p><strong>Competitive analysis</strong></p><p>We are not the only application on the market that offers a Gantt chart. There are more and more similar products, such as <a href="https://www.teamgantt.com/">Teamgantt</a>, <a href="https://www.proggio.com/">Proggio</a>, <a href="https://www.proofhub.com/">Proofhub</a> or <a href="https://ganttpro.com/">GanttPRO</a>, so we have someone to compare with, and get inspired by (By the way, you’re doing a great job, guys!). During this competition analysis, we review the features, write down their pros and cons, check the layout, system feedback, or information architecture, to name a few. Why all this?</p><blockquote>Good UX replicates known patterns, so the user doesn’t have to learn it all over again.</blockquote><p>Look at Google Docs and Microsoft Word, these are two very similar programs, even though the competing companies create them. The last but not least, it’s all about inspiration.</p><p><strong>First mockups</strong></p><p>The next step was to create the initial sketches, keeping in mind our previous research. I started with the simple layouts in <a href="http://www.figma.com/">Figma</a> using colors from our new palette (it was just after <a href="https://atlassian.design/">Atlassian</a> introduced its new branding). Each Gantt chart has the same items: timeline, rectangular tasks, grouping elements in the form of a clamp, rhombus-shaped milestones, and arrows as dependencies between the tasks. My job was to redesign them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BEM6w62JRzCrFHdqWDLd6g.png" /><figcaption><em>One of the first Gantt mockups</em></figcaption></figure><p>When the essential elements of the jigsaw puzzle were ready, I designed the next features from the priority list, which we defined together with the Product Owner. Let’s dig deeper into the redesign process for some of them.</p><p><strong>Designing tasks (again and again…)</strong></p><p>In the beginning, it seemed so easy. What may the task look like? Like a rectangle, obviously, but then things got a lot more complicated… We decided to add new attributes on tasks like summary, assignee, date, work progress, etc. We had to figure out how to combine all this information on one task. Some of the attributes did not go hand in hand with others, some of them were covering each other, some appeared only sometimes, and others were to be displayed permanently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FYuFp39JVB1FfWHpx7cijQ.png" /><figcaption><em>New task design</em></figcaption></figure><p>Problems arose when the task was very long or very short. Formerly, the name displayed in the middle of the rectangular task was sometimes not visible on the screen; in the second case, it merely did not fit into the task rectangle container. Often, something that was functional did not always turn out to be pretty or vice versa. It wasn’t still possible to predict some of the corner cases, and during the development, we had to make quick decisions on which way to go. Luckily, our developers are very patient and willing to help us to come up with solutions.</p><blockquote>It is worth asking programmers about limitations and technical possibilities because you can discover something new that you haven’t thought about before.</blockquote><p><strong>Zoom in on the scale</strong></p><p>The scale is just a never-ending story. The first idea was to reproduce the timeline as in the previous Gantt version, but with the zoom in and zoom out mechanisms as buttons. Ola (my teammate) described all the steps of the scale from the smallest to the largest. The specification had a detailed description of each level, together with the labels to be displayed, the appropriate widths and the mechanism developed for the different screen sizes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XKPHUtEE95q3AbXS5f5YHg.png" /><figcaption><em>Scale specification after developers’ suggestions</em></figcaption></figure><p>Developers found it too complicated, so they needed a more straightforward idea to implement. For them, the easiest way to go about it was to code the different levels of the scale, like days, weeks, months, quarters, and years, and then, depending on the view, select the appropriate three levels and combine them. It sounded logical and was a good compromise for us, but we had already lost a few months of work. At that point, I thought the topic of scale design was done. However, developers started to come up with questions “what if…” and we had to solve a lot of tricks on an ongoing basis; for example, (as in the case of tasks) some scale levels were long and there were no visible labels on them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_wmEG_oLoB_-X7HRhl_trg.png" /><figcaption><em>Sooo… What’s the date?</em></figcaption></figure><p>Finally, developers added a <a href="https://medium.com/@elad/css-position-sticky-how-it-really-works-54cd01dc2d46">CSS class “position sticky,”</a> and we were rescued! Another thing, some users work on a weekly view instead of a monthly view, and at the highest scale level (more than 1-year views), the labels didn’t fit week numbers. We solved it by hiding this level at the most top scales. Finally, we had to prepare several versions for the scale levels, e.g., days of the week as “Mon, 1” or just the number “1” so labels can fit the scale cell.</p><p><strong>Users’ feedback</strong></p><p>In the meantime, the idea of setting up a <a href="https://softwareplant.com/lab/">BigPicture LAB</a> has come up, and we started with UX Research. We divided users into groups and made contact with those who use the Gantt module. First, I sent out a few <a href="https://medium.com/bigpicture-one/the-survey-is-back-why-is-a-questionnaire-an-excellent-tool-for-remote-ux-research-8cc839774755">questionnaires</a> to design more features based on the answers. Next, together with the launch of the new Gantt, we inserted a poll in the application to collect feedback for particular elements, e.g., scale changes or creating and editing dependencies between tasks. To our surprise, over 300 people took part in the survey! Finally, two weeks after the release, I had dozens of interviews with users who had had the opportunity to test the new module, and that was a fantastic gain. In my opinion, these discovery meetings are the time when you can find out the most about your users, and so it was in our case.</p><p><strong>Final design</strong></p><p>During the process, we didn’t work much on the architecture information. We had a lot of feature enablers in the header, which made it a little bit messy. Finally, I removed all the labels from the buttons and added dropdowns in the header with new categories. It brought more order at a glance, but under dropdowns, there is still much more work to do. Since the decision to redesign, we have had at least two more hackathons, during which the developers made some additional features like the Infobar with an overview of Dependencies and Milestones. All these steps led me to the final version of Gantt, which you can see below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nx8KF_coq-AKmHxebsQYwg.png" /></figure><p>For comparison, see the old chart:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FhXObTTP4Pe6Dcwdll-9Ng.png" /></figure><p>We are now somewhere in the middle of this journey. We’ve just released the beta version of the Gantt, which means that we finished almost all of the set objectives. We’re also analyzing the feedback from IDIs and planning further product roadmap. 1 to 1 interview gave us a lot of insights. Conversations with real people who use our application were magical, and nothing can replace ideas coming from them. I’m glad that I can be a part of the Gantt redesign team!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IaJH2VFKafDu3yUwqvon3A.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2b00ee435c9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/redesigning-a-gantt-app-the-challenge-the-process-the-result-a2b00ee435c9">Redesigning a Gantt app: the Challenge, the Process, the Result</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</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 Scrum in contagion times]]></title>
            <link>https://medium.com/appfire/how-to-scrum-in-contagion-times-688562038d4f?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/688562038d4f</guid>
            <category><![CDATA[covid19]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[remote-working]]></category>
            <dc:creator><![CDATA[Marcin Nowak]]></dc:creator>
            <pubDate>Thu, 16 Apr 2020 09:53:40 GMT</pubDate>
            <atom:updated>2020-04-17T05:24:34.410Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to Scrum when contagion strikes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fH7vqTYN7eqGNcBfiZYb3w.jpeg" /></figure><p>Working from home is a hot topic in recent weeks–this will not change soon for sure. At <a href="https://softwareplant.com/">SoftwarePlant</a>, we used to believe that only direct communication could deliver significant results. That’s why this work model has been occasional.</p><p>The entire crew of over 100 people has switched to a remote mode overnight, including our Design Team. What challenges did we have to deal with, and how did we do it?</p><h3>Scrum ceremonies</h3><p>Arranging face-to-face meetings in the office was a big challenge before. Our team is involved in the work of all the development and product teams on a daily basis, so the chances of finding 30 minutes to “catch up” were often quite poor.</p><blockquote>It has changed.</blockquote><p>We are proud to have a flat organizational structure, so we went a step further. We decided to rotate the role of a Scrum Master every day. We believe that everyone should be equally involved in such ceremonies, especially at this special time. It certainly strengthens the team spirit and makes each of us more engaged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nKMARwKOx8nwnH5Il_-sKA.jpeg" /><figcaption><a href="https://softwareplant.com/">SoftwarePlant</a>’s Design Team during the daily sitting stand-up</figcaption></figure><p>Since we work in cozy slippers, we all are on <a href="https://zoom.us/">Zoom</a> every day at 8.30 AM. We tried to do stand-up’s on Skype and Hangouts before, but finally, we chose this magnifying platform for a couple of reasons:</p><ul><li>The quality is close to perfect.</li><li>Sharing the screen does not exclude the presenter from observing other participants when working on a single monitor.</li><li>Managing all users (silencing them, switching video focus) is a child’s play.</li><li>Sharing insights on an e-whiteboard is pure fun.</li><li>Playing with the virtual background wakes up better than coffee.</li><li>With standard plans, the 40-minute limit per meeting is not a problem.</li></ul><h3>Tools we use</h3><p>We keep the Sprint goals in the very App we design–<a href="https://softwareplant.com/bigpicture">BigPicture</a> (we are the dogfooding enthusiasts). With the Roadmap module, we can easily track the status of all Sprint objectives and observe the overall progress in percentages. That’s how we all are on the same page, and we can prevent possible delays.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*RHrAjzs45AweeO7HT_EDlA.jpeg" /><figcaption><a href="https://softwareplant.com/bigpicture/">BigPicture</a> Roadmap module</figcaption></figure><p>When the Sprint objectives are defined, it’s time to decompose them into tasks. That’s when the <a href="https://softwareplant.com/bigpicture/">BigPicture</a> Board module comes in handy. We can effortlessly divide large pieces of cake into smaller ones–easy to specify, work on, and deliver.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ox1vBbM1-GDimApsMX0S-w.png" /><figcaption><a href="https://softwareplant.com/bigpicture/">BigPicture</a> Board module</figcaption></figure><p>During the stand-up’s, Scrum Master shares the screen and goes through all the task reports available in <a href="https://softwareplant.com/bigpicture/">BigPicture</a>. We are giving comments on specific Jira issues and sharing feedback on ongoing sketches. We mostly work in <a href="https://medium.com/figma-design">Figma</a> (big hugs for you, guys 🥳), so the embedded designs are always on the table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MvEpGogHS57KKEePk_LNDg.png" /><figcaption><a href="https://softwareplant.com/bigpicture/">BigPicture</a> Reports module</figcaption></figure><p>When the Sprint comes to an end, it is time for a demo and retrospective sessions. These meetings last about an hour, so Zoom (with its standard plan) stops being the right solution. As the whole company is using the G Suite, we are hanging on to Hangouts (yeah!) where meetings are joined by PMs and stakeholders. With <a href="https://chrome.google.com/webstore/detail/google-meet-grid-view/bjkegbgpfgpikgkfidhcihhiflbjgfic">this Google Chrome plug-in</a>, we can see everyone on one screen–it’s a real lifesaver.</p><h3>Task collaboration</h3><p>When it comes to daily work, the entire <a href="https://softwareplant.com/">SoftwarePlant</a> crew communicates with each other via Slack. Each team has its public channel, which is extremely useful to “trace” the people responsible for the particular areas of the ongoing tasks.</p><p>Slack also offers video calls. The quality is not as good as it is in Zoom, but it’s just right for ad-hoc communication, even if it’s just a voice one. You’ll appreciate the ease of adding more colleagues to an ongoing call, the ability to share the screen, and “drawing” on the presented material.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bBcqxftyfb5klmwp5P6uVw.png" /></figure><p>As I have written before, we use Figma to design the <a href="https://softwareplant.com/bigpicture/">BigPicture</a> App. Paeans about its online collaboration abilities have already been expressed in about a billion other texts on the Medium. Compounded with a voice call, Figma is simply a perfect tool to work in these days for us.</p><p>As a team leader, I also appreciate the <a href="https://softwareplant.com/bigpicture/">BigPicture</a> Live sync feature. Using the Board module, I can keep an eye on my team’s progress, being sure that we are on the right track to complete all the planned work. With the Reports module, it’s even smoother–I see an up-to-date overview of all ongoing initiatives without the need to look at individual pieces in detail.</p><h3>Human interactions</h3><p>This part of the pre-virus reality is more difficult to substitute. We have different personalities and skillsets that we try to use simultaneously on projects, so the lack of constant, natural communication was–and still is–a big problem for us.</p><p>Each of us knows what remote communication usually looks like and what its limitations are, the lack of the other side’s “emotional feeling” being one of them. That’s why we decided to implement a company-wide rule of turning the cameras on during online meetings. We also learn the culture of running such gatherings by avoiding interruptions when the other person speaks (the conference tools’ mechanisms do not know then who to knock out or dim).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wBhHfod4SOB5Ug72ZdCaWg.jpeg" /><figcaption>Ania, our Graphic Designer, looks a little different these days. BTW: cool glasses, Ola!</figcaption></figure><p>And finally, we genuinely miss each other. We are a growing group of people who like each other very much and enjoy each other’s company. The whole crew notices the absence of shared lunches or morning coffee chats. Maybe a remote integration with the bottle of beer is a good idea for these days? We are especially eager to get to know those new colleagues who have joined our company in the time of plaque and, consequently, are often just a new Slack nickname for most of us.</p><p>Take care! Stay healthy and safe!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FS6ZfuYgdRZo%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DS6ZfuYgdRZo&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FS6ZfuYgdRZo%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/1909230a3bdccf2248d189b9e675742c/href">https://medium.com/media/1909230a3bdccf2248d189b9e675742c/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=688562038d4f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/how-to-scrum-in-contagion-times-688562038d4f">How to Scrum in contagion times</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UX in long-lasting products]]></title>
            <link>https://medium.com/appfire/ux-in-long-lasting-products-ae631e8d77b4?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/ae631e8d77b4</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Marta Mazurkiewicz]]></dc:creator>
            <pubDate>Tue, 10 Dec 2019 09:33:07 GMT</pubDate>
            <atom:updated>2019-12-10T09:33:07.656Z</atom:updated>
            <content:encoded><![CDATA[<p>Tuesday morning; 10 am. <a href="https://softwareplant.com/?source=post_page---------------------------">SoftwarePlant’s</a> Warsaw office. The sky is cloudy; the smell of coffee is <a href="https://www.google.com/maps/place/SoftwarePlant/@52.1943092,20.9329132,3a,75y,339.82h,74.25t/data=!3m6!1e1!3m4!1sAF1QipOL40I8r-aSq1ZpWp4VVtG_c_wkLSzxAtENz6Xz!2e10!7i10000!8i5000!4m5!3m4!1s0x471934fd7a362341:0x6412cff984359a3c!8m2!3d52.1942536!4d20.932663?source=post_page---------------------------">coming from the kitchen</a>. The scenery may seem like a lazy morning, but nothing could be further from the truth. A heated discussion has just started in our team, and it is about the position of UX in the company — we are wondering what the work of UX designers looks like in long-lasting and complex products. Our own tool, <a href="http://bigpicture.one/?source=post_page---------------------------">BigPicture</a>, is one of Jira Apps designed to meet the needs of Project Portfolio Managers.</p><blockquote><em>The product has been running for four years now, and it seems to be a never-ending story.</em></blockquote><p>We checked the Medium, obviously, but to our surprise, we have not found anything that could help or inspire us. There are tons of words describing good practices or typical UX processes. Everything looks simple: start from scratch, name the problem, and meet future users. Then, take a pencil and a piece of paper, put colorful stickers on the wall, and… find a solution. In the end, go to the streets to check your ideas. Repeat the process — easy, right? Well, not always so…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CgBlWtfycMHDzYSJ99S20A.jpeg" /><figcaption>Marta (it’s me!) and Aleksandra — Designing BigPicture</figcaption></figure><p>This was when we decided to start our writing career and share insights from the perspective of UX designers’ developing complex, long-lasting projects. Here, you can’t just start from scratch but you have to take into account everything that has already been created.</p><h3>Continuous improvement</h3><p>In our case, the product is still developing — here is no beginning and no end in sight. We can’t just go repeating the process of completing the tool over and over again… Of course, we iterate the UX process for small features, but at the same time, due to the complexity of the product, we often have to jump between topics. Therefore, we have time to check the solution adequacy quite late. Once we have done this, however, we feel great satisfaction with the improvement of the product.</p><h3>User habits</h3><p>The longer the users use your product, the stronger their habits become. This remains true also for products which are not easy to use. When we want to make changes to the system or redesign the flow, it is never through launching a revolution, but rather through gradual evolution. Having to take it step-by-step can sometimes be tiring and frustrating, especially when you want to introduce a better solution quickly, but it is also quite useful when you want to gain some time for improving each new feature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/0*althI3rxgds47s2C.jpeg" /><figcaption>Be like Aleksandra — reach the sky!</figcaption></figure><h3>Design system</h3><p>In products with repeatable features, it is good practice to create a design system. Treat it as a system of finished ‘bricks’ from which you assemble your product. Thanks to this approach, you will speed up the decision-making process in your project. The obvious benefit is not having developers reiterate questions about colors, sizes, and fonts, as the answers are already there in the system design. After a while, relying on the system can become monotonous and boring and you may find yourself wanting something a bit crazier, but it must not be at the expense of product consistency.</p><h3>Designers influence</h3><p>Being an independent company developing a product differs rather profoundly from working at an agency, where the client is the boss and has the final say about the project, even if it contradicts the underlying assumptions of UX or UI.</p><p>When designing your company’s own solution, you are the primary person responsible for the product, and it is up to you what it will look like and how the users will benefit from it. That’s a huge responsibility. It can, however, be matched by a huge sense of achievement when you realize that what you’ve helped to bring to life is appreciated by your end-users!</p><h3>Constant feedback</h3><p>With a product that has existed on the market for a longer time and has had regular users, you can always benefit from the user feedback and suggestions for new features. Sometimes there are more requests than you could possibly fit into the limited space on your product roadmap.</p><p>However, nothing beats the feeling when your users come forward to share their experiences allowing you to learn how your application is utilized in their day-to-day routine. To take full advantage of this invaluable opportunity afforded by our users, we have, for instance, created <a href="http://lab.bigpicture.one/?source=post_page---------------------------">BigPicture Lab</a>, which focuses on UX research.</p><p>These are some of the characteristics of the product similar to ours. In the following articles, we will describe in more detail how we deal with these challenges. We are curious to know what insights and lessons you have learned from working with complex products.</p><p><strong>Let’s learn from each other! Join </strong><a href="http://lab.bigpicture.one/?source=post_page---------------------------"><strong>BigPicture LAB</strong></a><strong> today</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*qJz8uhL0-k6zPtV1.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae631e8d77b4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/ux-in-long-lasting-products-ae631e8d77b4">UX in long-lasting products</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The survey is back: Why is a questionnaire an excellent tool for remote UX research?]]></title>
            <link>https://medium.com/appfire/the-survey-is-back-why-is-a-questionnaire-an-excellent-tool-for-remote-ux-research-8cc839774755?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/8cc839774755</guid>
            <category><![CDATA[surveys]]></category>
            <category><![CDATA[ux-research]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[research]]></category>
            <dc:creator><![CDATA[Marta Mazurkiewicz]]></dc:creator>
            <pubDate>Tue, 10 Dec 2019 08:53:54 GMT</pubDate>
            <atom:updated>2019-12-10T10:21:29.301Z</atom:updated>
            <content:encoded><![CDATA[<p>Users’ voice is undeniably important. Whenever you create a coffee machine, car cockpit or mobile app, you do it for someone. To deliver a solution that fits user needs, designers have to listen to them, feel them, and observe their behavior. However, it’s not always possible. Let’s take SoftwarePlant, for example. Our company is located in Warsaw, but most of the clients using our <a href="https://softwareplant.com/bigpicture/">BigPicture</a> app are not from Poland.</p><p>We’ve created an online space, called <a href="https://softwareplant.com/lab/">BigPicture LAB</a>, to let users talk about the app and give us feedback regardless of where they work and live. For us, it’s the way to test solutions and explore new ideas with the end-users. For the involved participants, it’s an opportunity to see new features in advance and to submit their proposals, so it’s a mutual benefit. There are several dozen people who cooperate with us and take part in our surveys. Yeah, they do fill out the questionnaires. How we (and they) do it?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZihtOoFFphBeqiEVqreapA.jpeg" /><figcaption>Working on BigPicture</figcaption></figure><p><strong>Choose the tool</strong></p><p>There is quite a broad choice of tools to do UX Research using forms. Probably the most popular and easy to use is <a href="https://docs.google.com/forms/">Google Forms</a>, with its ready to use templates. It gives flexibility in terms of survey creation, answer options, and many more. The vast possibilities in the settings are also worth noting.</p><p>If your company uses MS Suite, you can choose <a href="https://forms.office.com/">MS Forms</a>. It offers ready to use templates with distinct questions and ready-made sets of answers. A broad choice of colorful themes is a significant advantage. MS Forms have flexible sending options like e-mail, link, facebook, or even iframe.</p><p>Probably more professional is <a href="https://www.surveymonkey.com/">SurveyMonkey</a> dedicated specifically to create surveys. It allows creating lists of recipients to whom you can send e-mails in subsequent surveys. With this tool personalizing the appearance of the questionnaire is super easy, and you can also customize shareable URL links.</p><p>All of them prepare statistics for you.</p><p><strong>Create a recognizable template</strong></p><p>Having decided which tool fits your needs best, it’s time to prepare the e-mail template. Use the product or company logo to make it identifiable. The consistency of all touchpoints makes your brand professional and trustworthy. Besides, your recipients feel safe and learn the pattern. To design unforgettable e-mails, inspire yourself using <a href="https://reallygoodemails.com/">Really Good E-mails</a> library. Remember about the <a href="https://stripo.email/blog/email-template-size-width-height/">email template size</a> to fit all the screens where your newsletter may appear. The safe width is 600px.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*cYjkEYTnRODHF_DQqiDtgQ.png" /><figcaption>BigPicture Lab e-mail template</figcaption></figure><p><strong>Choose what you want to measure</strong></p><p>We are in a comfortable situation that our product runs over the years. During this time, the flow hasn’t changed, so users know how to use the app. When we want to add a new feature, we usually duplicate patterns, and we use internal design systems so that we can focus on substantive or less apparent aspects of new functionality. If the goal is to check the user flow, reconsider using surveys.</p><p>Have you ever wondered if the users will back up your idea? Developers’ work takes a lot of time, one wrong move, one wrong decision can cost a company a lot of money. What if the users do not accept the change? UX Designer’s job is a huge responsibility — checking and testing ideas with the users before the implementation to (among other things) reduce the costs. A good practice is to show some mockups to the end-users. Ok, but what’s then?</p><p>A/B tests performed with the help of a survey are our last discovery. When using this method, it’s easy to compare two ideas of the same feature. Ask users to say why they chose a particular option openly. It’s not achievable when part of users test the “A” version and another part test “B” version. Comparison enables new insights that appear when two options are visible at once. However, do not use the A/B test in the surveys to check conversion, because it’s just impossible to measure.</p><p>Being fans of data-driven design, we like to make decisions based on numbers and facts. Surveys help us gather quantitative and qualitative data. The former includes the ratings of usability aspects, like readability. Submit the existing mockups to the users and ask them to assess attractiveness or understandability (or whatever you need) of the feature on the scale from 1 to 5. Next, ask them specific questions like “What would you improve?” to explain their rate. You’ll be surprised by the fantastic insights from your users!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*YRU0FPkHLcFmvnECoXrNrw.png" /><figcaption>Statistics’ example from one of our surveys</figcaption></figure><p>Sometimes, before even sketching, we ask users exploring questions to discover their behaviors, habits, and points of view. Their responses will shape the project direction. The world of Project Portfolio Management is a broad one, and management practices may differ, for example, because of industry or organizational culture. It’s good to learn as many cases as possible to tailor a product for each user.</p><p><strong>Send questionnaire</strong></p><p>In the last step, place the survey link in your e-mail. To send one e-mail with the same content, but to multiple recipients, it is worth using a tool that automates this process. The first one is <a href="https://www.gmass.co/">GMass</a> (plugin Gmail), which takes a list of recipients from excel and personalizes the content, e.g., by inserting their names. Another one is called <a href="https://mailchimp.com/">Mailchimp</a>, with more possibilities like a list of recipients, statistics, e-mail templates, and much more. Whichever tool you prefer, remember to send e-mails to each participant individually, so that each of them feels unique and does not see who else is taking part in the study.</p><p><strong>Pros and cons of the surveys</strong></p><p>Nothing is perfect, and it also applies to the method that we are proposing to you. Researching through the forms prevents observing users’ behavior and forces the researcher to trust what people say. It also limits the scope of things to be tested. On the other hand, preparing surveys is less time-consuming, and they might be used on each stage of the project or whenever you need quick feedback.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8cc839774755" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/the-survey-is-back-why-is-a-questionnaire-an-excellent-tool-for-remote-ux-research-8cc839774755">The survey is back: Why is a questionnaire an excellent tool for remote UX research?</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Softwareplant’s hackathons empower our teams and enhance our products]]></title>
            <link>https://medium.com/appfire/how-softwareplants-hackathons-empower-our-teams-and-enhance-our-products-4efce566fecd?source=rss----8ca13cfaa92---4</link>
            <guid isPermaLink="false">https://medium.com/p/4efce566fecd</guid>
            <category><![CDATA[company-culture]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[hackathons]]></category>
            <dc:creator><![CDATA[Weronika W]]></dc:creator>
            <pubDate>Mon, 09 Dec 2019 14:39:09 GMT</pubDate>
            <atom:updated>2023-12-18T16:25:07.762Z</atom:updated>
            <content:encoded><![CDATA[<h3>How SoftwarePlant’s hackathons empower our teams and enhance our products</h3><p>We don’t want to brag, but our hackathons — or Ship-It Weeks, as we call them internally- are a big deal we’re very proud of. Ship-It Events, successfully introduced and popularized by IT/high-tech industry giants such as Atlassian, became regular events at SoftwarePlant in 2018. What makes them so unique? Instead of competing on weekends, we do it for a whole week during working hours. Instead of creating an abstract solution, we’re working on an actual product used by 10k+ project managers, including those from Fortune Global 500. And yes — even though it’s a hackathon, everyone gets paid the full rate for participating.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*_8lbnzs2Xkcs9w1h29Lv6g.jpeg" /></figure><h3>Some basic rules</h3><p>Every eight weeks, our developers freely form teams that’ll work for five days, from Monday to Friday. They all have the same task: to develop amazing new features for <a href="https://bigpicture.one/">BigPicture</a>, a mighty plugin to the JIRA Project Portfolio Management system and SoftwarePlant’s flagship product. The challenge is to create an innovative and functional design and ensure it’s ready to be released on Friday. And during Ship-It Weeks, the clock is ticking very fast!</p><h3>Busy week</h3><p>The so-called Sheep Squad — representatives of Support, Product Management, UX, Marketing, DevOps, and System Architecture divisions, ensures the smooth running of the event. They supervise the course of the event and assist all competing teams.</p><p>On Friday of the week preceding the hackathon, there is an official kick-off where all teams present their ideas. On Wednesday, there’s a checkpoint: Each team briefly presents the results of their work so far to Sheep Squad. They also discuss a plan of action for the remaining days, which at this point should focus on testing and bug fixing. Friday is the most exciting day. At 3:00 P.M., the entire company gathers for a demo presentation of all developed features. Each team takes the stage for about 10 minutes and takes everyone through their designs’ functionalities. And yes — we have an actual stage in our office!</p><p>After the presentations, it’s time to unwind and party! Each hackathon ends with a big and well-deserved celebration. And while our Planters are partying, the Sheep Squad goes for a meeting and a vote. They choose the winning teams in three categories representing our company’s values: Teamwork, Passion, and Getting things done.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dbVhObk26St0cSLM.jpg" /><figcaption>Ship-It Week hackathons agenda</figcaption></figure><h3>Mutual benefit and growth</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ADRwHa8wa7teBCEdkcDS_Q.png" /></figure><p>Ship-It Weeks became essential to our overall internal company culture, helping us excel as a product provider and grow as a team. For our employees, it became a platform for autonomous, innovative work. They are limited only by their imagination and capabilities. The Sheep Squad ensures our developers have all the tools and support they need to excel in their work throughout the event.</p><p>Do we ever get bored or tired of Ship-It Weeks? Never! As explained by Marcin, one of our senior developers:</p><blockquote>“In everyday work, we have to find time for things like company meetings, daily team meetings, problem-solving, bug fixing, etc. These things are important, but Ship-It Weeks are all about coding and creativity. And we’ll never get bored with that.”</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BCaq7-3hLvA5f9W_uEcR5Q.png" /></figure><p><em>Originally published at </em><a href="https://softwareplant.com/softwareplant-hackathon/"><em>https://softwareplant.com</em></a><em> on August 5, 2019.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4efce566fecd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/appfire/how-softwareplants-hackathons-empower-our-teams-and-enhance-our-products-4efce566fecd">How Softwareplant’s hackathons empower our teams and enhance our products</a> was originally published in <a href="https://medium.com/appfire">BigPicture by Appfire</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>