<?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 Chathuranga Dissanayake on Medium]]></title>
        <description><![CDATA[Stories by Chathuranga Dissanayake on Medium]]></description>
        <link>https://medium.com/@techdeck?source=rss-14d802e6788b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*MZOeCFTLzIty1PwkO-I1Cw.jpeg</url>
            <title>Stories by Chathuranga Dissanayake on Medium</title>
            <link>https://medium.com/@techdeck?source=rss-14d802e6788b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:48:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@techdeck/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 IFS Cloud Workflows Can Automate Entire Business Processes]]></title>
            <link>https://techdeck.medium.com/how-ifs-cloud-workflows-can-automate-entire-business-processes-f57722fbab37?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f57722fbab37</guid>
            <category><![CDATA[workflow-automation]]></category>
            <category><![CDATA[erp-automations]]></category>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[erp-software]]></category>
            <category><![CDATA[ifs-cloud]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Mon, 11 May 2026 09:18:48 GMT</pubDate>
            <atom:updated>2026-06-04T13:06:51.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/865/1*7tM600lOkikpCPxd5QMlZw.png" /></figure><p>There’s a particular kind of frustration that comes with working inside a powerful system and knowing, just knowing, that it can do more than what you’re seeing. That feeling is what pulled me deep into IFS Cloud workflows and BPA capabilities. The more I worked with it, the more capable it turned out to be.</p><p>During workflow implementations for real manufacturing scenarios, the kind where a single business process touches nine or ten different screens, needs to run in a specific sequence, and quietly breaks when a person does it manually at volume. Along the way I’ve hit walls, figured things out the hard way, and picked up a lot that I don’t see written about anywhere clearly.</p><p>So this is simply me sharing some of the things I learned while working with IFS Cloud BPA, what it can do in real scenarios, where it works really well, and some practical things that only become clear during implementation.</p><h4>How Workflows Get Triggered (3 Ways)</h4><p>Before getting into what workflows can do, it helps to be clear on how they start. There are three ways:</p><ol><li><strong>Projection Action — </strong>Triggered when a user or system directly performs an operation through the IFS projection layer, such as creating, updating, deleting records, or invoking a specific action or function. It represents a direct interaction with the system.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vA9UF5e6ZRHE_Hfbv_vBkg.png" /><figcaption>Projection Action Linked to a Workflow</figcaption></figure><ol><li><strong>Event Action</strong> — Triggered based on internal business events within IFS Cloud, such as a status change, process milestone, or a condition being met. It reacts to what happens inside the system and can also be used for validations, user prompts, or calling further projections.</li><li><strong>Workflow Command</strong> — You can also attach a custom command button to any screen a header or a line, wherever and that command fires the workflow when clicked. This is probably the most flexible trigger and the one I’ve found most useful in practice.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*IGSRg6S9tOLgTU1Ul9Cb0w.png" /><figcaption>Select “Execute Workflow” Command Type</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*E7qoAG6kh1Cnh3zdxRX5_A.png" /><figcaption>Configure Workflow Details</figcaption></figure><p>The timing also matters. A workflow can run <em>Before</em> a transaction (to validate or enrich data before it commits), <em>After</em> (to react once the main operation is done), or a<em>synchronously </em>in a completely separate background transaction. For anything non trivial, Asynchronous is the right call. The user clicks something and walks away while the system handles the rest.</p><h4><strong>What’s actually happening inside</strong></h4><p><em>Once a workflow is running, you have three main building blocks:</em></p><ul><li><strong>IFS API Tasks</strong> are how the workflow talks to IFS itself. Each task maps to a projection operation: Create, Read, Update, Delete, or Call (for bound actions and functions). These are more than generic REST calls. They work directly with IFS entity semantics, handle ETags, and store every response field directly as a workflow variable for the next step to use.</li><li><strong>Script Tasks</strong> let you write JavaScript between API calls. Filter a list, calculate a value, build a dynamic parameter, evaluate a condition, format a string. This is what makes a workflow actually think rather than just follow a sequence blindly.</li><li><strong>Gateways</strong> control branching and flow direction based on conditions: did the last step succeed, is the value above a threshold, loop back or continue. Standard BPMN logic, applied to live ERP operations.</li></ul><p>Stack these together and you can build flows that would have required custom PL/SQL development a few years ago.</p><h4><strong>Where this actually gets interesting(real scenarios)</strong></h4><ol><li><strong>Engineer to order manufacturing: configuration to standard part</strong></li></ol><blockquote>Configure-to-order environments often involve a long sequence of manual follow up steps after a configured product is confirmed. The sales team quotes the configured product, the customer confirms it, and then the process moves through multiple operational steps: creating the standard part, updating supplier details, setting cost structures, running cost calculations, copying costs across cost sets, updating sales pricing, updating customer agreements, and finally replacing the configured quotation line with the newly created standard part.</blockquote><blockquote>In many cases, this process spans multiple screens and has to be executed in a specific order, making it both time consuming and easy to break through manual handling.</blockquote><blockquote>In IFS Cloud, that entire sequence can run as a single workflow triggered from the Sales Quotation header. One click. The workflow loops through every completed configured line, processes each one end to end, logs what succeeded or failed, and surfaces a summary when it’s done. Nobody touches it in between.</blockquote><p>2. <strong>Finance: validations that actually match how your business works</strong></p><blockquote>IFS has built in approval flows, but real business processes are rarely that straightforward. A purchase order under a certain value might follow one path, while higher values require additional checks. If the supplier is not on the preferred list, the process may need extra validation regardless of the amount.</blockquote><blockquote>A BPA workflow can read the relevant data, evaluate conditions through scripts, and decide how the process should continue. Each path can then handle its own validations, notifications, status updates, and audit logging all within the same flow without needing separate custom development.</blockquote><p>3. <strong>Sales: pricing that propagates when agreements change</strong></p><blockquote>When a customer agreement gets renegotiated, the ripple effect is easy to miss. Open quotations still reference the old pricing. Discounts need adjusting. Getting ahead of that manually is tedious and people don’t always do it thoroughly.</blockquote><blockquote>A workflow triggered when the agreement updates can fan out across every affected record, apply the new logic, and flag exceptions for human review. The team sees a clean list of things that need attention rather than a problem discovered at invoicing.</blockquote><p>4. <strong>Procurement: supplier and cost updates in one pass</strong></p><blockquote>New supplier for an existing part. Someone needs to update the purchase part record, check the price list, recalculate landed cost, update the inventory unit cost four or five screens touched in order.</blockquote><blockquote>One command on the supplier record. The workflow reads existing data, calls the relevant operations, calculates what needs calculating, writes it back. The buyer reviews results rather than executing steps.</blockquote><h4><strong>The things I wish someone had told me before I started…</strong></h4><p>A lot of the core workflow concepts in IFS BPA are straightforward once you get used to them. But when building larger or more stateful flows, there are certain behaviours that only really make sense through implementation experience.</p><p>Most of these are manageable once understood properly, but they are the kinds of details that are easy to miss when you’re first getting started.</p><ol><li><strong>Before calling a bound action, you need the record first</strong></li></ol><blockquote>This one stopped me cold early on. In IFS, a bound action, triggering a calculation, executing a wizard step, running a functional ways operates on a specific record. When you’re in the UI, that context is implicit. You’re already looking at the record, so clicking the action just works.</blockquote><blockquote>In a workflow, you have to build that context yourself. The pattern is always: <strong>Read the record first, then Call the action.</strong> The Read fetches the entity and stores its Objkey and ETag as workflow variables. The subsequent Call uses those to establish which instance it’s acting on.</blockquote><blockquote>Miss the Read and the bound action has nothing to act on. It fails, often with an error that doesn’t point you anywhere useful.</blockquote><blockquote>Once I understood this I started seeing it everywhere; wizard steps, cost calculations, anything stateful. In most stateful or bound operations, the reliable pattern is: Read first, then Call.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GGuVmylVWOn_auxe1a03Ww.png" /><figcaption>Read Node (Red) Followed by Call Node (Green)</figcaption></figure><p>2. <strong>Virtual entity sessions don’t share state</strong></p><blockquote>IFS uses virtual entities heavily for wizard-style operations, multi-step processes where intermediate state lives in memory before it gets committed. The catch is that virtual child records created in one HTTP session don’t survive into the next one.</blockquote><blockquote>When automating a multi-step wizard, each stage is typically handled through separate IFS API Tasks. One thing that becomes clear fairly quickly is how sensitive some of those steps are to execution order. In flows that depend on shared virtual entity state, inserting an additional Read or breaking the sequence between related steps can cause the later step to lose access to the expected context. The result is usually an error indicating that a related record or virtual entity no longer exists, which can be surprisingly difficult to trace back to the actual cause.</blockquote><blockquote>The fix is understanding exactly which steps depend on shared virtual state and ensuring nothing breaks that chain. You can’t just map the UI steps one to one and assume it’ll behave the same way.</blockquote><p>3. <strong>Error handling has a frustrating ceiling</strong></p><blockquote>You’d expect to be able to surface a meaningful error to the user when something goes wrong mid-workflow “Part X failed because the supplier record didn’t exist,” that sort of thing. In practice this is harder than it sounds, and I went through a few attempts to get it right.</blockquote><blockquote>IFS has a Failure Event element in BPA that can display an error message but it rolls back the entire workflow transaction when it fires, including every step that already completed successfully. For a workflow processing multiple lines, that’s a non-starter. Everything correct gets undone along with the failure.</blockquote><blockquote>I also tried routing through a general action to surface dynamic errors, that approach had its own limits and couldn’t do what I needed either. What actually works is using the Log Errors option built into IFS API Tasks, collecting error details per step inside Script Tasks, building a summary, and presenting that once the workflow finishes. It’s a workaround rather than a clean solution, but it’s reliable and it doesn’t roll back completed work. Real-time error feedback during async execution is just limited you have to design around that reality.</blockquote><p><strong>4. Loop visibility is better with a counter than multi-instance</strong></p><blockquote>When iterating over multiple records, there are two structural options: multi-instance sub-processes or a manual counter with a gateway.</blockquote><blockquote>Multi-instance looks cleaner on the canvas. But the debug visibility inside a running multi-instance sub-process is limited; you can’t easily inspect what’s happening at each iteration. The counter pattern a simple index variable, a gateway that checks it against the total, an increment step at the end, gives you full visibility through the debug eye icon at every step of every loop. For most sequential processing scenarios, performance differences are negligible, and for development and troubleshooting the counter wins without question.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iW6xBkYtR7AOmEZvjzfzJA.png" /><figcaption>Debug View Showing Loop Counter and Workflow Iteration</figcaption></figure><h4><strong>Why this matters more than it used to…</strong></h4><p>The direction IFS Cloud is heading is clear: BPA, projection APIs, integrations, and workflow-driven automation are increasingly becoming major mechanisms for operational customization. Traditional custom development, PL/SQL, and modified application code carry a maintenance cost across every upgrade cycle. Workflows that operate through the standard API, integration, and BPA layers don’t carry that same cost. The business logic lives in the workflow rather than modified core code, making it easier to maintain, extend, and evolve over time.</p><p>This approach also makes it easier to integrate external systems and emerging AI-driven capabilities into business processes without introducing heavy customizations into the application itself.</p><p>For businesses running IFS Cloud, this shifts what’s worth automating. If a process is complex enough to be error-prone and frequent enough to matter, a workflow is probably the right answer now. The threshold for “let’s just build it” has dropped considerably. At the same time, organizations can remain more closely aligned with the evergreen upgrade path by adopting workflow-based customizations instead of modifying core application logic.</p><h4>A final thought</h4><p>Everything in this article came from actually building these workflows, hitting the constraints, and figuring out what works. None of it was obvious from the documentation. Most of it I learned by watching something fail in an interesting way and going back to understand why.</p><p>That’s kind of the point. IFS BPA at this level isn’t about knowing the tool, it’s about understanding what the engine is doing underneath the canvas. Once that clicks, the gap between what’s possible and what most teams are currently doing becomes pretty visible.</p><p>As IFS Cloud continues moving toward workflow-based customization, API-driven integrations, and AI-enabled business processes, that understanding becomes even more important. The organizations that embrace these approaches can automate more effectively while staying closer to the evergreen upgrade track and reducing long-term maintenance complexity.</p><p>I’ll keep sharing what I learn as the builds progress. If you’re working on something similar in IFS Cloud, or hitting walls I haven’t mentioned here, I’d genuinely love to hear about it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f57722fbab37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Future of ERP Data Cleaning  |  AI Automation in Bulk and Real Time for IFS, Acumatica, and…]]></title>
            <link>https://techdeck.medium.com/from-chaos-to-clean-an-ai-experiment-for-enterprise-erp-data-f76d97939965?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f76d97939965</guid>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 08:19:33 GMT</pubDate>
            <atom:updated>2025-08-17T13:00:08.136Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Future of ERP Data Cleaning | AI Automation in Bulk and Real Time for IFS, Acumatica, and Beyond</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iCUX36aCao4D5gOpyFWn2g.png" /></figure><p>When I first started working with ERP systems, I thought data cleanup was something that happened automatically. I figured platforms like <strong>Acumatica</strong> or <strong>IFS</strong> would quietly fix duplicates, normalize formats, and keep everything tidy without me lifting a finger.</p><p>Turns out, even the best ERP systems can struggle when the data gets messy.</p><p>Bad data creeps in quietly; duplicate records, inconsistent naming, typos, missing fields and suddenly your reports are off, your forecasts are wrong, and your integrations start breaking.</p><p>For me, tackling data quality has become one of the most satisfying challenges in ERP work. It’s a mix of detective work, problem solving, and system design. And lately, I’ve been experimenting with using AI to make it faster and more consistent.</p><h4><strong>Why This Matters in ERP(Acumatica, IFS…)</strong></h4><p>In ERP systems, messy data leads to real headaches:</p><ul><li><strong>Duplicate customers</strong> → inaccurate sales totals or account statements.</li><li><strong>Inconsistent product naming</strong> → inventory mismatches and confusion in MRP.</li><li><strong>Missing fields</strong> → integration failures with finance or supply chain tools.</li><li><strong>Typos</strong> → user frustration and wasted time.</li></ul><p>Clean data is the foundation that every ERP process depends on whether it’s Acumatica’s flexible cloud ERP or IFS’s global enterprise suite, or any other platform.</p><h4><strong>AI-Powered Cleanup Proof-of-Concept</strong></h4><p>I developed a Python script using the Groq API (OpenAI-compatible) to standardize customer names from an ERP export. While this solution works well, training a custom AI model on your specific ERP data patterns and business rules would deliver even more reliable, tailored results. This approach could be integrated into an Acumatica customization project or run within an IFS integration layer.</p><p>Real ERP data isn’t “a few neat typos”, it’s often the result of years of system migrations, manual data entry, and inconsistent formatting standards across teams and regions. That’s why I tested this approach with a dataset that feels closer to the real world mess ERP specialists see every day.</p><h4><strong>Mock ERP Dataset</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/1*uNsowC7hQmE4aVJBooqEHA.png" /><figcaption>Sample data used for AI cleanup test</figcaption></figure><h4><strong>Python Code (Groq API)</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-cidD7gQG_cjgfhgkAXdfA.jpeg" /><figcaption>AI standardization script pt.1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rcfyQ73mqu1srOL-DeRPWg.jpeg" /><figcaption>Script pt.2</figcaption></figure><h4><strong>Output</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bM48f--18W4UIFuAWWaYA.jpeg" /><figcaption>Cleaned results</figcaption></figure><h4><strong>How This Could Work in Real ERP Flows</strong></h4><p>For <strong>Acumatica</strong>:</p><ol><li>Pull data via REST API or OData.</li><li>Run it through the AI cleanup process.</li><li>Push updates back via PUT/PATCH calls, or trigger from a custom “Clean Data” action in the UI.</li></ol><p>For <strong>IFS</strong>:</p><ol><li>Export via Projections (exposed through OData).</li><li>Apply AI transformations.</li><li>Update records through Business API calls or Projection updates.</li></ol><h3>Recommended Approach: Real-Time Data Cleanup</h3><p>Bulk cleanup is essential for fixing historical data, but an even more effective strategy is <strong>cleaning data at the exact moment it’s entered</strong> into your ERP. This prevents incorrect or inconsistent information from ever becoming part of system’s other process.</p><p>Bulk cleanup is essential for fixing historical data, but an even more effective strategy is <strong>cleaning data at the exact moment it’s entered</strong> into your ERP. This prevents incorrect or inconsistent information from ever becoming part of your system’s records.</p><h3>Why First-Time Cleanup Matters</h3><ul><li><strong>Stops errors before they spread</strong> — no bad data flowing into orders, invoices, or reports.</li><li><strong>Keeps integrations consistent</strong> — connected systems receive clean, standardized data.</li><li><strong>Saves rework</strong> — no need to run mass cleanups later.</li></ul><h3>How to Implement</h3><h4>IFS Approach</h4><ul><li><strong>Application Messages</strong> — When a new Customer, Supplier, or Item is created, the system can send a message to an integration queue. A cleanup service receives it, standardizes the data, and sends the corrected information back to IFS.</li><li><strong>Event Actions</strong> — An “On Record Created” event can directly call a web service that runs cleanup logic, returning the corrected value before the record is finalized.</li><li><strong>Workflows</strong> — A step in a workflow can route new data through the cleanup process before it becomes active in the system.</li></ul><p>Typical Flow:</p><ol><li>User creates a new record in IFS.</li><li>Event sends the data to a cleanup service.</li><li>The service processes it, fixes issues, and sends the cleaned data back.</li><li>IFS updates the record before it’s used in transactions or reports.</li></ol><h4>Acumatica Approach</h4><ul><li><strong>Business Events</strong> — Trigger whenever a record is inserted, sending the new data to a cleanup service.</li><li><strong>Automation Steps</strong> — Automatically perform cleanup before a record can be saved.</li><li><strong>Customization Code</strong> — A <strong><em>RowPersisting </em></strong>event can call an external cleanup API, replace the field value with the standardized result, and then allow the save to continue.</li></ul><p>Typical Flow:</p><ol><li>New record is entered into Acumatica through the UI or an API.</li><li>The system sends the relevant fields to an external cleanup service.</li><li>The service returns a cleaned and standardized version.</li><li>Acumatica stores the corrected version in the database.</li></ol><h4>How the Cleanup Service Works</h4><p>The cleanup service itself can be a lightweight web application (for example, built with <strong>Flask in Python</strong>) that listens for HTTP requests from the ERP.</p><ul><li>It receives the raw data (e.g., “Acmee Corpii”).</li><li>It sends that value to the AI model (in this case via the Groq API) for standardization.</li><li>It applies any extra business rules (like removing “The” from company names or expanding “Ltd” to “Limited”).</li><li>It responds with the cleaned value (e.g., “Acme Corporation”) in JSON format.</li><li>The ERP takes that value and updates the record before committing it to the database.</li></ul><p>This setup works in both <strong>IFS</strong> and <strong>Acumatica</strong> and ensures that <strong>no bad data ever enters your master tables</strong>.</p><h4><strong>Why I’m Excited About This</strong></h4><p>I built this experiment to explore how AI’s pattern recognition can enhance ERP workflows, not as a replacement for ERP logic, but as an intelligent assistant that makes data cleanup faster, more consistent, and more accurate, especially when trained on your specific data patterns.</p><p>The next step for me is to connect this directly to live ERP instances and make it something users can run without leaving the system.</p><p>Better results can often be achieved by using a more powerful, paid AI API key these tend to provide higher quality responses and handle more complex transformations. Also, the quality of your prompt matters just as much as the model itself; carefully crafting clear, context-rich prompts can make a huge difference in the final outcome.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f76d97939965" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ReactJs Framework]]></title>
            <link>https://techdeck.medium.com/reactjs-framework-4b2c4f16a405?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b2c4f16a405</guid>
            <category><![CDATA[reactjs-tutorial]]></category>
            <category><![CDATA[javascript-frameworks]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[reactjs-development]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Sat, 14 May 2022 14:54:41 GMT</pubDate>
            <atom:updated>2022-06-27T05:58:33.296Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Introduction to ReactJs</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*qm99PBZm_YQu0MQ1tvJD9A.png" /></figure><p>React is a front-end JavaScript library for creating user interfaces using UI components that are free and open-source and Jordan Walke, a Facebook software engineer came up with the idea. It’s a component-based front-end library that’s only responsible for the application’s view layer.</p><p><strong>React Lifecycle</strong></p><p>React component has a lifecycle that you can track and change via its three stages: Mounting, Updating, and Unmounting.</p><p><strong>1.</strong> <strong>Mounting</strong></p><p>Mounting is the process of adding elements to the DOM.</p><p>React calls the below four built-in functions when mounting a component.</p><blockquote>· constructor()</blockquote><blockquote>· getDerivedStateFromProps()</blockquote><blockquote>· render()</blockquote><blockquote>· componentDidMount()</blockquote><p><strong>2.</strong> <strong>Updating</strong></p><p>The lifecycle moves on to the next stage after a component is updated.</p><p>When a component’s state or props change, the component is updated.</p><p>React executes the following five built-in functions in this order when a component is changed:</p><blockquote>· getDerivedStateFromProps()</blockquote><blockquote>· shouldComponentUpdate()</blockquote><blockquote>· render()</blockquote><blockquote>· getSnapshotBeforeUpdate()</blockquote><blockquote>· componentDidUpdate()</blockquote><p><strong>3.</strong> <strong>Unmounting</strong></p><p>When a component is unmounted, or deleted from the DOM as React calls it.</p><p>componentWillUnmount() calls when a component is unmounted.</p><p>Steps to set up a ReactJs project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/812/1*8UtNcaPyZn9DAArQLf5KAA.png" /></figure><p>The command “npx create-react-app” creates a React Boilerplate which is an open-source development tool, use to reduce development time. The below image shows a basic ReactJs Boilerplate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*_9aET94HMkc-h346qWfZJQ.png" /><figcaption>Structure of the Boilerplate</figcaption></figure><p>“npm start” command runs the node script that is listed under start in the package. json.</p><p><strong>What is package.json?</strong></p><blockquote>· Package.json keeps track of key project metadata that is required when publishing to npm.</blockquote><blockquote>· It also describes the project’s functional properties, which npm uses to install dependencies.</blockquote><p><strong>Why you should use ReactJs to develop your project.</strong></p><blockquote><strong>Speed -: </strong>ReactJs simply allows developers to use separate components of their application on both the client-side and the server-side, resulting in a faster development process.</blockquote><blockquote><strong>Flexibility</strong> -: React code is easier to maintain and more versatile than other frontend frameworks because of its modular structure. Businesses save a significant amount of time and money as a result of this flexibility.</blockquote><blockquote><strong>Performance</strong> -: The framework’s key features include a virtual DOM program and server-side rendering, allowing complicated projects to execute exceptionally quickly.</blockquote><blockquote><strong>Usability</strong> -: If you have some basic JavaScript expertise, deploying React is quite simple. So, anyone who is having good knowledge in JavaScript can easily learn ReactJs.</blockquote><p>Also, the reusability of components can get as a key benefit of the ReactJs framework as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/1*oPNyKu4idlos4HrFxdK9wQ.png" /><figcaption>Extensions to make coding easier</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b2c4f16a405" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is the Best Node.js framework: Express.js or Koa.js?]]></title>
            <link>https://techdeck.medium.com/what-is-the-best-node-js-framework-express-js-or-koa-js-4e35c989173b?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e35c989173b</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[node-js-framework]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[koajs]]></category>
            <category><![CDATA[expressjs]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Sat, 14 May 2022 14:37:00 GMT</pubDate>
            <atom:updated>2022-05-14T14:37:00.008Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Express.js for Web Application Development</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6tUIEr2A0m36xHGqz-Yc-w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ETcaw-gA1dYW4EFxqGK3w.png" /></figure><p>Express.js is a popular Node web framework.</p><p><strong>Usage of Express.js framework,</strong></p><blockquote>· Integrate with “view” rendering engines to provide replies by populating templates with data.</blockquote><blockquote>· Set up common web application settings such as the connection port and the location of templates for generating the response.</blockquote><blockquote>· It use to write handlers for requests with various HTTP verbs and at various URL paths.</blockquote><p>The npm command to install Koa.js is shown in the below image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/371/1*xWFTVm9B3dvfZXof7e_4xA.png" /><figcaption>npm command to install Express.js</figcaption></figure><blockquote>The ‘npm install express’ command actually does is, , it adds the module to the package.json file’s dependents list. Then, in the app directory, run npm install to automatically install modules from the dependencies list.</blockquote><p><strong>Why it is important to use Express.js for backend web development?</strong></p><blockquote>· It Creates a REST API server for you.</blockquote><blockquote>· Configuration and customization are simple.</blockquote><blockquote>· Allows you to define application routes using HTTP methods and URLs.</blockquote><blockquote>· Simple to combine with several template engines like EJS, and Jade.</blockquote><blockquote>· Databases such as MySQL, and MongoDB can be connected easily using this framework.</blockquote><h3>Koa.js for Web Application Development</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*GxPj72m09tC4egW88JVV2g.gif" /></figure><p>Koa.js is a minimal and flexible Node.Js web application framework created by<strong> </strong>the same team behind Express, Koa, a new web framework that aspires to offer a smaller, more expressive, and more robust base for online applications and APIs. Koa eliminates callbacks and dramatically improves error handling by using async functions.</p><p>In order to develop the backend of a web application should install the Koa.js. The npm command to install Koa.js is shown in the below image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*elFrsbzotMJKN0kofnIxag.jpeg" /></figure><p><strong>Why Koa.js is important to use for backend web development?</strong></p><blockquote>· Koa has a minimal code footprint (about 600 lines), making it extremely light.</blockquote><blockquote>· Koa makes use of try/catch, which helps with error handling.</blockquote><blockquote>· Asynchronous coding in Koa is clearer and more readable.</blockquote><blockquote>· Koa does not employ callbacks, allowing for easier control flow upstream and downstream.</blockquote><p>Koa makes use of asynchronous functions to reduce the requirement for callbacks and improve error handling. Koa’s core does not include any middleware. It offers an improved set of ways for speeding up and exciting the server-building process.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e35c989173b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Node.Js for Web Application Development]]></title>
            <link>https://techdeck.medium.com/node-js-for-web-application-development-d869c66017d0?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d869c66017d0</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[node-js-tutorial]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Sat, 14 May 2022 14:05:00 GMT</pubDate>
            <atom:updated>2022-08-07T05:36:46.412Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Brief Introduction about Node.Js</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jw9V__6jYhm2amP74D_0lw.png" /></figure><p>Node.Js is a back-end JavaScript runtime environment that runs on the V8 engine which is the Chrome browser’s JavaScript engine and it is open-source and cross-platform.</p><p>Ryan Dahl developed Node.Js. Unlike React, Node.Js is good at I/O intensive tasks by the use of I/O operations non-blocking nature. Node.Js includes many JavaScript libraries to assist with basic programming so, the ‘npm’ ecosystem for Node.Js is the world’s largest open-source library.</p><p>To perform non-blocking I/O operations Node.Js has an endless loop called, Event loop, which waits for tasks, completes them, and then goes to sleep until more chores arrive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*yOaP3MkOsYKAo9A7UG0r-Q.png" /><figcaption>Node.js Event Loop</figcaption></figure><h4>Why is Node.Js essential to use for web development?</h4><blockquote>· After the initial use, performance was improved by caching modules in memory.</blockquote><blockquote>· Because the V8 engine compiles the JS code directly into machine code, it provides better performance.</blockquote><blockquote>· The npm package manager and its enormous number of reusable modules are well-built.</blockquote><blockquote>· Scaling NodeJS apps horizontally and vertically is simple.</blockquote><blockquote>· Data-intensive real-time applications.</blockquote><p><strong>Here are some disadvantages of the Node.Js runtime environment.</strong></p><blockquote>· Node.Js is an asynchronous programming model, so it is a comparatively complex model than other synchronize programming models.</blockquote><blockquote>· When handling Heavy Computing Tasks, performance is reduced.</blockquote><blockquote>· Because of its Unstable API, Node.Js invites a lot of code updates.</blockquote><blockquote>· Choose Carefully — A lack of library support can put your code at risk.</blockquote><blockquote>Express.js and Koa.Js are popular Node.Js frameworks.</blockquote><blockquote>I will discuss more about Express.js and Koa.Js frameworks in my next articles.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d869c66017d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Version Controlling & NoSQL]]></title>
            <link>https://techdeck.medium.com/version-controlling-nosql-ac0f492b9f9b?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac0f492b9f9b</guid>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[version-control]]></category>
            <category><![CDATA[nosql]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Mon, 14 Mar 2022 05:52:20 GMT</pubDate>
            <atom:updated>2022-03-14T05:52:20.726Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Version Controlling</strong></h4><blockquote>The method of recording and controlling changes to software code is known as version control, sometimes known as source control. Version control systems are software tools that enable software development teams in managing source code changes over time. As a result, one person’s temporary or partial alterations do not interfere with the work of another.</blockquote><blockquote>Version control also allows one person to work on a project from various computers, so it’s useful even if you’re working alone.</blockquote><blockquote>Version control brings together work done by different team members at the same time.</blockquote><blockquote>In most scenarios, you can mix adjustments to several files or even the same file without losing any work. When two persons make contradictory updates to the same line of a file, the version control system will occasionally ask for human help in choosing what to do.</blockquote><blockquote>Version control allows you to see previous versions of your project. This is protection against computer failure or data loss. You can go back to a prior version if you make a mistake. A bug report from a previous version of your software can be reproduced and understood. You can also go back and undo particular edits without losing the work done previously.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rGR5N7eDStWl_Ded8zDiZQ.jpeg" /></figure><h4><strong>NoSQL</strong></h4><p>NoSQL is an approach to database design that enables the storage and querying of data outside the traditional structures found in relational databases, so basically, NoSQL databases are databases that don’t use relational tables to store data.</p><p>There are four major types of NoSQL types: key-value store, document store, column-oriented database, and graph.</p><blockquote>· <strong>Document databases</strong>, like JSON objects, store data in documents. Each document has a set of field and value pairs. Strings, numbers, Booleans, arrays, and objects are some of the most common forms of values.</blockquote><blockquote>Ex: MongoDB</blockquote><blockquote>· <strong>Key-value databases</strong> are a simpler sort of database that has keys and values for each item.</blockquote><blockquote>Ex: Redis, Riak, Memcached.</blockquote><blockquote>· <strong>Wide-column stores</strong> Tables, rows, and dynamic columns.</blockquote><blockquote>Ex: Cassandra</blockquote><blockquote>· <strong>Graph</strong>, stores entities (nodes) and relationships (edges). Edges contain information about the relationships between nodes, while nodes store information about objects.</blockquote><blockquote>Ex: Neo4j</blockquote><h4><strong>MongoDB</strong></h4><p>MongoDB is an open-source document-oriented database that is the most popular NoSQL database. ‘NoSQL’ stands for ‘non-relational’. It indicates that MongoDB isn’t built on the table-like structure of relational databases, but instead uses a completely different technique for data store and retrieval. The data storing format is similar to the JSON format.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*GL68V5wL-ZBd2tKajT7olg.png" /><figcaption>MongoDB document Structure</figcaption></figure><p>MongoDB has the following features:</p><blockquote>· <strong>Document Oriented</strong> — MongoDB maintains the core subject in the smallest number of documents possible, rather than dividing it up into various relational structures as RDBMS does. For example, it keeps all of a computer’s information in an one document called Computer, rather than in separate relational structures like CPU, RAM, and Hard disk.</blockquote><blockquote>· <strong>Scalability</strong> of MongoDB allows it to scale horizontally.</blockquote><blockquote>· <strong>Indexing</strong> — If there is no indexing a database would have to sift through every document in a collection to find the ones that match the query, which would be inefficient. As a result, indexing is required for efficient searching, and MongoDB utilizes it to analyze large volumes of data in a short amount of time.</blockquote><blockquote>· <strong>Duplication of information</strong> — MongoDB may be distributed across several servers. The data is duplicated in order to keep the system up and running in the event of hardware failure.</blockquote><blockquote>· <strong>Load balancing</strong> — Because data is stored in shards, it has an automatic load balancing setting.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac0f492b9f9b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to Application Frameworks]]></title>
            <link>https://techdeck.medium.com/introduction-to-application-frameworks-f1adea3e93c5?source=rss-14d802e6788b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1adea3e93c5</guid>
            <category><![CDATA[application-frameworks]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[full-stack-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Chathuranga Dissanayake]]></dc:creator>
            <pubDate>Thu, 24 Feb 2022 12:32:32 GMT</pubDate>
            <atom:updated>2022-02-24T12:38:14.345Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*Utbirzsh5IcCeCVpBZvKCw.jpeg" /></figure><p>This is a brief introduction about how to develop applications using industry standards and industry-leading frameworks.</p><p>There are five object-oriented principles that should follow when designing software products. Those are known as S.O.L.I.D,</p><blockquote><em>· </em><strong><em>Single responsibility</em></strong><em> — States that each class should have one specific purpose and a responsibility.</em></blockquote><blockquote><em>· </em><strong><em>Open-close</em></strong><em> — It’s possible to extend it, but it’s not possible to change it.</em></blockquote><blockquote><em>· </em><strong><em>Liskov substitution </em></strong><em>— States that functions that utilize base class pointers or references must be able to use derived class objects without being knowing of it.</em></blockquote><blockquote><em>· </em><strong><em>Interface segregation </em></strong><em>— States that no code should be forced to depend on methods it does not use.</em></blockquote><blockquote><em>· </em><strong><em>Dependency inversion</em></strong><em> — States that high-level modules should not depend on low-level modules.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*In9QWWXzBuvZ-cIicOOZnw.png" /></figure><p>In software engineering, there are some better technical solutions to overcome a business problem. In order to do it, should have to have a clear understanding of the problem. Then the problem can divide into smaller problems which are known as the divide and conquer method, it makes the problem less complex and easy to understand. Keep it simple and stupid (KISS) and when designing the solution, learn from the mistakes and keep in mind the reason software exists.</p><p>After designed a solution for a problem and when implementing that solution there are some important guidelines.</p><blockquote><em>· </em><strong><em>YAGNI</em></strong><em> — States a programmer should not add functionality until deemed necessary.</em></blockquote><blockquote><em>· </em><strong><em>DRY</em></strong><em> — Principle of reducing repetition in the code.</em></blockquote><blockquote><em>· </em><strong><em>Embrace abstraction </em></strong><em>— States system functions properly without knowing the implementation details of every component part.</em></blockquote><blockquote><em>· </em><strong><em>DRITW</em></strong><em> — Sates that reuse the solution for a problem that someone already solved, write code that does one thing well.</em></blockquote><blockquote><em>· </em><strong><em>Debugging</em></strong><em> is harder than writing code so make it readable as possible.</em></blockquote><blockquote><em>· </em><strong><em>Kaizen</em></strong><em> — Fix not just the bug but the code around it.</em></blockquote><h3>1. JavaScript</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dmdr9kc0T5LDSpTj3MEdOA.jpeg" /></figure><p>Asynchronous dynamically typed single-threaded language which supports OOP as well as functional programming.</p><p>When creating a JavaScript object, the constructor function is used with the ‘new’ keyword.</p><p>There is an object called ‘prototype’ in JavaScript which is used when creating objects, for inheritance and adding methods to a JavaScript class.</p><p>The ‘this’ keyword in JavaScript behaves differently than in other languages. The word ‘this’ in the context of an object refers to the object itself. ‘This’ refers to a global object in a global context.</p><p>JavaScript closure is a function that returns another function, it is used to encapsulate variables into a function and restrict access to it from the outside.</p><h3>2. Version controlling</h3><blockquote>Also known as source control is the practice of tracking and managing changes to software code.</blockquote><blockquote>Version control systems are software tools that help software teams manage changes to source code over time</blockquote><blockquote>Version control software tools — Git, CVS, SVN, TFS, Monotone, Bazaar…etc.</blockquote><h3><strong>Git</strong></h3><blockquote><em>Most popular version control system.</em></blockquote><blockquote><em>Free and open source</em></blockquote><blockquote><em>Supports protocols like SSH, HTTPS.</em></blockquote><blockquote><em>Commands — Git init, Git clone, Git add, Git stage, Git commit, Git push</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CkFfp1-D2NZxh3Rj3zMr-Q.png" /></figure><h3>3. NoSQL</h3><blockquote><em>NoSQL is an approach to database design that enables the storage and querying of data outside the traditional structures found in relational databases.</em></blockquote><blockquote><em>Open-source.</em></blockquote><blockquote><em>Removes the burden of data structure mismatches between in-memory applications and relational databases.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1adea3e93c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>