Introduction

I had been working with Laravel, a robust PHP framework, for over 10 years and it had served me well. Like many other developers I've collaborated with, I, too, have grown accustomed to its quirks and learned to overlook its shortcomings. In some instances, I've even developed my own packages to address its limitations. Nonetheless, I've never ceased my search for a superior alternative, but I've found that nothing has quite lived up to my expectations for a suitable replacement. Golang piqued my interest as a potential web development language since its initial launch, yet during my initial encounters, it was still a relatively young language. It wasn't until 2019 that I revisited Golang, and after careful consideration, I made the decision to embrace it as my next web development language.

Why Moving from Laravel to Golang

Laravel is an all-inclusive, comprehensive and very bloated framework. It tries to integrate a wide array of functionalities, including database access, queuing systems, HTTP routing, session management, authentication mechanisms, dependency injection and more. Nonetheless, Laravel is over bloated. For instance, it heavily relies on various external packages, leading to an accumulation of over 18,000 files within your Composer folder. Laravel exhibits multiple inconsistencies that become apparent when transitioning between different versions. The technical decisions in Laravel are very questionable and can be perceived as somewhat authoritative, often urging the community to conform in order to be able to migrate to the latest version. Opting not to migrate to the latest Laravel version always has dire consequences. Your application finds itself unsupported, eventually running out of crucial security updates and support.

Golang resides on the opposite end of the spectrum, offering the means to perform tasks with utmost precision. It results in a single, streamlined executable, making deployment and monitoring remarkably straightforward. Cross-platform compatibility seamlessly falls into place. Moreover, the language incorporates inherent formatting, and transitioning to the next version is as smooth as a leisurely stroll in the park.

Trying Out Rust First

During my assessment of various programming languages, I decided to explore Rust. Both languages seemed very similar at first. The development experience was relatively straightforward; however, I encountered a few issues that led me to conclude that Rust wasn't the right fit for my needs.

First and foremost, Rust's compilation speed left much to be desired. Tasks that took mere seconds in Golang extended to minutes in Rust, which was a significant time investment I couldn't afford.

Secondly, Rust didn't play well with Windows, especially on the database libraries part, whereas Golang proved to be exceptionally cross-platform, ensuring a smoother development experience.

Lastly, Rust didn't fully live up to its reputation as a secure and virtually impenetrable language. I discovered that it was just as prone to exceptions as many other languages, diminishing its appeal.

Ultimately, these factors led me to part ways with Rust and embrace Golang as my language of choice for web development.

Letting Go of Frameworks

When transitioning from a framework like Laravel, the initial impulse is often to gravitate towards something similar. In my case, I started my Golang journey with Beego. Beego is a fantastic framework with many features pre-packaged, much like Laravel. However, it shares Laravel's opinionated nature and hides many of its implementations beneath the surface. While there was nothing inherently wrong with it, I yearned for a deeper understanding and full control over my project's workings, which Beego didn't quite offer.

My second attempt led me to Fiber. I chose it because it positioned itself as a slim and speedy Golang framework akin to Express. Yet, similar to Beego, it also carried a significant degree of opinionation. Additionally, it didn't quite align with Golang's idiomatic style, and it pushed several libraries onto its users, which felt somewhat awkward.

In the end, I decided to take the plunge and embrace Golang without a framework. All I truly needed was a well-designed, idiomatic router library. That's when I discovered Chi, and it turned out to be a perfect fit. Chi provided the flexibility and control I craved, making it a seamless and efficient companion for my Golang web development journey.

Finding the Correct Libraries

Transitioning to Golang was a bit of a challenging experience. I soon realized that Golang's library ecosystem, particularly in the realm of web development, didn't offer the same extensive set of pre-built features and utilities that I was accustomed to in languages like PHP. In fact, even the standard library in Golang appeared to lag behind PHP's feature-rich standard library. Simple tasks that you often take for granted in web development, such as stripping tags, URL escaping, and similar functionalities, were conspicuously absent.

However, Golang's strength lies in its simplicity and the ability to craft your own modules. This was precisely the path I chose to follow. Determined to overcome these limitations, I embarked on a journey of building my own utility library. Slowly but by bit it became a comprehensive collection of the tools and functions I needed for web development in Golang. By crafting these modules from scratch, I could tailor them to my exact requirements and preferences, ensuring that my Golang projects had the capabilities I needed to deliver exceptional results. In the process, I not only met the challenges head-on but also gained a deeper understanding of Golang's flexibility and extensibility, which allowed me to shape the language to meet my specific needs.

Getting Rid of Templates

Golang's standard library does include a templating library, but using it feels like a massive pain. It's so frustrating working with it, which is the reason why there is a proliferation of third-party libraries attempting to fill this gap in the Golang ecosystem. However, the interesting thing to note is that many of these third-party libraries tend to adopt a template rendering approach akin to what you'd find in other popular frameworks such as Laravel or Django and also come short of expectations.

Having accrued over two decades of experience in web development, I came to this Golang templating challenge with a clear vision of what I needed. Each of the existing libraries fell short in some way, and I knew precisely how they missed the mark. This is where the true strength of Golang came into play - it allows you to craft solutions that align exactly with your requirements and preferences.

In my case, I decided to take the initiative and create my own declarative interface library, tailored to my exact needs. This approach allowed me to address the issue perfectly, ensuring that the templating engine functioned in a way that made sense for my projects.

Web Development with HTMX

Web development in Golang is pretty much non existent. Most of the Golang projects out there predominantly use JavaScript front-end frameworks like React or Vue.js, with Golang taking on the role of an API server. While this approach works for some, it wasn't the path I wanted to tread.

The idea of relying heavily on full-fledged JavaScript frameworks, especially when Golang offers such a robust and capable language, felt somewhat counterintuitive and out of touch with my preferences. It seemed like a step backward, and it raised questions about whether there was a more efficient way to leverage Golang's capabilities for building dynamic web applications.

That's where HTMX came into the picture and filled a crucial void. HTMX provided the ideal bridge between Golang and web development by allowing you to create dynamic and interactive web applications without fully committing to complex JavaScript frameworks. Its compatibility with Golang allowed me to build feature-rich applications with server-side rendering, delivering a more seamless and efficient development experience that aligned better with my vision.

In Conclusion

Transitioning from Laravel to Golang was definitely the right journey for my web development endeavors. It was a decision that not only met but exceeded my expectations. With Golang, I found a world where the quirks and idiosyncrasies of Laravel were a thing of the past, and only the finest aspects of web development remained.

One of the key benefits that became evident early on was that I was no longer at the mercy of the inconsistent, version-driven updates that often characterize the Laravel ecosystem. Golang offered a level of stability and continuity that allowed me to work at my own pace, without the pressure of constantly adapting to new versions every six months or facing the prospect of losing essential security maintenance and patches.

Now, after three years of immersing myself in Golang as my primary web development language, I can confidently declare that I would make the same choice without a moment's hesitation. The transition wasn't just a change of technology; it represented a shift towards a more streamlined, efficient, and user-centric approach to web development. It has provided me with the tools and freedom to create exceptional projects and has been a source of satisfaction and professional growth throughout my journey. Golang has not just met but exceeded my expectations, reinforcing my belief that it was indeed the right path for me.