JT's Weblog

My Used Page, Part 1

published: October 28, 2025 estimate: 10 min read view-cnt: 1 views

Note: This is the second edition of this article (re-post). I’ve refined the content to focus on the most interesting insights and technical depth. Part 2 and Part 3 refinements are coming soon.

I mentioned the uses page in the previous article.

It was fun looking at the statistics to see what other people use as their daily driver.

However, it is important to know the sample size whenever talking about statistics.

“Uses page” currently includes ~900 records at the time I wrote this article.

In comparison to other famous surveys in the software development area:

• Stack Overflow: Developer Survey 2024
  • +65,000 responses
• JetBrains: Developer Ecosystem 2024
  • +23,000 responses
• Devographics: State of JavaScript 2024
  • +14,000 responses

How this differs from these surveys is that you can find more details about hardware setup and OS-related stuff on the “uses page”. (e.g. keyboard, ergonomic chair, which Linux distro…)

Furthermore, you can see how other developers build their personal websites, including their tech stacks.

The low popularity of “uses page” is due to the fact that:

1. Not every developer has a personal website (though those who do are mostly front-end focused developers)
2. Even if a developer has one, they might not be aware that this movement exists

In other words, I’m not going to make a dedicated /uses page for now (at least not for 2-3 months) 🤣🤣

Just a shout out to the movement though, and maybe someone reading this article would love to join them.

The Used Page

Looking back, I feel that reviewing the tools I’ve used is more valuable.

Here I try to list the tools I’ve used and organize them into three categories: battle tested (used in my previous jobs), personal usage, current learning.

I will also split tools into smaller groups for a better reading experience.

Extra note: I probably forgot a few items since 8+ years of development experience is a lot to remember.

Here we GO!

Battle Tested (Used In Previous Jobs)

Language

• CSharp: the one that earns me a living.
  • LINQ became my bridge into metaprogramming - learning how it works behind the scenes (expression trees built into the framework, composing user-defined LINQ providers) eventually led me to explore the Roslyn compiler API.
  • The fact that you can manipulate abstract syntax trees without additional packages still amazes me.
  • I don’t use CSharp that much these days, but I’m still fascinated by how it evolves
• JavaScript: another language that feeds me.
  • It was fascinating to make things work in the browser where everyone can open devtools to debug.
  • I don’t have many complaints about the weak typing, though ‘this’, prototypes, and semicolon/parentheses rules still catch me off guard
• TypeScript: legendary language designed by the guy who also designed CSharp.
  • it was probably the first time I realized that a language could have so many utilities and operators to interact with a ‘type’
  • not to mention legend has it that the “type system” of TypeScript on its own is Turing Complete, just amazing!
• Regex: probably one of my best skills among a group of developers.
  • Yes, I’m calling myself a pro without reading “Mastering Regular Expressions” - practical experience counts for something.
  • Important to know: Regex has many different ‘flavors’ with their own implementations.
  • Shout out to Regex101 - the killer feature is debugging the matching process step by step
• Python: the hot programming language. I admit the syntax is indeed graceful and resonates with my pursuit of minimalism
  • however, I don’t want to use it that much. just call me a rebel

Back-end

• Entity Framework (+Core): I loved it when I first used it. I was an early adopter of LINQ in my workspace.
  • once you get used to LINQ, there’s no reason to reject EF
  • Important concepts: pros & cons of db-first vs code-first scaffolding; not every adapter implements the full feature set
  • the crucial difference between IQueryable (deferred execution) vs IEnumerable (immediate execution); how cache mechanisms work
  • the only GOTCHA is how you refactor the code when a performance bottleneck hits
• HtmlAgilityPack: I learned about XPATH from this tool. It’s fascinating how CSS Selector differs from XPATH
  • true coding gurus know the cases when XPATH shines
• Dapper: the tool for developers who prioritize performance or feel uncomfortable with too much LINQ abstraction
• ADO.NET: the good old friend. I once dove into the entire dataset and adapter API. They surely made something robust except for the weak types.
• ASP.NET Web API: used it with ease. However, you can still get into trouble trying to strongly type all the filtering criteria.
  • also, it has similar problems like MVC where middleware might be messy

DB

• SQL Server: good old relational database. One must know how to debug missing JOIN records or know when JOIN statements can cause cartesian explosion
  • Important concepts: pros & cons of normalization vs denormalization (i.e. Star schema for data warehousing)
  • the difference between transactional data and master data - should the data be treated as immutable events or not?
• Elasticsearch: the very first NoSQL database I used. it enlightened me with tons of concepts
  • e.g. DSL, text-processing, tokenization, search engine, distributed system, Lucene
• SSMS: the default graphical client everyone uses to connect to SQL Server. (compared to DBeaver) it’s good at altering table schemas with advanced features
• DBeaver: the open source alternative for connecting to databases. (compared to SSMS) rich user experience
  • e.g. execute SQL statement under the current cursor, batch row editing, copy-paste blob image

IDE & Editor & Extra Goodies

• VSCode: early adopter since 2016. Lightweight, fast, and changed how developers think about editors.
  • VSCodeVim wasn’t great back then, but the ecosystem evolved beautifully
• Visual Studio: VsVim is better than VSCodeVim in my experience.
  • One must know how Visual Studio handles the build process behind the scenes - the journey starts from manually editing csproj files, introducing custom tasks, which eventually leads you into the DevOps area
• ILSpy: reminds me of when debugging production issues. one of the steps is to use ILSpy to check if I’ve deployed the wrong version. true story.
• Roslyn: the dotnet team has made the Roslyn compiler very easy to work with. This is where my metaprogramming journey (started from LINQ expression trees) really took off. If you love metaprogramming, check it out
  • things to remember: syntax tree is different from symbols. You can install Visual Studio extensions for the Roslyn syntax tree visualizer

Web Full-Stack & Application

• ASP.NET WebForm: viewstate, postback, code-behind, UpdatePanel, and the beautiful life cycle chart that I used to set as my wallpaper 🤣🤣. Good old days
• ASP.NET MVC: culture shock migrating from WebForm to MVC, but got used to it once you figure out how controller and routing works.
  • the messiest part is usually the over-complicated middleware setup
• ASP.NET RazorPage: cleaner version of WebForm. it’s better, but I used it less in my work experience, what a shame
• Postman: first launch in 2012. every developer’s go-to tool to test out various API endpoints.
  • I have experience using the scripting feature to compose integration tests
  • however, I doubt it would be the best practice in the era of LLM
• Kibana: you’ll be surprised how sophisticated an Elasticsearch web-client could be. It has full-fledged dashboard and sys-admin features, it even has its own DSL to query (KQL syntax)
  • One must know the difference between Lucene syntax and KQL syntax - it confuses every beginner!

Automation & Testing

I’m not a professional engineer in the test & automation domain. I use these tools to automate across different service providers - by that I mean external software we cannot control, that don’t simply provide API endpoints. Thus, GUI automation tools are necessary to do the dirty job. Looking back, I was essentially doing RPA without using proper RPA tools (not recommended).

• Playwright: amazing tool with built-in browser, tracer (debugger), and runs different browsers in parallel. The DX is fantastic
• AutoIt: still remember my first impression. it’s amazing how many things you can do via this tool.
  • I once used this tool to enhance my live demo, using hotkeys to activate descriptive popups just like how you do animations in PowerPoint
• NUnit: I know the value of unit tests. just don’t have enough TDD experience in my career

Web Front-end

• DataURL: I’ve used this to build a flag calculator for my colleague, surprise surprise!
• JQuery: I learned this in my first job in 2017-2020; one must know how the plug-in system works; and all the nasty closure and IIFE
• CSS & HTML: comfortable debugging grid, flex, media query; know the box model, semantic elements. Haven’t spent enough time on a11y and CSS animations yet
• React: knew the GOTCHA of hooks and re-renders; knew about the tasty eco-system; just enough to build an admin site from scratch
• TanStack Suite: the TanStack stuff gave you the knowledge of extracting functional logic from the UI
• TailwindCSS: I started using it without any preprocessor experience; the DX is smooth
• Vite: I started using it without any webpack experience; simple and fast

Web Front-end UI Component

• React Admin: a fantastic project to learn how to abstract an admin site properly. also shout out to the awesome doc site
• Material UI: the legendary UI since 2014. One might be surprised by how much stuff you can abstract from an input field
• Telerik Kendo: the OG commercial UI library (first launch in 2011). the tool has its place in the .NET eco-system
  • thus, I am fortunate enough to encounter it twice in my career
• CKEditor: first launched in 2003. encountered this tool twice in my career, seems to be the go-to option for WYSIWYG feature

DevOps: VM, OS, Cloud… etc

I don’t do much fancy stuff in the DevOps area. Most of the time I just deploy, make sure it works, then leave. Fun story: small to medium size companies seldom have dedicated DevOps developers. In other words, the way of DevOps is something related to company culture or the attitude of how developers treat their jobs.

• Windows admin basics: IIS setup (site, port, pool, folder, 32/64 bit), Task Scheduler (organize folders for teammates), Windows Server environment. It’s okay for .NET work, but you might be upset if you heavily rely on the non-dotnet open source ecosystem
• GitHub Action: extremely rich eco-system. I only use the basic stuff
• Docker: just use it. nothing special. (I use docker to host the ELK solution, btw)

Desktop & Other Platform

• ConsoleApp: my favorite interface for quick admin automation. however, I have a hunch that Powershell might do a better job
• WinForm: one of the very first applications I shipped in my career back in the day when I was studying my Master degree. I knew almost nothing about web development then. However, it was smooth to bridge from WinForm to WebForm. The biggest caveat of WinForm is probably the lack of RWD

END OF THE STORY

I exceeded my expected content length again 😓 I will leave the “personal usage” and “current learning” parts for the next article.

These are the tools I used in my previous work experience. I’m not sure if this is the right format to record things, but it’s a good starting point.

Hope someone finds one or two interesting things here.
See you in the next one 💪💪