<?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 Harshana Madusanka Jayamaha on Medium]]></title>
        <description><![CDATA[Stories by Harshana Madusanka Jayamaha on Medium]]></description>
        <link>https://medium.com/@harshanacslab?source=rss-489752b171ef------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*8XgcpWjHWwsv-whn.</url>
            <title>Stories by Harshana Madusanka Jayamaha on Medium</title>
            <link>https://medium.com/@harshanacslab?source=rss-489752b171ef------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:02:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@harshanacslab/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 Use ChatGPT to Learn English Effectively]]></title>
            <link>https://medium.com/@harshanacslab/how-to-use-chatgpt-to-learn-english-effectively-18cceefcf1ab?source=rss-489752b171ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/18cceefcf1ab</guid>
            <category><![CDATA[english]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Harshana Madusanka Jayamaha]]></dc:creator>
            <pubDate>Wed, 27 Nov 2024 15:14:42 GMT</pubDate>
            <atom:updated>2024-11-27T15:14:42.734Z</atom:updated>
            <content:encoded><![CDATA[<p>Learning English can be challenging, but with the right tools, it becomes an exciting and rewarding journey. ChatGPT, an AI-powered assistant, is one such tool that can make learning English interactive, personalized, and engaging. Here’s how you can use ChatGPT to improve your English language skills:</p><h3>1. Expand Your Vocabulary</h3><p>ChatGPT can help you learn new words and their meanings, as well as how to use them in sentences.</p><ul><li><strong>Learn Word Definitions:</strong> Ask for the meaning of any word and see it used in context.<br><em>Example:</em> “What does ‘ambivalent’ mean? Can you use it in a sentence?”</li><li><strong>Discover Synonyms and Antonyms:</strong> Expand your vocabulary further by learning related words.<br><em>Example:</em> “What are synonyms for ‘happy’? What are its antonyms?”</li></ul><h3>2. Master Grammar</h3><p>Understanding grammar is key to using English effectively, and ChatGPT can be your personal grammar coach.</p><ul><li><strong>Get Grammar Tips:</strong> Clarify confusing grammar rules or differences.<br><em>Example:</em> “What’s the difference between ‘who’ and ‘whom’?”</li><li><strong>Fix Grammar Mistakes:</strong> Share your sentences for corrections or improvements.<br><em>Example:</em> “Correct this sentence: ‘She don’t likes pizza.’”</li></ul><h3>3. Practice Real-Life Conversations</h3><p>Improve your speaking and listening skills by simulating real-world scenarios with ChatGPT.</p><ul><li><strong>Role-Play Situations:</strong> Practice dialogues for everyday activities.<br><em>Example:</em> “Pretend you’re a shopkeeper, and I’m buying groceries.”</li><li><strong>Casual Conversations:</strong> Engage in informal chats to improve fluency.<br><em>Example:</em> “Can we talk about movies? I want to practice my English.”</li></ul><h3>4. Improve Your Writing</h3><p>ChatGPT can act as your writing coach, helping you improve essays, letters, or paragraphs.</p><ul><li><strong>Write Better Essays:</strong> Share your work and get constructive feedback.<br><em>Example:</em> “Here’s my essay on climate change. Can you review it for grammar and structure?”</li><li><strong>Draft Formal and Informal Letters:</strong> Learn how to write emails or letters for various purposes.<br><em>Example:</em> “How do I write a formal email to my professor?”</li></ul><h3>5. Learn Pronunciation</h3><p>While ChatGPT doesn’t produce audio, it can guide you with phonetic spellings and pronunciation tips.<br><em>Example:</em> “How do you pronounce ‘entrepreneur’? Can you break it down phonetically?”</p><h3>6. Enhance Reading Comprehension</h3><p>Build your comprehension skills by summarizing texts and answering questions.</p><ul><li><strong>Summarize Passages:</strong> Share a paragraph or article for a concise summary.<br><em>Example:</em> “Can you summarize this text for me in simple terms?”</li><li><strong>Ask Questions:</strong> Test your understanding by asking follow-up questions about a passage.</li></ul><h3>7. Prepare for Exams</h3><p>ChatGPT can be a valuable resource for English proficiency exams like TOEFL or IELTS.</p><ul><li><strong>Practice Speaking and Writing:</strong> Answer sample questions and get feedback.<br><em>Example:</em> “Can you give me a TOEFL speaking question and evaluate my response?”</li><li><strong>Take Grammar Quizzes:</strong> Test your skills with quizzes created by ChatGPT.<br><em>Example:</em> “Can you create a grammar quiz for me on past tense usage?”</li></ul><h3>8. Learn Idioms and Expressions</h3><p>Mastering idioms and expressions adds depth to your language skills.<br><em>Example:</em> “What does ‘break the ice’ mean? Can you use it in a sentence?”</p><h3>9. Understand Cultural Context</h3><p>English varies by region, and ChatGPT can help you understand these differences.<br><em>Example:</em> “What’s the difference between ‘color’ and ‘colour’?”</p><h3>10. Get Recommendations</h3><p>Beyond text-based learning, ChatGPT can suggest resources to improve your listening and speaking skills.<br><em>Example:</em> “Can you recommend podcasts for improving my English?”</p><p><strong>Final Thoughts</strong><br>ChatGPT is a versatile tool that can help you improve all aspects of your English language skills. Whether you’re practicing conversations, refining your writing, or mastering grammar, it’s like having a personal tutor at your fingertips. The key is consistency — make ChatGPT a part of your daily learning routine, and you’ll see noticeable progress.</p><p>Start your journey today and unlock your potential in mastering English!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18cceefcf1ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Engineering Principles: DRY, KISS, and YAGNI]]></title>
            <link>https://medium.com/@harshanacslab/software-engineering-principles-dry-kiss-and-yagni-751c1ef0e972?source=rss-489752b171ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/751c1ef0e972</guid>
            <category><![CDATA[kiss-principle]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[dry-principle]]></category>
            <category><![CDATA[yagni-principle]]></category>
            <dc:creator><![CDATA[Harshana Madusanka Jayamaha]]></dc:creator>
            <pubDate>Wed, 13 Nov 2024 13:46:58 GMT</pubDate>
            <atom:updated>2024-11-13T13:49:55.671Z</atom:updated>
            <content:encoded><![CDATA[<h3>DRY (Don’t Repeat Yourself)</h3><p><strong>Principle:</strong> The DRY principle emphasizes the importance of reducing repetition within code. Repetition can lead to more errors, higher maintenance costs, and inconsistency. When the same piece of code or logic appears in multiple places, it should be abstracted out into a single location that can be reused.</p><h3>Example:</h3><p><strong>Without DRY:</strong></p><pre>public class Calculator {<br>    public int add(int a, int b) {<br>        return a + b;<br>    }</pre><pre>    public int subtract(int a, int b) {<br>        return a - b;<br>    }</pre><pre>    public int multiply(int a, int b) {<br>        return a * b;<br>    }</pre><pre>    public double divide(int a, int b) {<br>        return a / b;<br>    }</pre><pre>    public int addAndSubtract(int a, int b, int c) {<br>        return a + b - c; // repeated addition and subtraction logic<br>    }<br>}</pre><p><strong>With DRY:</strong></p><pre>public class Calculator {<br>    public int add(int a, int b) {<br>        return a + b;<br>    }</pre><pre>    public int subtract(int a, int b) {<br>        return a - b;<br>    }</pre><pre>    public int multiply(int a, int b) {<br>        return a * b;<br>    }</pre><pre>    public double divide(int a, int b) {<br>        return a / b;<br>    }</pre><pre>    public int addAndSubtract(int a, int b, int c) {<br>        return subtract(add(a, b), c); // reuse add and subtract methods<br>    }<br>}</pre><h3>KISS (Keep It Simple, Stupid)</h3><p><strong>Principle:</strong> The KISS principle advocates for simplicity in design and implementation. The idea is to avoid unnecessary complexity, making code easier to understand, maintain, and debug.</p><h3>Example:</h3><p><strong>Without KISS:</strong></p><pre>public class OrderProcessor {<br>    public void processOrder(Order order) {<br>        if (order != null &amp;&amp; order.getItems() != null <br>               &amp;&amp; !order.getItems().isEmpty() <br>               &amp;&amp; order.getCustomer() != null) {<br>            // complex processing logic<br>            for (Item item : order.getItems()) {<br>                // process each item<br>            }<br>        } else {<br>            // handle invalid order<br>        }<br>    }<br>}</pre><p><strong>With KISS:</strong></p><pre>public class OrderProcessor {<br>    public void processOrder(Order order) {<br>        if (!isValidOrder(order)) {<br>            // handle invalid order<br>            return;<br>        }<br>        // simple processing logic<br>        for (Item item : order.getItems()) {<br>            // process each item<br>        }<br>    }</pre><pre>    private boolean isValidOrder(Order order) {<br>        return order != null &amp;&amp; order.getItems() != null <br>                    &amp;&amp; !order.getItems().isEmpty() <br>                              &amp;&amp; order.getCustomer() != null;<br>    }<br>}</pre><h3>YAGNI (You Aren’t Gonna Need It)</h3><p><strong>Principle:</strong> YAGNI encourages developers to avoid adding functionality until it is necessary. This helps in reducing the complexity and avoiding wasted effort on features that may never be used.</p><h3>Example:</h3><p><strong>Without YAGNI:</strong></p><pre>public class UserManager {<br>    public void createUser(String username, String password) {<br>        // create user<br>    }</pre><pre>    public void createUser(String username, <br>           String password, String email, <br>           String phoneNumber, String address) {<br>        // create user with additional details<br>    }<br>}</pre><p><strong>With YAGNI:</strong></p><pre>public class UserManager {<br>    public void createUser(String username, String password) {<br>        // create user<br>    }<br>}</pre><h3>Summary</h3><ul><li><strong>DRY (Don’t Repeat Yourself):</strong> Avoid duplication of code by abstracting repeated logic into reusable methods or components.</li><li><strong>KISS (Keep It Simple, Stupid):</strong> Keep code simple and straightforward to make it more understandable and maintainable.</li><li><strong>YAGNI (You Aren’t Gonna Need It):</strong> Do not add functionality until it is necessary, preventing unnecessary complexity.</li></ul><p>These principles collectively help in writing clean, maintainable, and efficient code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=751c1ef0e972" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding C1 and C2 Compilers in Java]]></title>
            <link>https://medium.com/@harshanacslab/understanding-c1-and-c2-compilers-in-java-efd4a47dfd4f?source=rss-489752b171ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/efd4a47dfd4f</guid>
            <category><![CDATA[java-compiler]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Harshana Madusanka Jayamaha]]></dc:creator>
            <pubDate>Wed, 13 Nov 2024 13:42:41 GMT</pubDate>
            <atom:updated>2024-11-13T13:42:41.940Z</atom:updated>
            <content:encoded><![CDATA[<p>In Java, the Just-In-Time (JIT) compiler is a part of the Java Virtual Machine (JVM) that improves the performance of Java applications by compiling bytecode into native machine code at runtime. The JIT compiler includes two different compilers, known as the C1 and C2 compilers, each with distinct optimization strategies and purposes.</p><h3>C1 Compiler (Client Compiler)</h3><p>The C1 compiler, also known as the client compiler, is designed for fast startup times and lower memory consumption. It performs lighter and quicker optimizations, which makes it suitable for applications that require quick startup and responsiveness.</p><p>Key characteristics of the C1 compiler include:</p><ul><li><strong>Quick Compilation:</strong> Prioritizes fast compilation times over deep optimizations.</li><li><strong>Low Overhead:</strong> Consumes less memory and resources during compilation.</li><li><strong>Profile-Guided Optimization:</strong> Can use profiling data to guide optimizations but keeps them relatively simple.</li></ul><h3>C2 Compiler (Server Compiler)</h3><p>The C2 compiler, also known as the server compiler, is designed for long-running server applications where peak performance is critical. It performs more aggressive and complex optimizations, which can lead to better performance at the cost of longer compilation times and higher memory consumption.</p><p>Key characteristics of the C2 compiler include:</p><ul><li><strong>Deep Optimization:</strong> Applies more advanced and resource-intensive optimizations to the code.</li><li><strong>Higher Overhead:</strong> Takes more time and memory to compile, aiming for better runtime performance.</li><li><strong>Profile-Guided Optimization:</strong> Uses extensive profiling data to apply sophisticated optimizations.</li></ul><h3>Tiered Compilation</h3><p>Modern JVMs use a feature called tiered compilation, which combines both C1 and C2 compilers to balance the trade-offs between quick startup times and long-term performance.</p><p>In tiered compilation:</p><ul><li>The JVM starts by using the C1 compiler for methods, benefiting from its fast compilation speed.</li><li>As the application runs and the JVM gathers profiling information, it identifies “hot” methods (methods that are frequently executed).</li><li>These hot methods are then recompiled using the C2 compiler, benefiting from its deeper optimizations.</li></ul><p>Tiered compilation aims to provide a good balance, ensuring quick startup times while still optimizing critical parts of the application for peak performance.</p><h3>How to Control Compilers</h3><p>You can control the use of C1 and C2 compilers through JVM options:</p><ul><li><strong>Disable C2 Compiler:</strong> -XX:TieredStopAtLevel=1</li><li><strong>Disable C1 Compiler:</strong> -XX:TieredStopAtLevel=4</li><li><strong>Disable Tiered Compilation:</strong> -XX:-TieredCompilation</li></ul><p>By default, tiered compilation is enabled in most modern JVMs, as it provides a good balance between startup performance and peak performance.</p><h3>Improving Code Cache Size</h3><p>The code cache is a region of memory where the JIT-compiled code is stored. If your application is large or has many hot methods, you might need to increase the code cache size to prevent frequent code cache flushing, which can degrade performance.</p><p>You can improve code cache size using the following JVM options:</p><ul><li><strong>Initial Code Cache Size:</strong> -XX:InitialCodeCacheSize= (default: 160K)</li><li><strong>Reserved Code Cache Size:</strong> -XX:ReservedCodeCacheSize= (default: 240M in JDK 8)</li><li><strong>Code Cache Expansion:</strong> -XX:CodeCacheExpansionSize= (size by which the code cache is expanded)</li></ul><p>Example:</p><pre># Increase the initial and reserved code cache sizes<br>java -XX:InitialCodeCacheSize=32m -XX:ReservedCodeCacheSize=512m -jar myapp.jar</pre><h3>Example Usage</h3><pre># Disable tiered compilation to use only C1 compiler<br>java -XX:-TieredCompilation -jar myapp.jar</pre><pre># Use only C2 compiler<br>java -XX:TieredStopAtLevel=4 -jar myapp.jar</pre><pre># Increase the initial and reserved code cache sizes<br>java -XX:InitialCodeCacheSize=32m -XX:ReservedCodeCacheSize=512m -jar myapp.jar</pre><h3>Summary</h3><ul><li><strong>C1 Compiler (Client Compiler):</strong> Quick, less memory-intensive, good for fast startup and responsiveness.</li><li><strong>C2 Compiler (Server Compiler):</strong> Slower, more memory-intensive, performs deep optimizations for peak performance.</li><li><strong>Tiered Compilation:</strong> Uses both C1 and C2 compilers to balance startup speed and long-term performance.</li><li><strong>Improving Code Cache Size:</strong> Adjust InitialCodeCacheSize, ReservedCodeCacheSize, and CodeCacheExpansionSize to optimize performance for large applications.</li></ul><p>Understanding the roles of C1 and C2 compilers, how to configure them, and how to optimize code cache size can help you improve the performance of your Java applications based on their specific needs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efd4a47dfd4f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding -XX:+PrintCompilation Output in Java]]></title>
            <link>https://medium.com/@harshanacslab/understanding-xx-printcompilation-output-in-java-7d1a3e50997e?source=rss-489752b171ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d1a3e50997e</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[compilers]]></category>
            <dc:creator><![CDATA[Harshana Madusanka Jayamaha]]></dc:creator>
            <pubDate>Tue, 05 Nov 2024 01:56:58 GMT</pubDate>
            <atom:updated>2024-11-05T02:00:27.322Z</atom:updated>
            <content:encoded><![CDATA[<p>The -XX:+PrintCompilation flag in the Java Virtual Machine (JVM) prints information about the methods being compiled by the Just-In-Time (JIT) compiler. When you enable this flag, the JVM will output a log of compilation events to the standard output. Each line of the output provides information about a specific method being compiled. Here, I&#39;ll explain the meaning of the different columns and markers, specifically focusing on the n, s, and % markers as seen in your example.</p><h3>Explanation of Output Columns and Markers</h3><p>Here’s a breakdown of what each column and marker means:</p><ul><li><strong>Timestamp</strong>: The time (in milliseconds) since the JVM started when the compilation event occurred.</li><li><strong>Compilation ID</strong>: A unique identifier for each compilation task within the JVM’s lifecycle.</li><li><strong>Optimization Level</strong>: The level of optimization applied (e.g., 1, 3, 4).</li><li><strong>Method Name and Details</strong>: The fully qualified name of the method being compiled, along with the size of the method in bytes.</li><li><strong>Marker</strong>: Indicates special conditions or additional information about the compilation.</li></ul><h3>Common Markers</h3><ul><li><strong>n</strong>: Indicates that the method is a native method.</li><li><strong>s</strong>: Indicates that the method is synchronized.</li><li><strong>%</strong>: Indicates that the method has been compiled at a higher optimization level.</li></ul><h3>Detailed Breakdown of Example Output</h3><p>Let’s go through a portion of the example output line by line:</p><pre>44    1       3       java.lang.String::charAt (29 bytes)<br>46    2     n 0       java.lang.System::arraycopy (native)   (static)<br>48    3       3       java.lang.String::hashCode (55 bytes)<br>48    4       3       java.lang.String::indexOf (70 bytes)<br>49    5       3       java.lang.String::equals (81 bytes)<br>49    7       3       java.lang.Object:: (1 bytes)<br>49    6       3       java.lang.String::length (6 bytes)<br>51    8       3       java.lang.AbstractStringBuilder::ensureCapacityInternal (27 bytes)<br>52    9       3       java.lang.CharacterData::of (120 bytes)<br>53   14       3       java.lang.AbstractStringBuilder::append (29 bytes)<br>53   10       3       java.lang.CharacterDataLatin1::getProperties (11 bytes)<br>55   19       4       java.lang.String::charAt (29 bytes)<br>57   15       3       java.lang.StringBuilder::append (8 bytes)<br>58    1       3       java.lang.String::charAt (29 bytes)   made not entrant<br>59   26       1       java.lang.Object:: (1 bytes)<br>59    7       3       java.lang.Object:: (1 bytes)   made not entrant<br>59   22       3       PrimeNumbers::isPrime (35 bytes)<br>60   25       3       java.lang.Integer:: (10 bytes)<br>60   29 %     4       PrimeNumbers::isPrime @ 2 (35 bytes)</pre><h3>Explanation of Specific Lines</h3><p><strong>Line 1:</strong></p><pre>44    1       3       java.lang.String::charAt (29 bytes)</pre><ul><li><strong>44</strong>: Timestamp in milliseconds since JVM start.</li><li><strong>1</strong>: Compilation ID.</li><li><strong>3</strong>: Optimization level.</li><li><strong>java.lang.String::charAt (29 bytes)</strong>: Method name and size.</li></ul><p><strong>Line 2:</strong></p><pre>46    2     n 0       java.lang.System::arraycopy (native)   (static)</pre><ul><li><strong>46</strong>: Timestamp in milliseconds since JVM start.</li><li><strong>2</strong>: Compilation ID.</li><li><strong>n 0</strong>: Native method compilation.</li><li><strong>java.lang.System::arraycopy (native)</strong>: Method name, indicating it’s a native method.</li><li><strong>(static)</strong>: Indicates that the method is static.</li></ul><p><strong>Line 3:</strong></p><pre>48    3       3       java.lang.String::hashCode (55 bytes)</pre><ul><li><strong>48</strong>: Timestamp in milliseconds since JVM start.</li><li><strong>3</strong>: Compilation ID.</li><li>Similar to Line 1, but for the hashCode method.</li></ul><p><strong>Line 16:</strong></p><pre>60   29 %     4       PrimeNumbers::isPrime @ 2 (35 bytes)</pre><ul><li><strong>60</strong>: Timestamp in milliseconds since JVM start.</li><li><strong>29</strong>: Compilation ID.</li><li><strong>% 4</strong>: Indicates high-level optimization.</li><li><strong>PrimeNumbers::isPrime @ 2 (35 bytes)</strong>: Method name and size, compiled at high optimization level.</li></ul><h3>Not Entrant Methods</h3><p><strong>Not Entrant</strong>: Indicates that the method is no longer considered “hot” and is de-optimized, potentially to be recompiled if it becomes hot again.</p><pre>58    1       3       java.lang.String::charAt (29 bytes)   made not entrant<br>59    7       3       java.lang.Object:: (1 bytes)   made not entrant</pre><h3>Summary of Compilation Markers</h3><ul><li><strong>n Marker</strong>: Indicates native methods.</li><li><strong>s Marker</strong>: Indicates synchronized methods.</li><li><strong>% Marker</strong>: Indicates methods compiled with high-level optimization.</li></ul><p>This detailed breakdown should help you understand the output of the -XX:+PrintCompilation flag and the significance of the n, s, and % markers in the context of JIT compilation in the JVM.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d1a3e50997e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is L1, L2 and L3 Support Engineering]]></title>
            <link>https://medium.com/@harshanacslab/what-is-l1-l2-and-l3-support-engineering-6e9ca20c1dbb?source=rss-489752b171ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e9ca20c1dbb</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[application-support]]></category>
            <category><![CDATA[customer-service]]></category>
            <category><![CDATA[applications-engineer]]></category>
            <dc:creator><![CDATA[Harshana Madusanka Jayamaha]]></dc:creator>
            <pubDate>Sat, 25 May 2019 17:47:39 GMT</pubDate>
            <atom:updated>2019-05-25T17:56:09.436Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is L1, L2, and L3 Support Engineering</h3><h3>In this article, I’m going to explain about the Software support engineering role with my experience. I was a Level 2 and 3 support Engineer during my career.</h3><p>L1 — Level 1<br>L2 — Level 2<br>L3 — Level 3<br>Ticket — Incident</p><p>L1 support includes interacting with customers, understand their issue and create tickets against it. The ticket then routed to the relevant L2 support ( Integration support, Server &amp; Storage support, etc …). L1 support Engineers have basic knowledge of product/service and skill to troubleshoot a very basic issue like password reset, software installation/uninstallation/reinstallation.</p><p>L2 support manages the tickets which routed to them by L1( L2 support also can create tickets against any issue noticed by them). They have more knowledge, more experience in solving related complex issues and can guide/help L1 support folks job in troubleshooting. If the solution not provided at this level then escalate to the L3.</p><p>L3 is the last line of support and usually comprise of a development team which addresses the technical issues. They are expert in their domain and handle the most difficult problems. They do the code changes, research and develop the solution for challenging new or unknown issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*6ZEuhQrG1UYwuveNV-PDbQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e9ca20c1dbb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>