<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Konstantin Dinev on Medium]]></title>
        <description><![CDATA[Stories by Konstantin Dinev on Medium]]></description>
        <link>https://medium.com/@konstantindinev?source=rss-40673d29c70a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*gLFsYBEnV9uysKYW</url>
            <title>Stories by Konstantin Dinev on Medium</title>
            <link>https://medium.com/@konstantindinev?source=rss-40673d29c70a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 02:03:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@konstantindinev/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Improve the Performance of Angular Application?]]></title>
            <link>https://medium.com/ignite-ui/how-to-improve-the-performance-of-angular-application-a87c075bd789?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a87c075bd789</guid>
            <category><![CDATA[angular-optimization]]></category>
            <category><![CDATA[angular-app]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[ignite-ui]]></category>
            <category><![CDATA[ignite-ui-angular]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Thu, 27 Jul 2023 00:00:48 GMT</pubDate>
            <atom:updated>2023-08-15T07:21:35.533Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to Improve the Performance of Angular Applications?</h3><figure><img alt="angular optimization" src="https://cdn-images-1.medium.com/max/1024/1*lcnrVufXZyAej2-xBMehsQ.jpeg" /></figure><p>Angular has become a very popular and widely adopted framework for developing modern web applications. This technology is both very powerful and feature-rich. Everything that you need as a web developer comes out-of-the-box and Angular allows for easy configuration, maintaining, and expanding any application built on top of the framework.</p><p>And by now, you’ve probably already put together one or more Angular applications, but are they optimal?</p><p>In Part 2 of my Software Performance series, then, I will talk about Angular optimization, demonstrating how to improve the performance of an Angular application using an Angular example app that I built. I will use Chrome Dev Tools to derive an initial lighthouse score, in order to determine where the application stands initially. Let’s take a look at what can be improved and how.</p><p>Other blogs from this series:</p><p><a href="https://medium.com/ignite-ui/software-performance-web-61158c8583d">Software Performance [Web]</a> Part I</p><p><strong>Quick Article Overview:</strong></p><ul><li>Ways to improve Angular Performance</li><li>Angular build and improving the initial lighthouse scoring</li><li>Angular pre-rendering and server-side rendering</li><li>Angular lazy loading</li><li>Optimizing images</li><li>Wrap up</li></ul><h3>How to Improve The Performance of Angular Applications</h3><p>For this article, I will use a sample Angular application that I’ve put together. At the time of writing this article, the application uses the following features and libraries:</p><ul><li>Angular 16</li><li>Ignite UI for Angular 16</li><li>RxJS 7</li><li>PWA (Angular service worker)</li><li>Server-side rendering (express server)</li><li>Angular localization</li></ul><h3>Angular Build</h3><p>Everything seems to be running just fine when I’m running the application in a development environment, but the initial lighthouse score is not very high:</p><figure><img alt="lighthouse score with development environment run" src="https://cdn-images-1.medium.com/max/847/0*wJhgzN6fVPxs-H_w.png" /></figure><p>When I look at what the suggestions for improving the lower scoring sections are , I see where the issues are coming from. The first big issue is the size of the resources (JavaScript, styles, static resources) that are transferred to the client.</p><figure><img alt="Angular app performance optimization opportunities" src="https://cdn-images-1.medium.com/max/847/0*IVioFQq-e3mCIusZ.png" /></figure><p>This issue is resolved easily by running a production build of my Angular application rather than a development one. Always build with production configuration prior to deployment. This will resolve the warning to reduce the size of JavaScript and CSS. Let’s take a look at the angular.json file at the root of our Angular repository to see how the production build differs:</p><pre>&quot;configurations&quot;: {<br>  &quot;production&quot;: {<br>    &quot;budgets&quot;: [<br>      {<br>        &quot;type&quot;: &quot;initial&quot;,<br>        &quot;maximumWarning&quot;: &quot;2mb&quot;,<br>        &quot;maximumError&quot;: &quot;5mb&quot;<br>      },<br>      {<br>        &quot;type&quot;: &quot;anyComponentStyle&quot;,<br>        &quot;maximumWarning&quot;: &quot;10kb&quot;<br>      }<br>    ],<br>    &quot;fileReplacements&quot;: [<br>      {<br>        &quot;replace&quot;: &quot;projects/common/src/environments/environment.ts&quot;,<br>        &quot;with&quot;: &quot;projects/common/src/environments/environment.prod.ts&quot;<br>      }<br>    ],<br>    &quot;localize&quot;: true,<br>    &quot;optimization&quot;: true,<br>    &quot;outputHashing&quot;: &quot;all&quot;,<br>    &quot;sourceMap&quot;: false,<br>    &quot;namedChunks&quot;: false,<br>    &quot;extractLicenses&quot;: true,<br>    &quot;vendorChunk&quot;: false,<br>    &quot;buildOptimizer&quot;: true,<br>    &quot;serviceWorker&quot;: true,<br>    &quot;i18nMissingTranslation&quot;: &quot;error&quot;,<br>    &quot;ngswConfigPath&quot;: &quot;projects/bellumgens/src/ngsw-config.json&quot;<br>  },<br>  &quot;bg&quot;: {<br>    &quot;localize&quot;: [<br>      &quot;bg&quot;<br>    ]<br>  }<br>}</pre><p>There’s Once I run the application with a production configuration, the difference in score is significant in terms of load-time performance:</p><figure><img alt="lighthouse score with production build in dev environment" src="https://cdn-images-1.medium.com/max/847/0*km5i_VxTqWL0wAwn.png" /></figure><p>If I look at the opportunities list again, the number of suggestions is much lower. The biggest opportunities listed at about text compression are unused JavaScript and caching of static resources:</p><figure><img alt="remaining opportunities for optimizing Angular performance" src="https://cdn-images-1.medium.com/max/847/0*blGfvZdyX_JjUv_S.png" /></figure><h3>Angular Pre-Rendering and Server-Side Rendering</h3><p>Angular is a Single Page Application (SPA) framework. By default, the lifecycle of the app is such that upon a request from a client, the server that hosts the application serves down an HTML file that includes all the necessary script and style references. However, it is empty of body content. Once the scripts and styles are requested and served, the application is bootstrapped and populated with content based on the JavaScript logic for the given application. Angular provides two mechanisms to improve this lifecycle by serving actual content in the initial HTML document. To do this, the JavaScript logic of the application needs to be executed prior to serving the document. The ways to do it:</p><ul><li>Either at build time ( <a href="https://angular.io/guide/prerendering">pre-rendering </a>) — for pages with mostly static content.</li><li>Or at run time on the server ( <a href="https://angular.io/guide/universal">server-side rendering </a>) — for pages with more dynamic content that need to deliver up-to-date content on every request.</li></ul><p>I have enabled server-side rendering for the Angular example app and I’m using the <a href="https://expressjs.com/">express engine </a>to enable text compression and static resource caching. This is done by adding the following to my express server logic:</p><pre>export const app = (lang: string) =&gt; {<br>  // server scaffolded by [ng add @nguniversal/express-engine]<br>...<br>  // enable compression [npm install compression]<br>  const compression = require(&#39;compression&#39;);<br>  server.use(compression());<br>...<br>  // Serve static files from /browser with 1y caching<br>  server.get(&#39;*.*&#39;, express.static(distFolder, {<br>    maxAge: &#39;1y&#39;<br>  }));<br>...<br>}</pre><p>I will serve the app with server-side rendering and run the lighthouse test again. The initial load improved even further, bringing the first contentful paint to under a second, while the speed index is reduced to 1.2 seconds.</p><figure><img alt="lighthouse score with Angular server-side rendering" src="https://cdn-images-1.medium.com/max/847/0*YhYGAWEfrG1MsQJF.png" /></figure><p>The leftover opportunities for Angular optimization are to reduce unused JavaScript and CSS.</p><figure><img alt="performance optimization leftover opportunities" src="https://cdn-images-1.medium.com/max/847/0*D-1xrogwTxTElP-0.png" /></figure><p>To deal with these, I will have to do some application refactoring.</p><p>In order to reduce the unused JavaScript, the best approach would be to create <a href="https://angular.io/guide/lazy-loading-ngmodules">lazy-loaded routes</a>. This will tell the Angular framework which components are not needed in the top-level module and will split the JavaScript into modules, the logic for which is loaded only when the requested route is loaded.</p><p>The Angular example app I’m using for this blog uses larger components, like the <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/grid">igx-grid</a>, which are not part of the home route. I’m separating the routes using this component into a separate module. This way, I’m going to have that component loaded only after the routes using the component are loaded. After separating the modules, the routes look like this:</p><pre>export const routes: Routes = [<br>  { path: &#39;&#39;, component: HomeComponent },<br>  { path: &#39;register&#39;, component: RegistrationComponent },<br>  { path: &#39;unauthorized&#39;, redirectTo: &#39;unauthorized/&#39;, pathMatch: &#39;full&#39; },<br>  { path: &#39;unauthorized/:message&#39;, component: UnauthorizedComponent },<br>  { path: &#39;emailconfirm&#39;, component: EmailconfirmComponent },<br>  { path: &#39;strategies&#39;, loadChildren: () =&gt; import(&#39;./strategies/strategies.module&#39;).then(m =&gt; m.StrategiesModule) },<br>  { path: &#39;emailconfirm/:error&#39;, component: EmailconfirmComponent },<br>  { path: &#39;players&#39;, loadChildren: () =&gt; import(&#39;./player-section/player.module&#39;).then(m =&gt; m.PlayerModule) },<br>  { path: &#39;team&#39;, loadChildren: () =&gt; import(&#39;./team-section/team.module&#39;).then(m =&gt; m.TeamModule) },<br>  { path: &#39;notifications&#39;, loadChildren: () =&gt; import(&#39;./notifications/notifications.module&#39;).then(m =&gt; m.NotificationsModule) },<br>  { path: &#39;search/teams/:query&#39;, component: TeamResultsComponent },<br>  { path: &#39;search/players/:query&#39;, component: PlayerResultsComponent },<br>  { path: &#39;**&#39;, component: HomeComponent }<br>];</pre><p>The team.module is the one loading the grid I&#39;m using, so the code for it looks like this:</p><pre>@NgModule({<br>  imports: [<br>    CommonModule,<br>    FormsModule,<br>    // ...<br>    IgxGridModule,<br>    // ...<br>    TeamComponent,<br>    // ...<br>  ]<br>})<br>export class TeamModule { }</pre><p>Looking at the build, this is the result of the initial splitting:</p><figure><img alt="separating Angular app into lazy loading modules" src="https://cdn-images-1.medium.com/max/746/0*LJiD69oJiriFXXug.png" /></figure><p>Another thing that needs to be done to improve the performance of the Angular application is to limit the size of the CSS to the styles that are used. I’m using <a href="https://www.infragistics.com/products/ignite-ui-angular">Ignite UI for Angular </a>as my UI library and there’s a great how-to article on <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/general/how-to/how-to-customize-theme#theme-optimization">customizing and optimizing the component themes</a>.</p><h3>Optimizing Images</h3><p>Another aspect of the Angular optimization that should be done is optimizing the images. Lighthouse check will tell you if you’re using suboptimal images by type or size. Make sure the images you load are not larger than the containers they go in and that they are with optimal encoding. I now use .webp format for images. It reduces the quality a little, but still, the application does not require the highest fidelity images.</p><p>Images cause layout shifts after they are loaded. Hence, it’s a good idea to set width and height attributes on the images so the browser knows the dimensions before loading the images. If you’re missing the images&#39; aspect-ratio settings (width and height), Lighthouse will warn you. This will reduce or completely eliminate the layout shifts.</p><h3>NgOptimizedImage to Enforce Image Best Practices</h3><p>Angular exposes a directive that enforces image best practices and optimizes image loading for you. It’s called <a href="https://angular.io/api/common/NgOptimizedImage">NgOptimizedImage</a> and it is rather easy to use. All you need to do is import CommonModule if you&#39;re still in an NgModule based Angular application, or import NgOptimizedImage in the component where you want to use it. Then, instead of using src to set the image source attribute, you use ngSrc instead.</p><p>Finally, you can further specify the loading priority for each image and tell the app to lazy-load every non-critical image. If I remove the width and height attributes, then what I get running the app is:</p><figure><img alt="improving performance of angular by specifying loading proirity" src="https://cdn-images-1.medium.com/max/1001/0*zmyQRKmwlmlfaj-y.png" /></figure><p>And that’s it.</p><h3>Wrap Up…</h3><p>Improving the performance of Angular applications may require continuous monitoring, optimization, and best practices to ensure the app performs efficiently and reliably under various conditions. But in the end, this is how you deliver the ultimate UX, attract and retain users, maintain competitiveness, and achieve business success.</p><figure><img alt="Ignite UI Angular benefits" src="https://cdn-images-1.medium.com/max/650/0*tsF-PXhJkA4AYA0a.gif" /></figure><p><em>Originally published at </em><a href="https://www.infragistics.com/community/blogs/b/infragistics/posts/improve-performance-of-angular-applications"><em>https://www.infragistics.com</em></a><em> on July 27, 2023.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a87c075bd789" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/how-to-improve-the-performance-of-angular-application-a87c075bd789">How to Improve the Performance of Angular Application?</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[App Builder — The Low-Code Platform That Caters It All]]></title>
            <link>https://medium.com/ignite-ui/app-builder-the-low-code-platform-that-caters-it-all-8dafa8450c9f?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/8dafa8450c9f</guid>
            <category><![CDATA[blazor]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[web-components]]></category>
            <category><![CDATA[low-code]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Fri, 02 Dec 2022 12:59:41 GMT</pubDate>
            <atom:updated>2024-06-07T12:33:14.446Z</atom:updated>
            <content:encoded><![CDATA[<h3>App Builder — The Low-Code Platform That Caters It All</h3><figure><img alt="low-code app builder" src="https://cdn-images-1.medium.com/max/774/1*-Vcu9iqAdH06NA6anIlbvA.png" /></figure><p>What does the usual lead-up to app building look like? In general, what you have to do with the development team is:</p><ul><li>Collaborate through different tools or meetings</li><li>Bring in stakeholders at different stages</li><li>Calculate the costs and risks posed by given technology stack</li><li>Build interactive prototypes</li><li>Build proof of concepts with the chosen technology stack</li></ul><p>And all of this before you even start with the actual building. You and your team have to <em>decide</em>; have to <em>choose</em>.</p><p>Yes, your design team can work on an app, crafting a design in Sketch or Figma, but your development team cannot start until you choose the technology stack. But think of this for a moment — <strong>what happens when you don’t have to <em>choose</em> the technology stack upfront</strong>? Is it possible to choose the technology stack after the application is already built to a certain extent, without having to rewrite it from scratch? Is it possible to change the technology stack after the choice has been made, again, without having to rewrite the app from scratch? What type of tool can achieve and cater to all of this?</p><p><strong><em>The not-so-modest answer is App Builder™.</em></strong></p><p>This low-code platform reshapes how teams think of development by bringing together the most popular app development frameworks and the most popular design tools. With an integrated design system (<a href="https://www.infragistics.com/products/indigo-design">Indigo.Design</a>) and full-featured UI components, <a href="https://www.appbuilder.dev/platform">App Builder</a> modernizes not just the approach, but the mindset dev and design teams have about projects. Using it, you, in fact, are given the opportunity and the means to develop software, starting either from scratch within the App Builder or by using a pre-built screen design in Sketch and Figma imported into the App Builder. You can work on a new project with the idea of building AN application. Not <a href="https://www.infragistics.com/products/ignite-ui-blazor">Blazor</a> or <a href="https://www.infragistics.com/products/ignite-ui-angular">Angular</a> or <a href="https://www.infragistics.com/products/ignite-ui-web-components">Web Components</a> application but “A” technology-agnostic application that can be easily code-generated and downloaded against any of the supported technology stacks at any point of the development process.</p><figure><img alt="Application generated in pure Web Components implementation" src="https://cdn-images-1.medium.com/max/941/1*xz_cHQwQUM8L7amI-P4dSg.png" /><figcaption>Application generated in pure Web Components implementation</figcaption></figure><p>This means you have the ability to choose what is targeted by that app at any point in time and not the other way around — to select the technology stack and build the app based on it.</p><p>Now, the dev community still appears to be divided by two key but significantly different beliefs in terms of low code:</p><ol><li>Some believe the end of human development is just around the corner, and low-code/no-code tools are just a tiny bit away from producing the most optimal output.</li><li>Others shiver every time they hear the words “low code” because they doubt low-code/no-code tools can produce high-quality code and efficient software solutions.</li></ol><p>But App Builder has already gone far beyond clean code generation only. Making a giant leap with the latest 22.2 product upgrade, it now focuses on things like:</p><ul><li>Component and feature-parity between target frameworks</li><li>Data Grid, Tree Grid, and more availability on all platforms</li><li>Full Web Components Code Generation output in addition to Blazor and Angular</li><li>Complete UI Kit support by adding Figma UI Kits</li><li>Ability to share app previews publicly</li></ul><figure><img alt="App Builder design to code story" src="https://cdn-images-1.medium.com/max/1024/1*8xSuMVU_o8wpAva4biaVDA.png" /></figure><p>After all, this is what really <a href="https://medium.com/ignite-ui/infragistics-design-to-code-solution-explained-e9378eb448e7">completes the entire design-to-code story</a>, empowering you to build an app and then choose what framework to target.</p><p>To demonstrate the complete feature and component parity capability, let’s say you want to create an app which contains a view displaying large amounts of hierarchical tabular data. You can start a new web application with almost no dependencies (web components) scaffolded with a CLI. Then you can add a view containing a <a href="https://www.infragistics.com/products/ignite-ui-web-components/web-components/components/grids/tree-grid/overview">Tree Grid</a> component, again using the CLI, you can quickly bind your data with very little code and use a variety of events to customize the component behaviors. The difference with App Builder is that you can start building before you choose Web Components as your target. You can create the view and routing structure visually, and you can simply drag and drop the tree grid component onto the design surface in the desired view. Databinding is also part of the visual experience in the App Builder and it allows you to bind directly to already-existing RESTful services you have. Then, you can make the choice on the fly to generate against Angular, Web Components, or Blazor. You can also switch between frameworks on the fly or generate against multiple such. It’s built to be a click of a button away with App Builder.</p><h3>Recap: Some Key Facts About App Builder With the 22.2 Release in Mind</h3><p>Intended to change the way you build mission-critical solutions, the low-code App Builder enables you to kick-start your app with a new type of development techniques and methodologies, taking you very far before you have to write (or even generate) any code. And with the <a href="https://www.infragistics.com/community/blogs/b/infragistics/posts/app-builder-22-2-whats-new">App Builder 22.2 Release</a>, it marks one of the most significant upgrades in its capabilities to date.</p><ul><li>It now supports Web components as a target.</li><li>It lets you generate the app in Blazor, Angular, and/or Web Components.</li><li>Full component and feature parity between the target platforms.</li><li>Now adds a band-new Figma UI kit that maps to a real component set.</li><li>It arrives with tons of new components, such as a Tree Grid, Accordion, Rating, Tabs, Tree, and Navigation Drawer.</li><li>Improved features, including OpenAPI improvements, filtering for endpoints, and Repositioned zoom settings.</li><li>Offers full Safari browser support.</li><li>Share App Preview functionality.</li></ul><p>App Builder even provides the most modern approach and high-speed RAD development to desktop application developers, enabling them to migrate to larger web application projects with an upgraded UI toolbox with more grids and charts.</p><p>It still helps teams overcome the chaos of multiple tools, legacy systems, and cumbersome processes across teams while delivering business-critical solutions at the same time.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FuT3k_HZiWbU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DuT3k_HZiWbU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FuT3k_HZiWbU%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/c50555504187fc342a004b18aad17837/href">https://medium.com/media/c50555504187fc342a004b18aad17837/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8dafa8450c9f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/app-builder-the-low-code-platform-that-caters-it-all-8dafa8450c9f">App Builder — The Low-Code Platform That Caters It All</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infragistics’ Design-to-code Solution Explained]]></title>
            <link>https://medium.com/ignite-ui/infragistics-design-to-code-solution-explained-e9378eb448e7?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9378eb448e7</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[web-components]]></category>
            <category><![CDATA[low-code]]></category>
            <category><![CDATA[blazor]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Tue, 22 Nov 2022 15:14:18 GMT</pubDate>
            <atom:updated>2025-02-21T12:48:07.300Z</atom:updated>
            <content:encoded><![CDATA[<h3>App Builder’s Design-to-Code Solution Explained</h3><figure><img alt="Infragistics’ design-to-code solutions — App Builder and Indigo.Design" src="https://cdn-images-1.medium.com/max/774/1*D_ulN0rL-Eg2hRUE3UkZhw.jpeg" /></figure><p>In this article I will explain the core components and models of Infragistics’ low-code/no-code design-to-code solutions and quickly break down the 3 different sizes of organizations so you can better understand their app development cycles and the ways in which <a href="https://www.appbuilder.dev/platform">App Builder</a> fits in to streamline everything from design to code. My idea is to help you learn how such design-to-code solutions reinvent web app design and development and what exactly makes them a necessity for all your processes.</p><h3>What Is Design to Code?</h3><p>In brief, design-to-code is the process of transitioning a software application from its design phase to the software implementation. This process usually involves handoffs between multiple teams.</p><h3>What Are Design-to-Code Tools</h3><p><em>noun</em></p><p>Web app design and development platforms that work as a single source of truth to bring together teams, eliminate handoffs, and streamline every single phase from the web application design and development process.</p><p>This is how I would define these app development accelerators.</p><p>The need for tools that serve as time-savers is growing and enterprises from different sectors (fintech, clinical studies, IT, health, travel, logistics) have started to see and implement them as business-critical solutions. So, innovations like Indigo.Design and App Builder step in to make huge progress and refine web app design and development.</p><h3>How Different Size Companies Build Web Apps</h3><p>The process can be quickly summed up like this — If you want to build an application, you start with a design that you’re going to put together in terms of an app. Since in the individual developer/small shop size organization, the designer and developer can and often are the same person, it will be you again who will then take that design and develop the web application for it. Once you are satisfied with what you have made, you match it against the design again. You look at it, you say “All looks fine, I’ve tested everything”, and then, you deploy it. And this web application is made live.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*DKBjMq4oXcuYtJQb.jpg" /><figcaption>Individual developer/small shop development process</figcaption></figure><p>Simple, right? But wait for it.</p><p>This process, which includes a design-develop-deploy phase with few subphases, is typical for individual developer/small shop organizations that include a maximum of five people (usually developers) and, at most, one designer.</p><p>If we look at a mid-size organization as a comparison, it comprises around 250 employees—not all of them developers, of course.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*txlhMZ9Trn4QWofz.jpg" /><figcaption>Mid-size organization development process</figcaption></figure><p>There are different departments—sales, marketing, a designated design team, and so on. They either build apps for themselves or as contractors, responding to the needs of other companies and external projects. The app development process is pretty much the same, but there are several other intermediate steps.</p><p>Then, we have large-size organizations, and the app development process here is as follows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*YtiZuqj4I6wM2zAL.jpg" /><figcaption>Large organizations development process</figcaption></figure><p>More steps, more approvals, more stakeholders that get involved in every step — design, development, approval, deployment. Usually, teams have to collaborate over different mediums, platforms, apps, and even countries and time zones. There are various types of software that the organization utilizes to produce wireframing, view designs, screen designs, and deliver an actual web app in the end.</p><p>Also, more requirements are being posed for this type of organization, and apps are often built for internal purposes and use. System integrators fall into the large organization category, but they still primarily build large apps for other organizations.</p><p>Looking at these organizations, there is no significant difference between the steps that they usually take to build their software. It is the amount of collaboration cycles and handoffs that complicate the process. Here comes one of the biggest challenges when teams collaborate — they usually do it over too many mediums. They use Outlook for e-mail, Teams for video calls, GitHub, and web tools for tasks. There are also Visual Studio Online or TFs git, vector graphic design platforms, and team collaboration frameworks that mix in on top of all other tools. It is a lot. And juggling between tools and software products usually brings in a lot of friction.</p><p>Our solution considers not only the design and development operations but also the collaboration process. It starts with <a href="https://www.infragistics.com/community/blogs/b/infragistics/posts/building-a-design-system">a design system</a> that integrates <a href="https://appbuilder.dev/">low-code/no-code App Builder</a> to align UX, product management, and product development.</p><h3>App Builder in a Nutshell</h3><p>App Builder is a <a href="https://www.youtube.com/watch?v=G2au0V4EXig">design-to-code</a> platform that enables operational alignment, deep collaboration, and ongoing innovation at the product level (DesignOps) with a complete low-code multi-user experience for web application delivery.</p><ul><li>Enables enterprise UX and product delivery teams to operationalize compatibility between UX, product management, and product development</li><li>Supports Sketch and Figma design files</li><li>Works as a single source of truth across enterprise teams, facilitating collaboration with stakeholders</li><li>Allow for user testing with deep analytics, and image-based prototyping</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LaWvHeLnhU4FU5BXF3s8Pw.png" /></figure><h3>Core Parts of Infragistics’ Design-to-Code Solution</h3><h4>UI Kits — The Third-party Design Tooling Implementation of The Indigo.Design System​</h4><p>The <a href="https://www.appbuilder.dev/blog/guide-to-ui-kits">UI kits</a> follow the exact same design system for all technologies, which means that designers can even switch their tool for choice (say from Sketch or Figma) and they will still be supported to continue designing with symbols provided by us for the specific tool.</p><ul><li>They target and help designers regardless of what tool they use, enabling them to work with a tool of their choice while being able to integrate with App Builder, reducing friction</li><li>Work as the source of truth for UI components, independent of platform implementation</li><li>There are adapters for Sketch and Figma as well, which utilize the metadata behind the UI kit symbols in order to bring the designed screens into the App Builder and visualize them in terms of actual components</li></ul><h4>UI components — Framework-specific Reusable Component Implementations</h4><p>Their behaviors, look and feel are driven by the design system.</p><ul><li>Reusability of concepts across frameworks​</li><li>Every new component is made available in the App Builder platform</li><li>A toolbox for <a href="https://www.infragistics.com/products/ignite-ui-angular">Angular</a>, <a href="https://www.infragistics.com/products/ignite-ui-blazor">Blazor</a>, <a href="https://www.infragistics.com/products/ignite-ui-react">React</a>, <a href="https://www.infragistics.com/products/ignite-ui-web-components">Web Components</a>.</li></ul><h4>Common App Model — The Centerpiece of the System</h4><p>It allows us to describe applications in a framework agnostic manner.</p><ul><li>Abstract a way of defining application structure, views, and interactions​</li><li>Enables you to have one and the same app in different technologies</li><li>Takes a design, makes it understandable for the App Builder, and enables code generation for Angular, Blazor, or Web Components (React still in progress)</li><li>Defines common patterns across technologies​</li><li>Generated by design tool parsers on top of the UI kits, the App Builder, or other third-party plugins​</li></ul><h4>App Builder — The Crown Jewel of Our Design-to-Code Solution</h4><p>In brief, App Builder is the platform that allows you to visually design apps and generate code for them against Angular, Blazor, or Web Components (React coming soon) in a low-code/no-code fashion. Everything is drag-and-drop, delivering a true WYSIWYG development experience. You have components in the toolbox, different types of view layouts you can choose from, and navigation/structure between the views.</p><ul><li>Uses Angular/Blazor components, covering all design and application requirements</li><li>Works as a time-saver that produces code to kickstart your app with the same, or better quality as the code you would write yourself</li><li>Allows you to start your app from scratch, from ready-to-use project templates, or from already finished Figma, Sketch, or Adobe XD design files</li><li>Serves as a single source of truth that facilitates collaboration between developers, designers, PMs, and stakeholders​ that can come in at any stage of the app development cycle</li><li>Consumes the common application model through the parsers (the meta data provided from the UI kits) and produces it through its design surface</li><li>Receives <a href="https://www.youtube.com/watch?v=i0RggYN3eqM">continuous enhancements and features</a></li></ul><p>One of our clients highlights that:</p><p><em>“Out of my experience, the App Builder enables time savings of 70% or more when creating a fully functional app framework. The collaboration with designers, customers and other parties involved is considerably accelerated and significantly optimized.</em></p><p><em>The ability to easily create an application with the UI components and styles used in the final app and to show them interactively without programming them in advance is a priceless advantage when it comes to realizing customer requirements.</em></p><p><em>The Angular app generated by App Builder is no different from an application created with the Angular CLI and can be completed with the usual workflow.”</em></p><h4>Code Preview and Generation</h4><p>Code Gen is a service that consumes the Common App Model and produces framework-specific code for applications .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*2fceAmaBCEIDtUUe.jpg" /><figcaption>App Builder Preview with Code</figcaption></figure><ul><li>Understands the transition from an abstract app model to the specific product implementing the UI components in the application​</li><li>Understands common application patterns — routing, behaviors, transitions​</li><li>Can deploy the generated application to a new GitHub Repository​</li><li>Can PR updates to an existing GitHub Repository​</li><li>In the future will be able to initiate a build and Azure deploy of the generated application​</li><li>Lets you toggle the code-view ON and see it side-by-side with the running application</li><li>There is <a href="https://www.appbuilder.dev/blog/angular-code-generation">code generation for Angular</a> or <a href="https://www.appbuilder.dev/blog/blazor-code-generation">Blazor code generation</a></li></ul><h4>GitHub Integration</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/0*WlJs_9clWgKG8rUa.png" /><figcaption>App Builder GitHub integration</figcaption></figure><p>Through the App Builder, we enabled GitHub integration. You can sync the project you work on from the design surface to a GitHub repository, where the actual generated code in the targeted platform can reside.</p><ul><li>Generated code from designs can be uploaded directly to GitHub as new user repositories​</li><li>Updates to designs with associated GitHub repository can be initiated as a Pull Request through the App Builder</li><li>App Builder will offer deployment of the generated application directly to Azure​</li><li>Code Generator creates GitHub actions yml for deployment and CI</li></ul><p>And that’s it.</p><p>When you’re in the IT sector, you quickly come to realize that the agents, the processes, and the factors that affect the way in which we currently put together web apps are constantly changing and becoming more complex.</p><p>There are:</p><p>Fusion teams, individual developers, single-player designers, stakeholders, PMs, UX writers, marketers, usability testers, clients with their specific requirements, digital-savvy consumers who can very quickly discard software developments that lack the velocity, functionality, and comprehensiveness they are used to.</p><p>Ideation phases, designing, <a href="https://www.appbuilder.dev/blog/designer-developer-handoff">handoffs</a>, coding, POCs, iteration, testing, deployment, marketing, and so forth.</p><p>Compressed time, dynamic working environments, change in priorities, digital transformation, and scattered communication across different channels.</p><p>It sounds too complex, takes too long, and could really use some automation and tooling.</p><p>This is why design and development “reinventors” like App Builder step in, speed up DesignOps and DevOps, and refine the way we craft modern-day web applications with about 80% increased time-to-market.</p><p><em>This blog was originally posted in the </em><a href="https://www.infragistics.com/community/blogs/b/infragistics/posts/infragistics-design-to-code-solution"><em>Infragistics Blogs</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9378eb448e7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/infragistics-design-to-code-solution-explained-e9378eb448e7">Infragistics’ Design-to-code Solution Explained</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Angular Pivot Grid & How to Get Started with ItI?]]></title>
            <link>https://medium.com/ignite-ui/what-is-angular-pivot-grid-how-to-get-started-with-iti-6e9d6b700f4?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e9d6b700f4</guid>
            <category><![CDATA[components]]></category>
            <category><![CDATA[pivot-tables]]></category>
            <category><![CDATA[pivot]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Tue, 29 Mar 2022 15:12:33 GMT</pubDate>
            <atom:updated>2024-04-15T07:12:19.910Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is Angular Pivot Grid &amp; How to Get Started with It in Ignite UI?</h3><p>In this post, we will review Pivot Grids and will explain what and when they are used for. Most importantly, we will cover in depth what Angular Pivot Grid is in particular and will show you how to easily get started with our Ignite UI for Angular Pivot Grid component.</p><p>In essence, Ignite UI for Angular offers a wide variety of high-performance angular grid components. The <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/grid">igx-grid component</a> is probably the best choice for showing high-volume flat tabular data in an Angular application, but it also supports a compact <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/master-detail">master-detail</a> with a custom non-tabular details view. The <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/treegrid/tree-grid">igx-tree-grid component</a> is ideal for displaying hierarchical data with homogeneous schema with hierarchical aggregations on it. The <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/hierarchicalgrid/hierarchical-grid">igx-hierarchical-grid</a> is the component allowing developers to show full table hierarchy for application scenarios requiring the visualization of large amounts of relational data. The only major grid component that Ignite UI was missing so far, was a pivot grid component, and <a href="https://github.com/IgniteUI/igniteui-angular/releases/tag/13.1.0-alpha.1">igniteui-angular 13.1.0</a> introduces <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/pivotGrid/pivot-grid">igx-pivot-grid</a> with an accompanying pivot data selector component!</p><h4>What is a Pivot Grid?</h4><p>The most familiar reference to a pivot is probably the one in excel. A pivot grid gives users tabular UI where they can configure different dimension settings for rows and columns, as well as data filters and data aggregations. It basically allows for data view slice-and-dice. End-users prefer pivot views for large amounts of data to be brought down to a compact consumable view, which offers only the dimensions and the data relevant to what the user wants to see at a particular point of time.</p><h4>What are pivot grids used for?</h4><p>Unlike typical data grids and tables where you can create a static view, pivot grids and tables allow you to not only present the data from a given data table in the structure it is stored, but to also change the way data is being displayed. For example, imagine we have a pivot grid preset to show sales for products in different countries. In the current view we have periods separated by years and quarters, and we can see each country and products. But, if we want to switch the view, we can actually make it possible to filter the data and see how we’re doing not by country but by individual product instead in particular timeframe, years, and quarters.</p><p>Here’s an example of a sample pivot table view of profits aggregated by quarters and separated by country and product.</p><figure><img alt="sample pivot table view of profits by country and then product" src="https://cdn-images-1.medium.com/max/1024/1*n3csIabVxLprYWe6k_5znA.png" /><figcaption>sample pivot table view of profits by country and then product</figcaption></figure><p>This visualization is done by using the new igx-pivot-grid component. The view is not fixed only to these dimensions. The component allows me to change the way I see the data by dragging and dropping columns into the corresponding bands for row and column dimensions, as well as to add other aggregations and filters. All I need to do to see the same data in the example above, but broken down by product first, and then by country for each product, is to switch the product and country chips in the column dimensions strip.</p><figure><img alt="sample pivot table view of profits by product and then country" src="https://cdn-images-1.medium.com/max/1024/1*7AcA2Xqu-MuQU9ZuggbDxA.png" /><figcaption>sample pivot table view of profits by product and then country</figcaption></figure><h4>Angular Pivot Grid Data</h4><p>The visualization shown above suggests a complex structure of the data the grid is bound to. However, this is not the case. The grid binds directly to a flat data collection. Aggregations and dimension transformations are performed by the underlying client-side grid engine according to configurations provided by the developer or defined by end-users through interactions with the UI. This is what an individual data record the grid above is bound to looks like:</p><pre>{</pre><pre>  &quot;Country&quot;: &quot;UK&quot;,</pre><pre>  &quot;Product&quot;: &quot;Vermont&quot;,</pre><pre>  &quot;Units Sold&quot;: &quot;501&quot;,</pre><pre>  &quot;Manufacturing Price&quot;: 15,</pre><pre>  &quot;Sale Price&quot;: 23,</pre><pre>  &quot;Gross Sales&quot;: 26440,</pre><pre>  &quot;Discounts&quot;: null,</pre><pre>  &quot;Sales&quot;: 26440,</pre><pre>  &quot;COGS&quot;: 16185,</pre><pre>  &quot;Profit&quot;: 11255,</pre><pre>  &quot;Date&quot;: &quot;1/1/20&quot;,</pre><pre>  &quot;Month Name&quot;: &quot;January&quot;,</pre><pre>  &quot;Year&quot;: &quot;2020&quot;</pre><pre>}</pre><h4>So what about OLAP services and cube data?</h4><p>The igx-pivot-grid is a client-side Angular component, which expects JSON data. If you have an OLAP service, you can use it with this pivot grid. The component exposes hooks, which allow you to override (opt out of) the client-side functionality and hand-over all the cube work to your OLAP service. The grid will just display the data that your service returns.</p><h4>And is there UI for adding dimensions?</h4><p>Yes, there is. We call this the pivot data selector. I intentionally didn’t show it in the screenshots above, in order to focus on the pivot table. Continuing the example above, I may want to see aggregations of the revenue in addition to the profit.</p><figure><img alt="pivot grid and pivot data selector — adding revenue aggregations" src="https://cdn-images-1.medium.com/max/1024/1*Guq5DebbhAO_Jb9r7OH2jQ.png" /><figcaption>pivot grid and pivot data selector — adding revenue aggregations</figcaption></figure><p>I can also change the visualization completely by switching which data columns are shown as row and which by column dimensions. Here’s the same data but showing country records by quarters aggregated by product sales and profits.</p><figure><img alt="Changing the pivot view to show country row dimensions by quarters" src="https://cdn-images-1.medium.com/max/1024/1*BiRBhFgNpD-_hsrdK9Sj5g.png" /><figcaption>Changing the pivot view to show country row dimensions by quarters</figcaption></figure><h4>How to Get Started with the Ignite UI for Angular Pivot Grid?</h4><p>If you’ve never used Ignite UI for Angular before, I suggest you go to the <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/general/getting-started">general getting started</a> first and then to proceed with the <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/pivotGrid/pivot-grid">articles on the pivot grid</a>. Component documentation is accompanied by live running samples with code inside. One of the things you need to get started is data. If you don’t have your data ready and available when you want to try the component for the first time, you can always use the sample data, which we’ve used in the samples. If you get stuck, or simply want to share your experience with the components, you can always get a hold of somebody on the Infragistics team in the <a href="https://discord.gg/39MjrTRqds">Infragistics Discord server</a>. You can also submit issues in the <a href="https://github.com/IgniteUI/igniteui-angular">Ignite UI for Angular GitHub repository</a>.</p><p>And in case you are searching for a complete set of Material-based UI widgets, components &amp; sketch UI kits, check out the comprehensive <a href="https://www.infragistics.com/products/ignite-ui-angular">Ignite UI library for Angular</a> and <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/grid">Angular data grids.</a></p><p>Or why not even go for our brand-new <a href="https://www.appbuilder.dev/platform">WYSIWYG drag-and-drop App Builder</a> software to speed up development time and cut development time and costs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e9d6b700f4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/what-is-angular-pivot-grid-how-to-get-started-with-iti-6e9d6b700f4">What is Angular Pivot Grid &amp; How to Get Started with ItI?</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Low code development — developer’s view]]></title>
            <link>https://medium.com/ignite-ui/low-code-development-developers-view-fafde4e423f8?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/fafde4e423f8</guid>
            <category><![CDATA[low-code]]></category>
            <category><![CDATA[low-code-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[low-code-platform]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Wed, 26 May 2021 13:41:26 GMT</pubDate>
            <atom:updated>2024-04-15T08:53:13.449Z</atom:updated>
            <content:encoded><![CDATA[<h3>Low code development — developer’s view</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZUGMaJEXsZHVSYx9" /><figcaption>Photo by <a href="https://unsplash.com/@jstrippa?utm_source=medium&amp;utm_medium=referral">James Harrison</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’m writing this article from the point of view of a software engineer and developer with 10+ years of experience. My experience with software varies from designing and building smaller web applications, through web UI frameworks, to larger SaaS applications. I consider myself having decent experience and I claim that I’m a skilled developer and know my way around. I don’t need tools that produce code for me, because I would produce better code myself. But would I really, and are low-code solutions producing suboptimal code? In this article I’m going to build a case for a specific low-code solution: <a href="https://www.appbuilder.dev/platform">App Builder</a>. The solution currently outputs Angular, Blazor, and Web Components applications. The examples would be with Angular specific concepts.</p><h3>Starting from scratch</h3><p>Starting an Angular application from scratch has never been easier. The Angular CLI prepares a repository for me with a single command and allows me to subsequently produce new components, directives, services, modules, pipes, etc. with a single command. This saves time from manually creating files and populating the bootstrapping code by hand. It also sets everything up for unit testing, static code analysis, e2e testing, building, etc. This is a good example of a tool that produces code with the same quality, if not better, than I would produce myself. I use it all the time and given the number of installs the Angular CLI has on NPM, other developer use it too!</p><p>Let’s take the Angular CLI one step further, though. We have produced our own CLI called the <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/general/cli-overview">Ignite UI CLI</a>, which not only produces project structure and blank components, but also allows you to scaffold preconfigured UI components for different scenarios. This saves even more time from writing out component configuration code by hand, but still requires manual configuration changes to achieve the specific scenario we’re aiming for in an application.</p><p>What if we take the CLI and add some GUI on top of it? Well, Nrwl have already done that with the <a href="https://nx.dev/latest/angular/getting-started/console">Angular Console</a>. It’s still a tool, which produces container files with configuration in your project repository. Anything further needs to be coded by hand.</p><p>In any case, after creating the structure of our applications, we need to add lots of code to create a functional app with UI that matches the designs that we have created, or have been handed off to us.</p><p>So what if we could actually start from the point where we have the designs laid out in components for us?</p><h3>Creating POCs</h3><p>How does a concept get to a proof of concept (POC) in my experience? We have a high level vision or target and designers start conceptualizing this vision in screens they create using the tools they are used to. Designers I’ve worked with mostly have preference for Sketch and Adobe XD (depending on their choice of Mac vs. PC). Then those high fidelity screens are presented and handed over for coding, so the POC can come alive. At this point I not only have to bootstrap an Angular application, but also have to visualize everything that comes from these high fidelity designs into actual functional components, so the POC can be presented to stakeholders in order to get approval for full implementation. Implementation of the POC can take up to a day per screen, depending on how detailed or how complex the screens are. Having the Angular components helps, since they are ready to use and things like lists, avatars, grids, etc. are ready to use with simple configuration, but I still have to lay them out, configure and tweak in order to get as close to the design as possible. However, very often POCs get scrapped or reworked several times after they have been evaluated, because stakeholders tend to like static screens, but once they see them in an interactive POC, they notice issues they have not been able to discover in the initial designs. This creates a lot of waste!</p><p>Now, what if I can get the design to be interactive, or at least represented by real Angular components. Wouldn’t this eliminate tons of waste for me and my team and wouldn’t this speed up the POC creation and evaluation phase tremendously?</p><h3>Starting from scratch with App Builder</h3><p>The App Builder platform lets me do precisely what I asked for! When I first open it up, I see that it lets me start from scratch, from premade layouts or applications and it also lets me upload a Sketch file or use Figma UI plugin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n680uSHVTUHRRA_ywv3tfQ.png" /><figcaption>App Builder new app screen</figcaption></figure><p>As I mentioned, I already have Sketch files to start from, so my starting point is from a Sketch design. This is what the sketch design I’m going to work with looks like (visualized in XD, since I work on a PC):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rhm4RBsotF7pgwIPHOv1PQ.png" /><figcaption>Sample Sketch design</figcaption></figure><p>Let’s see what the App Builder produces when the Sketch screens are uploaded and processed by the tool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FcGRRegXbbPDMqANZESnTw.png" /><figcaption>People App Sketch design loaded in App Builder Screen #1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ON6cljRlTBLKPjtUleL7Pw.png" /><figcaption>People App Sketch design loaded in App Builder Screen #2</figcaption></figure><p>So far it looks like another design canvas visualization of what we have in Sketch, which is pretty similar to what Adobe XD does when opening Sketch designs. However, <strong>it’s not</strong>! Let’s see why by going into preview mode and inspecting the code view:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N2Hy4HbrmlCu90Ena1TLtw.png" /><figcaption>Home screen of the People App in App Builder preview with code</figcaption></figure><p>As you can see, each view has a generated Angular component for it, and inside there’s pretty clean component template and definition, which is composed of other components. The four screens produced in the App Builder from the Sketch design are also completely independent components in the App Builder. There’s no routing between them, or interactions that connect them. This is so, because the Sketch design doesn’t define any dependencies between the screens and the tool has no metadata to work off of. I will go ahead and download the generated application from the App Builder by clicking the “Generate App” button in edit mode and this is what I get:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1KTPfREQS9sPucObvNr9JQ.png" /><figcaption>Downloaded generated People App from the App Builder</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xNobLxSSc7tXun2bEiGE7w.png" /><figcaption>Home page of the generated People App through App Builder</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5gw9rghViTXaS1YwdBSbww.png" /><figcaption>Running home page of the generated People App through App Builder</figcaption></figure><p>As you can see, I did nothing after uploading the sketch design in order to get a running Angular application produced with Ignite UI for Angular components used in the Sketch design that I have received. This is what I was looking for! I just eliminated the waste and made my starting point with the app be much more developed than simply scaffolding my application through a CLI. In fact, the base repository that the App Builder generates is scaffolded using the Ignite UI CLI and then components are generated on top of this repository. I already see an issue though — what if I change the code in the generated application? How would this sync with the App Builder? Well, the answer is that the App Builder provides integration with <a href="https://github.com/">GitHub</a>, which allows me to not just download the generated code repository, but to be able to put this code into a GitHub repository and to pull new updates from the App Builder to the GitHub repository.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iO1TRKb9EBJBtROTj0zcyQ.png" /><figcaption>Publishing from the App Builder to GitHub</figcaption></figure><p><strong>NOTE:</strong> The sample design is created using the <a href="https://cloud.indigo.design/redirect/download/ui-kit">Ignite UI Kit for Sketch</a>, which is important because this is how the App Builder knows how to deterministically convert Sketch symbols into corresponding Ignite UI for Angular components.</p><h3>Advanced App Builder Usage</h3><p>There are UI patterns that I often reuse between applications. My usual approach is to create a small internal library of components and to reuse it across different applications. Example of such patterns would be a login and registration screen. Let’s see how I can do the same thing using the App Builder. I have created an App called Common UI Patterns, which contains different components I reuse often across applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TrMMztY0OzZAV1Q5xquSrw.png" /><figcaption>Common UI Patterns App in the App Builder</figcaption></figure><p>Now I’m going to copy my Login view and I’m switching to a different application I’m working on where I want to add it. I’ll add a content dialog window and I’m going to paste my login view into the dialog content.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fp740srYKaLHCJ_C9P9HCg.png" /><figcaption>Adding a login window to the team collaboration application</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ror4zEdssY0x8Q7wsRTIhw.png" /><figcaption>Content Dialog Window created</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KIhlo4N9w9TvCGuXMyKS6g.png" /><figcaption>The login view is added</figcaption></figure><p>You will notice that the color of the login button is different. Did I change it after pasting? No. The pattern automatically adjusts itself to the theme applied to the application that I’m working on because of the <strong><em>powerful theming engine</em></strong> that <a href="https://www.infragistics.com/products/ignite-ui-angular">Ignite UI for Angular</a> offers. I can demonstrate this through the theming pane.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JPCufJGo_nGSgSJc0r0xTA.png" /><figcaption>Changing the application theme</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CDNcyUW90U0-fTWxH6f2pA.png" /><figcaption>The theme is applied to the reused component</figcaption></figure><p>The code generation of the App Builder will take care of generating the Sass for the color palettes and the necessary theming mixin calls.</p><p>I have the login view now, but I need to make the application spawn it. I will replace the avatar in the navbar with a login button and will attach an action to it, which spawns the login dialog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hkTqWSSoNeIr7mfDGomZKg.png" /><figcaption>Adding a login button</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S9GNycOjQJi3dx47quKbkQ.png" /><figcaption>Attaching an action to the login button</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rqtAbuULZJCp3xB_0MFkyw.png" /><figcaption>In preview mode the login dialog is spawned by clicking “Login”</figcaption></figure><p>As a final step, let’s generate the application to see what we will get. I download the repository and open it in <a href="https://code.visualstudio.com/">VSCode</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4MrOpLHtg8yZkRMF8mG59A.png" /><figcaption>The generated repository opened in VSCode</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PqIMT37PyW84Pf_XfxkDjA.png" /><figcaption>Generated Angular app landing page</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6iq511qs5DEVNqz-AWLLlA.png" /><figcaption>Login view after clicking the login button</figcaption></figure><p>I was able to produce this within a few minutes using a ready-to-use app template and a UI pattern project, which I’ve created earlier. Isn’t this amazing?</p><p><strong>NOTE</strong>: In the example I give, I use a separate application project where I keep my UI patterns. The upcoming feature updates of the platform will include UI patterns as items users can develop and add directly into their own toolbox, so they don’t have to switch projects.</p><h3>Conclusion</h3><p>My initial opinion on low-code solutions was somewhat skeptical, but after looking at the code the App Builder produces, which I don’t have to redo myself, but can instead build on top of, I think that low-code solutions can actually be a really helpful mechanism for streamlining the app development process and for reducing and eliminating waste during hand-offs. Also, the fact that I can use the App Builder to generate the same applications that I just created as Blazor applications, by just switching the target from a drop down, make it even more useful, as I’m not locked to a target framework. Regardless of the fact that this is a platform I’m heavily involved with, I have been looking at it entirely from an external developer point of view.</p><p>The App Builder platform and the <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/general/getting-started">Ignite UI for Angular</a> component library can be tried out for free!</p><h3>Additional Resources</h3><p>Read more on <a href="https://www.appbuilder.dev/blog/what-is-low-code-development">low-code development</a></p><p>Read more on <a href="https://www.appbuilder.dev/blog/angular-code-generation">Angular code generation</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fafde4e423f8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/low-code-development-developers-view-fafde4e423f8">Low code development — developer’s view</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Performance [Web]]]></title>
            <link>https://medium.com/ignite-ui/software-performance-web-61158c8583d?source=rss-40673d29c70a------2</link>
            <guid isPermaLink="false">https://medium.com/p/61158c8583d</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-performance]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Konstantin Dinev]]></dc:creator>
            <pubDate>Tue, 25 Jun 2019 12:46:11 GMT</pubDate>
            <atom:updated>2023-04-12T13:24:00.048Z</atom:updated>
            <content:encoded><![CDATA[<p>Performance is one of the most important, if not the most important, vectors that should be considered when producing software products. The adoption of your software by new users, as well as the retention of those users relies heavily on the performance that your solution has. Hence the very famous anecdote with the Google search engine, that meaningful search results must be returned to the user within three seconds of initiating the search. Going past the three second mark makes the user hit the refresh button of the browser, thinking that something went wrong. Performance is not important just for search engines, however. Users expect any software, that they use daily, to load fast and to respond fluidly to their interactions.</p><h3><strong>Software Performance Dimensions</strong></h3><p>Software performance is not a single feature that we can implement, or measurement that we can take. It’s the general behavior of the software. All features of the software we produce need to take into account how well they perform individually, and in combination. There are three main dimensions that we can measure software performance on, and to respectively try to improve it on — load time performance, run-time performance, and soft performance. When looking to improve the performance of our software, all three dimensions need to be considered, because going after no single one of them would not improve the general satisfaction of our users.</p><h4><strong>Load Time Performance</strong></h4><p>This is probably the easiest of the three dimensions for us to observe and measure. Load time performance is simply how fast our software application loads. For a desktop application, the time is measured from the user interaction triggering the software executable application, to the time the user can start interacting with the software. We call this measurement “time to interactive”. Load time performance is very important for on-boarding your new users.</p><h4><strong>Run-time Performance</strong></h4><p>Run-time performance is defined by how responsive our software is to user interactions. Run-time performance would be different for each navigation within the application, as well as each interaction with a component within it. Measuring run-time performance is done on multiple levels — individual component responsiveness, general view responsiveness, navigation between views, memory consumption. Run-time performance is important for user retention.</p><h4><strong>Soft Performance</strong></h4><p>Soft performance is the trickiest of dimensions, as it’s defined by the general usability of your software. It’s measured by observing users and evaluating how easy and intuitive it is for them to perform the general tasks your software is intended for. Soft performance on its own has plenty of dimensions, from how easy it is for your user to find and navigate to the feature they want to use, through how appealing the look and feel of your application is, to how good the error messages your software produces are, in order for your end user to understand what they did wrong.</p><h3><strong>Performance in Web</strong></h3><p>Performance in web is a complicated subject, as it does not simply depend on how the software was written and what hardware the client machine has. It’s also heavily dependent on the type of browser being used, and on the way assets and resources have been optimized. Over the past 10 years things have gotten a lot better with the end of support for Windows XP and respectively for Internet Explorer 6, 7, 8 (also mostly 9 and 10). However, Internet Explorer 11 still comes with the latest version of Windows, and some legacy applications, especially the ones that still include ActiveX modules require IE11 to run. If you think that this scenario is edge-case, you should know that there are a lot of such enterprise applications that still exist! With IE11 in mind, performance in web applications becomes even trickier.</p><p>Let’s look at the different performance aspect that we should consider for web applications, and how should we tackle them to provide our users with the most optimal performance possible. Based on the previous overview, we will look at load time performance, run-time performance, and soft performance.</p><h3><strong>Load Time in Web</strong></h3><p>Load time performance is the time it takes for your application to load, for the user request in the browser, to the time the application is interactive. There are various tools that you can use in order to measure load time performance of your web application, and in general they will give you suggestions on what you should be doing in order to improve each performance aspect the tool measures. Currently I would suggest that you use the <a href="https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk">Lighthouse</a> Google Chrome extension to measure your application’s lighthouse score.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*faDrQkG6Almf7O28wKRaAQ.png" /><figcaption>Lighthouse performance report</figcaption></figure><p>The values that we should be first looking at are: First Contentful Paint, First Meaningful Paint, and Time to Interactive.</p><h4><strong>First Contentful Paint</strong></h4><p>The first contentful paint is when the first text or image is rendered on the page. The first contentful paint depends entirely on the time to download the resources required by your app and on the work the browser needs to do before it starts rendering DOM.</p><p>To decrease the time to your app’s first contentful paint, you need to minimize the size and number of resources downloaded by your app initially, and you also need to minimize the number of render-blocking external resources, like external stylesheets.</p><p>After you’ve done that, make sure you also perform:</p><ol><li>Resource caching for returning users.</li><li>Minification of you text-based assets, like JavaScript files and CSS Stylesheets. <a href="https://github.com/mishoo/UglifyJS2">Uglify.js</a> is your friend!</li><li>Compression of your text-based assets. Every browser nowadays supports <a href="https://opensource.googleblog.com/2015/09/introducing-brotli-new-compression.html">Brotli</a> and/or gzip compression!</li><li>Remove unused code from text-based assets. Modern JavaScript frameworks, like <a href="https://angular.io/">Angular</a>, employ tree shaking and code splitting mechanisms to minimize the size of the payload that is being delivered to the client machine. With older code base, make sure that you remove links to old stylesheets that are no longer used, and to JavaScript files that are also obsolete.</li></ol><h4><strong>First Meaningful Paint</strong></h4><p>The first meaningful paint is when the primary content of your page is visible. The page is not yet fully interactive, but the end user sees content rendered.</p><p>To decrease the time to your app’s first meaningful paint, you need to look at optimizing the Critical Rendering Path of your application. The Critical Rendering Path is the set operations that need to be performed between receiving the HTML, CSS and JavaScript resources of your app and the rendering of pixels on the user screen that represent the final result these resources are intended to produce.</p><p>To optimize the time your app takes until the first meaningful paint is produced, work on optimizing your render-blocking resources, especially CSS. CSS is a render-blocking resource, because without your stylesheets, your app has a completely different look and feel. You can optimize CSS by providing appropriate media rules to your CSS link references. If, for example, a CSS is annotated with a media query for specific device orientation, or specific screen sizes, then it won’t be considered render blocking, and the rendering wouldn’t be delayed by it. This means that splitting your media-specific CSS out of the main CSS file, and loading them separately, will provide a performance boost to your application.</p><p>Refer to <a href="https://developers.google.com/web/fundamentals/performance/critical-rendering-path/">this article</a> on in-depth information and suggestions about optimizing the Critical Rendering Path performance.</p><h4><strong>Time to Interactive</strong></h4><p>Time to interactive is the time it takes for your page to become fully interactive. This means that not only the content is fully visible, but also all page event handlers have already been registered for the visible content, and the page responds to user interaction within 50 milliseconds.</p><p>Some applications optimize the first contentful and first meaningful paint at the expense of interactivity. This could turn users away, as it creates suboptimal experience for them. It’s rather confusing to have a fully visible page, and the page to not respond to user interactions because event handlers have not yet been attached.</p><p>To optimize the time the interactive, defer or remove all unnecessary JavaScript executions that are being ran during page load time. The most critical measure for time to interactive is the JavaScript boot-up time, and the JavaScript payload size.</p><h3><strong>Run-time Performance in Web</strong></h3><p>Run-time performance is defined by how responsive your application is to user interaction. The best way to identify performance bottlenecks of your application is to use the browser developer tools. My personal preference leans towards the Chrome developer tools.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ObYouZEreCR_j7nsuWbVqg.png" /><figcaption>Chrome Dev Tools performance tab</figcaption></figure><p>It’s also good to use the memory profiler provided by the dev tools, in order to identify memory leaks in the application, because those cause the performance of the application to degrade over time. This is especially important when using a SPA (single page application) framework like Angular or React, as your entire application runs as a single web page, and not freeing up resources properly will lead to your application not only having worse performance, but also crashing after it has been used for a certain period of time. A good introduction to memory profiling and detecting leaks can be found <a href="https://developers.google.com/web/tools/chrome-devtools/memory-problems/">here</a>.</p><p>Each individual component in your web application, as well as the interactivity between all of them, define the run-time performance of your application. To ensure good run-time performance of your web application, you should consider these guidelines:</p><ol><li><strong>Minimize the number of DOM nodes and the depth of the DOM node tree </strong>— try to have as few DOM nodes as possible. The recommendation is to have less than 1500 DOM nodes in total, and a DOM tree depth less than 32.</li><li><strong>Minimize the number of event handlers you attach to DOM elements </strong>— try to have as few event handlers as possible. If you’re repeating event handlers on the same type of element in a list, for example, then attach a single delegated event handler on the list element, instead of individual event handlers directly to the elements they target inside the list.</li><li><strong>Properly size images in your application</strong> — make sure the images are not larger than the containers they’re placed inside. Large images make your load time and runtime performance a lot slower.</li><li><strong>Defer offscreen image loading</strong> — make sure that images that should not be immediately visible have a deferred load policy.</li></ol><h3><strong>Soft Performance in Web</strong></h3><p>Soft performance is defined by the general UX (user experience) of your application. Soft performance cannot be measured, but what you can do is perform usability studies for core components of your application to discover bottlenecks for your application’s usability. Such studies are created and carried out by UX experts with physical observations or by software, which records user interaction of the subjects participating in the <a href="https://www.infragistics.com/products/indigo-design/user-testing">usability study</a>. A good tool for usability studies is <a href="https://www.infragistics.com/products/indigo-design">Indigo.Design</a>, which lets you create mock prototypes of your application, and then allows you to define and carry out a usability study on top of it. <a href="https://static.infragistics.com/marketing/Website/IndigoStudio/Sample-Usability-Report.pdf?v=201807251413">Here’s a sample</a> of the report this tool produces.</p><p>In general, to improve the soft performance of your application, you need to:</p><ol><li><strong>Ensure that core features are immediately accessible</strong> — if you want large percentage of your users to access a certain feature, then either directly present your users with it, or create a navigation element that leads to it. Core features should be accessible within two user interactions with your page.</li><li><strong>Core navigation elements are easily distinguishable on the page</strong> — if you have a navigation element that is your “call to action” or navigates to a core feature, then make sure it doesn’t blend with the rest of the page, or does not go off-screen when the page is loaded. Use larger font and contrasting color for it.</li><li><strong>The information flow is consistent</strong> — make sure that related information is not scattered on the page. Usually users go through information diagonally starting at the top left corner.</li><li><strong>Make your content accessible </strong>—<a href="https://www.w3.org/WAI/standards-guidelines/aria/"> a11y</a> is a must in web. Make sure you run accessibility tests for your application. The Lighthouse Chrome extension also produces accessibility reports.</li></ol><p>Example is how we’ve approached the usability of data filtering within our <a href="https://www.infragistics.com/products/ignite-ui-angular">Ignite UI for Angular</a> <a href="https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/grid.html">grid component</a>. There are two different filtering UIs that can be used with the component, but the general interaction with either one is such that within two interactions with the component, the user gets filtering results. In the first mode, there’s an always visible filter chip in a static row right below the grid header elements. Clicking the filter chip transitions the filter row to a filtering input for the corresponding column, the input is on focus and a condition to filter (“contains” for string columns) by has already been pre-selected. The UI is ready for input. As the user starts typing, the column is being filtered according to what they are typing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VZ8ZvbKAJ9VZDysTjZQ7_A.gif" /></figure><p>As you can see, the filtered results are available to the user within two user interactions with the component. What is not apparent by the screenshot, is that this component is also fully accessible. The filter chip elements are can also be accessed with only the keyboard, and the filtering can be applied using only the keyboard also. The elements are also screen readable. I’m giving this component as an example, because it’s complex enough to be compared to an application.</p><h3>Other Considerations</h3><p>You should be aware that all three performance dimensions should be considered together. Focusing on one can potentially hurt another. An example would be too much focus on run-time performance, which can lead to a degradation in the soft performance aspect, and vice-versa. I will illustrate this example, again, with a grid component on a web page. Grid components, in general, are intended to visualize large quantities of tabular data. In order to satisfy the requirements of a web application for load time and run-time performance, they need to virtualize the DOM elements they render, and to either swap or reuse DOM elements when the user performs vertical and horizontal scrolling on the component’s container. Let’s see how this looks in different existing grid components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*J-2gqZlHODX7cyaPjBmMzw.gif" /><figcaption>ag-grid scrolling</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tdUeSwIiKN-rVMjwryAb5w.gif" /><figcaption>igx-grid scrolling</figcaption></figure><p>Notice that both grids have good run-time scrolling performance. The first one, however, has a noticeable visual tear which is caused by the debounced scroll handling put in place to improve run-time performance. This means that there’s a delay between the scrolling events and the rendering. The result is reduced soft performance in favor of run-time performance.</p><h3>Conclusion</h3><p>Software performance is a very broad topic, and what I have done in this article is to scrape the surface of it, by looking as the general performance concepts. My colleague, <a href="https://twitter.com/brianlagunas">Brian Lagunas</a>, has created a <a href="https://www.infragistics.com/community/blogs/b/infragistics/posts/15-wpf-performance-tips-for-2019">great article</a> with performance tips for WPF that you can checkout.</p><p>Next I will dive deeper into performance of Angular web application, where I will look at more framework and technology specific aspects of performance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61158c8583d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ignite-ui/software-performance-web-61158c8583d">Software Performance [Web]</a> was originally published in <a href="https://medium.com/ignite-ui">Ignite UI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>