<?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 I Putu Aldy Cahyakusuma on Medium]]></title>
        <description><![CDATA[Stories by I Putu Aldy Cahyakusuma on Medium]]></description>
        <link>https://medium.com/@ialdyksma?source=rss-81b706a2f65d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VTEm9vVtUSoWl3gcCQHhnw.jpeg</url>
            <title>Stories by I Putu Aldy Cahyakusuma on Medium</title>
            <link>https://medium.com/@ialdyksma?source=rss-81b706a2f65d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:39:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ialdyksma/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 We Keep Crypto Apps Fast Under High-Frequency Updates]]></title>
            <link>https://medium.com/@ialdyksma/how-we-keep-crypto-apps-fast-under-high-frequency-updates-2b495acca3d1?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b495acca3d1</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Sat, 03 Jan 2026 10:54:18 GMT</pubDate>
            <atom:updated>2026-01-03T10:54:18.248Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WKnXw1e1G9xvEPVVLjXsmA@2x.jpeg" /></figure><p>Working as a frontend engineer in the crypto industry comes with a unique set of challenges. Beyond typical UI concerns, we constantly deal with security constraints, real-time data, and performance issues across a wide range of devices — from low-end phones to high-end flagships.</p><p>One of the biggest differences compared to traditional apps is the nature of the data itself. Crypto prices change rapidly, often multiple times per second. If we are not careful, how we handle these updates can easily degrade app performance, especially on low-end Android devices.</p><p>From my experience, performance issues are rarely reported by iOS users. Most complaints come from Android users, usually tied to specific screens that render frequent real-time updates.</p><p>So what can we do to mitigate this?</p><h4>1. Control Update Frequency with Batching</h4><p>The first thing to evaluate is how often your data actually changes and how often the UI needs to react to it.</p><p>Instead of updating the store every time new data arrives from a WebSocket, apply batching. Collect updates over a short interval and apply them in a single update cycle. This significantly reduces unnecessary re-renders and state updates, especially when prices update aggressively.</p><p>Batching helps smooth out bursts of updates and gives the UI a predictable update cadence, which is critical for maintaining responsiveness on lower-end devices.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OHyU6Jf0Qrz8lPB6C8v84A.png" /></figure><h4>2. Update Only What Matters</h4><p>Not all data fields are equally important.</p><p>Identify critical fields such as price, volume, or percentage change. If a WebSocket update does not affect these key fields, there is often no reason to push an update to the store. Skipping non-essential updates helps reduce CPU usage and keeps the UI responsive.</p><p>In real-time systems, blindly propagating every incoming update is one of the fastest ways to introduce performance bottlenecks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7asK0O59xd4PpsYpcC3SHg.png" /></figure><h4>3. Normalize and Preprocess Data Before Rendering</h4><p>Do as much work as possible before data reaches the UI layer.</p><p>Normalize incoming data and pre-format values — for example, number formatting, rounding, or precision handling — before passing them to the UI. This reduces the workload during rendering and prevents repeated formatting logic from running on every render cycle.</p><p>The UI should focus on rendering, not data transformation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EO2Y7UkgM4GpviKZ7IgUPA.png" /></figure><h4>4. Follow Platform-Appropriate Rendering Best Practices</h4><p>This sounds obvious, but it’s often overlooked.</p><p>When rendering lists, use the right list component for your use case. Enable virtualization, avoid rendering off-screen items, and lazily load heavy screens when possible. On Android especially, inefficient list rendering can quickly become a performance bottleneck.</p><p>A single poorly configured list can negate all other performance optimizations.</p><p><a href="https://reactnative.dev/docs/performance#flatlist-rendering-is-too-slow-or-scroll-performance-is-bad-for-large-lists">https://reactnative.dev/docs/performance#flatlist-rendering-is-too-slow-or-scroll-performance-is-bad-for-large-lists</a></p><h4>5. Use Atomic Rendering with Zustand</h4><p>State management plays a major role in rendering performance, especially in real-time apps.</p><p>A common mistake when using global state is subscribing components to more data than they actually need. When unrelated state changes, these components re-render unnecessarily.</p><p>With Zustand, you can achieve atomic rendering by subscribing components only to the exact slice of state they depend on. Instead of subscribing to an entire market object, a price row component should subscribe only to the price field. This ensures the component re-renders only when that specific value changes.</p><p>When combined with batching and selective updates, atomic rendering significantly reduces render frequency and CPU usage — particularly on Android devices under high-frequency updates.</p><pre>// marketStore.ts<br>type Market = {<br>  price: number<br>  volume: number<br>}<br><br>type MarketState = {<br>  markets: Record&lt;string, Market&gt;<br>}<br><br>export const useMarketStore = create&lt;MarketState&gt;(() =&gt; ({<br>  markets: {},<br>}))<br><br>// ❌ Bad: subscribes to all symbols<br>const markets = useMarketStore(state =&gt; state.markets)<br>const price = markets[symbol].price<br><br><br>// ✅ Good: atomic subscription per symbol + field<br>const price = useMarketStore(<br>  state =&gt; state.markets[symbol]?.price<br>)</pre><p>Real-time crypto apps are inherently demanding. However, with careful control over update frequency, selective state updates, proper preprocessing, platform-aware rendering, and atomic subscriptions, it’s possible to deliver a smooth and reliable experience — even on low-end devices.</p><p>Performance is not a single optimization. It’s the result of many small, deliberate decisions made throughout the frontend architecture.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b495acca3d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Experience as a Frontend Engineer in Crypto]]></title>
            <link>https://medium.com/@ialdyksma/being-frontend-engineer-at-a-crypto-exchange-a0a4e554ef0f?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0a4e554ef0f</guid>
            <category><![CDATA[crypto]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[software-engineer]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Sun, 21 Sep 2025 14:03:17 GMT</pubDate>
            <atom:updated>2025-09-21T14:08:22.787Z</atom:updated>
            <content:encoded><![CDATA[<p>Working as a frontend engineer at a crypto exchange is like being a chef in a restaurant that never closes. The market runs 24/7, and so does the pressure. Let me share what this is really like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/853/1*u-ZqcRKiHlrVtsi4zqGgjw.jpeg" /></figure><h3>What It’s Really Like</h3><p>When I first joined, I thought it’d be all fancy charts and trading interfaces. And yeah, that’s part of it, but there’s way more. You’re not just building websites and mobile apps — you’re building infrastructure that handles people’s money, sometimes millions of dollars.</p><p>The first thing that hits you is the speed. Everything moves fast. New token launches? You need to support it yesterday. Major market event? Your trading interface better not crash. It’s like building a race car while driving it.</p><h3>The Technical Side</h3><p>Real-time data is a beast. You’re not just fetching from an API and showing it. You’re dealing with WebSocket connections pushing thousands of price updates per second. One small bug in your data handling, and suddenly all prices are wrong. That’s not just embarrassing — it could cost users real money.</p><p>Then there’s security. Every input field, every API call, every piece of user data needs to be treated like nuclear codes. You can’t just trust user input. You can’t assume your API responses are safe. Every line of code needs security in mind.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2Fule4vhcY1xEKQ%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExcDJhdjh6b3FmbWF6OXlldHZkdGplbXR4NjcycmJ4b280emprMDdrMyZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2Fule4vhcY1xEKQ%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia4.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExMG0wNTlnNXFuandkbzAyZXZjc3phczg2Z21kZG5pbmxpMGwxbWpldCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2Fule4vhcY1xEKQ%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="435" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f9c203869d111cdf80d8c7fcc920e46/href">https://medium.com/media/4f9c203869d111cdf80d8c7fcc920e46/href</a></iframe><h3>The User Experience Challenge</h3><p>Crypto users aren’t your typical website visitors. They’re traders, investors, and people just trying to understand digital money. They need interfaces that are both powerful and simple. A trader needs complex charts and millisecond trade execution, while a beginner needs to understand what they’re doing without getting lost.</p><p>You’re constantly balancing functionality and usability. Give power users all the tools they need, but make sure someone buying their first Bitcoin doesn’t get lost in a maze of technical indicators.</p><h3>The Learning Curve</h3><p>Coming from traditional web dev, crypto was a steep learning curve. Suddenly I needed to understand blockchain, smart contracts, and DeFi protocols. But here’s the thing — you don’t need to be a crypto expert to build great frontend experiences. Just understand enough to build the right tools.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FqZgHBlenHa1zKqy6Zn%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExaGVrZmFjY3I3MHAyYzdqbjhxN2xhMHVnNWVzcGthbTAxdGg1dm1raCZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2FqZgHBlenHa1zKqy6Zn%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia1.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExbXlmMjg3YWM4dGRnb3FvaW1zOTY4Mzg3Nm0yZjU5Z2xoZWR4MXdkZyZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2FqZgHBlenHa1zKqy6Zn%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="435" frameborder="0" scrolling="no"><a href="https://medium.com/media/822523d8c3ac00a97feeb8c4ac9d9711/href">https://medium.com/media/822523d8c3ac00a97feeb8c4ac9d9711/href</a></iframe><p>The technical side is different too. You’re working with libraries and frameworks that are still evolving. Some tools you use today might not exist next year. You need to be comfortable with change and always learning.</p><h3>Working with Global Teams</h3><p>Working at a crypto exchange means working with people from all over the world. My team has developers from different countries, each bringing their own perspective. This diversity is great for problem-solving, but you need to be good at communication.</p><p>Working with people from different cultures brings new ideas and approaches to solving problems. It’s like having access to a global knowledge base right in your office.</p><h3>The Impact</h3><p>What I love most is the impact. Every feature I build, every bug I fix, every performance improvement directly affects real people using real money. When I optimize a trading interface to be faster, traders can execute better trades. When I improve UX for new users, more people can safely enter crypto.</p><p>It’s not just writing code — it’s building the future of finance. Every day, I’m helping create tools that make digital money more accessible.</p><h3>The Challenges</h3><p>Of course, it’s not all sunshine and rainbows. The regulatory environment is constantly changing, which means requirements can shift overnight. What was legal yesterday might need to change tomorrow. You need to build flexible systems that adapt quickly.</p><p>Market volatility also affects your work. When Bitcoin crashes or pumps, your servers better be ready for the traffic spike. You can’t just build for normal usage — you need to build for the extremes.</p><h3>Advice for New Developers</h3><p>If you’re thinking about joining a crypto exchange as a frontend engineer, here’s what I’d tell you:</p><p>1. <strong>Learn crypto basics</strong> — You don’t need to be an expert, but understanding how blockchain works helps you build better products.</p><p>2. <strong>Focus on performance</strong>— Crypto users expect fast, responsive interfaces. Every millisecond matters.</p><p>3. <strong>Think security first</strong> — Every feature you build needs to be secure by default.</p><p>4. <strong>Be ready for change</strong>— The crypto space moves fast, and you need to move with it.</p><p>5. <strong>Embrace the global team</strong> — Working with people from different cultures and time zones is part of the job.</p><h3>The Bottom Line</h3><p>Working as a frontend app and web engineer at a crypto exchange is challenging, exciting, and rewarding. You’re building tools that power the future of money, working with cutting-edge technology, and solving problems that didn’t exist a few years ago.</p><p>It’s not for everyone. The pace is fast, the pressure is real, and the learning never stops. But if you thrive on challenges and want to be part of something bigger than just building websites, it might be perfect for you.</p><p>The crypto world is still young, and there’s so much more to build. Every day brings new opportunities to create something that’s never existed before. And that’s what makes this job so exciting.</p><p>Thanks for reading, and may your code always compile on the first try!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FB4dt6rXq6nABilHTYM%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExYjNybmVzeHR5MXE0ejRvcTg2MHU2aWxieWlwemY5YnJ0czBteHVybSZlcD12MV9naWZzX3NlYXJjaCZjdD1n%2FB4dt6rXq6nABilHTYM%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia3.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExZHNqZ2h6azJwamRsdGxqMmUxNmk4cTFveWlobGxpOTh2YWhhamhxaCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw%2FB4dt6rXq6nABilHTYM%2Fgiphy_s.gif&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="409" frameborder="0" scrolling="no"><a href="https://medium.com/media/6ffc209d17ce110e0b4d4881881eebf9/href">https://medium.com/media/6ffc209d17ce110e0b4d4881881eebf9/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0a4e554ef0f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Improving Code Quality Isn’t Worth the Cost]]></title>
            <link>https://medium.com/@ialdyksma/when-improving-code-quality-isnt-worth-the-cost-c31fcb0bcc4a?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c31fcb0bcc4a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Sat, 26 Oct 2024 06:24:35 GMT</pubDate>
            <atom:updated>2024-10-26T06:24:35.952Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M5VIXaeTp1fM8mYQJhghMQ@2x.jpeg" /></figure><p>As a software engineer, I often come across messy source code and find myself wanting to clean it up or improve it. While better code can make things easier to maintain in the future, I’ve learned that not all messy code needs to be changed. Every piece of code has its own reasons for being the way it is.</p><p>When I was a junior engineer, I thought cleaning up code was always the right thing to do. However, I’ve come to realize that creating software is about more than just making the code pretty. it’s also about considering time, quality, and cost.</p><p>In software development, trade-offs are part of the process. If you focus on speed, you might have to accept lower quality and higher costs. On the other hand, if you want top-quality software, you need to expect to spend more time and money. And if staying within budget is your main goal, the quality may suffer. Each choice has its consequences, so it’s important to think them through.</p><p><strong>Not every piece of bad code needs to be rewritten.</strong> Sometimes, the original code serves a purpose or fits with the project goals. When you think about revamping an app, you might see three possible outcomes: <strong>the app could perform better, stay the same, or even get worse</strong>. Before diving into a revamp, it’s crucial to look at not just the code’s quality but also its context and how it fits into the overall project. This helps make sure that any changes you make are truly helpful.</p><p>For example, if you spend a year revamping an app to improve its performance, and you succeed, your boss might praise you or even consider you for a promotion. But if the outcome is the same or worse than before, the results could be serious you might risk losing your job for spending a year on something that didn’t bring real benefits.</p><p>In conclusion, while the desire to improve messy code is natural, it’s essential to remember that not every piece of code needs a complete overhaul. Understanding the context and purpose of existing code can save time and resources, allowing teams to focus on what truly matters for the project. By weighing the trade-offs between code quality, time, and cost, we can make smarter decisions that lead to better outcomes. Ultimately, a thoughtful approach to software development helps ensure that we deliver not only functional software but also a product that meets the needs of users and stakeholders alike.</p><p>Thank you for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c31fcb0bcc4a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Writing Clear and Effective Tests with the GWT Structure]]></title>
            <link>https://medium.com/@ialdyksma/writing-clear-and-effective-tests-with-the-gwt-structure-5abad2158c46?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5abad2158c46</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Thu, 24 Oct 2024 14:49:40 GMT</pubDate>
            <atom:updated>2025-07-13T15:58:32.768Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h4cfQ46N9Kgmx9CzPhu9mg@2x.jpeg" /></figure><p>When it comes to writing tests for your code, having a clear and organized structure can make a big difference. One popular method is the GWT (Given-When-Then) structure. This approach breaks down tests into three easy-to-understand parts, making it simpler to follow what each test is doing.</p><p>In this article, we’ll explore the GWT structure and provide an example using a simple function called renameRupiah. Let&#39;s dive in!</p><h3>What is the GWT Structure?</h3><p>The GWT structure consists of three main parts:</p><ol><li><strong>Given</strong>: This is where you describe the initial setup or starting conditions for the test. It sets the stage for what you are testing.</li><li><strong>When</strong>: This part describes the action that triggers the behavior you want to test. It shows what you do to test the function or feature.</li><li><strong>Then</strong>: This part explains what you expect to happen after the action. It’s where you check if the outcome is correct.</li></ol><h3>Example: Testing the renameRupiah Function</h3><p>Let’s look at a practical example using a function that renames currency strings. Here’s the code for our tests:</p><pre>// rename.ts<br>export function renameRupiah(input: string): string {<br>  // Check if the input is &quot;Rupiah Token&quot;<br>  if (input === &quot;Rupiah Token&quot;) {<br>    return &quot;Rupiah&quot;; // Return &quot;Rupiah&quot; if the input matches<br>  }<br>  <br>  // If input is not &quot;Rupiah Token&quot;, return the original input<br>  return input;<br>}</pre><pre>// utils.test.tsx<br>import { faker } from &#39;@faker-js/faker&#39;;<br>import { renameRupiah } from &#39;./rename&#39;;<br><br>describe(&#39;renameRupiah function&#39;, () =&gt; {<br>  <br>  it(&#39;returns &quot;Rupiah&quot; when given &quot;Rupiah Token&quot;&#39;, () =&gt; {<br>    // GIVEN: The input string is &quot;Rupiah Token&quot;<br>    const input = &#39;Rupiah Token&#39;;<br><br>    // WHEN: renameRupiah function is called with the input<br>    const result = renameRupiah(input);<br><br>    // THEN: It should return &quot;Rupiah&quot;<br>    expect(result).toBe(&#39;Rupiah&#39;);<br>  });<br><br>  it(&#39;returns the original string when input is not &quot;Rupiah Token&quot;&#39;, () =&gt; {<br>    // GIVEN: A random currency name is generated<br>    const randomName = faker.finance.currencyName();<br><br>    // WHEN: renameRupiah function is called with the random name<br>    const result = renameRupiah(randomName);<br><br>    // THEN: It should return the original string<br>    expect(result).toBe(randomName);<br>  });<br>});</pre><h3>Breaking Down the Example</h3><p>Let’s break down the example to see how the GWT structure works:</p><h4>Test 1: Renaming “Rupiah Token”</h4><ol><li><strong>Given</strong>: We set up the test by defining the input string as “Rupiah Token”.</li><li><strong>When</strong>: We call the renameRupiah function with the input.</li><li><strong>Then</strong>: We check if the result is “Rupiah”. If it is, the test passes!</li></ol><h4>Test 2: Handling a Random Currency Name</h4><ol><li><strong>Given</strong>: Here, we use the faker library to create a random currency name.</li><li><strong>When</strong>: We call the renameRupiah function with this random name.</li><li><strong>Then</strong>: We expect the result to be the same as the input. If it matches, the test passes!</li></ol><h3>Benefits of Using the GWT Structure</h3><p>Using the GWT structure has several advantages:</p><ul><li><strong>Clarity</strong>: Each part of the test is clearly defined, making it easier for anyone reading the test to understand its purpose.</li><li><strong>Consistency</strong>: Following the same format for each test helps keep your code organized, making it easier to maintain as your project grows.</li><li><strong>Simplicity</strong>: Breaking tests into smaller parts helps you focus on one aspect at a time, reducing confusion.</li></ul><h3>Conclusion</h3><p>The GWT structure is an excellent way to write clear and organized tests. By breaking down your tests into Given, When, and Then parts, you make it easier for others (and yourself) to understand what your tests are doing. Try using this approach in your next testing project, and you’ll likely see improvements in clarity and maintainability!</p><p>Happy testing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5abad2158c46" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Ask to Ask When You Can Just Ask?]]></title>
            <link>https://medium.com/@ialdyksma/why-ask-to-ask-when-you-can-just-ask-ed3943141527?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed3943141527</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Tue, 13 Feb 2024 16:51:30 GMT</pubDate>
            <atom:updated>2025-07-13T15:46:52.822Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why ask to ask when you can just ask?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_8Yt22YybMi0kED6hfAklw@2x.jpeg" /></figure><p>Every day, thousands of people ask for help online but never get answers. Not because others don’t want to help, but because the questions are too unclear. This happens when people “ask to ask” instead of just asking their real question right away.</p><h3>The Problem: Unclear Questions That Don’t Get Answered</h3><p>Have you seen requests like these in online groups?</p><p><strong>Case 1: Looking for Experts</strong> “Any Flutter Expert around?”</p><p>This question doesn’t tell us what you need help with. People who know Flutter might be online, but they won’t answer because they don’t know if they can help with your specific problem. Your question gets ignored and disappears in the group.</p><p><strong>Case 2: The “I Have a Question” Message</strong> Imagine getting a message that says, “Hey, I have a question” and then nothing else. You’re left waiting for them to tell you what they actually want to know. This back-and-forth wastes time and annoys everyone.</p><h3>Before we talk about better ways to ask, let’s understand why people communicate like this:</h3><ul><li><strong>They think it’s polite</strong>: They want to check if someone is available first</li><li><strong>They don’t want to bother people</strong>: They worry that jumping straight into details might be too much</li><li><strong>They’re not sure</strong>: They don’t know if they’re asking the right people</li><li><strong>It’s a habit</strong>: They learned this from talking face-to-face, where it makes more sense</li></ul><h3>The Better Way: Be Clear and Direct</h3><p>Instead of beating around the bush, tell people exactly what you need help with right away. For example:</p><p><strong>“Hi, I’m getting an error when trying to add login to my Flutter app. I tried clearing my files and reinstalling everything, but it’s still broken. Here’s the error message: [show the error]. Can someone help me fix this?”</strong></p><p>This way tells helpers:</p><ul><li>What you’re working on</li><li>What’s going wrong</li><li>What you already tried</li><li>What kind of help you need</li></ul><h3>Why This Works Better</h3><p><strong>For you (the person asking):</strong></p><ul><li>You get answers faster</li><li>The answers are more helpful</li><li>More people with the right skills will help you</li><li>Less going back and forth to explain things</li></ul><p><strong>For the group:</strong></p><ul><li>People can quickly see if they know how to help</li><li>Everyone saves time</li><li>Future people with the same problem can find your question easily</li><li>Less useless messages in the group</li></ul><h3>Simple Steps for Better Questions</h3><p>When you need help online, include these things:</p><ol><li><strong>What you’re doing</strong>: What project or task are you working on?</li><li><strong>What’s wrong</strong>: What specific problem are you having?</li><li><strong>What you tried</strong>: What did you already do to try to fix it?</li><li><strong>What you want</strong>: What do you hope someone can help you with?</li><li><strong>Show details</strong>: Include error messages, pictures, or code if needed</li></ol><h3>How This Helps Everyone</h3><p>When you give all the important information right away, people don’t need to ask you more questions to understand your problem. This saves time for everyone and makes online groups better places to learn and get help.</p><p>The main point is simple: when you need help, tell people exactly what you need. This makes everything work better for everyone.</p><p><strong>The point here is not to ask to ask, just ask.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed3943141527" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The correct way to display Images on the website]]></title>
            <link>https://medium.com/@ialdyksma/the-correct-way-to-display-images-on-the-website-c2abd25fd941?source=rss-81b706a2f65d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2abd25fd941</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[I Putu Aldy Cahyakusuma]]></dc:creator>
            <pubDate>Fri, 02 Dec 2022 16:15:39 GMT</pubDate>
            <atom:updated>2024-05-05T09:54:46.764Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pG6lB1mOC1L1utcVaB155Q@2x.jpeg" /><figcaption>Photo by Andrew Keymaster on Unsplash</figcaption></figure><p>The average website has an image in it, the image on a website is closely related to the benchmark <strong>performance</strong>, which can be seen from <strong>Core Web Vitals</strong>, Google or search engines use this benchmark to determine the ranking of a website. So in conclusion images are very influential to the user experience, page ranking, and also the business that we have.</p><h3>1. Lazy Loading</h3><p><strong>Lazy loading </strong>(also called on-demand loading) is an optimization technique for online content, be it a website or a web app.<br>Instead of loading the entire web page and rendering it to the user in one go as in bulk loading, the concept of lazy loading assists in loading only the required section and delays the remaining, until it is needed by the user.</p><p>In the case of an e-commerce website, for sure we will see lots of pictures on each product list that is displayed. Of course, the products displayed are not few. There are users who scroll to the bottom and some who don’t. From this case, there is something we can optimize by displaying images that the user sees first in the viewport, images outside the viewport are loaded when we need them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WPJT15_xcwTkpZJA" /></figure><p>Here is an example of how to implement lazy loading on HTML:</p><pre>&lt;img src=<br>    &quot;images/image.jpg&quot;<br>    loading=&quot;lazy&quot; <br>    width=&quot;300&quot; height=&quot;300&quot; <br>/&gt;</pre><p><strong>Approach: </strong>To use Lazy Loading, use the loading attribute of the image tag in HTML. Here are the supported values for the loading attribute:</p><ul><li><strong>auto: </strong>Default lazy-loading behavior of the browser, which is the same as not including the attribute.</li><li><strong>lazy:</strong> Defer loading of the resource until it reaches a calculated distance from the viewport.</li><li><strong>eager:</strong> Load the resource immediately, regardless of where it’s located on the page.</li></ul><p>Here is the browser that supports lazy loading:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jWW8LtU0vY6WANUqKcphVQ.png" /></figure><h3><strong>2. Preload</strong></h3><p><a href="https://web.dev/preload-critical-assets">Preload</a> lets you tell the browser about critical resources that you want to load as soon as possible before they are discovered in HTML. This is especially useful for resources that are not easily discoverable, such as fonts included in stylesheets, background images, or resources loaded from a script.</p><p>Example usage :</p><pre>&lt;link rel=&quot;preload&quot; as=&quot;image&quot; href=&quot;wolf_1600.jpg&quot;&gt;</pre><p>Before</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xlAMtA1atqdGtJlq" /><figcaption>Before using Preload</figcaption></figure><p>After</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bbj9IhCk74RtdMQl" /><figcaption>After using preload</figcaption></figure><p>As we can see the image loaded first than any other assets.</p><h3>3. Use the optimal image format</h3><p>Using the optimal image also helps us to deliver good-quality content, for example, If we want to display an image <strong>vector</strong> most optimal format is <strong>svg</strong> cause</p><p>SVG stands for scalable vector graphics, and it is a file format that allows you to display vector images on your website. This means that <strong>you can scale an SVG image up and down as needed without losing any quality</strong>, making it a great choice for responsive web design.</p><p>And when you want to display a <strong>rasther</strong> image most optimal format is webp or avif.</p><p>According to Google’s own data, <strong>WebP</strong> lossless compression is 26% smaller than PNGs and its lossy compression is 25–34% smaller than JPEGs. For sites that use a lot of images, switching over could make a significant impact and shave valuable milliseconds of loading time, especially on mobile.</p><p>The comparison :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FYmc57sOX7VEc0tkQH8glQ.png" /></figure><p>Here’s a tool to format images to <strong>WebP</strong> that I use <a href="https://squoosh.app/">https://squoosh.app</a></p><h3><strong>4. Define explicitly the image size</strong></h3><p>Imagine you’ve started reading an article when all of a sudden elements shift around the page, throwing you off and requiring you to find your place again. This is very common on the web, including when reading the news.</p><p>Always include width and height size attributes on your images and video elements. Alternatively, reserve the required space with <a href="https://css-tricks.com/aspect-ratio-boxes/">CSS aspect ratio boxes</a>. This approach ensures that the browser can allocate the correct amount of space in the document while the image is loading. That will help us to avoid <strong>Cumulative Layout Shift (Core Web Vitals)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2hA-f52km_uajr9l" /></figure><h3>5. Use Alternative Attribute</h3><p>Defining alternative attribute helps us to improve the accessibility website, when one day an image on a website cannot be loaded alternative text can help the user to find out what image is being displayed, And also give the alternative text to optimize website SEO. When users search for an image on Google, Google would give our image and the user probably visit our website.</p><p>Example :</p><pre>&lt;img src=<br>    &quot;images/persia_cat.jpg&quot;<br>    alt=&quot;A Persia Cat&quot; <br>    width=&quot;300&quot; height=&quot;300&quot; <br>/&gt;</pre><p>Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2abd25fd941" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>