<?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[Gravel Product &amp; Tech - Medium]]></title>
        <description><![CDATA[Curated thoughts and stories from @Gravel product and tech team - Medium]]></description>
        <link>https://medium.com/gravel-engineering?source=rss----bfa9c86bd70d---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Gravel Product &amp;amp; Tech - Medium</title>
            <link>https://medium.com/gravel-engineering?source=rss----bfa9c86bd70d---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 07:09:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/gravel-engineering" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Getting Started with Kotlin Multiplatform and Kotlin Compose: A Step-by-Step Guide]]></title>
            <link>https://medium.com/gravel-engineering/getting-started-with-kotlin-multiplatform-and-kotlin-compose-a-step-by-step-guide-0d152a8d9e22?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/0d152a8d9e22</guid>
            <category><![CDATA[mobile-app-framework]]></category>
            <category><![CDATA[cross-platform-ui]]></category>
            <category><![CDATA[kmp-setup-guide]]></category>
            <category><![CDATA[android-ios-integration]]></category>
            <category><![CDATA[kotlin-vs-flutter]]></category>
            <dc:creator><![CDATA[Akbar Dzulfikar]]></dc:creator>
            <pubDate>Fri, 30 Aug 2024 03:40:05 GMT</pubDate>
            <atom:updated>2024-09-03T01:42:28.669Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MqpROzWmOGzbkIa5.png" /></figure><p>Imagine this: You’re developing an app that works flawlessly on both Android and iOS. You’ve written the code once, but it runs everywhere — no need to manage separate codebases, no more duplicated efforts. This is the promise of Kotlin Multiplatform (KMP) and Kotlin Compose. It’s a developer’s dream come true, and today, I’m going to show you how to make that dream a reality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*ZFopIb-UQhqBJeFX.png" /></figure><h3>Prerequisites</h3><p>Before we dive in, make sure your development environment is set up with the following:</p><ul><li><strong>Kotlin</strong>: Our primary language.</li><li><strong>IntelliJ IDEA or Android Studio</strong>: Your go-to IDE.</li><li><strong>Kotlin Multiplatform Project Template</strong>: Available from JetBrains, this template will kickstart our journey.</li></ul><h3>Step 1: Download the KMP Project Template</h3><p>Head over to the Kotlin Multiplatform website and grab the project template. This isn’t just any template — it’s your launchpad to building apps that bridge the gap between platforms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*j0OGYySxtgsPNi6e.gif" /></figure><h3>Step 2: Open the Project in Your IDE</h3><p>Once you’ve got the template, extract the zip file and fire up your IDE. Opening the project should be a breeze, revealing a pre-configured structure that’s ready to go. This is where the magic begins.</p><h3>Step 3: Explore the Project Structure</h3><p>At this point, you might be wondering, “What makes KMP so special?” The answer lies in the project structure. You’ll find three core modules:</p><ul><li><strong>common</strong>: The beating heart of your app, where the shared logic lives.</li><li><strong>androidApp</strong>: All things Android, from UI to platform-specific implementations.</li><li><strong>iosApp</strong>: The counterpart to your Android module, tailored for iOS.</li></ul><p>Here’s an interesting insight: In traditional app development, you’d be writing separate code for each platform. But with KMP, you’re cutting that work in half — maybe even more. It’s like discovering a secret shortcut that saves you hours of work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*6fo7lgpJ0bNxr4sJ.gif" /></figure><h3>Step 4: Run the App</h3><p>The real test comes when you run the app. Fire it up on an emulator or device, and watch as the same codebase powers both Android and iOS apps. It’s a satisfying moment, seeing your efforts come to life across platforms with minimal effort.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/0*AlTj5HOsBDZdcw4T.gif" /></figure><h3>Step 5: Start Building Your App</h3><p>Now, the canvas is yours. With the project set up, you’re free to dive into Kotlin Compose and start crafting your app’s UI. The possibilities are endless — what will you build? As you modify the sample code and add your own features, you’ll see just how powerful and flexible KMP and Kotlin Compose truly are.</p><h3>Conclusion</h3><p>As you wrap up this guide and start your journey into Kotlin Multiplatform and Kotlin Compose, ask yourself: What could you achieve if you could focus on innovation rather than maintenance? By embracing these tools, you’re not just writing code — you’re shaping the future of app development. The only question left is: What will you create next?</p><p><strong>Bio</strong>: Laksamana Akbar Dzulfikar,</p><p>Senior Android Engineer.</p><h3>Currently, I’m open to work.</h3><p>Kotlin Multiplatform, Kotlin Compose, cross-platform development, KMP, JetBrains, Android Studio, IntelliJ IDEA, mobile app development, shared codebase, Android app, iOS app, project template, Kotlin programming, multiplatform project, app development guide, mobile UI design, Kotlin documentation, Jetpack Compose.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d152a8d9e22" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/getting-started-with-kotlin-multiplatform-and-kotlin-compose-a-step-by-step-guide-0d152a8d9e22">Getting Started with Kotlin Multiplatform and Kotlin Compose: A Step-by-Step Guide</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Android 14’s Foreground Service Requirements Might Break Your App — and How to Fix It]]></title>
            <link>https://medium.com/gravel-engineering/why-android-14s-foreground-service-requirements-might-break-your-app-and-how-to-fix-it-c1cbcf469b69?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/c1cbcf469b69</guid>
            <category><![CDATA[handling-android-changes]]></category>
            <category><![CDATA[foregroundservicetype]]></category>
            <category><![CDATA[update-for-android-14]]></category>
            <category><![CDATA[android-14-foreground]]></category>
            <category><![CDATA[workmanager-fixes]]></category>
            <dc:creator><![CDATA[Akbar Dzulfikar]]></dc:creator>
            <pubDate>Tue, 27 Aug 2024 12:57:57 GMT</pubDate>
            <atom:updated>2024-09-03T01:42:46.970Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why Android 14’s Foreground Service Requirements Might Break Your App — and How to Fix It</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*c0noL-ju4Hj3UJFAJZVpvg.png" /></figure><h3>Introduction: The Hidden Challenge in Android 14’s New Rules</h3><p>As Android developers, we’re no strangers to changes in the operating system that demand adjustments to our apps. However, with Android 14, a subtle yet significant change has emerged, one that’s already causing headaches across the developer community: the new requirement for explicitly defining `foregroundServiceType` for both services and WorkManager tasks. At first glance, it seems like a simple update — just add a line or two to your manifest, right? But the reality is more complex, and if you miss the nuances, your app could crash in ways that are frustratingly hard to diagnose.</p><p>Imagine this: you’ve built a sleek, responsive app that handles background tasks flawlessly. It’s been through rigorous testing, and your users love it. But then, Android 14 rolls out, and suddenly, your app is throwing `IllegalArgumentException` errors. What went wrong? It’s all in the details of how Android 14 handles foreground services — and if you’re not careful, these changes could trip up even the most seasoned developers.</p><p>— -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*f5Ifhdq2buDk6kXppjXvhA.png" /></figure><h3>The Story: A Small Change with Big Consequences</h3><p>Let’s take a step back and explore what’s happening under the hood. Android 14 introduced a mandatory requirement to define `foregroundServiceType` when using foreground services. This change was designed to improve battery life and user privacy by ensuring that apps clearly state their purpose for running in the foreground. It’s a well-intentioned update, but it comes with an unexpected pitfall: WorkManager, the go-to solution for deferrable background tasks that need guaranteed execution, also requires this `foregroundServiceType` definition — despite it being abstracted from direct service management.</p><p>Here’s where things get tricky. Many developers assumed that setting the `foregroundServiceType` in the manifest was enough, only to be greeted by crashes that pointed to mismatches between the `foregroundServiceType` in the code and what was declared in the manifest. For instance, if you’re using WorkManager for tasks like data synchronization, you might define `android:foregroundServiceType=”dataSync”` in your manifest. But if your WorkManager code implicitly expects a different service type or none at all, Android 14 will reject the mismatch, and your app will crash with a cryptic error:</p><pre>java.lang.IllegalArgumentException: foregroundServiceType 0x00000010 is not a subset of foregroundServiceType attribute 0x00000000 in service element of manifest file</pre><p>This isn’t just a theoretical problem — developers around the world are encountering it. The confusion arises because the change isn’t about adding a single line to your manifest; it’s about ensuring that every `foregroundServiceType` in your app’s code matches exactly with what you’ve declared in the manifest. Miss this, and your carefully crafted background tasks could fail, leaving you scrambling to debug.</p><p>if you haven’t define the foreground service type the error will be:</p><pre>android.app.InvalidForegroundServiceTypeException: Starting FGS with type none callerApp=ProcessRecord{d71e6c9 28248:com.graveltechnology.oui.debug/u0a624} targetSDK=34 has been prohibited</pre><p>— -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*80ML3NkQ1vXFh008E7M2Vg.png" /></figure><h3>The Impact: Why Developers (and Others) Should Care</h3><p>So, who needs to pay attention to this change? Primarily, developers. But the ripple effects extend beyond the development team. Product managers, quality assurance testers, and even customer support teams need to be aware of this potential issue. A crashing app can lead to negative reviews, increased support tickets, and even loss of users — especially if the crash is tied to background tasks that users rely on, like data sync or location tracking.</p><p>For developers, this means that every time you use WorkManager for foreground tasks, you must be vigilant. Ensure that your `foregroundServiceType` is correctly defined both in your code and in your manifest. It’s not just about passing the build; it’s about delivering a seamless experience to your users, regardless of what version of Android they’re running.</p><p>For others in the tech ecosystem, understanding this change is key to maintaining smooth operations. If you’re a product manager, you need to allocate time for your dev team to address these updates. If you’re in QA, be on the lookout for this specific crash in Android 14. And if you’re in customer support, prepare to reassure users that a fix is on the way — armed with knowledge about the root cause.</p><p>— -</p><h3>The Solution: How to Fix the Foreground Service Issue</h3><p>If you’re facing this issue, here’s how to fix it.</p><h4><strong>1. Update the `AndroidManifest.xml` with the Correct `foregroundServiceType`</strong></h4><p>For WorkManager to work correctly in Android 14, you need to explicitly define the `foregroundServiceType` in your manifest file. Here’s how to do it:</p><pre>xml<br>&lt;manifest xmlns:android=&quot;http://schemas.android.com/apk/res/android&quot;<br> package=&quot;com.example.myapp&quot;&gt;<br>&lt;! - Permissions for data synchronization or location tracking →<br> &lt;uses-permission android:name=&quot;android.permission.FOREGROUND_SERVICE_DATA_SYNC&quot; /&gt;<br> &lt;uses-permission android:name=&quot;android.permission.FOREGROUND_SERVICE_LOCATION&quot; /&gt;<br>&lt;application<br> android:allowBackup=&quot;true&quot;<br> android:label=&quot;@string/app_name&quot;<br> android:supportsRtl=&quot;true&quot;<br> android:theme=&quot;@style/AppTheme&quot;&gt;<br>&lt;! - Define the service with the correct foreground service type →<br> &lt;service<br> android:name=&quot;androidx.work.impl.foreground.SystemForegroundService&quot;<br> android:foregroundServiceType=&quot;dataSync&quot;/&gt;<br><br><br> <br> &lt;/application&gt;<br>&lt;/manifest&gt;</pre><h4><strong>2. Ensure Your WorkManager Code Matches the Manifest</strong></h4><p>Next, in your WorkManager code, ensure that you’re setting the `ForegroundInfo` with the correct `foregroundServiceType`:</p><pre>class MyForegroundWorker(context: Context, params: WorkerParameters) :<br> CoroutineWorker(context, params) {<br>override suspend fun doWork(): Result {<br> // Create a notification<br> val notification = createNotification()<br>// Set the foreground work with a specific service type<br> val foregroundInfo = ForegroundInfo(<br> notificationId,<br> notification,<br> ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC<br> )<br> setForegroundAsync(foregroundInfo)<br>// Perform the task here, e.g., data sync or location tracking<br> // …<br>return Result.success()<br> }<br>private fun createNotification(): Notification {<br> // Build and return a notification<br> return NotificationCompat.Builder(applicationContext, CHANNEL_ID)<br> .setContentTitle(&quot;Syncing Data&quot;)<br> .setContentText(&quot;Data synchronization in progress…&quot;)<br> .setSmallIcon(R.drawable.ic_notification)<br> .build()<br> }<br>}</pre><h4><strong>3. Rebuild and Test Your App</strong></h4><p>After making these changes, rebuild your app and test it thoroughly on devices running Android 14. Ensure that the crashes are resolved and that your foreground tasks are functioning as expected. Happy!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*wYFrc7Ags0nCImFyRhXROA.jpeg" /></figure><p>— -</p><h3>Conclusion: Stay Ahead of the Curve</h3><p>Android 14’s new `foregroundServiceType` requirement is more than just a minor tweak — it’s a fundamental change in how foreground services are handled, and it affects both traditional services and WorkManager tasks. Developers must stay ahead of these changes to avoid frustrating crashes that can damage both your app’s reputation and user trust.</p><p>As Android continues to evolve, so too must our approach to development. By understanding and adapting to these changes, we can ensure that our apps remain robust and reliable, no matter what new challenges the OS throws our way.</p><p>So, whether you’re a developer, product manager, or part of the support team, it’s time to take note of this crucial update. Your users — and your app’s future — depend on it.</p><p><strong>Bio</strong>: Laksamana Akbar Dzulfikar,</p><p>Senior Android Engineer.</p><h3>Currently, I’m open to work.</h3><h4>Keywords:</h4><p>Android 14 foregroundServiceType, WorkManager Android 14,Android 14 service crash fix, Foreground service Android 14, Android manifest foregroundServiceType, Fix WorkManager crash Android 14, Android 14 developer updates, ForegroundServiceType mismatch, Android app development tips, Android 14 background tasks</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1cbcf469b69" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/why-android-14s-foreground-service-requirements-might-break-your-app-and-how-to-fix-it-c1cbcf469b69">Why Android 14’s Foreground Service Requirements Might Break Your App — and How to Fix It</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding and Implementing “Articulating Design Decisions” by Tom Greever: Insights from My…]]></title>
            <link>https://medium.com/gravel-engineering/understanding-and-implementing-articulating-design-decisions-by-tom-greever-insights-from-my-6f80759d0a94?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/6f80759d0a94</guid>
            <dc:creator><![CDATA[Rodrigo Osvaldus]]></dc:creator>
            <pubDate>Wed, 31 Jul 2024 06:58:55 GMT</pubDate>
            <atom:updated>2024-07-31T06:58:55.396Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding and Implementing “Articulating Design Decisions” by Tom Greever: Insights from My Experience</h3><blockquote><strong>“Communicating about the designs is more important than the designs themselves.” — Tom Greever</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdekuolXjeDtCsxNEXR25w.png" /></figure><p>The quotes above illustrate the importance of communication skills for a designer.</p><p>In my approximately three years of experience as a product designer, the challenge I consistently encounter is obtaining approval for my designs during presentations. Effectively communicating the intent and purpose of our designs is crucial to ensure that every stakeholder understands the design decisions we make. Tom Greever’s book “Articulating Design Decisions” serves as a crucial guide for designers aiming to improve their ability to justify and explain their design choices. This article will provide a concise summary of Greever’s key points and offer practical tips and tricks also example on how to implement these strategies in your work.</p><h3>Summary of “Articulating Design Decisions”</h3><p>Tom Greever’s book is centered around the idea that design is not just about creativity and aesthetics, but also about communication and rationale. Here are the core concepts Greever discusses:</p><h4>1. Understanding the Stakeholders</h4><ul><li><strong>Identify Stakeholders:</strong> Know who will be affected by your design decisions, including clients, team members, and end-users.</li><li><strong>Understand Their Needs:</strong> Recognize the different goals and priorities of each stakeholder to address their concerns effectively.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i_1U2Ye6j7JRNl75rz1P3Q.png" /><figcaption>Every stakeholder speaks different “language”, know who you speaking with.</figcaption></figure><h4>2. Framing the Conversation</h4><ul><li><strong>Set the Stage:</strong> Create a context for your design decisions by explaining the problem you are solving.</li><li><strong>Tell a Story:</strong> Use storytelling techniques to make your rationale more relatable and understandable.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-d9mRDarVEhl9Fef-a8W1A.png" /><figcaption>Share the context is a key, don’t give the design bluntly.</figcaption></figure><h4>3. Using Data and Research</h4><ul><li><strong>Leverage Data:</strong> Back up your design decisions with data from user research, analytics, and usability testing.</li><li><strong>Show, Don’t Tell:</strong> Use visuals and prototypes to illustrate your points clearly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f_tUPM5XgVgMlAbbc7uiOg.png" /><figcaption>Backed up with data and research will help they understand.</figcaption></figure><h4>4. Presenting with Confidence</h4><ul><li><strong>Be Confident:</strong> Present your decisions assertively to instill confidence in your audience.</li><li><strong>Be Open to Feedback:</strong> Encourage questions and feedback to show that you value others’ input and are willing to adjust your approach if necessary.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0BDVOaHOBcCzYPAqISOWKA.png" /><figcaption>Be confident with your design, explain what you do.</figcaption></figure><h4>5. Handling Objections</h4><ul><li><strong>Stay Calm and Respectful:</strong> Respond to criticism calmly and respectfully, without becoming defensive.</li><li><strong>Clarify Misunderstandings:</strong> Address any misunderstandings by reiterating your key points and providing additional evidence if needed.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h1mh03i0uTOaAJuWRjQrng.png" /><figcaption>Sometimes saying “Okay” , “Sure” , “Yes” is not a sin for designer.</figcaption></figure><h3>Tips and Tricks for Implementing Greever’s Strategies</h3><h4>1. Preparation is Key</h4><ul><li><strong>Do Your Homework:</strong> Before any meeting, thoroughly understand your audience and prepare your arguments. Gather all necessary data and examples to support your design decisions.</li><li><strong>Practice Your Pitch:</strong> Rehearse your presentation multiple times to ensure clarity and confidence.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*n6UFtpGI_rtEzj_VnYVSnw.png" /></figure><h4>2. Effective Storytelling</h4><ul><li><strong>Create a Narrative Arc:</strong> Structure your presentation with a clear beginning, middle, and end. Start with the problem, move through your process, and conclude with the solution.</li><li><strong>Use Personas:</strong> Develop user personas to help stakeholders empathize with the end-users and understand the rationale behind your decisions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*wzxGWUX5L1S5hQ_9pf71eA.png" /></figure><h4>3. Visual Communication</h4><ul><li><strong>Create Compelling Visuals:</strong> Use high-quality visuals, such as wireframes, mockups, and prototypes, to illustrate your points. Visual aids can make complex ideas more accessible.</li><li><strong>Keep It Simple:</strong> Avoid overwhelming your audience with too much information. Focus on the most critical points and explain them clearly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*pSKELwAr7zuA2nkQuvfIug.png" /></figure><h4>4. Engage Your Audience</h4><ul><li><strong>Ask Questions:</strong> Engage your audience by asking questions and encouraging participation. This can help you gauge their understanding and address any concerns in real-time.</li><li><strong>Listen Actively:</strong> Pay attention to feedback and be willing to adjust your approach based on the input you receive.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*mhLiczHtNfw9ZWYNloh-Lw.png" /></figure><h4>5. Building Credibility</h4><ul><li><strong>Use Credible Sources:</strong> When referencing data or research, ensure your sources are reputable and relevant. This builds trust and credibility with your audience.</li><li><strong>Show Your Work:</strong> Share your design process and the steps you took to arrive at your decisions. Transparency helps build trust and demonstrates your expertise.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*2HFsdJ3IVb7L3Rnq1pXlvw.png" /></figure><h3>Last but not least…</h3><p>All the guides, tips, and tricks mentioned above are things I have tried to implement in my daily life as a product designer at a company. I have always found reading this book and practicing its advice very helpful, especially since communication is a day-to-day challenge I encounter. However, despite following these steps, we cannot always convince stakeholders. There are many factors not mentioned above that can influence stakeholders’ acceptance of our designs. Ultimately, we must understand that we are dealing with humans, not robots; we may follow these steps but cannot fully expect the same results from every person we encounter.</p><p>When you feel you have implemented all the advice above but still struggle to communicate effectively with stakeholders at your workplace, take a step back and reflect. As product designers, our daily routine involves empathizing with human beings (users), and you might apply the same empathy towards your stakeholders. By trying to be more empathetic towards them, you may discover your own art of communication to solve your issues.</p><blockquote>Because at the end of the day, your stakeholder is also a <strong>human</strong>, just like the users and you!</blockquote><p>That’s all, and thank you for reading this far. Hope to see you in the next article.</p><p>Cheers! 🥂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f80759d0a94" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/understanding-and-implementing-articulating-design-decisions-by-tom-greever-insights-from-my-6f80759d0a94">Understanding and Implementing “Articulating Design Decisions” by Tom Greever: Insights from My…</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Outsmarting OTP Spammers: The Importance of Server-Side Validation & a Smooth Registration Process]]></title>
            <link>https://medium.com/gravel-engineering/outsmarting-otp-spammers-the-importance-of-server-side-validation-a-smooth-registration-process-b23b0f8736a6?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/b23b0f8736a6</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[otp-verification]]></category>
            <category><![CDATA[registration]]></category>
            <category><![CDATA[spam]]></category>
            <dc:creator><![CDATA[Akbar Dzulfikar]]></dc:creator>
            <pubDate>Wed, 10 Jul 2024 04:58:46 GMT</pubDate>
            <atom:updated>2024-07-10T04:58:46.444Z</atom:updated>
            <content:encoded><![CDATA[<p>Stop OTP spam from draining your resources and driving users away. Learn how to implement robust server-side validation and optimize your registration flow for a secure and seamless user experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*nBdgbJRcYgrsNkrW.jpg" /><figcaption><a href="https://www.freepik.com/free-photos-vectors/spamming">Spamming Images — Free Download on Freepik</a></figcaption></figure><h3><strong>Mitigating OTP Spam</strong></h3><p>OTP spam is more than just an annoyance; it’s a significant threat to your business. It inflates operational costs due to unnecessary SMS transmissions and can damage your app’s reputation, negatively impacting user acquisition and conversion. But fear not! This article will provide a comprehensive solution to combat OTP spam, from implementing robust server-side validation to optimizing your registration flow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KlcNSApUPIt5lbSlChiq1Q.jpeg" /><figcaption><a href="https://www.freepik.com/free-photos-vectors/mitigation-strategy/4">Page 4 | Mitigation Strategy Images — Free Download on Freepik</a></figcaption></figure><h3><strong>Server-Side Validation: A Powerful Shield Against OTP Spam Attacks</strong></h3><ul><li><strong>Server-Side OTP Verification:</strong> Server-side validation ensures OTPs are checked directly on the server, not on the user’s device, preventing misuse and reuse.</li><li><strong>Implementation of Additional Security Measures:</strong> In addition to OTP verification, server-side validation allows the implementation of rate limiting (limiting the number of OTP requests per time) and CAPTCHA (a test to distinguish humans from bots), enhancing the application’s security.</li><li><strong>User Database Protection:</strong> Server-side validation protects the user database from unauthorized access and brute-force attacks attempting to guess OTPs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DMPI9mJK7wbbyOdXpMQYAw.jpeg" /><figcaption><a href="https://www.freepik.com/search?format=search&amp;last_filter=query&amp;last_value=validation+security&amp;query=validation+security&amp;type=vector">Validation security Vectors | Free download (freepik.com)</a></figcaption></figure><h3><strong>Registration Flow Optimization: The Key to Improved User Conversion</strong></h3><ul><li><strong>OTP Placement at the End of the Process:</strong> Requesting OTP after users have filled out all registration information reduces friction and increases the likelihood of users completing the registration process.</li><li><strong>Smoother User Experience:</strong> An intuitive and efficient registration flow enhances the user experience, encouraging more users to complete registration and become loyal customers.</li><li><strong>Reduction in Registration Abandonment:</strong> By reducing barriers early in the process, registration flow optimization can significantly decrease the abandonment rate during the registration stage.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*taPWTcFtgDBBcV8z.jpg" /><figcaption><a href="https://www.freepik.com/search?format=search&amp;last_filter=query&amp;last_value=step+1+2+3+4+&amp;query=step+1+2+3+4+">Step 1 2 3 4 vectors, photos and PSD files | Free download (freepik.com)</a></figcaption></figure><h3><strong>Benefits of Implementing Server-Side Validation and Registration Flow Optimization</strong></h3><ul><li><strong>Enhanced Security:</strong> Protects the application from OTP spam attacks and fraud, safeguarding user data.</li><li><strong>Cost Savings:</strong> Reduces operational costs associated with unnecessary OTP SMS transmissions.</li><li><strong>Increased User Conversion:</strong> Optimizes the registration flow to increase the number of users who successfully register and become customers.</li><li><strong>Strengthened Brand Reputation:</strong> A secure and trustworthy application enhances user confidence in your brand.</li><li><strong>Customer Satisfaction:</strong> A better user experience during the registration process improves overall customer satisfaction.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*cGMqkoc0dSVABdvU.jpg" /><figcaption><a href="https://www.freepik.com/search?format=search&amp;last_filter=query&amp;last_value=happy+leader&amp;query=happy+leader">Happy leader vectors, photos and PSD files | Free download (freepik.com)</a></figcaption></figure><h3><strong>Closing (Conclusion):</strong></h3><p>Don’t let OTP spam hinder your app’s success. By implementing server-side validation and optimizing your registration flow, you can create a secure, user-friendly, and trustworthy environment for your users. Safeguard your business today!</p><p>Our <a href="https://salamchat.id/">salamchat.id</a> app can also generate OTP for your app, want to know more? contact us.</p><p>Written by: Laksamana Akbar Dzulfikar, Senior Software Engineer</p><p><a href="https://www.linkedin.com/in/akbar-dzulfikar/">Akbar Dzulfikar | LinkedIn</a></p><p><strong>Slug:</strong> server-side-otp-validation-registration-flow</p><p><strong>keywords: </strong>OTP spam, OTP spam protection, server-side validation, registration flow optimization, user conversion, user experience, security, cost savings, brand reputation, customer satisfaction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b23b0f8736a6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/outsmarting-otp-spammers-the-importance-of-server-side-validation-a-smooth-registration-process-b23b0f8736a6">Outsmarting OTP Spammers: The Importance of Server-Side Validation &amp; a Smooth Registration Process</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exact Alarm Permission: Google Play’s Ticking Time Bomb for Android Developers?]]></title>
            <link>https://medium.com/gravel-engineering/exact-alarm-permission-google-plays-ticking-time-bomb-for-android-developers-e29e4d20b572?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/e29e4d20b572</guid>
            <dc:creator><![CDATA[Akbar Dzulfikar]]></dc:creator>
            <pubDate>Mon, 08 Jul 2024 09:44:11 GMT</pubDate>
            <atom:updated>2024-07-08T09:44:11.163Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android App Developers: Don’t Get Caught Off Guard!</h3><p>Google Play’s policy changes regarding the Exact Alarm Permission are shaking up app submissions. Does your Android app need this permission? Ignoring the new rules could lead to rejection. Understand the requirements and avoid a development disaster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*g1NI7lhMYvTjDFw_" /><figcaption>Photo by <a href="https://unsplash.com/@ahsanjaya?utm_source=medium&amp;utm_medium=referral">Muhammad Daudy</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Exact Alarm Permission: What’s the Fuss?</h3><p>AlarmManager, a powerful Android tool for scheduling tasks, has become stricter. The Exact Alarm Permission, introduced in Android 12, is now essential for apps needing precise task scheduling. But, why is this a problem? Google Play has tightened the screws, limiting this permission’s use to specific app categories.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F_DxEtDZdUcNBqHv" /><figcaption>Photo by <a href="https://unsplash.com/@possessedphotography?utm_source=medium&amp;utm_medium=referral">Possessed Photography</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Exact Alarm Permission: Misunderstand the Rules, Pay the Price!</h3><p>Developers are scrambling to understand the implications. If your app falls under “alarm clocks,” “calendars,” or “reminder” categories, you’re in the clear. However, for other apps, using this permission can trigger rejection unless you demonstrate a valid use case. This isn’t just about ticking clocks — it’s about user experience, battery life, and complying with Google’s vision for a streamlined Android ecosystem.</p><p>The definition of the problem is twofold:</p><ol><li><strong>Misunderstanding:</strong> Many developers are unaware of the changes or misinterpret the eligibility criteria.</li><li><strong>Impact:</strong> Rejection means delays, lost revenue, and potentially, having to redesign core app functionality.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R3lHDsRR7Ei2Srq4" /><figcaption>Photo by <a href="https://unsplash.com/@kaip?utm_source=medium&amp;utm_medium=referral">Kai Pilger</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The Declaration</h3><p>This requires developers to explain their app’s use case and justify why the Exact Alarm Permission is necessary. This additional step can be confusing and time-consuming, especially for those who are unaware of the policy changes or unsure if their app qualifies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/971/1*0OB0hbSGveRU59UKtZzQFg.png" /><figcaption>Image I, The Declaration</figcaption></figure><p>When attempting to upload an app bundle to internal testing via fastlane, we developers encounter an error related to the Exact Alarm Permission.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rf4wtr4ENb53xrZlwoBM4Q.png" /><figcaption>Image II, Failed Upload to Internal Testing</figcaption></figure><p>Then, after attempting re-upload few times through fastlane, we discovered that a justification for using the Exact Alarm Permission was mandatory only after trying a manual upload.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*Ph5CqrwdCKRLzX8f_AN4LA.png" /></figure><p>Then, we’re good to go.</p><h3>Closing (Conclusion):</h3><p>Don’t let your app submission become a ticking time bomb. Review Google’s guidelines thoroughly, assess if your app truly needs the Exact Alarm Permission, and if so, be prepared to justify it. By understanding and adapting to this new policy, you ensure a smooth submission process and avoid development setbacks.</p><p>For a messaging app that prioritizes user privacy and seamless communication, consider <a href="http://salamchat.id/">salamchat.id</a>. We’ve successfully navigated these guidelines, ensuring a hassle-free submission experience.</p><p><strong>Laksamana Akbar Dzulfikar</strong></p><p><strong>Senior Software Engineer (Android)</strong></p><p><strong>Keywords:</strong> Exact Alarm Permission, Android, Google Play, App Submission, App Development, AlarmManager</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e29e4d20b572" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/exact-alarm-permission-google-plays-ticking-time-bomb-for-android-developers-e29e4d20b572">Exact Alarm Permission: Google Play’s Ticking Time Bomb for Android Developers?</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Local Composition for More Efficient Code on Your Android Composable App]]></title>
            <link>https://medium.com/gravel-engineering/local-composition-for-more-efficient-code-on-your-android-composable-app-f1a0a6ed0358?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/f1a0a6ed0358</guid>
            <category><![CDATA[composable-architecture]]></category>
            <category><![CDATA[android-compose]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <dc:creator><![CDATA[Muhammad Utsman]]></dc:creator>
            <pubDate>Mon, 08 Jul 2024 08:35:09 GMT</pubDate>
            <atom:updated>2024-07-08T08:35:08.968Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Iv1xpZ6yI_iTO9Lf" /><figcaption>Photo by <a href="https://unsplash.com/@bel2000a?utm_source=medium&amp;utm_medium=referral">Belinda Fewings</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>CompositionLocal is a mechanism in Compose used to share data hierarchically within Compose components without explicitly passing it as a parameter. This makes the code cleaner and more efficient.</p><p>With CompositionLocal, you can store and access data at a specific composition level without needing to pass the data through parameters. This is useful in situations where you want to share data among multiple components within a composition hierarchy without having to send it separately to each component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K7IW3chqVxa-v5H1JS8MnA.png" /></figure><p>There are several advantages to implementing CompositionLocal:</p><ol><li><strong>Isolation of State at Composition Level</strong>: CompositionLocal allows you to isolate state or data at a specific composition level. This means that certain state or data can only be accessed by components within that composition hierarchy, reducing the risk of unwanted changes.</li><li><strong>Better Code Understanding</strong>: With CompositionLocal, the usage of state or data within components doesn’t need to be explained through repeated parameters. This enhances code understanding, making it cleaner and more consistent.</li><li><strong>Separation Between Components</strong>: CompositionLocal helps separate dependencies among components within the UI hierarchy. This allows you to replace or update a component without affecting other components within the same hierarchy.</li><li><strong>Flexible Usage</strong>: You can easily use CompositionLocal to share data or state related to UI presentation, such as color themes, languages, text scales, and much more. This provides flexibility in managing more specific displays.</li><li><strong>Avoiding Global Dependencies</strong>: CompositionLocal helps avoid the use of widely shared global variables or states, which can lead to confusion and difficulty in tracing the source of issues.</li><li><strong>Simplified Dependency Management</strong>: CompositionLocal can serve as a simpler alternative to managing dependencies compared to Dependency Injection. This is particularly useful in smaller projects or simple UI compositions.</li><li><strong>Ease of Use</strong>: Using CompositionLocal is straightforward. You only need to define the CompositionLocal key, provide the value through CompositionLocalProvider, and access it within components within the hierarchy.</li></ol><p>However, it’s important to remember that CompositionLocal has its limitations. It’s not used for managing complex dependencies or for storing data that needs to exist outside the UI composition lifecycle. In such cases, Dependency Injection might still be a more suitable solution.</p><p>Overall, CompositionLocal is a powerful tool for managing state and dependencies at the composition level within the Compose framework. It helps create more structured, clean, and readable code.</p><p>Since CompositionLocal can store the state of an instance, there&#39;s no need to worry about memory leaks because new instances won&#39;t be recreated during recomposition. This characteristic is similar to the functionality of Dependency Injectors and Service Locators in terms of accessibility.</p><p>With this functionality, the usage of DI (Dependencies Injection) libraries like Dagger and Koin can be minimized. Why minimize it? That’s a good question. There are several impacts of excessive use of DI or Service Locators, including:</p><ol><li><strong>Performance</strong>: Using DI (Dependencies Injection) or Service Locators can negatively impact application performance. The mechanism of injection or dependency lookup can require extra time at runtime, potentially disrupting the application’s responsiveness, especially if not well optimized.</li><li><strong>Overhead and Memory</strong>: The usage of DI or Service Locators can introduce extra memory overhead, especially when dealing with complex object hierarchies or heavy dependencies. This can affect memory consumption and lead to performance issues.</li><li><strong>Code Readability</strong>: Too many dependencies in the codebase can make it difficult to read and understand. Excessive openness of dependencies or unstructured distribution can make the execution flow convoluted and confusing.</li><li><strong>Architectural Impact</strong>: Overusing DI or Service Locators can obscure the application’s architecture and create complex interdependencies between components. This can make development harder and less structured.</li><li><strong>Security</strong>: Injecting or locating too many dependencies can open up potential security issues. Sensitive data might be exposed or misused if dependencies aren’t managed properly.</li></ol><p>To avoid these issues, careful consideration is needed when using DI or Service Locators. With CompositionLocal, many aspects of DI or Service Locator usage can be replaced. Let’s consider a case.</p><p>Suppose we have a CartViewModel class that has a dependency on CartUseCase at the constructor level.</p><pre>class CartViewModel(private val useCase: CartUseCase) : ViewModel() {<br><br>    val cartState get() = useCase.cartReducer.dataFlow.asStateFlow()<br><br>    val cartUiConfig: MutableStateFlow&lt;CartUiConfig&gt; = MutableStateFlow(CartUiConfig())<br>}</pre><p>The common approach is to inject the CartUseCase instance into the constructor. However, with CompositionLocal, we can manually inject it into the node that requires it using the previously provided CartUseCase instance. This is an original technique with a fairly efficient trick, eliminating the need for additional libraries for DI or Service Locator.</p><p>At the node level, the implementation will look like this:</p><pre>@Composable<br>fun Cart() {<br>    // get instance with local composition<br>    val useCase = LocalCartUseCase.current<br>    val viewModel = rememberViewModel { CartViewModel(useCase) }<br><br>    // composable layout<br>}</pre><p>The CartUseCase will be obtained from the CompositionLocal named LocalCartUseCase. Of course, LocalCartUseCase is defined beforehand and provided within the same CompositionLocalProvider scope.</p><pre>// define with error default value<br>val LocalCartUseCase = compositionLocalOf&lt;CartUseCase&gt; { error(&quot;Not provided&quot;) }<br><br>@Composable<br>fun App() {<br>    // create instance<br>    val cartUseCase = remember { CartUseCase.newInstance() }<br><br>    // provide instance into local composition<br>    CompositionLocalProvider(<br>        LocalCartUseCase provides cartUseCase<br>    ) { <br>        CommonTheme {<br>            // content<br>        }<br>    }<br>}</pre><p>In this structure:</p><ul><li>The LocalCartUseCase is declared using compositionLocalOf, which defines a CompositionLocal key with a default value that throws an error if the value is not provided.</li><li>Within the App() composable function, an instance of CartUseCase is created using remember to ensure it persists across recompositions.</li><li>The created cartUseCase instance is then provided to the CompositionLocalProvider using the syntax LocalCartUseCase provides cartUseCase. This means that any composable function within the scope of this provider can access the provided cartUseCase instance using LocalCartUseCase.current.</li></ul><p>This way, the useCase variable in the Cart() composable function can retrieve the CartUseCase instance that was provided and stored in the LocalCartUseCase CompositionLocal.</p><p>However, despite this efficiency, it can’t entirely replace DI or Service Locators at the architecture layer level, especially when dealing with the creation of UseCases or Repositories that require classes outside of the Compose node.</p><p>You can found example implementation in my playground Kotlin Compose Multiplatform <a href="https://github.com/utsmannn/tokobola">here</a>.</p><h4>Conclusion</h4><p>In conclusion, CompositionLocal is a mechanism in Jetpack Compose for sharing data hierarchically between Compose components without having to pass it explicitly as parameters. This makes the code cleaner and more efficient.</p><p>CompositionLocal has several advantages such as isolating state at certain composition levels, better code understanding, separation between components, flexible use, avoiding global dependencies, and simpler dependency management.</p><p>However, CompositionLocal has limitations. It is not used to manage complex dependencies or to store data that needs to exist outside the UI composition lifecycle.</p><p>This concept is also being implemented in our migration to Jetpack Compose for the SalamChat app, an engaging and feature-rich messaging app. You can see our application on <a href="https://salamchat.id/">salamchat.id</a>.</p><p>This article is part of a story series about modern android development. Stay tuned for the next article!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1a0a6ed0358" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/local-composition-for-more-efficient-code-on-your-android-composable-app-f1a0a6ed0358">Local Composition for More Efficient Code on Your Android Composable App</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Collaborate and Improve: How Design Critique Can Transform Your Work]]></title>
            <link>https://medium.com/gravel-engineering/collaborate-and-improve-how-design-critique-can-transform-your-work-389d81cf9c7b?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/389d81cf9c7b</guid>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[design-critique]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Lishera Rizqi Rahmatulloh]]></dc:creator>
            <pubDate>Wed, 03 Jul 2024 05:30:03 GMT</pubDate>
            <atom:updated>2024-07-03T05:30:02.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Rvy0pqZz60hc2ZKZPpt5g.png" /><figcaption>Generated using AI</figcaption></figure><p>Have you ever created a design that you thought was great enough, only to receive feedback that actually made sense? Have stakeholders ever pointed out issues you didn’t notice? If you’re a designer, you’ve likely experienced these moments. There are always blind spots we can’t see. So how do we identify and address these blind spots before a design goes into development? How can we incorporate all stakeholders’ perspectives? One effective strategy is design critique.</p><p>As a product designer, I often find inspiration in unexpected places. One day, while scrolling through Instagram, I stumbled upon a story by one of the famous Indonesian UX experts. His Google Calendar was packed, and one entry caught my eye: “Design Critique”. Intrigued, I delved into researching this concept and realized how crucial it could be for our team at Gravel, which had grown from just two designers to five. Here’s a little of what I found and why I believe design critique is essential for improving our work.</p><h3>What is Design Critique?</h3><p>Design critique is a collaborative activity where team members gather to analyze and provide feedback on a design. The goal is to enhance the quality of the design, ensuring it meets its initial objectives. By collecting perspectives from various stakeholders, we can determine if the design effectively addresses the intended goals.</p><h3>Critique vs. Criticism</h3><p>It’s essential to distinguish between critique and criticism. Critique aims to uncover opportunities, identify what works, pose questions, and be objective. In contrast, criticism often finds faults, focuses on what’s lacking, and can be negative and personal. The goal of a design critique is to build up and improve, creating a safe space for development rather than a tense environment filled with judgment.</p><h3>Why Do Design Teams Hold Design Critiques?</h3><p>Design critiques are vital for several reasons:</p><ol><li>Encouraging a feedback culture <br>They promote a culture of feedback within the company, encouraging designers to articulate their decisions and align with other teams.</li><li>Gaining diverse perspectives <br>Feedback from different team members helps identify blind spots and missed opportunities.</li><li>Maintaining consistency <br>They ensure that designs are consistent with the overall design system.</li><li>Personal and professional growth <br>Regular feedback sessions contribute to the personal development of designers, helping them improve their skills continually.</li></ol><h3>When Do We Need Design Critique?</h3><p>Design critique can be valuable at <strong>any stage</strong> of the design process, from ideation and wireframing to prototyping and even post-production. The earlier and more frequent feedback is incorporated, the higher the quality of the final design.</p><h3>Who Should Be Involved in Design Critique?</h3><p>A successful design critique involves several key roles:</p><ol><li>Presenter<br>Describes the problem being solved and presents the design solutions.</li><li>Facilitator<br>Manages the schedule, ensures the session stays on track, and keeps the focus.</li><li>Note taker<br>Records the feedback and action steps.</li><li>Critiquers/audience<br>Includes stakeholders such as product managers, engineers, marketers, etc., who understand the problem statement and ask insightful questions.</li></ol><h3>How Does a Design Critique Look?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FNYdpAehRvcf5-AxtI-urQ.png" /><figcaption>Process of Design Critique</figcaption></figure><p>A typical design critique session involves:</p><h4>1. Preparation</h4><p><strong>Presenter</strong>: Prepares by outlining the problem, hypothesis, goals, and go through the proposed solutions.</p><p><strong>Facilitator</strong>: Sends invitations a few days in advance with a clear agenda.</p><p>As a presenter you can use this framework:</p><blockquote>I am showing [early/mid/late] work</blockquote><blockquote>Around [the problem]</blockquote><blockquote>Because [why it’s a problem]</blockquote><blockquote>And am looking for feedback around [specific focus for feedback]</blockquote><h4>2. Presentation</h4><p><strong>Presenter</strong>: Shares the design work, explains the context, and specifies what feedback is needed.</p><h4>3. Discussion</h4><p><strong>Audience</strong>: Provides feedback through positive, constructive, questions and new ideas feedback.</p><p>Feedback framework:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yniv9bWlmX5EuXIul6gcMA.png" /></figure><p>As an audience, you can put the sticky notes right next to the design.</p><h4>4. Conclusion</h4><p><strong>Note taker</strong>: Summarizes the action plans and reinforces the idea that great designers seek diverse feedback to enhance user experience.</p><p>Incorporating regular design critiques can significantly elevate the quality of design work. By fostering a culture of constructive feedback and collaboration, teams can ensure their designs are robust, user-centered, and aligned with business goals. As we continue to grow and evolve, embracing design critique will be crucial for our success and continuous improvement. By embracing design critique, we can improve not only our designs but also our skills and team dynamics.</p><p>Reference</p><ul><li><a href="https://medium.com/designatmeta/critique-is-an-important-part-of-any-design-process-whether-you-work-as-part-of-a-team-or-solo-ef3dcb299ce3">https://medium.com/designatmeta/critique-is-an-important-part-of-any-design-process-whether-you-work-as-part-of-a-team-or-solo-ef3dcb299ce3</a></li><li><a href="https://www.toptal.com/designers/product-design/productive-design-critique-guide">https://www.toptal.com/designers/product-design/productive-design-critique-guide</a></li><li><a href="https://www.nngroup.com/articles/design-critiques/">https://www.nngroup.com/articles/design-critiques/</a></li><li><a href="https://medium.com/designatmeta/peek-inside-a-facebook-design-critique-c4833efda26e">https://medium.com/designatmeta/peek-inside-a-facebook-design-critique-c4833efda26e</a></li><li><a href="https://uxdesign.cc/dont-take-design-critique-as-an-insult-6cf187ca6308">https://uxdesign.cc/dont-take-design-critique-as-an-insult-6cf187ca6308</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=389d81cf9c7b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/collaborate-and-improve-how-design-critique-can-transform-your-work-389d81cf9c7b">Collaborate and Improve: How Design Critique Can Transform Your Work</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why optimize ? The Power of Batch Operations, Batch Processing, and Concurrency]]></title>
            <link>https://medium.com/gravel-engineering/why-optimize-the-power-of-batch-operations-batch-processing-and-concurrency-4e9fa1e52e5c?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/4e9fa1e52e5c</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[batch-processing]]></category>
            <category><![CDATA[experience]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[James Leopold]]></dc:creator>
            <pubDate>Mon, 10 Jun 2024 11:50:29 GMT</pubDate>
            <atom:updated>2024-06-10T11:50:29.620Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why optimize ? The Power of Batch Operations, Batch Processing, and Concurrency</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L3ExFVP-YKfzGknz" /></figure><p>In today’s interconnected digital world, the efficient management of bulk operations, batch processing, and concurrency is crucial for optimizing performance and resource utilization. These concepts play a pivotal role especiallu in software development. In this article, I will share my personal experiences with bulk operations, batch processing, and concurrency, providing specific examples, challenges faced, and lessons learned as a Backend Engineer.</p><h3>My Journey with Batch Operations</h3><p>My recent experience with batch processing was from developing a Mass Broadcast Message feature. As a Backend Engineer, the term “Batch”, “Bulk”, and “Concurrency” is very common especially when handling big operations. The past week, I have been give the opportunity to develop a Blast Message feature for our messaging application “SalamChat”.</p><h3>Challenges Faced</h3><p>At first it seems quite simple, just apply concurrency when looping sending &amp; writing those messages to Database. But the problem arose when you realize that looping the create operation to the database is limited and that doing the operation one by one with a pause to not overload the database connection would take me 2 hours to complete.</p><p>The Bulking helped med to face the looping of creating messages instead of doing it one by one I managed to insert them in a big query of creating operation.</p><p>Meanwhile Batching helped me to not bulk all messages at once (which would also take a lot of resources in an instance). By batching them into smaller messages per iteration, I’d only have around 20 iteration of small sized bulk operations that would not freeze the server operations.</p><p>Finally running the batch concurrently so they all run asynchronously would speed up the task making the ETA around 5 minutes to finish processing all messages (from 2 hours of process).</p><h3>Lessons Learned</h3><ol><li><strong>Efficiency through Batching</strong> : Batching tasks can significantly enhance performance by dividing those big tasks into smaller size operation and running them concurrently, the smaller size gives the server more room to handle other API endpoints while doing the smaller batches.</li><li><strong>Time saving using concurrency </strong>: Integrating concurrency into the batch operations made it so that they can run in parallel, and since the operation is quite lightweight it would still be lower resource usage compared to one big chunk of hundred thousands insert operation.</li><li><strong>Bulking to reduce stress load </strong>: A single insert operation might seem fast if it’s just one or a hundred single insert operations. But when we talk about mass data, we need a way to compress this big load. Transaction might help but to loop each transaction one by one would still take some resources from the machine. Best way to reduce the load is by combining transaction to the database with bulking each operation. In my case i was able to reduce thousands of loop insert operation to 20 Batch of loop insert operation with each loop containing a smaller ammount of insert operation in one query.</li></ol><h3>Future add-ons</h3><ol><li><strong>Scaling the batch dynamically</strong> : Dividing the batches dynamically is a nice feature as well, since the userbase might grow, it’s needed for the codebase to adapt to the demands.</li><li><strong>Putting min — max bulk into remote config</strong> : By applying remote config that can be easily altered or modified when needed is really useful as the applications demands grow.</li></ol><h3>Conclusion</h3><p>In conclusion, my personal journey with my last feature development was a nice trip to seek efficiency and optimization (every programmer’s friend). Reminding us why we are developers, finding the easiest solution is alright, but a proper optimized one should never be forgotten. This article is just one of the many ways we can implement an optimized driven solution.</p><p>Although, searching for the most optimized and resource efficient way doesn’t always have to be our first choice. Easy solutions are fast to achieve, but I just want to point out that it has to be <strong>temporary </strong>(and searching for an optimized code makes me feel alive as a coder).</p><p>By sharing my experiences and insights, I hope it inspire others to not forget an important practice for us coders, enabling them to push creativity to complexities of challenges or tasks ahead with confidence and proficiency.</p><p>This Medium article is a reflection of my personal experiences and a comprehensive exploration of the benefits, challenges, and best practices associated with batch operations, batch processing, and concurrency. It aims to equip readers with valuable insights for effectively managing and implementing these concepts in their own way. Also big thanks to my Salam Team for supporting me and each other to accomplish these hard tasks together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*rImoN3WIz-5m3ERS.jpg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e9fa1e52e5c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/why-optimize-the-power-of-batch-operations-batch-processing-and-concurrency-4e9fa1e52e5c">Why optimize ? The Power of Batch Operations, Batch Processing, and Concurrency</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Engineer to Product Manager: Lessons Learned as a Gravel Intern]]></title>
            <link>https://medium.com/gravel-engineering/from-engineer-to-product-manager-lessons-learned-as-a-gravel-intern-b817a67739f3?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/b817a67739f3</guid>
            <category><![CDATA[product-manager]]></category>
            <category><![CDATA[career-switch]]></category>
            <category><![CDATA[technical-product-manager]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Fajar Wirazdi]]></dc:creator>
            <pubDate>Wed, 22 May 2024 13:31:48 GMT</pubDate>
            <atom:updated>2024-05-22T13:31:48.814Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IIFni3BZuhVdhmNzJmk0DQ.png" /></figure><p>As a seasoned software engineer and IT support professional with over 8 years of experience, I never thought I’d find myself drawn to the world of product management. But after graduating from Apple Developer Academy and Hacktiv8 Coding Bootcamp, I realized my passion for bringing products to life. That’s what led me to <a href="https://gravel.co.id/">Gravel</a> in March 2024 as a Product Manager Intern, and it’s been an incredible ride so far.</p><p>In just two months, I’ve learned valuable lessons that go beyond the technical aspects of product development. These insights have teach me the importance of collaboration, open communication, empathy, and adaptability in this fast-paced environment.</p><p><strong>From the </strong><a href="https://salamchat.id/"><strong>SalamChat</strong></a><strong> Tribe to Superpowers in Collaboration</strong></p><p>My journey began with the <a href="https://salamchat.id/">SalamChat</a> tribe, where the mantra “Collaboration is key” resonated deeply from day one. It wasn’t just about working together; it was about understanding each other’s strengths and weaknesses. In our brainstorming sessions, I witnessed the magic that happens when diverse skillsets and expertise come together to create something truly remarkable.</p><p>This emphasis on collaboration wasn’t just lip service. Early on, I was thrown into the deep end, tasked with understanding the product vision, working with cross-functional teams, and navigating the tech stack. It was overwhelming, but the team’s openness and willingness to help created a safe space for me to learn and grow.</p><p><strong>The Power of Clear Communication and Embracing the Unexpected</strong></p><p>As I explore deeper, I understand the importance of clear communication. I learned to articulate my thoughts clearly, provide constructive feedback, and ask questions without fear. This open communication boost a sense of trust and transparency within the team.</p><p>Of course, things didn’t always go according to plan. There were times when we encountered technical problems that threatened to block our progress. But these challenges turned into valuable lessons in flexibility and prioritization. I remember one instance where the team gather together to find a solution to an unexpected obstacle, and it solidified the importance of adaptability in this dynamic field.</p><p><strong>Leveraging My Technical Background as a Product Manager Intern</strong></p><p>Having a background in software engineering (Full-Stack) proved invaluable during my internship. Here’s how I bridged the gap between technical development and product vision:</p><ul><li><strong>Technical Expertise Informs Product Decisions:</strong> My understanding of the tech stack allowed me to participate in technical discussions, assess feature feasibility, and make informed product decisions alongside engineers.</li><li><strong>Facilitating Cross-Functional Collaboration:</strong> My experience has made me better at communicating between the product and engineering teams. I could translate technical concepts into user-centric language and vice versa, ensuring everyone was on the same page. This smoothened the development process and ensured features met both technical and user requirements.</li><li><strong>Identifying Technical Opportunities:</strong> Leveraging my technical background, I actively looked for opportunities to improve the product’s technical foundation. I suggested potential integrations with existing APIs or explored new technologies that could enhance user experience or streamline development processes.</li><li><strong>Building Trust Through Technical Proficiency:</strong> My ability to understand and discuss technical aspects of the product earned the trust of the engineering team. This encourage open communication, allowing for earlier identification and resolution of technical challenges.</li></ul><p>In essence, my technical background became a bridge between product vision and technical execution. It allowed me to actively contribute to product development, collaborate effectively with engineers, and ultimately, deliver a better product.</p><p><strong>Supporting User-Centered Design with Research and Data</strong></p><p>Beyond technical expertise, I embraced the opportunity to contribute to the product through user experience (UX) research. I assisted in analyzing user feedback to gain a deeper understanding of user needs and pain points. This focus on user-centered design helped us ensure that the product we were building addressed real user problems.</p><p>I’m passionate about user research and eager to learn more about user metrics and data analysis tools like Mixpanel. This data-driven approach, combined with UX research, will ensure our product decisions are informed by user behavior, leading to a product that excels in both functionality and user satisfaction. It aligns perfectly with the <a href="https://salamchat.id/">SalamChat</a> tribe’s focus on user-centered development.</p><p><strong>Looking Ahead: Growth, Gratitude, and Giving Back</strong></p><p>As I reflect on my time at <a href="https://gravel.co.id/">Gravel</a>, I’m incredibly grateful for the opportunities to learn and grow. The <a href="https://salamchat.id/">SalamChat</a> tribe has become like good friends, and I’m constantly motivated by their dedication. This internship has shown me that being a product manager is not just about delivering a product; it’s about building relationships, fostering a sense of belonging, and creating an environment where everyone can thrive.</p><p>Looking ahead, I’m excited to take on new challenges, learn from my mistakes, and contribute to <a href="https://gravel.co.id/">Gravel</a>’s continued growth. With the <a href="https://salamchat.id/">SalamChat</a> tribe by my side, I’m confident that we’ll achieve great things together. In the spirit of the tribe, let’s keep “running together, encouraging each other, and making something amazing happen!”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b817a67739f3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/from-engineer-to-product-manager-lessons-learned-as-a-gravel-intern-b817a67739f3">From Engineer to Product Manager: Lessons Learned as a Gravel Intern</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Simple Animations to Add Magic to Your Interface]]></title>
            <link>https://medium.com/gravel-engineering/a-simple-animations-to-add-magic-to-your-interface-10700d9d9f9b?source=rss----bfa9c86bd70d---4</link>
            <guid isPermaLink="false">https://medium.com/p/10700d9d9f9b</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[interaction-design]]></category>
            <category><![CDATA[animation]]></category>
            <dc:creator><![CDATA[Nadia Humairo]]></dc:creator>
            <pubDate>Wed, 22 May 2024 02:56:51 GMT</pubDate>
            <atom:updated>2024-05-22T02:56:51.791Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GSAqsNk7otMND6jCy9oNzQ.png" /></figure><p>Want to make your app more engaging and fun to use? Animation can do just that!🪄🧙🏻‍♀️<br>In this tutorial, I will show you how to create a simple animation that will make your app feel more compelling and interactive.</p><p><strong>What’s the big deal about animation?🤔</strong></p><p>💭 Imagine this: you’ve spent countless hours designing and developing your app, pouring your heart and soul into creating a seamless user experience. But giving your best efforts, users are still abandoning your app in droves. They’re confused, frustrated, and ultimately, unimpressed😞</p><p>But, when you add animation to your app, you create a more immersive experience for your users. It’s like ✨<em>adding a sprinkle of magic dust to your app</em>✨, makes it more enjoyable to use and can even help guide users through your app’s features.</p><h3><strong>Let’s get started!</strong></h3><p>To create a simple animation, follow these 5 easy steps:</p><p><strong>💢 Step 1: Prepare Your Illustrations<br></strong>First things first, you’ll need a handful of illustrations that already positioned just the way you imagine. For this tutorials, I’ve got 5 diverse illustrations ready to go, each serving a specific purpose.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gSuHZQeNl84txaeHALRDzA.png" /><figcaption>Step 1. <strong>Prepare Your Illustrations</strong></figcaption></figure><p><strong>💢 Step 2: Create a Component Set<br></strong>Next, I‘ll wave my magic wand by selecting all frames and clicking this tiny icon and.. BOOM! Your component set is now magically created🎉<br>Hmm.. who’s just discovered this handy shortcut for creating components with multiple variants? Drop a comment below!😛</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JqyEXTK_VxVLhL5UxuxPGQ.png" /><figcaption>Step 2.1. <strong>Create a Component Set</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EfU99GMPvT9Vk_x5r8VWog.png" /><figcaption>Step 2.2. <strong>Create a Component Set</strong></figcaption></figure><p><strong>Step 3: Name Your Components and Variants <br></strong>Now, let’s get personal! Give your components and variants some love by naming them. I kept it simple with straightforward names. Make sure to give each variant a different name by clicking the properties.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RLt0e8emCYBLUPmag1nZeQ.png" /><figcaption>Step 3. <strong>Name Your Components and Variants</strong></figcaption></figure><p><strong>Step 4: Define Your Animation Style</strong> <br>It’s time to unleash your creativity by defining the animation style prototype you desire. In this case, we’ll fine-tune the speed and states to perfection. Zoom image to take a look my settings💖</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kuNKceBKVPQNGd7bTuvi-A.png" /><figcaption>Step 4. <strong>Define Your Animation Style</strong></figcaption></figure><p><strong>Step 5: Preview and Refine</strong> <br>YAY! We’re done. Let’s copy one variants creation for a spin and see how it looks within a sleek bottom sheet. Ready to be amazed?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*MVLpceKyVzTb-rh2mnaL2w.gif" /><figcaption>Step 5. <strong>Preview and Refine</strong></figcaption></figure><p>By the end of this tutorial, you’ll have a simple yet effective animation that’ll make your app more engaging and fun to use. So, let’s get started!</p><p>Now, are you ready to take your animation skills to the next level and hand over the reins to your developers?<br>Imagine being able to simply hand over your animation file and saying, ✨<em>Hey, dev team! Just add this one file and… Make this magic happen!</em>✨</p><p>Let me know in the comments if you’re as excited as I am about this possibility! Thank you:)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10700d9d9f9b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/gravel-engineering/a-simple-animations-to-add-magic-to-your-interface-10700d9d9f9b">A Simple Animations to Add Magic to Your Interface🪄</a> was originally published in <a href="https://medium.com/gravel-engineering">Gravel Product &amp; Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>