2025¶

React Conferences to attend this month

It's October and I'll be attending two major React-focused conferences this month: React Conf and Next.js Conf. I plan to join both online — which is great because both events offer free virtual attendance. No travel, no hotel, no registration fees — just pick the talks you want to watch and learn.

• React Conf: https://conf.react.dev/
• Next.js Conf: https://nextjs.org/conf

React Conf 2025

React Conf is the official community conference for React. Expect keynote updates from the React team, roadmap discussions, and a broad selection of community talks that cover core React, advanced patterns, rendering strategies, concurrent features, performance, and integrations with modern tooling.

What to expect

• Key announcements from the React team (library improvements, documentations, new APIs).
• Deep-dive talks from community members about patterns, architecture, and real-world solutions.
• Sessions focused on performance, concurrent rendering, and server/edge rendering strategies.
• Practical demos and code samples you can apply to your projects.

How to join

• The livestream and recordings are typically available for free — sign up via the React Conf landing page to get updates and session info: https://conf.react.dev/
• Keep an eye on the schedule and add sessions you care about to your calendar (note the timezone).

Who should attend

• Frontend engineers using React or thinking about adopting it.
• Architects and engineering leads evaluating rendering strategies (client vs. server vs. edge).
• Anyone migrating desktop apps to the web using web-first stacks (React + TypeScript + Next.js).

Next.js Conf 2025

Next.js Conf gathers the broader Next.js community — from hobbyists to enterprise builders. It's focused on things you can actually ship with Next.js: routing and layouts, server components, Incremental Static Regeneration, image optimization, and edge runtimes. This year’s conference also emphasizes AI-driven experiences and performance at scale.

What’s the difference between virtual and in-person

• Virtual: Free access to livestreamed sessions and talks. You can tune in from anywhere; sessions are usually scheduled in Pacific Time (check the site for exact times).
• In-person: Held at The Midway with limited tickets. In-person attendees get access to networking, workshops, and curated interactive experiences (meals and social time are typically included).

How to join

• Register for the virtual stream and see the schedule at https://nextjs.org/conf
• If you attend virtually, plan around the listed timezone (often 9:00 AM to 5:00 PM PT) and bookmark the sessions you don’t want to miss.

Who should attend

• Developers building production apps with Next.js.
• Teams exploring server-side rendering, edge functions, or improving SEO and performance.
• Engineers looking to integrate AI features or optimize delivery with edge platforms.

Tips for getting the most from both conferences

• Review the schedule beforehand and mark the sessions most relevant to your work.
• Watch keynotes live for announcements; catch the recorded talks later for deep dives.
• Try to attend at least one practical session and one architecture/strategy talk each day.
• Save code samples and links from slides to a shared note (use GitHub/Gist or a private repo).
• If timezone makes live attendance hard, prioritize sessions you want to ask questions about and watch the rest on-demand.

Why attending conferences matters (especially for React)

React and the surrounding ecosystem evolve quickly. Conferences are high-density learning events where you: - Learn about new APIs and patterns early, so you can assess adoption risks and benefits. - See real-world use cases and migration paths — invaluable when moving desktop apps to web-based UIs. - Discover performance and accessibility best practices that directly impact production quality. - Get inspired by how other teams solve similar problems (architecture, testing, deployment). - Build awareness around tooling (TypeScript integrations, bundlers, edge runtimes, AI tooling).

Attending — even virtually — helps you and your team stay current and make more informed technical decisions.

Training & Consulting — React, TypeScript, Next.js, and migrations

I offer hands-on training and consulting in: - React and TypeScript best practices (components, typing strategies, state management). - Next.js fundamentals and advanced features (SSR, SSG, ISR, server components, edge functions). - Migration planning and execution for moving desktop applications to the web (UI/UX adaptation, data access, authentication, performance tuning). - Architecture reviews, code audits, and performance optimization workshops. - Short, focused training sessions (half-day or full-day) and longer, project-based engagements.

If you'd like customized training, an architecture review, or help migrating a project, please get in touch via the contact page: /contact/ — or use the contact form on this site to start a conversation about your goals and timeline.

Summary

React Conf and Next.js Conf are both excellent, practical resources for staying up-to-date with the rapidly changing React ecosystem. They offer high-value talks, demos, and announcements — and both provide free virtual options so you can learn without travel. If you want help turning conference learnings into concrete improvements for your projects, I’m available to consult and train your team.

Why You Need to Switch to Delphi 13 and its 64-bit IDE Yesterday

For most Delphi developers, the switch to 64-bit isn’t obvious at first glance. After all, for decades since Delphi 2, we’ve been working quite happily in a 32‑bit IDE, building applications, connecting to databases, and delivering production software.

With the introduction of 64‑bit compilers for Windows and other platforms, the natural assumption was:

“As long as I can compile 64‑bit executables from the 32‑bit IDE, I’m fine— right?”

Not quite. Let’s talk about why sticking to the 32‑bit IDE is holding you back, and why the time to switch is right now.

The Old World: 32‑bit IDE, 64‑bit Output

Today, Delphi allows you to build executables for multiple platforms, including 64‑bit Windows. Technically, you could stay in the 32‑bit IDE and compile flawless 64‑bit executables. That’s already been the case for years.

So why bother changing the IDE itself?

Because of one thing in particular: database drivers.

The Database Problem: Why the IDE Matters

Most Delphi developers working with databases rely on FireDAC. FireDAC integrates beautifully with the IDE, letting you connect to live data sources right at design time. This is crucial for productivity—you can design forms, test queries, and preview results without having to run your app every few minutes.

Here’s the catch:
- A 32‑bit IDE can only talk to 32‑bit database drivers.
- Many database vendors have already stopped shipping 32‑bit drivers.

That means if you’re still working in the old 32‑bit IDE:
- You can’t connect to 64‑bit-only databases inside the IDE.
- You’re stuck waiting until runtime to test queries and data access.
- Your workflow becomes clunky, slow, and far less efficient.

In other words, Delphi might still compile your app, but you as the developer lose one of Delphi’s greatest strengths: live data at design time.

Real-World Impact

Popular databases like MySQL and PostgreSQL have already moved to offering only 64‑bit drivers. This trend is only accelerating.

If your daily work relies on design‑time database connectivity—and if you use FireDAC, it almost certainly does—then staying on the 32‑bit IDE locks you out of modern database development.

Why You Should Switch Yesterday

Switching to Delphi 13 and its Delphi 64‑bit IDE ensures:
- ✅ Full FireDAC functionality at design time
- ✅ Compatibility with modern 64‑bit database drivers
- ✅ Faster, more streamlined development workflows
- ✅ Future-proofing your projects as 32‑bit support fades away

Yes, you can still technically build 64‑bit apps with the 32‑bit IDE. But unless you’re okay with doing all your database work blind until runtime, it’s no longer a practical choice.

Summary

The bottom line is simple:
- If you use FireDAC and connect to databases, the 64‑bit IDE is no longer optional—it’s essential.
- Many of the most popular databases (MySQL, PostgreSQL, and others) only offer 64‑bit drivers now.
- The longer you postpone the switch, the more painful your development experience will become.

So don’t wait. Switch to Delphi 13 with its 64‑bit IDE and compiler today.

Need Help?

If you’re facing challenges with the transition, database integration, or optimizing workflows in Delphi, I offer consulting and training services to help teams modernize quickly and confidently.

📩 Get in touch, and let’s make your Delphi development future‑ready.

Better-Auth taking over management of Auth.js

I’ve tried a lot of authentication frameworks for React and Next.js in the last year. I wanted something that just works, is secure, and lets me move fast without wrestling with OAuth flows or rolling my own session handling.

For a long time I liked Auth.js (formerly NextAuth.js). It solved many problems out of the box and made it possible to own auth without spending months on integrations. But there were a couple of things that held me back when starting new projects: progress on the project sometimes felt slow to my eyes, and the getting-started documentation could be tricky to follow when you were just learning the library.

Then I learned about Better-Auth — and honestly, I never looked back. Better-Auth felt clearer, more opinionated where it needed to be, and focused on the primitives teams actually reuse. It removed the friction I had with Auth.js when building new apps.

The big news

Last week, there’s been some news that validates that move and makes the ecosystem healthier: Auth.js is now maintained and overseen by the Better-Auth team.

What happened (short summary)

• Auth.js, the project previously known as NextAuth.js, has been handed over to the Better-Auth team for maintenance and stewardship.
• Better-Auth began as an effort to make authentication primitives easier to own and evolve. The two projects share similar goals: reduce friction around OAuth, sessions, and common auth patterns so developers can ship faster and more safely.
• The transition means existing Auth.js users can continue without disruption. Security patches and urgent fixes will be handled, and Better-Auth has published guidance for teams thinking about migration.

Why this matters

• Consolidation: Rather than keeping two competing ecosystems, the stewardship under Better-Auth should help the community converge on a single, more capable solution.
• Roadmap alignment: Better-Auth plans to bring missing capabilities (for example, stateless session support without a database) into its core, which reduces fragmentation and long-term maintenance burden for teams.
• Continuity: If you’re already using Auth.js/NextAuth.js, the immediate work is to keep running as before — the new maintainers will keep fixing security issues and producing migration guides.

My recommendation

• If you’re starting a new project today: consider Better-Auth first. It’s where the active development and direction are headed, and it’s built with the kinds of primitives I keep needing.
• If you maintain an existing Auth.js project: you can continue operating as-is. Check Better-Auth’s migration guide and roadmap if you want to plan a migration — there’s no urgent need to move unless you want the new features.

Final thoughts

Auth.js helped a lot of teams ship real auth quickly. Better-Auth grew out of those same needs and now carries the torch forward. This transition should mean fewer duplicated efforts and a clearer path for teams to own their auth. I’ll be watching the migration guides and trying out new Better-Auth features in upcoming projects.

Need help?

If you’d like help learning how to implement authentication in web applications, I can guide you step-by-step: choosing and configuring an auth library (Better‑Auth, Auth.js, or custom), designing secure session/token flows, and writing example code. I especially enjoy helping teams migrate Delphi desktop applications to the web—I'll map your existing auth and session model to a web-friendly approach, outline a migration checklist, and provide practical tips to avoid common traps.

Send details about your app and requirements and I’ll suggest a concrete plan.

Source of this news

• Better-Auth announcement

Vercel Web Interface Guidelines

Vercel, the company behind the popular Next.js framework, has published a comprehensive set of Web Interface Guidelines. These guidelines provide best practices and recommendations for building modern web applications using Next.js and other web technologies.

They also included their customizations which are specific to Vercel.

Following comprehensive interface guidelines like these is crucial for creating web applications that truly serve their users. Poor user experience design can make even the most powerful applications frustrating and inaccessible, leading to user abandonment and business failure. These guidelines address fundamental UX principles such as accessibility, performance, and intuitive interaction patterns that directly impact user satisfaction and engagement.

Modern web development extends far beyond just making things work—it's about creating experiences that feel natural, inclusive, and delightful across all devices and user capabilities. By adhering to established patterns for keyboard navigation, focus management, loading states, and responsive design, developers can ensure their applications work seamlessly for users with disabilities, on slow networks, and across the diverse landscape of modern devices. This attention to detail not only improves user retention but also enhances SEO performance and reduces support costs.

Key Areas Covered

The guidelines focus on several critical aspects of web interface development:

• Interactions: Keyboard accessibility, focus management, mobile input optimization, and loading states
• Animations: Performance-optimized motion with proper easing and reduced-motion support
• Layout: Responsive design, optical alignment, and safe area considerations
• Content: Accessible typography, proper state handling, and internationalization
• Forms: Input validation, autocomplete integration, and submission handling
• Performance: Rendering optimization, network budgets, and image loading strategies
• Design: Color contrast, shadows, and visual consistency

Vercel-Specific Customizations

Vercel has also included their own brand-specific preferences, particularly around copywriting standards. They emphasize active voice, action-oriented language, consistent terminology, and positive framing of error messages. Their approach prioritizes clarity and conciseness while maintaining encouraging, problem-solving communication even in failure scenarios.

Need help?

Looking to migrate your desktop Delphi applications to modern web technologies? I specialize in helping developers transition from traditional desktop development to web-based solutions using TMS WEB Core, React, or Next.js. Whether you're modernizing legacy VCL applications or building entirely new web interfaces, I can guide you through the process and ensure your applications follow current best practices. You can contact me via my website.

FlexCel is the perfect report generator for any frontend

FlexCel is a powerful library for creating and manipulating Excel files in Delphi and .NET applications. You can export to many image formats as well as PDF files.

The product allows you to create templates in Excel, which makes it easy to design and format reports. You can use all the features of Excel, such as formulas, charts, and conditional formatting. Then, in your backend, you can use FlexCel to populate the templates with data from your database or other sources.

It is currently distributed by TMS Software, a well-known company in the Delphi community. You can find more information about FlexCel on their website. As said, it is available for both Delphi and .NET, so you can use it in various types of applications.

However, this is a major understatement. FlexCel is not just a tool to create Excel files. It is a comprehensive solution for generating reports in various formats, including PDF, images (PNG, JPEG, BMP, GIF, TIFF), and even HTML.

I have been using FlexCel for Delphi and .NET for many years. It is a fantastic library for generating Excel and PDF reports from templates. I have used it in various projects, from small desktop applications to large web services. In my books you can find real-world examples of how to use FlexCel in Delphi applications to create reports. In my latest book about Modern Delphi Application development, I have a whole chapter dedicated to FlexCel and reporting as well as in my book about creating Web Services with XData.

Another Use Case

Recently, I have been working on a Next.js project that required generating complex reports that users had to download as PDF files. I decided to use FlexCel for .NET in the backend, and it worked like a charm. I had two alternatives implementing the backend:

• Using Delphi with WebBroker or RAD Server
• Using Delphi with XData

Both these alternatives would have worked, but I decided to go with ASP.NET Core because I wanted to explore the .NET ecosystem as Microsoft has recently made great improvements with .NET Core to compile for any platform, including Linux and macOS. Also, ASP.NET Core Minimal APIs are very easy to use and get started with.

Deployment Scenario

Deployment is very easy. I picked Linux as the operating system to save costs on hosting. A server that is capable of hosting a Linux ASP.NET Core application is much cheaper than a Windows server. The same is obviously true if you want to host a Delphi application on Windows. Thankfully, Delphi comes with a Linux compiler and both XData and FlexCel support Linux.

To isolate the reporting service from the outside world and only to expose the Web Application, I created a Docker Compose setup with two containers:

• One container for the Next.js frontend
• One container for the ASP.NET Core backend

The two containers communicate via a private network. The Next.js application calls the ASP.NET Core backend to generate the reports. The backend uses FlexCel to create the reports and returns them to the frontend, which then serves them to the user.

The Web Application is accessible via HTTPS, and the backend is only accessible from the frontend container. This setup ensures that the backend is not exposed to the internet, which adds an extra layer of security.

Conclusion

FlexCel is a fantastic library for generating reports in various formats. It is easy to use and integrates well with both Delphi and .NET applications. If you need to generate reports in your application, I highly recommend giving FlexCel a try. You can find more information about FlexCel on the TMS Software website.

Need help?

If you need help with FlexCel, Delphi, .NET, or anything else related to software development, feel free to reach out to me. I offer consulting and training services and would be happy to assist you with your project. You can contact me via my website.