Faith & Code | Reflections by Errong

Only God Gives Certainty We live in an age overflowing with information but starving for certainty. Every day we are surrounded by countless opinions through social media, news outlets, podcasts, and online discussions. Everyone seems to have a perspective, yet very few are willing to say, "This is true." As Christians, we are not immune to this cultural shift. Even Bible studies can slowly become discussions about what each person thinks instead of seeking what God has already spoken. This sermon on Proverbs 3:5-6 challenged me to ask a simple but profound question: Where does my certainty come from? Trust Is More Than Agreement When Proverbs tells us to "Trust in the Lord with all your heart," it is not simply asking us to agree with God's existence. Biblical trust means placing the full weight of our lives upon Him. It is like the person trapped in a burning building who jumps into the firefighters' rescue net. There is complete dependence. Ther...

  Looking Ahead with Confidence: Christ Has Already Won "Lead us not into temptation, but deliver us from the evil one." — Matthew 6:13 Celebrating fifty years as a church is more than commemorating a milestone. It is celebrating fifty years of God's unwavering faithfulness to His bride. While anniversaries naturally invite us to look back with gratitude, this sermon challenged us to do something equally important—to look ahead with confidence. As Christians living in Canada, it is easy to feel concerned about the future. Biblical values are increasingly unpopular, churches face growing cultural pressure, and many parents and grandparents worry about the spiritual future of their children. These concerns are real, but they are not the whole story. The Heidelberg Catechism reminds us that every Christian lives in the middle of a spiritual war. The Battle We Often Forget When we hear the words, "Lead us not into temptation," we often think about avoiding bad habit...

The Church's Greatest Challenge: Remaining Faithful to the Truth Celebrating fifty years of a local church is a wonderful milestone. Over five decades, countless lives have been touched through baptisms, weddings, funerals, professions of faith, missionary work, and faithful worship. Behind every ministry, every answered prayer, and every transformed life stands one unchanging reality—God's faithfulness. As we look back with gratitude, we should also look forward with wisdom. Buildings may age, leadership may change, cultures may shift, but one challenge remains constant for every generation of Christians: Will we remain faithful to the truth of God's Word? The Church Does Not Belong to Us It is tempting during anniversary celebrations to focus on human accomplishments. We thank faithful pastors, elders, deacons, volunteers, and members. Their service certainly deserves appreciation. Yet Scripture reminds us that Christ is the One who builds His church. Ev...

ParallelStream vs Virtual Threads in Java 21: What Actually Works for Database Workloads Java offers multiple ways to parallelize work, but not all concurrency models are suitable for database-heavy workloads. In modern systems, especially with large batch processing (e.g., 10,000–50,000 IDs), choosing the right model can drastically change performance. This article compares ParallelStream and Virtual Threads (Java 21) using a real-world scenario: batch database queries in Oracle. 🧠 The Problem: Large Batch Database Queries A common backend scenario is fetching data using large ID lists: Example: - 40,000 transaction IDs - Chunked into 1,000 per query - ~40 database queries executed The key question becomes: how do we execute these 40 queries efficiently? ⚙️ Approach 1: ParallelStream IntStream.range(0, batchCount) .parallel() .mapToObj(i -> repository.query(batch)) How it works Uses ForkJoin common pool Thread count ≈ number of CP...

How to Optimize a Slow JPA Query Processing 40K+ IDs (Real Performance Tuning Guide) Handling large datasets efficiently is one of the most common challenges in backend engineering. In this post, I’ll walk through how a query processing 40,000+ IDs went from ~24 seconds down to a few seconds using practical optimization techniques. All domain-specific details have been intentionally removed to focus purely on reusable engineering patterns. 📉 The Problem A service fetches data using a JPA query with a large IN clause and joins between tables: SELECT new SomeDto( A.primaryId, A.field1, A.field2, B.field3, C.metric1, C.metric2 ) FROM EntityA A LEFT JOIN A.relatedEntity B LEFT JOIN EntityC C ON C.refId = A.primaryId WHERE A.primaryId IN :ids Even with chunking (~900 IDs per query), total execution time was around 24 seconds . 🚨 Root Causes Unoptimized JOIN conditions Missing database indexes Sequential query execution ORM (JPA) over...

How We Optimized a Spring Boot Pagination Query by 36× (From 1.8 Minutes to 3 Seconds) In high-traffic backend systems, slow database queries are often the hidden bottleneck that quietly kills performance. In our case, a paginated query powering a reporting API was taking 1.8 minutes to respond under load. After optimization, we reduced it to ~3 seconds . 36× faster ~97.2% less execution time ~3500% performance improvement Here’s how we did it — and the key lessons you can apply immediately. 🧱 The Problem: Slow Pagination Query We had a Spring Data JPA query backing a paginated API. It involved multiple filters, joins, and was returning a large dataset. Original issues: Full entity loading Heavy object graph hydration Unnecessary columns fetched Inefficient filtering logic Expensive pagination count The database schema (simplified and anonymized) looked like this: TABLE txn_line ( line_id BIGINT, order_id BIGINT, product_code ...

Sprint Design Notes: LDAP (OUD vs AD) and SQL Lookup Optimization Today was a light but productive design session focused on aligning the team on upcoming sprint stories. While the implementation itself is not overly complex, the discussion surfaced two important architectural considerations: How we handle large identifier lookups in SQL queries How we manage LDAP-based authentication and group access control (OUD vs AD) This post documents both topics for future reference and knowledge sharing. SQL Lookup Design: Handling Large Identifier Lists One of the stories requires supporting lookup by identifier list, where the input may contain a comma-separated list of values. The Problem Directly passing a large list of identifiers into SQL introduces several risks: SQL query length limitations (database dependent) Overly large IN (...) clauses Performance degradation on large parameter sets SELECT * FROM orders WHERE identifier IN (...very long list...