---
title: "jahanzaib12 (@jahanzaib12) | Hashnode"
description: "Learning, Building, and Sharing Code. Read the latest articles by jahanzaib12 on Hashnode."
url: "https://hashnode.com/@jahanzaib12"
---

@jahanzaib12

# jahanzaib12

@jahanzaib12 · London, UK · Joined June 2026

Learning, Building, and Sharing Code

## Comments

[The point about projects overestimating how well they know their users really stood out to me. The interviews show why direct feedback matters, especially in numerical JavaScript where something can run correctly without making its numerical validity obvious. I also found the AI discussion interesting because the problem isn’t simply whether AI-generated contributions are good or bad. The bigger issue is that AI makes submitting code much easier while the cost of reviewing and validating that code hasn’t decreased in the same way. That puts more pressure on maintainers and existing review processes. The finding about trust was also important. Stars and download counts can show popularity, but they don’t necessarily tell you whether a numerical library is actually reliable. Making tests, reference implementations, and validation practices visible seems like a much stronger way to build that trust.](https://hashnode.com/posts/lessons-learned-100-interviews-about-numerical-javascript/6a997eb951b65a4fefea8225/comment/6a9a1ae647881b0d957978a7)

Comment · Article · Sep 4 · [Lessons learned: 100 interviews about numerical JavaScript](https://hashnode.com/posts/lessons-learned-100-interviews-about-numerical-javascript/6a997eb951b65a4fefea8225)

[The key is to treat the item master as controlled reference data rather than just a list of names. Before procurement tracking starts, I’d validate a few core fields: item ID, description, unit of measure, classification, status, and ownership. For duplicates, don’t merge records based only on similar wording. Compare the unit, packaging, technical qualifiers, and actual operational meaning, since two similarly named items may still be different. It’s also useful to normalize descriptions first so differences in capitalization, spacing, or abbreviations don’t hide potential matches. I’d then have the relevant end-user offices confirm the ambiguous cases, assign a responsible catalog steward, and test whether representative users can reliably find and select the correct items. Only after critical duplicates and unit issues are resolved should the validated baseline be loaded and procurement tracking begin.](https://hashnode.com/posts/procurement-item-master-validation-lgu/6a98c9dcbc782795d1c6b7dc/comment/6a98f2ae0f91a827752eaf2d)

Comment · Article · Sep 3 · 1 · [How Should LGUs Validate Item Master Data Before Procurement Tracking Begins?](https://hashnode.com/posts/procurement-item-master-validation-lgu/6a98c9dcbc782795d1c6b7dc)

[I like the distinction between normal wrapping and emergency breaking here. It’s tempting to use word-break: break-all when a long value causes a layout issue, but applying it globally can make Arabic prose much harder to read. Scoping overflow-wrap: anywhere to genuinely unbreakable values seems like a much safer approach. The point about min-inline-size: 0 is also easy to overlook. In flex or grid layouts, the child’s intrinsic minimum size can prevent the ellipsis from working even when the other properties look correct. I’d also agree that identifiers and error messages deserve a different policy from card titles. An ellipsis is fine for a preview, but not when the hidden portion could change what a user needs to copy, verify, or act on.](https://hashnode.com/posts/arabic-text-truncation-css-qa/6a96b4524502e489ae8fb302/comment/6a9774ad453860b23bd7e792)

Comment · Article · Sep 2 · [Arabic text truncation in production: a CSS and QA guide](https://hashnode.com/posts/arabic-text-truncation-css-qa/6a96b4524502e489ae8fb302)

[I found the distinction between JPA and Hibernate particularly helpful. It’s easy for beginners to assume they are the same thing, but explaining JPA as the specification and Hibernate as an implementation makes the relationship much clearer. The progression from JDBC to Spring Data JPA also makes sense because each step removes a specific layer of repetitive work rather than replacing everything at once. I also liked the dirty checking example, since it shows why ORM can be useful without hiding the fact that database operations are still happening underneath. The “learn JDBC to understand databases, Hibernate to understand ORM” takeaway is a practical way to think about the learning order.](https://hashnode.com/posts/jdbc-to-spring-data-jpa-the-evolution-of-java-database-access-explained-for-beginners/6a95e43762e9ec76ab0851c9/comment/6a965539d35fde92465c49ad)

Comment · Article · Sep 1 · 1 · [🚀 JDBC to Spring Data JPA: The Evolution of Java Database Access Explained for Beginners](https://hashnode.com/posts/jdbc-to-spring-data-jpa-the-evolution-of-java-database-access-explained-for-beginners/6a95e43762e9ec76ab0851c9)

[The first-response checklist is probably the most useful part here. I like the emphasis on identifying the actual symptom before immediately generating an AWR report or running an advisor. Checking the alert log and active sessions first can quickly rule out things like blocking or an obvious database error. The point about wait events is important too. Looking at whether the system is spending time on I/O, CPU, locks, or redo gives you a much better direction than simply assuming the database needs more memory or configuration changes. This kind of practical troubleshooting is also useful when working through databases assignment help because it shows how the concepts apply to real Oracle environments rather than just theory. The redo prioritization feature in 26ai is also interesting for mixed OLTP and batch workloads.](https://hashnode.com/posts/oracle-ai-database-26ai-performance-tuning-basics/6a92fce2ba87c06410e9384e/comment/6a94d24b514906032626db47)

Comment · Article · Aug 31 · 1 · [Oracle AI Database 26ai: Performance Tuning Basics](https://hashnode.com/posts/oracle-ai-database-26ai-performance-tuning-basics/6a92fce2ba87c06410e9384e)

[The point about struggling through assignments being where the real learning happens really resonates. Tutorials are useful for getting started, but there’s a big difference between recognizing code when you see it and being able to produce it yourself. I also like your point about using AI for the “why” rather than simply asking for the solution. It’s easy to get working code without developing the problem-solving skills behind it. When I get stuck on an assignment, getting help to understand where my approach went wrong can be useful, rather than simply taking a completed solution. Going back and fixing the problem myself is where the learning actually happens. I agree there isn’t one universal “right way.” The important part is spending enough time actively solving problems instead of constantly looking for the next resource.](https://hashnode.com/posts/how-to-learn-programming-the-right-way/6a912861957ef08d9e22558c/comment/6a92235f6e745364d9e512c6)

Comment · Article · Aug 29 · 1 · [How to learn Programming "The Right Way"](https://hashnode.com/posts/how-to-learn-programming-the-right-way/6a912861957ef08d9e22558c)

[The distinction between Map and Set becomes much clearer when you look at the problem each one solves. I especially like using Set when uniqueness is the main requirement, since it avoids having to manually check whether a value already exists. For Map, the ability to use objects or other values as keys is really useful in situations where an object’s string-keyed properties would be limiting. The dedicated methods like has(), get(), and set() also make the intent pretty clear. One thing worth remembering is that choosing Map or Set isn’t automatically about being “faster” than objects or arrays. The better choice usually depends on the data structure and operations your code actually needs.](https://hashnode.com/posts/javascript-map-and-set-explained-store-data-smarter/6a908db462bdf93d7fe182f0/comment/6a9101551bcd6efd96cde130)

Comment · Article · Aug 28 · 1 · [JavaScript Map and Set Explained: Store Data Smarter](https://hashnode.com/posts/javascript-map-and-set-explained-store-data-smarter/6a908db462bdf93d7fe182f0)

[The interesting part here is how several small validation weaknesses have to line up before the deserialization issue becomes useful. The Unicode soft-hyphen bypass and the loose != comparison are good examples of why validation needs to match the actual application logic. The duplicate-property trick is probably the most interesting part, since the application's regex sees role=request while PHP ultimately ends up with role=admin. It shows how validating a serialized representation without considering how PHP will interpret it can be dangerous. Overall, the write-up does a nice job of showing that the vulnerability wasn't just unserialize() itself. The surrounding validation checks also played an important role in the exploit chain.](https://hashnode.com/posts/brunnerctf-php-2003-writeup/6a8b0bd013d6c9e2a997446f/comment/6a8fb5afea05c087ba62a034)

Comment · Article · Aug 27 · [BrunnerCTF - php-2003 Writeup](https://hashnode.com/posts/brunnerctf-php-2003-writeup/6a8b0bd013d6c9e2a997446f)

[A nice part of this setup is that it keeps the project workflow consistent. Having uv handle the environment and commands means you don’t have to remember which tool should be run through which virtual environment or package manager. I also like the separation of responsibilities: the formatter keeps the code style consistent, the linter catches common issues, mypy adds another layer of checking, and tests verify the actual behaviour. None of these replaces the others, so having them work together is useful. The biggest benefit is probably reducing setup decisions for future projects. Once the configuration is in place, starting a new project becomes much more repeatable instead of rebuilding the same tooling from scratch every time.](https://hashnode.com/posts/how-i-set-up-a-python-project-in-2026-uv-ruff-mypy-and-friends/6a8c324b559f08cfbe150f77/comment/6a8d17dbc21b49299d5c1f7a)

Comment · Article · Aug 25 · [How I Set Up a Python Project in 2026: uv, ruff, mypy and friends](https://hashnode.com/posts/how-i-set-up-a-python-project-in-2026-uv-ruff-mypy-and-friends/6a8c324b559f08cfbe150f77)

[A desktop observability tool like this can be really useful because “idle” from the user’s perspective doesn’t necessarily mean the system is doing nothing. Background services, Electron processes, updates, indexing, and other applications can still consume resources. For an Electron implementation, I’d focus on collecting a small set of metrics consistently rather than polling everything too frequently. CPU usage, memory, disk activity, active processes, and timestamps usually give enough context to explain most spikes. It’s also worth separating data collection from the UI layer. Keeping the monitoring work in the main process and sending only the required data to the renderer can help keep the interface responsive. If a particular metric looks incorrect, the exact collection code and a sample of the reported values would be useful to determine whether the issue is with the OS API, sampling interval, or how the values are being calculated.](https://hashnode.com/posts/your-computer-is-busy-when-you-re-not-building-a-desktop-observability-tool-with-electron/6a8b2acb3c37ef9318e444d0/comment/6a8bc287a3c04d779ae37286)

Comment · Article · Aug 24 · 1 · [Your Computer Is Busy When You're Not: Building a Desktop Observability Tool with Electron](https://hashnode.com/posts/your-computer-is-busy-when-you-re-not-building-a-desktop-observability-tool-with-electron/6a8b2acb3c37ef9318e444d0)