Stories by Minseo Kim on Medium

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/all-o-one-data-structure-c31c1973cc89?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/940/1*Ibzz6cHyXHWevA9vH7kZWw.png" width="940"></a>
A combination of hash tables and circular doubly-linked list.
<a href="https://blog.stackademic.com/all-o-one-data-structure-c31c1973cc89?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

All O’ One Data Structure

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/least-recently-used-lru-cache-0ba6ff0ed587?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/940/1*YEcYESESFE5_AWbb1WT1tg.png" width="940"></a>
Part of my LeetCode Grind
<a href="https://blog.stackademic.com/least-recently-used-lru-cache-0ba6ff0ed587?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

Least Recently Used (LRU) Cache

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/how-to-implement-priority-queues-in-python-55c99da4a030?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/1920/1*u2h7Sx6SzLfUf0V4WFX16A.jpeg" width="1920"></a>
Implementing priority queues with binary heaps
<a href="https://blog.stackademic.com/how-to-implement-priority-queues-in-python-55c99da4a030?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

How to Implement Priority Queues in Python

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/how-to-store-user-data-after-signing-up-in-supabase-comprehensive-guide-937f57e4bd9d?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/940/1*1J64tkKpVpybl_fAVezMLg.png" width="940"></a>
With SQL functions &amp; triggers
<a href="https://blog.stackademic.com/how-to-store-user-data-after-signing-up-in-supabase-comprehensive-guide-937f57e4bd9d?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

How to Store User Data after Signing up in Supabase — Comprehensive Guide

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/implementing-deque-from-scratch-in-java-26e0ad79aa10?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/2600/0*8PrWXgm_RN-XLem9" width="6000"></a>
A deque, short for “double-ended queue,” is a data structure that allows insertion and deletion of elements from both ends (front and…
<a href="https://blog.stackademic.com/implementing-deque-from-scratch-in-java-26e0ad79aa10?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

Implementing Deque From Scratch in Java

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/how-to-create-a-simple-form-with-nextjs-app-router-738e8c8db207?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/940/1*VuSE1dxO-HDf30bpri32GQ.png" width="940"></a>
With the introduction of App Router in Next.js, building forms on your website has changed from Pages Router…
<a href="https://blog.stackademic.com/how-to-create-a-simple-form-with-nextjs-app-router-738e8c8db207?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

How to Create a Simple Form with NextJS App Router

<div class="medium-feed-item">
<a href="https://blog.stackademic.com/how-dynamic-programming-is-used-in-an-image-resizing-algorithm-5a014810a742?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/1822/1*WSyYFliow4A-h41jgDOSow.png" width="1822"></a>
Seam Carving is an image-processing algorithm that can resize an image while preserving its main features.
<a href="https://blog.stackademic.com/how-dynamic-programming-is-used-in-an-image-resizing-algorithm-5a014810a742?source=rss-a316dca889cd------2">Continue reading on Stackademic »</a>
</div>

How Dynamic Programming is Used in an Image Resizing Algorithm

<div class="medium-feed-item">
<a href="https://medium.com/@minseo_kim/this-1-mindset-shift-completely-changed-how-i-manage-my-time-20932ea65e9a?source=rss-a316dca889cd------2"><img src="https://cdn-images-1.medium.com/max/2600/0*VjlGeqWlnnES-hjt" width="4592"></a>
Non-Medium members can access the story here.
<a href="https://medium.com/@minseo_kim/this-1-mindset-shift-completely-changed-how-i-manage-my-time-20932ea65e9a?source=rss-a316dca889cd------2">Continue reading on Medium »</a>
</div>

This 1 Mindset Shift Completely Changed How I Manage My Time.

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CX5FY2XfypMyZT1s"><figcaption>Photo by <a href="https://unsplash.com/@glenncarstenspeters?utm_source=medium&amp;utm_medium=referral">Glenn Carstens-Peters</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What is Abstraction?</h3>
Abstraction is a fundamental concept in Object-Oriented Programming (OOP) that involves concealing the intricate implementation details and presenting only the essential information to users for interaction. This approach enables users to focus solely on what the code accomplishes rather than how it accomplishes it behind the scenes.
For instance, consider a remote control. It offers a user-friendly interface allowing users to perform actions like turning the television on/off, adjusting the volume, or changing channels. However, users remain unaware of the detailed implementation behind these functionalities.
<h3>Abstraction in Java</h3>
In Java, abstraction finds expression through two primary mechanisms: abstract classes and interfaces.
<h4>Abstract classes</h4>
The abstract keyword, among Java's non-access modifiers, serves to define abstract classes and methods within them.
Returning to our remote control analogy, abstract classes enable us to capture common functionalities shared among various types of remote controls, such as turning devices on/off. Meanwhile, specific functionalities like changing channels may differ in implementation.
<pre>abstract class RemoteControl { // Abstract method to change the channel public abstract void changeChannel(int channel); // Concrete method to turn the device on public void turnOn() { System.out.println("Turning on the device"); } // Concrete method to turn the device off public void turnOff() { System.out.println("Turning off the device"); } } // Subclass for TVRemoteControl class TVRemoteControl extends RemoteControl { public void changeChannel(int channel) { System.out.println("Changing TV channel to " + channel); } } // Subclass for DVDRemoteControl class DVDRemoteControl extends RemoteControl { public void changeChannel(int channel) { // DVD players don't have channels, so this method does nothing } }</pre>
Observing the code snippet above, several key points emerge:
<ol>
<li>Abstract methods lack implementation details.</li>
<li>Other methods within the abstract class possess concrete implementations and, thus can be shared with inheriting subclasses (e.g., TVRemoteControl, DVDRemoteControl).</li>
<li>The extends keyword facilitates the inheritance of properties from the abstract class by subclasses.</li>
<li>Abstract classes cannot be instantiated directly; instead, they are inherited by relevant subclasses.</li>
</ol>
<h4>Interfaces</h4>
In Java, an interface acts as a reference type, solely permitting constants, method signatures, default methods, static methods, and nested types.
<pre>// Interface representing a remote control interface RemoteControl { // Method to change the channel void changeChannel(int channel); // Method to adjust the volume void adjustVolume(int volume); }</pre>
Key considerations regarding interfaces include:
<ol>
<li>Declaration via the interface keyword.</li>
<li>Methods lacking a body, akin to abstract methods in abstract classes.</li>
<li>Although not shown in the code, interfaces can include constants, implicitly public, static, and final.</li>
</ol>
Subclasses can then implement the declared interface using the implements keyword.
<pre>// Class representing a TV remote control implementing the RemoteControl interface class TVRemoteControl implements RemoteControl { public void changeChannel(int channel) { System.out.println("Changing TV channel to " + channel); } public void adjustVolume(int volume) { System.out.println("Adjusting TV volume to " + volume); } } // Class representing a DVD remote control implementing the RemoteControl interface class DVDRemoteControl implements RemoteControl { public void changeChannel(int channel) { // DVD players don't have channels, so this method does nothing } public void adjustVolume(int volume) { System.out.println("Adjusting DVD volume to " + volume); } }</pre>
With the introduction of Java 8, interfaces gained support for default and static methods, enhancing their utility. Default methods allow method declarations with implementations within the interface itself, which can either be utilized by subclasses or overridden using the @Override keyword. Similarly, static methods in interfaces operate akin to those in regular classes, enabling method invocation without object instantiation.
<h3>Choosing Between Abstract Classes and Interfaces</h3>
Both abstract classes and interfaces share the goal of concealing implementation details from users. However, they exhibit differences that make them suitable for distinct use cases.
For instance, they differ in terms of access modifiers. While interface methods are inherently public and abstract, and interface fields are implicitly public, static, and final, abstract classes offer flexibility in access modifiers for their fields and methods.
Use abstract classes when:
<ol>
<li>Providing a common base implementation for a group of related classes.</li>
<li>Sharing code among multiple closely related classes.</li>
<li>Declaring non-static or non-final fields.</li>
<li>Providing default implementations for some methods while leaving others for subclass implementation.</li>
<li>Utilizing constructors or needing to define constructors with different parameters in subclasses.</li>
</ol>
Use interfaces when:
<ol>
<li>Defining a contract specifying the behavior expected from implementing classes.</li>
<li>Achieving multiple inheritance of type, as a class can implement multiple interfaces but extend only one class.</li>
<li>Ensuring loose coupling between components by programming to interfaces rather than concrete implementations.</li>
<li>Supporting functionality across unrelated classes (e.g., Comparable).</li>
<li>Defining a mixin or marker interface without adding method implementations (e.g., Serializable).</li>
</ol>
<h3>Conclusion</h3>
In summary, interfaces offer greater flexibility and promote better design practices like loose coupling and polymorphism. They are ideal for defining contracts and achieving multiple inheritance of type. However, if common implementation code needs to be shared among related classes or a base class with default behavior is necessary, abstract classes may be more suitable. In practice, a combination of interfaces and abstract classes is often utilized in Java projects to leverage their respective strengths.
<h3>Stackademic 🎓</h3>
Thank you for reading until the end. Before you go:
<ul>
<li>Please consider clapping and following the writer! 👏</li>
<li>Follow us <a href="https://twitter.com/stackademichq">X</a> | <a href="https://www.linkedin.com/company/stackademic">LinkedIn</a> | <a href="https://www.youtube.com/c/stackademic">YouTube</a> | <a href="https://discord.gg/in-plain-english-709094664682340443">Discord</a>
</li>
<li>Visit our other platforms: <a href="https://plainenglish.io/">In Plain English</a> | <a href="https://cofeed.app/">CoFeed</a> | <a href="https://venturemagazine.net/">Venture</a> | <a href="https://blog.cubed.run/">Cubed</a>
</li>
<li>More content at <a href="https://stackademic.com/">Stackademic.com</a>
</li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=62e3fbdc8f7d" width="1" height="1" alt=""><hr>
<a href="https://blog.stackademic.com/understanding-abstractions-in-java-62e3fbdc8f7d">Understanding Abstractions in Java</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Understanding Abstractions in Java

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wbIfNL9spL70T1H7"><figcaption>Photo by <a href="https://unsplash.com/@lautaroandreani?utm_source=medium&amp;utm_medium=referral">Lautaro Andreani</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure>Fetching data from databases or external APIs is a fundamental task, not just in React but across every web application. Typically, this involves using JavaScript’s Fetch API alongside standard React hooks like useState and useEffect. However, there is a more elegant solution for managing data in React applications — useSWR.
<h3>What is useSWR?</h3>
useSWR stands for Stale-While-Revalidate. In simple terms, it loads cached data first for users to interact with while simultaneously fetching the latest data from the backend. This approach preserves a smooth user experience by quickly presenting various pages. It is a React hook that simplifies and optimizes data fetching.
<h3>Data Fetching without useSWR</h3>
Let’s explore how data fetching can be achieved using standard React hooks before diving into useSWR.
Consider a component called Products, responsible for displaying a list of products on an e-commerce website. We'll employ useState to manage:
<ol>
<li>Actual data upon successful fetching,</li>
<li>Errors encountered during fetching, and</li>
<li>Loading state during the fetching process</li>
</ol>
<pre>const [productList, setProductList] = useState([]); const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState();</pre>
To retrieve data from a REST API endpoint, an async function called fetchData is created. Inside this function, state variables are updated based on the fetch response or encountered errors.
<pre>const fetchData = async () =&gt; { try { setIsLoading(true); const response = await fetch("api/products"); const data = await response.json(); setProductList(data.products); } catch (error) { setError(error); } finally { setIsLoading(false); } };</pre>
Using useEffect, we invoke fetchData to run when the component mounts.
<pre>useEffect(() =&gt; { fetchData(); }, []);</pre>
The component is then rendered based on the relevant state variables.
<pre>if (isLoading) return &lt;div&gt;Loading...&lt;/div&gt;; if (error) return &lt;div&gt;{error.message}&lt;/div&gt;; return ( &lt;div className="product-container"&gt; {productList.map(item =&gt; { // Render productItem into component. })} &lt;/div&gt; );</pre>
While functional, this approach requires handling multiple states and involves verbose code for error and loading management.
<h3>Data Fetching with useSWR</h3>
By leveraging useSWR, we can streamline our code for both enhanced readability and performance.
<h3>Implementation</h3>
To use useSWR, start by installing it in your React project:
<pre>npm install swr</pre>
Next, create a fetcher function that acts as a wrapper for the native fetch API:
<pre>const fetcher = async url =&gt; { const response = await fetch(url); return await response.json(); };</pre>
Now, let’s see how useSWR simplifies the code:
<pre>import useSWR from 'swr'; const Products = () =&gt; { const { data, error, isLoading } = useSWR("api/products", fetcher); if (isLoading) return &lt;div&gt;Loading...&lt;/div&gt;; if (error) return &lt;div&gt;{error.message}&lt;/div&gt;; return ( &lt;div className="product-container"&gt; {data.map(item =&gt; { // Render productItem into component. })} &lt;/div&gt; ); };</pre>
With useSWR, the code is more concise and significantly easier to read.
<h3>Benefits of useSWR</h3>
Apart from its succinct syntax, useSWR offers several advantages:
<h4>Automatic Caching and Revalidation</h4>
useSWR provides cached data for quicker rendering while simultaneously updating with the latest data in the background. This enhances user interaction as users can engage with cached data while fresh data is fetched.
<h4>Built-in Error Handling</h4>
By including built-in error states, useSWR eliminates the need for extra error-handling code, contributing to more concise and convenient programming.
<h4>Optimized Data Fetching</h4>
useSWR optimizes performance by minimizing unnecessary requests, re-renders, or code imports.
<h3>Conclusion</h3>
In conclusion, transitioning from traditional data fetching methods to leveraging useSWR in React offers a paradigm shift in both code elegance and user experience. The concise syntax, automatic caching with background revalidation, and built-in error handling streamline the development process.
By adopting useSWR, developers can significantly reduce boilerplate code, enhance readability, and optimize performance. Moreover, its adaptability and configurability empower teams to tailor data fetching strategies to suit the specific needs of their applications.
This React hook not only simplifies the handling of data but also enriches the overall user interaction by presenting cached data swiftly while seamlessly updating with the latest information. As React evolves, useSWR stands as a powerful tool to simplify complex data management and elevate the efficiency of modern web applications.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=70d69bd576b3" width="1" height="1" alt="">

Latest Articles