Other day iI woke to some unsettling news in the .NET ecosystem. Rumors are swirling—and some blog posts are starting to corroborate—that NUKE, the build system I’ve come to rely on for almost all my C# projects, is being effectively abandoned.

The word on the street is that the primary developer, Matthias Koch, has reached a breaking point. After years of pouring heart and soul into the project, the lack of financial incentive and the sheer weight of maintaining such a critical piece of infrastructure has taken its toll. What’s even more concerning is the talk that any future development might happen in a fork that could be closed-source or move to a paid model.

This hits home. Hard. I just wrote about how much I love Nuke, and now the foundation feels like it’s shifting under my feet.

The Search for a Substitute

When a tool you depend on enters “maintenance mode” or changes its licensing terms, the first instinct is to look for a lifeboat.

Interestingly, Cake 6.0 was recently released, and it seems the team there has been paying attention. They’ve introduced the Cake.Sdk, which feels very much like an answer to NUKE’s “code-first” philosophy. It moves away from the old .cake scripts and toward standard .cs files with a project-based approach. It’s got that IDE integration and strongly-typed feel that made me switch to NUKE in the first place.

Is it enough to make me jump ship? Not yet. For the time being, I’m sticking with NUKE. The existing code is MIT licensed, and even if the official repo is archived, the current version still works. But the long-term viability is definitely a question mark.

The Cost of “Free”

This situation shines a harsh spotlight on the open-source ecosystem. We—developers and businesses alike—have become incredibly comfortable building empires on the back of free labor. We depend on these “tiny” projects maintained by one or two people, and we often forget that there’s a human on the other side of that GitHub handle.

If we care about these tools, we have to support them. Whether it’s through GitHub Sponsors, Open Collective, or enterprise licenses, “free” always has a cost. If the maintainers can’t pay their bills or find a reason to keep going beyond “community spirit,” the project eventually collapses.

I’m at a crossroads here. Are you already testing the waters with Cake 6 or maybe something else like Modular Pipelines? For now, I’ll keep my Nuke scripts running, but I’ll be keeping a very close eye on the horizon.

I’ve always been obsessed with one thing: consistency. Whether I’m building code on my local machine or watching it run in the belly of a GitLab runner, I want the exact same behavior. I wanted a build process that didn’t care where it was—it should be just as comfortable on my laptop as it is on a third-party server.

When I started the SuCoS project, I knew I needed a build system that could match my ambition. It wasn’t just about compiling and testing; I wanted it to handle everything—generating tags, creating releases, and even cooking up a fresh Docker image every week.

After several late-night coding sessions—the kind fueled by too many coffee cups and far too many crumpled design sketches—I finally found my answer in Nuke. Instead of scattering my pipeline across a dozen separate stages in GitLab’s YAML, I let Nuke step in as my omnipotent orchestrator.

The Maestro in C#

At its heart, Nuke is an automation maestro. It’s like having a conductor for your code, ensuring every task is performed at the perfect moment. And the best part? This maestro speaks my favorite language: C#.

Before Nuke, I had to manually command GitLab to execute every step—dotnet restore, dotnet clean, dotnet build, dotnet test. Now, I just tell GitLab one thing: nuke test. That master command is like a potent incantation that triggers Nuke to handle everything else.

Since it’s written in C# instead of messy YAML, I have way more confidence in my builds. C# gives me that sense of solidity I crave. I love the fact that when I call nuke, the first thing it does is compile itself before building anything else. It’s a self-affirming echo that makes me feel right at home.

To keep things tidy, I also brought in GitVersion to handle Semantic Versioning (SemVer). It’s like having a diligent librarian who examines my commits, applies the Semantic Commit standards, and assigns the perfect version number without me lifting a finger.

Taming the Beast

Of course, no journey is without its bumps. While Nuke is powerful, I hit a few snags along the way.

Some tasks, like creating tags and releases, are very GitLab-centric and rely on their API. This means they aren’t quite as portable as I’d like and required some extra tinkering to get right. It was a small price to pay for the automation I gained.

As SuCoS grew, my build class started growing like a weed. It was becoming a nightmare to manage—a real “herding cats” situation. My solution? I split the class Build : Nuke into several partial classes. This turned an unruly mob of code into a disciplined, organized team. Now, my build logic is clean and easy to navigate.

The beauty of this setup is that if anyone forks SuCoS on GitHub, the build system will still work almost flawlessly with just a few minor tweaks.

In the ever-evolving landscape of web development, Static Site Generators have gained immense popularity due to their simplicity, speed, and ease of use. I migrated this site from WordPress to a SSG and have no regrets. However, navigating through the complexities of existing tools like Hugo and DocFX can sometimes be a daunting task, even for advanced developers. Recognizing this challenge, I decided to embark on a personal journey to create a solution. Thus, I give you SuCoS (JuiCeS in Portuguese - a playful nod to my roots and the delightful simplicity I aim for), a C# static site generator that simplifies the process while offering incredible performance.

The Origin

The day I found myself tangled in a web of Hugo templates, I realized something had to change. It felt akin to wandering in a labyrinth without a torch; even ChatGPT, my trusty AI companion, seemed lost. I felt like Bilbo Baggins in the tunnels, minus a riddle-solving partner. I experimented with DocFX, but its rigidity left me wanting. I even dabbled with Rust’s Zola, but found it lacking in richness. I yearned for something more versatile, more fluid.

That’s when it hit me. Why not carve my own path? Why not conjure a static site generator that would render the process as simple as connecting the dots, rather than cracking the Enigma code? With .Net 7 back on track, I knew I had my foundation. It promised familiarity, richness in features, and a performance-driven mentality. Also, the new compilation options for a single file, trimmed and self-contained appeared to be an ideal match.

Thus, the seed of SuCoS was planted.

The Process

Building SuCoS, I focused on 3 critical features.

Firstly, I envisioned a site builder as fast as the wind, quick as a cheetah on the savanna. The result? A C# DotNet 7 engine that churns out pages at breakneck speed. To curb my OCD, I created a test site with 100,000 pages (about 10% of the size of Portuguese Wikipedia) and it took less than 1ms per page!

Secondly, I aimed for an easy-to-use yet versatile template system. I wanted to sidestep the hieroglyph-like complexity of Hugo templates and embrace something more intuitive. Enter Liquid templates - as adaptable and refreshing as water, as straightforward as ABC.

Finally, the third critical feature: a live server for local development. I craved a system that would be as responsive and alive as an eager co-author, watching my every keystroke, reflecting each change I made to content or theme files on the local server, erasing the need for monotonous manual refreshing. To top it all off, I implemented a nifty little report that fires off at the end of the building process, allowing you to marvel at the lightning speed of your site’s creation.

SuCoS wouldn’t be complete without a trusty sidekick. Enter Nuke, an invaluable building system that automates the building and releasing process, even providing a Docker container image to make life easier.

The Roadmap

The very v1.0.0 version is live! And to showcase its MVP (minimum viable product), its official site (https://sucos.brunomassa.com/) was built using SuCoS itself! How cool is it?! But this is just the ‘Iron Man Mark 1’ phase. Like Tony Stark, I’m constantly refining and improving. I’ve recruited GitLab CI/CD as my faithful AI, J.A.R.V.I.S., who ensures that a fresh, improved version sees the light of day every week. The journey towards the ‘Endgame’ continues, each iteration bringing us one step closer.

One of my milestones is to convert this very site to SuCoS by the end of July 2023. Ambitious? Yes. Achievable? Absolutely.

Join in this adventure. Connect with the community on Twitter, Mastodon, Discord, and Matrix. Let’s steer this ship together, transforming the world of static site generation into an easy and delightful journey, one page at a time.

Once upon a time, in the land of curly braces, I, a devoted C# enthusiast, embarked on a daring adventure to explore the mysterious realm of Rust. Rust burst onto the scene like a supernova, capturing the hearts and minds of developers around the globe. Its focus on safety, performance, and concurrency has earned it a dedicated following, and even the Linux kernel couldn’t resist Rust’s allure. As Rust continues to make waves in the world of systems programming, C# watches from the sidelines, confidently flexing its newfound performance muscles and ready to take on any challenge that comes its way.

While Rust’s safety features and swift performance tempted me, its cryptic syntax and peculiar design choices soon had me pining for the familiar embrace of C#. Rumor had it that C# and .NET 7 had been hitting the performance gym, so I decided to rekindle our romance. In this blog post, I’ll chronicle my journey back to C# and compare its newfound strength with Rust using some good ol’ benchmarking results.

C# Sharpens Its Edge

It turns out that while I was flirting with Rust, C# had been diligently honing its edge like a master swordsmith. .NET devs had been forging tirelessly to improve C#’s performance and the .NET runtime, forging the razor-sharp .NET 7.

The Computer Language Benchmarks Game showcased the fruits of C#’s labor, revealing significant improvements in execution time and memory consumption. C# now slices through performance benchmarks alongside Rust, demonstrating that it’s no longer the blunt underdog in the performance arena.

Meanwhile, the TechEmpower web framework benchmarks crowned ASP.NET Core among the elite, proving that C# and .NET 7 can deliver high-performance web applications with the precision of a finely-crafted blade, rivaling Rust-based web frameworks like Axum.

C#’s “New” Superpower

During its time at the forge, C# discovered a new superpower: Ahead-of-Time (AOT) compilation. This newfound ability allows C# to compile code into native machine code before runtime, skipping the more leisurely Just-In-Time (JIT) compilation process.

AOT compilation not only reduces startup times but also enhances performance optimization. AOT and JIT compilations are like two superheroes with different origin stories, each with its own strengths and weaknesses. AOT, the more proactive of the two, compiles code into native machine code before runtime, flexing its muscles to reduce startup times and optimize performance. On the other hand, JIT, the more leisurely and contemplative hero, compiles code during runtime, taking its sweet time to optimize based on the application’s real-world usage.

C#, being the more application-driven and versatile chameleon that it is, initially chose JIT as its trusty sidekick. However, as C# realized it could cater to more performance-critical scenarios, like games, it embraced AOT, stepping out of its comfort zone and broadening its horizons.

• AOT-only
  • C
  • C++
  • Rust
• JIT-only
  • Java (mostly JIT, but can use AOT in specific cases)
  • Ruby
• Both AOT and JIT
  • C#
  • Go
  • Kotlin/Native (for native platforms)

The Rusty Side of the Coin

Rust is undeniably a fascinating language, boasting a focus on safety and exceptional performance. However, its syntax and design choices can sometimes feel like deciphering ancient hieroglyphics. With a slew of abbreviated keywords like fn, mut, and impl, Rust might as well be speaking in code.

In addition, Rust’s syntax deviates significantly from its more familiar counterparts like C# and Java. Rust’s concepts of lifetimes and ownership can leave developers accustomed to garbage-collected languages scratching their heads in bewilderment.

Check a box on which concept to you ever heard of:

• Lifetimes and Ownership
• Borrow Checker
• Pattern matching syntax with match and _ (wildcard)
• Option and Result types for error handling
• Trait-based generics
• Macros with a ! syntax

Congratulations: you scored Zero points!

Meanwhile, C# retains its elegant simplicity, with meaningful keywords and design choices that prioritize readability and user-friendliness. Over time, C# has embraced modern features like pattern matching, nullable reference types, and async/await, all while maintaining its easy-going charm.

Back to The Future

My escapade into Rust was undoubtedly an eye-opening experience, allowing me to appreciate the powerful capabilities of both languages. However, Rust’s enigmatic syntax and design choices had me yearning for the warm, familiar comfort of C#. Returning to the latest C#, I discovered a language that had evolved and adapted, offering a potent combination of performance, elegance, and ease of use.

As C# and .NET 7 bask in the limelight, little do they know that .NET 8 is waiting in the wings, ready to dazzle us with even more breathtaking improvements. Rumor has it that .NET 8 will further incorporate functionalities from popular third-party libraries, making it an even more enticing one-stop shop for developers. With the pace of innovation accelerating, the future of C# and the .NET universe looks brighter than ever.

So, my fellow developers, let my tale be a testament to the importance of keeping an open mind and daring to explore new horizons. However, sometimes, the grass isn’t always greener on the other side. In my case, I found that C# was the perfect blend of power and familiarity that I had been seeking all along.

As you navigate the tumultuous seas of programming languages, remember to consider your project’s specific needs, performance requirements, and personal preferences. Each language has its quirks and charms, and the right fit will depend on your unique circumstances. In the end, it’s about finding the language that makes your heart sing and your code soar.

Smart homes are becoming increasingly popular as technology continues to advance and become more accessible. You can control various devices and appliances in your home through a single app or voice assistant. It can include lights, temperature control, security systems, and more.

You can control these lights through voice commands through platforms like Google Assistant or Amazon Alexa. With smart lights, you can easily set the mood in your home by adjusting the color, brightness, and temperature of the lights. You can also automate lighting by setting schedules or creating scenes, such as turning on the lights when you enter a room or dimming them for movie night. The typical sales pitch “Endless Possibilities” does apply here!

I started to transform my house into a Smart Home about a year ago and I’m loving it!

DIY

One of the most affordable and customizable options for building a smart home is to use Home Assistant with a Raspberry Pi. Home Assistant is an open-source platform that allows you to integrate and control various smart devices in your home. It is free and can be easily installed on a Raspberry Pi, making it accessible to people with a range of technical skill levels. Home Assistant supports a wide variety of smart lights, including those from popular brands like Philips.

One of the benefits of using Home Assistant with a Raspberry Pi is that it is free of paid service. All smart-device companies offer a paid subscription service to unlock some extra features. The Home Assistant community has hundreds of tips and tutorials to replicate them on your own. This means that you don’t have to worry about recurring subscription fees or being locked into a specific platform.

Unlike paid smart home services, particularly those in other countries, you can be confident that your private information and data are secure and not being monitored or accessed by anyone else. You have full control over your data and devices, and you can be sure that your security cameras, personal information, and other sensitive data are not being shared with any third parties. This level of privacy is crucial in today’s world where data privacy concerns are becoming more widespread. By choosing this DIY smart-home setup, you can enjoy the benefits of a connected home without worrying about the privacy implications of using a paid service.

Node-RED, included as a plugin, allows for even greater customization and automation in your smart home. You can create “flows” that automate various tasks, such as recording security video when motion is detected, sending notifications to your phone, or turning on the lights when you enter a room. This can make your smart home even more intelligent and responsive to your needs, freeing up time and effort that would otherwise be spent on manual tasks. The plugin provides a visual interface for building these automations, making it easy to set up and modify your flows, even if you have little to no programming experience. By incorporating Node-RED into your Home Assistant setup, you can take your smart home to the next level and make it truly your own.

I had to configure an online backup. Raspberry Pi has a history of failing, especially the micro-SD. It gives me peace of mind knowing that even if my Raspberry Pi fails, I can easily restore my Home Assistant setup without any hassle.

Wallet and Keys Free

Another great feature of a smart home is the ability to leave your keys and wallets behind when you leave the house. With smart locks and phone-based payment systems, you now can control access to your home and pay for purchases with just your phone. It can make life much more convenient, as you won’t need to carry a bulky keychain or wallet everywhere you go. It’s pocket freedom! Simply use your phone to unlock your front or garage door, and pay for your morning coffee – all without ever having to dig through your pockets or purse. The counterpart is the single point of failure: in case I lose my phone (or get robbed), I will have no money and no way to enter my house. :(

I did the right thing to start to automate my home a year back. Building a smart home with Home Assistant on a Raspberry Pi is a cost-effective and customizable option for people who want to control their home appliances and devices from one central location. A valid warning: it’s addictive to tweak each device or flow to fit your taste. Just take care of not getting into the rabbit hole!