Stories by Minseo Kim on Medium

<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="">

Simplifying React: Fetching Data with useSWR

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uCHxgKJAFPdj0zVB"><figcaption>Photo by <a href="https://unsplash.com/@emilianovittoriosi?utm_source=medium&amp;utm_medium=referral">Emiliano Vittoriosi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The Challenge</h3>
Sharing your thoughts and projects through blogs can solidify your knowledge and attract an audience. I wanted to feature my articles on my personal website, but I realized the benefit of using well-established platforms like Medium for greater visibility. Yet, I still aimed to display some of these articles on my site so that visitors to my website won’t have to visit a separate link to view some of the articles that I’ve written. Therefore, I sought solutions to:
<ol>
<li>Gather essential data (titles, content, images) from my Medium articles automatically.</li>
<li>Present this data effectively on my website.</li>
</ol>
<h3>The RSS Feed Solution</h3>
Medium offers RSS feeds (a web feed format) that allow API calls to fetch the latest articles. To simplify data handling for my NextJS-built website, I used <a href="https://rss2json.com/">rss2json.com</a> to convert the feed into JSON format.
See the result at <a href="http://minseokim.me/articles">minseokim.me/articles</a>.
<h3>Fetching Data via API</h3>
Here’s a simple function to retrieve Medium posts via an API call:
<pre>export const getMediumPosts = async () =&gt; { // API call to convert Medium RSS to JSON const response = await fetch("https://api.rss2json.com/v1/api.json?rss_url=https%3A%2F%2Fmedium.com%2Ffeed%2F%40minseo_kim"); const data = response.json(); return data; };</pre>
This function returns a JSON Object with status indicators, feed data, and an array of Medium articles.
<h3>Server-Side Rendering</h3>
Using NextJS’s server-side rendering (SSR), I employed getStaticProps() to pre-generate HTML files for production. The code snippet below demonstrates how data retrieval occurs, which are then passed as props to respective components:
<pre>export const getStaticProps = async () =&gt; { // Fetching Medium posts const { status, feed, items } = await getMediumPosts(); // Error handling if (status === "error") { return { props: { status, url: "https://medium.com/@minseo_kim", }, }; } // Consolidating categories for filtering const categoriesDict = {}; items?.forEach((item) =&gt; { const categories = item.categories; // Logic for categories aggregation }); return { props: { status, feed, items, categories: categoriesDict, }, revalidate: 3600, // Refresh data every hour }; };</pre>
The useEffect() function in React helps filter articles based on selected categories, offering a smoother user experience.
<pre>const BlogsPage = (props) =&gt; { const { status, feed, items, categories } = props; const [filteredArticles, setFilteredArticles] = useState(items); const router = useRouter(); const searchCategory = router.query.category; useEffect(() =&gt; { if (searchCategory === undefined || searchCategory === "") return; const newArticlesArray = items?.filter((item) =&gt; item.categories.includes(searchCategory) ); setFilteredArticles(newArticlesArray); }, [searchCategory]); return ( &lt;div&gt; &lt;h1&gt;Latest Articles&lt;/h1&gt; {status === "ok" ? ( &lt;BlogsContainer posts={filteredArticles} feed={feed} categories={categories} /&gt; ) : ( &lt;p&gt; Error in retrieving articles, please visit{" "} &lt;a href="https://medium.com/@minseo_kim"&gt;this Medium Feed&lt;/a&gt; to check out more articles! &lt;/p&gt; )} &lt;/div&gt; ); };</pre>
I will not go into the details of the components, but here’s a snippet of the UI which will display the preview of each Medium article:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eSWuvzpaloY9iBbvH-azqw.png"><figcaption>A snippet of my personal website (<a href="https://www.minseokim.me/articles">minseokim.me/articles</a>)</figcaption></figure><h3>Rendering Article Components</h3>
To display individual articles, I utilized dynamic routes in NextJS. On top of using getStaticProps, getStaticPaths will make sure that necessary pages pertaining to the articles are pre-generated during build time. The code below shows how it can be implemented:
<pre>export const getStaticProps = async (context) =&gt; { // Fetch individual article data const { params } = context; const postData = await getSingleMediumPost(params.postId); return { props: { postData, }, revalidate: 3600, }; }; export const getStaticPaths = async () =&gt; { // Generating paths for individual articles const { items } = await getMediumPosts(); const postIds = items.map((item) =&gt; item.title.toLowerCase().split(" ").join("-") ); // Logic for generating article paths return { paths: postIds.map((postId) =&gt; ({ params: { postId: postId } })), fallback: false, }; };</pre>
Finally, rendering the article content safely involves sanitizing HTML strings using isomorphic-dompurify before using dangerouslySetInnerHTML. As mentioned in the <a href="https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html">React documentation</a>, dangerouslySetInnerHTML must only be used when the data source is trusted and sanitized.
<h3>Conclusion</h3>
In conclusion, leveraging Medium’s RSS feed enables seamless integration of Medium articles onto a personal website. I would like to thank <a href="https://medium.com/u/ee3dca3b5deb">Asiful Alam Fahim</a> and his <a href="https://javascript.plainenglish.io/how-i-successfully-added-medium-blogs-to-my-website-abafd76c4182">article</a> on integrating Medium articles on his website.
Check out the following links for my personal website and the source code on GitHub respectively. Thanks for reading!
<ul>
<li><a href="https://www.minseokim.com/">Minseo Kim</a></li>
<li><a href="https://github.com/terrykms/personal-website">GitHub - terrykms/personal-website</a></li>
</ul>
<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 on <a href="https://twitter.com/stackademichq">Twitter(X)</a>, <a href="https://www.linkedin.com/company/stackademic">LinkedIn</a>, and <a href="https://www.youtube.com/c/stackademic">YouTube</a>.
</li>
<li>
Visit <a href="http://stackademic.com/">Stackademic.com</a> to find out more about how we are democratizing free programming education around the world.
</li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=7eff8bcb32d0" width="1" height="1" alt=""><hr>
<a href="https://blog.stackademic.com/showcasing-medium-articles-on-your-nextjs-website-7eff8bcb32d0">Showcasing Medium Articles on Your NextJS Website</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.

Showcasing Medium Articles on Your NextJS Website

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJSDJ_YBmAhbx5jDYDbfpg.jpeg"><figcaption>Image by <a href="https://www.freepik.com/free-photo/3d-rendering-social-media-icon_59781222.htm#query=telegram&amp;position=0&amp;from_view=search&amp;track=sph">Freepik</a></figcaption></figure>This project aims to simplify payroll accounting and streamline the calculation of earnings from part-time work using the Telegram bot API.
<h3>Background</h3>
<ul>
<li>
Programming Language: Python</li>
<li>
Featured Libraries: <a href="https://python-telegram-bot.org/">python-telegram-bot</a>, <a href="https://pypi.org/project/pymysql/">pymysql</a>
</li>
<li>
Cloud Hosting: AWS EC2</li>
<li>
Database: Amazon RDS (MySQL)</li>
</ul>
<h3>Logic</h3>
The project’s functionality is organized around a set of commands initiated with a /start command:
<ol>
<li>/add</li>
<li>/edit</li>
<li>/summary</li>
</ol>
<h4>/add</h4>
The /add command allows users to input their work data into the database. The bot collects the following information from the user:
<ul>
<li>Date of the shift</li>
<li>Type of the shift</li>
</ul>
In addition to this data, the bot automatically assigns an ID and records the user’s Telegram username for each entry. This username is used later to filter relevant entries. The SQL command for adding data is as follows:
<pre>INSERT INTO Entries (shift_date, shift_type, username) VALUES (%s, %s, %s);</pre>
<h4>/edit</h4>
The /edit command is a pivotal component of this project, allowing users to modify their recorded data. The process commences by requesting the user to provide a date instance. Once the user provides a date, the system checks whether an instance corresponding to that date exists in the database for the specific username. This step ensures data integrity and provides users with the ability to make necessary amendments.
<h4>/summary</h4>
The /summary command delivers a valuable feature by offering users a comprehensive overview of their recorded instances. When executed, this command retrieves all instances from the database that pertain to the specific user, enabling them to access their complete work history with ease.
<h3>ConversationHandler: Managing User Interactions</h3>
The conversation management aspect of the project is facilitated by the <a href="https://python-telegram-bot.org/">python-telegram-bot</a> library, which comprises two integral packages: telegram and telegram.ext.This library is employed to manage the various stages of the conversation that users have with the Telegram bot. The heart of this management is the ConversationHandler, which is configured with three main parameters:
1. entry_points: The entry_pointsparameter defines how conversations are initiated. It can be triggered through telegram.ext.CommandHandleror telegram.ext.MessageHandler.
2. states: The statesparameter, which is a dictionary, outlines the different stages of a conversation. For example, after initiating the /add command, there are three distinct stages:
<ul>
<li>Entering the date of the shift</li>
<li>Specifying the type of shift</li>
<li>Confirming data entry before saving it in the database.</li>
</ul>
3. fallbacks: The fallbacksparameter, which is another list, is used to handle commands or messages that are not explicitly defined in the state parameter. It is particularly useful for managing unexpected interactions and providing users with options like /cancel to exit ongoing conversations.
Here’s an example configuration of the ConversationHandler:
<pre>conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ INITIATION: [CommandHandler('add', add), CommandHandler('edit', edit), CommandHandler('summary', summary)], CHECK_DATE: [MessageHandler(filters.TEXT, check_date)], CHECK_SHIFT_TYPE: [MessageHandler(filters.TEXT, check_shift_type)], CONFIRM_DATA_ENTRY: [MessageHandler(filters.TEXT, confirm_data_entry)], CHECK_DATE_FOR_EDIT: [MessageHandler(filters.TEXT, check_date_edit)], CHECK_EDIT_OR_DELETE: [MessageHandler(filters.TEXT, check_edit_or_delete)], EDIT_SHIFT_TYPE: [MessageHandler(filters.TEXT, edit_shift_type)], }, fallbacks=[CommandHandler("cancel", cancel), MessageHandler(filters.COMMAND, unknown)] )</pre>
This well-structured configuration ensures that conversations between users and the Telegram bot proceed smoothly and logically.
<h3>Potential Enhancements</h3>
<h4>Connection Pooling</h4>
While the current setup is tailored for a single user, it is worthwhile to consider connection pooling for future scalability. As the project expands with a substantial user base, implementing connection pooling can significantly enhance performance, resource efficiency, and effective management of connections with the database.
<h4>Code Organization</h4>
As this project started as a prototype, simplicity in code organization sufficed as long as it met functionality requirements. However, for more extensive development, one can consider compartmentalizing the codebase into various segments for improved reference and maintenance. For instance, establishing separate modules for database-related functions, while bot-related functions can be categorized according to specific functionalities.
<h3>Conclusion</h3>
In conclusion, this project presented an enjoyable and valuable experience, leveraging the capabilities of the free API offered by the Telegram bot. The source code is available <a href="https://github.com/terrykms/money-telebot">here</a>, and I welcome any feedback or contributions to enhance this project further.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=156c16844be7" width="1" height="1" alt="">

Latest Articles

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