Forem: Lion The Hoon

Fixing WebView2 Issues in Linux Bottles: How I Got It Working

Lion The Hoon — Sun, 21 Dec 2025 06:22:37 +0000

Since setting up Bottles, I’ve been happily running my favorite Windows applications on my Linux development machine. Life was good—I was productive, comfortable, and didn’t have to dual‑boot or spin up a VM just to get work done.

The Problem: A Windows App That Needs WebView2 on Linux

Recently, I needed a desktop app to manage my investments. The app offers Windows, iOS, and Android versions—but unfortunately, no native Linux support. To make things more interesting, some key features are only available in the Windows version.

No problem, I have Bottles for that!

I installed the Windows version using Bottles, launched it, and everything seemed fine at first. Most features worked flawlessly. However, when I opened a specific window, I was greeted with a popup:

WebView2 is not installed. Do you want to install it?

Sure—I needed that feature, so I installed WebView2. The installation completed successfully, and the window opened… but the content was completely blank.

At this point, it was clear that WebView2 wasn’t behaving correctly inside Bottles on Linux.

The Usual Troubleshooting (and a Lucky Find)

Like most of us would do, I asked ChatGPT for help. I tried a few suggestions, but no luck. So I went old‑school and Googled the issue.

Thankfully, I stumbled upon a helpful Reddit post that pointed me in the right direction. And yes—it worked.

The Solution: Getting WebView2 to Work in Bottles

Here’s a quick summary of what fixed the issue for me.

Step 1: Install Proton GE in Bottles

Open Bottles and go to Preferences (Shortcut: Ctrl + ,)
Navigate to the Runners tab
Scroll down to Proton GE
Install the latest available version—at the time of writing, this was ge-proton10-26

Step 2: Switch the Bottle Runner to Proton GE

Open the specific Bottle where your Windows app is installed
Go to Options > Settings > Components > Runner
Change the runner to the ge-proton10-26 version you just installed

Step 3: Install Required Dependencies

Go to Dependencies
Install the following packages:
vcredist2022
vcredist2019
dotnet48

The Result: WebView2 Working Perfectly on Linux

And that’s it.

I relaunched the app, opened the problematic window again—and this time, the content loaded exactly as expected. No blank screen. No errors. Just a fully functional WebView2 component running inside Bottles on Linux.

Final Thoughts

If you’re running Windows applications on Linux using Bottles and run into WebView2 rendering issues, switching to Proton GE and installing the right dependencies can make all the difference. Hopefully, this saves you some time—and a bit of head‑scratching.

Happy hacking on Linux!

The original post can be found here.
Note: This post was written by me and edited by AI.

How I Made My AMD RX6750XT Work for Machine Learning (Despite ROCm Limitations)

Lion The Hoon — Thu, 01 May 2025 07:31:37 +0000

The GPU Regret: AMD vs Nvidia for AI Development

The 2020–2022 crypto boom made buying GPUs a nightmare, especially Nvidia’s RTX series. Back then, Team Red’s RX6000 lineup felt like a steal. I grabbed an AMD RX6750XT—same chip as the RX6700XT (gfx1031)—and skipped ray tracing for affordable rasterization. "Price over pixels," right?

Fast forward to 2024. Crypto’s fading, but the AI boom exploded. As a developer itching to experiment with LLMs and PyTorch, I realized my mistake: Nvidia’s CUDA dominance leaves AMD GPUs in the dust. ROCm—AMD’s answer to CUDA—officially supports RX6800XT (gfx1030) but snubs RX6700XT/6750XT (gfx1031). Cue the regret.

If I could time-travel, I’d slap my 2022 self and yell: “Buy an RTX 3070 instead!” But since I’m stuck with my RX6750XT, here’s how I forced it to play nice with machine learning workloads.

Hacking ROCm Support for RX6700XT/6750XT GPUs

Tools Used:

OS: Linux Mint 22.1
GPU: AMD RX6750XT (gfx1031)

Step 1: Install AMD Drivers & ROCm Runtime

Download the AMD amdgpu-install Debian Package for RX6700XT from here.
Install the package (no tutorial here—trust your Googling skills).
Run: amdgpu-install --usecase=graphics,rocm

Step 2: User Permissions & Reboot

Add yourself to the video and render groups:

sudo usermod -a -G video $USER  
sudo usermod -a -G render $USER

Reboot.

Step 3: The GFX1031 vs GFX1030 Spoof

Post-reboot, run rocminfo. You should be able to see your GPU here.

Step 4: Making Sure it Works

Here’s my working Ollama Docker command:

docker run -d --restart always \  
  --device /dev/kfd --device /dev/dri \  
  -v ollama:/root/.ollama -p 11434:11434 \  
  --name ollama \  
  -e HSA_OVERRIDE_GFX_VERSION=10.3.0 \  
  -e HCC_AMDGPU_TARGET=gfx1030 \  
  ollama/ollama:rocm

Final Thoughts

AMD’s improving ROCm, but driver issues and hardware restrictions linger. Hopefully the situation improves for future platforms.

References:

Notes: this blog post was edited by AI.

How to Run Windows Applications on Linux Using Bottles: A Step-by-Step Guide

Lion The Hoon — Mon, 31 Mar 2025 10:26:38 +0000

Are you transitioning from Windows to Linux but struggling to replace tools like Notepad++ or WinMerge? Thanks to Wine and Bottles, you can now run Windows-only applications natively on Linux. This guide will show you how to install Windows apps on Linux effortlessly, perfect for .NET developers or anyone needing Windows tools in a Linux environment.

Why Use Bottles

Bottles simplifies running Windows software on Linux by managing Wine configurations automatically. Unlike manual Wine setups, Bottles offers:

Pre-configured environments ("bottles")
Easy installer integration
Desktop shortcuts for Windows apps

Step 1: Install Bottles via Flatpak

Bottles is available as a Flatpak, ensuring compatibility across Linux distributions. Run:

flatpak install flathub com.usebottles.bottles

Step 2: Configure Bottles Permissions

To enable desktop shortcuts and home directory access, run these commands:

# Allow desktop entries  
flatpak override com.usebottles.bottles --user --filesystem=xdg-data/applications  
flatpak override com.usebottles.bottles --user --filesystem=~/.local/share/applications  

# Optional: Access home directory  
flatpak override com.usebottles.bottles --user --filesystem=home

Step 3: Install Windows Applications

Launch Bottles and create a new "bottle".
Download your Windows app’s installer (e.g., Notepad++ or WinMerge).
In Bottles, click Run Executable… and select the installer.
Follow the Windows-style installation prompts.

Step 4: Create Desktop Shortcuts

Go to the Programs list in your bottle.
Click the kebab menu (⋮) next to the app.
Select Add Desktop Entry to launch the app from your Linux desktop.

Conclusion

With Bottles and Wine, running Windows applications on Linux is easier than ever. Whether you’re a .NET developer needing Notepad++ or a power user reliant on WinMerge, this setup bridges the gap between Windows and Linux workflows.

Note: this post is edited by AI. The original post is available here.

Using the Decorator Pattern with Autofac for Selective Service Registration

Lion The Hoon — Sat, 25 Jan 2025 14:22:23 +0000

The other day, while working on a ticket at my job, I was tasked with adding a validation step to the checkout process for a specific platform. Initially, I thought this would be a simple change. I added the validation logic to the shared CheckoutProcessCommandHandler class, which looked like this:

class CheckoutProcessCommand : ICommandHandler
{
    public void Handle()
    {
        if (platform == 'specific-platform' && !Validate())
        {
            throw new InvalidOperationException();
        }

        // Other checkout logic...
    }
}

After creating a pull request (PR), I assumed the ticket was complete. However, a reviewer suggested using a decorator pattern and registering it in the platform's Autofac module instead. The challenge? There were multiple ICommandHandler implementations registered in the Autofac module, and I needed a way to apply the decorator to a single class only.

What is the Decorator Pattern?

The decorator pattern is a structural design pattern that allows you to dynamically add new functionality to an object by wrapping it in one or more decorator classes. Importantly, it does this without altering the object's original structure.

Why Use the Decorator Pattern?

Reusability: You can create reusable components to extend functionality.
Maintainability: Keeps the original codebase clean and focused on core logic.
Flexibility: Allows dynamic composition of behaviors at runtime.

Registering a Decorator in Autofac

Here’s a simple example of how to register a decorator in Autofac. In this example, we have two classes implementing ICommandHandler: CheckoutProcessCommand and PaymentProcessCommandHandler. Additionally, there’s a decorator class, CommandHandlerDecorator, which adds functionality by printing an additional message.

Interface Definition

ICommandHandler.cs:

interface ICommandHandler
{
    void Handle();
}

Command Handler Implementations

CheckoutProcessCommand.cs:

class CheckoutProcessCommand : ICommandHandler
{
    public void Handle()
    {
        Console.WriteLine($"{nameof(CheckoutProcessCommand)}.{nameof(Handle)}");
    }
}

PaymentProcessCommandHandler.cs:

class PaymentProcessCommandHandler : ICommandHandler
{
    public void Handle()
    {
        Console.WriteLine($"{nameof(PaymentProcessCommandHandler)}.{nameof(Handle)}");
    }
}

The Decorator

CommandHandlerDecorator.cs:

class CommandHandlerDecorator(ICommandHandler innerHandler) : ICommandHandler
{
    public void Handle()
    {
        Console.WriteLine($"{nameof(CommandHandlerDecorator)}.{nameof(Handle)}");
        innerHandler.Handle();
    }
}

Autofac Registration

Here’s how we register the command handlers and the decorator:

var builder = new ContainerBuilder();
builder.RegisterType<CheckoutProcessCommand>().As<ICommandHandler>();
builder.RegisterType<PaymentProcessCommandHandler>().As<ICommandHandler>();
builder.RegisterDecorator<CommandHandlerDecorator, ICommandHandler>();
var container = builder.Build();
foreach (var handler in container.Resolve<IEnumerable<ICommandHandler>>())
{
    handler.Handle();
}

Output

When you run the application, the output will look like this:

CommandHandlerDecorator.Handle
CheckoutProcessCommand.Handle
CommandHandlerDecorator.Handle
PaymentProcessCommandHandler.Handle

Notice that CommandHandlerDecorator.Handle is executed before each command handler’s message. This happens because the decorator is applied to all instances implementing ICommandHandler. However, this isn’t the behavior we want—we need to target a specific implementation.

The Solution: Keyed Services in Autofac

After consulting the Autofac documentation on Keyed Service, I found a solution to apply the decorator to a specific implementation. Here’s the updated code:

var builder = new ContainerBuilder();
builder.RegisterType<CheckoutProcessCommand>().As<ICommandHandler>();
builder.RegisterType<PaymentProcessCommandHandler>().Keyed<ICommandHandler>(nameof(PaymentProcessCommandHandler));
builder.RegisterDecorator<ICommandHandler>(innerInstance => new CommandHandlerDecorator(innerInstance), nameof(PaymentProcessCommandHandler));

var container = builder.Build();
foreach (var handler in container.Resolve<IEnumerable<ICommandHandler>>())
{
    handler.Handle();
}

Updated Output

CommandHandlerDecorator.Handle
CheckoutProcessCommand.Handle
CommandHandlerDecorator.Handle
PaymentProcessCommandHandler.Handle

The decorator is now only applied to PaymentProcessCommandHandler, as desired.

Conclusion

Using Autofac’s keyed services allows for precise control over which classes to apply decorators to. This approach helped me implement the required functionality without affecting other parts of the system. My PR was approved, and I was finally able to close the ticket!

The original post could be found here

Note: this blog post was edited by ChatGPT for a better reading experience.

Understanding Linux Shells: Interactive, Non-Interactive, and RC Files

Lion The Hoon — Sun, 12 Jan 2025 05:47:08 +0000

The original post could be found here.

Recently, while compiling a .NET application that contains a build step to install npm dependencies. I encountered an issue that got me diving deep into Linux shell configurations. The problem began with a seemingly simple command: npm install. Instead of success, I got this error:

/usr/bin/env: npm: No such file or directory

Confused, I switched to my terminal (using zsh) and ran the same command. It worked perfectly! This led me to discover the differences between interactive and non-interactive shells, the role of rc files, and how environment variables are loaded.

If you’ve faced similar issues, this post will guide you through the nuances of Linux shells and their configuration files.

What Are Interactive and Non-Interactive Shells?

Linux shells can operate in two main modes: interactive and non-interactive. Understanding their behavior is essential for debugging issues like missing environment variables.

Interactive Shell

An interactive shell is a shell session where you interact directly by typing commands. For instance:

Opening a terminal and running ls or cd.
Prompts like $ (for regular users) or # (for root) are visible.

Interactive shells source specific configuration files, enabling personalized setups like custom $PATH variables, aliases, and functions.

Examples of Interactive Shells:

Launching a terminal emulator (e.g., GNOME Terminal or iTerm2).
Accessing a remote server via ssh.

Non-Interactive Shell

Non-interactive shells execute scripts or commands without user interaction. They are typically used by applications, scripts, or cron jobs.

Examples of Non-Interactive Shells:

Running a script: bash script.sh.
Executing commands within another program: Process.Start() in C#.

Unlike interactive shells, non-interactive shells do not source all configuration files, which can lead to discrepancies in environment variables.

Key Shell Configuration Files

Linux shell startup behavior depends on whether the shell is interactive or non-interactive, and whether it is a login or non-login shell. Here's a breakdown of the key files for Bash and Zsh.

Files for Bash

Global Files:

/etc/profile: Sourced by login shells. Sets global environment variables.

User-Specific Files:

~/.bash_profile : Sourced by login shells. Used for user-specific login configuration.
~/.bashrc: Sourced by interactive non-login shells. Typically includes aliases and functions.
~/.bash_login: Sourced after ~/.bash_profile. Typically shows welcome messages or customer commands.
~/.profile: A fallback for ~/.bash_profile (used by other shells too).
~/.bash_logout: Soured when login shell exits. Typically perform cleanup for the session.

Files for Zsh

~/.zshenv: Sourced by all Zsh shells.
~/.zshrc: Sourced by interactive shells.
~/.zprofile: Similar to Bash’s ~/.bash_profile, sourced by login shells.
~/.zlogin: Sourced after ~/.bashrc during login.
~/.zlogout: Sourced during logout.

How These Files Are Sourced

Interactive Login Shell (e.g., SSH or TTY Login)

Bash:
- Bash startup: /etc/profile > ~/.bash_profile > ~/.bash_login > ~/.profile.
- Often, the ~/.bash_profile sources the ~/.bashrc file.
- Bash exit: ~/.bash_logout.
Zsh:
- Zsh startup: ~/.zshenv > ~/.zprofile > ~/.zshrc > ~/.zlogin.
- Zsh exit: ~/.zlogout.

Interactive Non-Login Shell (e.g., Terminal Emulator)

Bash:
- ~/.zshenv > ~/.bashrc.
Zsh:
- ~/.zshrc.

Non-Interactive Shell (e.g., Script Execution)

Bash:
- Does not source interactive files like ~/.bashrc by default.
- Will locate and source $BASH_ENV.
Zsh
- ~/.zshenv.

Troubleshooting and Best Practices

Scenario: Missing PATH in Non-Interactive Shell

When I debugged my application, I realized that my npm binary was not in the PATH because the non-interactive shell didn’t source ~/.zshrc, where nvm adds its path. To resolve this, I added the following to ~/.zshenv:

export PATH="$HOME/.nvm/versions/node/v22.9.0/bin:$PATH"

Best Practices

Understand Your Shell:
- Know if your shell is Bash or Zsh and whether it’s interactive or non-interactive.
Centralize Common Configurations:
- Use files like ~/.bashrc or ~/.zshrc for reusable configurations.
Export Variables Globally:
- For critical variables, export them in files sourced by all shell types (e.g., ~/.zshenv or ~/.profile).

Conclusion

Interactive and non-interactive shells serve different purposes, and understanding how they source configuration files can save hours of debugging. By organizing shell configurations effectively, you can avoid common pitfalls like missing environment variables.

Fixing SSR Rendering Issues with Angular Resolver for Async Pipe Data

Lion The Hoon — Thu, 31 Oct 2024 12:45:58 +0000

My blog site, still a WIP though, is an Angular build time pre-rendered static site. I chose to develop this blog as a static site as I don't foresee I need dynamic contents, helps with Search Engine Optimization (SEO), and the greatest factor, I can just host this blog site with firebase for free :D

Problem: Async Pipe Not Rendering on the Server Side

During development of this blog site with Angular SSR, I ran into a situation where the HTML returned from the dev server lacked blog content. Although the site was rendering on the server side, the actual content wasn’t visible in the HTML sent from the server; it was only populated on the client side. Here's how my initial setup looked:

Initial Component Code

`blog.component.ts`:

@Component({
  selector: 'app-blog',
  templateUrl: './blog.component.html',
  styleUrl: './blog.component.scss',
})
export class BlogComponent implements OnInit, OnDestroy {
  blog$ = new BehaviorSubject<Blog | undefined>(undefined);
  id$: Observable<string>;
  private subscriptions: Subscription[] = [];

  constructor(
    private readonly blogService: BlogService,
    route: ActivatedRoute
  ) {
    this.id$ = route.params.pipe(map((p) => p['id']));
  }

  ngOnInit(): void {
    this.id$
        .pipe(
            mergeMap((id) => {
                return this.blogService.getBlogById(id).pipe(
                    tap((blog) => {
                        this.blog$.next(blog);
                    })
                );
            })
        )
        .subscribe();
  }
}

`blog.component.html`:

<h1 class="blog-title">{{ (blog$ | async)?.title }}</h1>
<div class="blog-content" [innerHTML]="(blog$ | async)?.content"></div>

Resulting Rendered HTML

Upon viewing the rendered HTML from the server, I saw this:

<h1 class="blog-title"><!--ngEnt--></h1><div class="blog-content"><!--ngEnt--></div>

The missing content meant that the async pipe was not rendering on the server side. After investigating, I found this helpful article, which explained that ngOnInit is rendered synchronously. The server completes rendering before the data is retrieved, causing the async pipe to return undefined.

Solution: Using Angular Resolver to Fetch Data Before Rendering

The solution to this issue is to leverage an Angular Resolver. Resolvers fetch the necessary data before Angular activates a route, allowing SSR to render the content directly without waiting for client-side data retrieval.

Updated Component with Resolver

With the resolver implemented, the updated component code looks like this:

`blog.component.ts`:

@Component({
  selector: 'app-blog',
  templateUrl: './blog.component.html',
  styleUrl: './blog.component.scss',
})
export class BlogComponent implements OnInit, OnDestroy {
  blog$ = new BehaviorSubject<BlogDto | undefined>(undefined);

  constructor(private readonly route: ActivatedRoute) {}

  ngOnInit(): void {
    this.subscriptions.push(
      this.route.data.subscribe((data) => {
        const blog: BlogDto = data['blog'];
        this.blog$.next(blog);
      })
    );
  }
}

Adding the Blog Resolver

The Blog Resolver ensures that the blog content is loaded before the component is activated. Here’s the resolver code:

`blog-resolver.service.ts`:

export class BlogResolverService implements Resolve<BlogDto | undefined> {
  constructor(private readonly blogService: BlogService) {}

  resolve(
    route: ActivatedRouteSnapshot,
    _: RouterStateSnapshot
  ): MaybeAsync<BlogDto | undefined> {
    const blogId = route.params['id'];
    return this.blogService.getBlogById(blogId);
  }
}

Applying the Resolver to Routes

To apply the resolver to your routes, add it to your Angular router configuration. Here’s an example:

const routes: Routes = [
  {
    path: 'blog/:id',
    component: BlogComponent,
    resolve: { blog: BlogResolverService },
  },
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule],
})
export class BlogRoutingModule {}

Final Thoughts on Angular Resolver for SSR

Using Angular Resolver is an effective way to make sure that your SSR-rendered content is loaded and ready to be displayed. This not only improves the user experience but also ensures search engines can index your pre-rendered content. When implemented correctly, a resolver minimizes the need for post-rendering data fetching, making your application more efficient and SEO-friendly.

For further reading, check out the official Angular documentation on resolvers to deepen your understanding.

Link to the original blog post.

How to Set Up Microsoft Office on Linux Mint 21.3: A Comprehensive Guide

Lion The Hoon — Sun, 21 Jul 2024 07:05:38 +0000

Transitioning from Windows to Linux can be both exciting and challenging. While Linux Mint 21.3 offers a smooth and enjoyable experience, the absence of an official Microsoft Office version for Linux can be a significant hurdle for many users. Fortunately, there’s a way to bring Microsoft Office apps like Excel, PowerPoint, and Word to your Linux desktop. In this guide, I’ll walk you through setting up Microsoft Office on Linux Mint 21.3 using WinApps and Docker.

Why No Official Microsoft Office for Linux?

It's understandable to feel frustrated by the lack of a native Microsoft Office version for Linux. However, Microsoft’s decision to focus on Windows and macOS makes sense from a business perspective. If transitioning to Linux were as easy as switching between software, more users might leave Windows for Linux. Thankfully, there are alternative methods to access Office apps on Linux.

Using WinApps to Run Microsoft Office on Linux

While native support is missing, you can still use Microsoft Office on Linux by running it in a Windows environment using WinApps (https://github.com/winapps-org/winapps). WinApps renders Windows applications running on a Windows environment on your Linux desktop with the RDP protocal. I chose to run Windows environment via Docker containers. Here’s how you can set it up:

Step 1: Install Docker on Linux Mint 21.3

Follow the Docker Installation Guide: Linux Mint 21.3 is based on Ubuntu 22.04, so you’ll need to follow the Docker installation steps for Ubuntu Jammy Jellyfish. You can find the official guide here (https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository).
Add Docker’s Official GPG Key and Repository:
- If you encounter errors related to the repository not found for “virginia” (Linux Mint’s code name), you may need to tweak the commands. This error occurs because Docker’s repository does not recognize the “virginia” code name directly. Try the following commands:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(echo "virginia") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Configure Docker to Run as a Non-Root User:
- Create the docker group: sudo groupadd docker.
- Add your user to the docker group: sudo usermod -aG docker $USER.
- Log out and log back in for the changes to take effect.

Step 2: Install the Prerequisites

Clone the WinApps Repository:
- Clone the repository from GitHub: WinApps GitHub Repo.
Install FreeRDP:
- Since FreeRDP 3 is not available in Linux Mint 21.3’s official repository, install it via Flatpak.

flatpak install flathub com.freerdp.FreeRDP
sudo flatpak override --filesystem=home com.freerdp.FreeRDP # To use `+home-drive`

Step 3: Create a Windows Environment in Docker

Configure Docker:
- Use the default configurations, credentials, disk space, RAM, etc., provided in the compose.yaml file or customise it to your liking. Find out more here dockur/windows repo.
Start Your Windows Environment:
- Open your terminal, navigate to the WinApps repo, and run: docker compose up.

Step 4: Install Microsoft Office Apps

Access the Windows Environment:
- Remote into your Windows environment via http://127.0.0.1:8006.
Install a Web Browser:
- Install a browser with Microsoft Store.
Install Office 365:
- Download and install Office 365 as you would on a regular Windows machine.

Step 5: Update Windows Credentials (Optional)

Change the Default Password:
- The default Windows environment credentials are docker with an empty password. Update this password for added security.

Step 6: Use Microsoft Office Apps on Your Linux Desktop

Create a WinApps Configuration File:
- Create a configuration file at ~/.config/winapps/winapps.conf containing the following:

RDP_USER="docker"
RDP_PASS=""
#RDP_DOMAIN="MYDOMAIN"
#RDP_IP="192.168.123.111"
#WAFLAVOR="docker" # Acceptable values are 'docker', 'podman' and 'libvirt'.
#RDP_SCALE=100 # Acceptable values are 100, 140, and 180.
#RDP_FLAGS=""
#MULTIMON="true"
#DEBUG="true"
#FREERDP_COMMAND="xfreerdp"

Run the Install Script:
- Navigate to the WinApps repo and execute: ./setup.sh. Follow the prompts to add Office apps to your Linux desktop.
Additional Applications:
- Only apps from the official supported list will appear. For running other applications, refer to the WinApps readme (https://github.com/winapps-org/winapps?tab=readme-ov-file#running-applications-manually).

Conclusion

Setting up Microsoft Office on Linux Mint 21.3 might seem like a daunting task, but using WinApps and Docker makes it achievable. By following these steps, you can seamlessly integrate Microsoft Office into your Linux environment, allowing you to continue using familiar tools while exploring the benefits of Linux.

Feel free to leave a comment if you have any questions or run into issues during the setup process. Happy computing!

Backup and Restore Linux OS with Rsync

Lion The Hoon — Mon, 08 Apr 2024 13:12:14 +0000

As a Software Engineer tackling challenges in the realm of Software Engineering, I recently encountered the task of efficiently backing up and restoring an Ubuntu OS running on a Single Board Computer (SBC). This seemingly straightforward task proved to be more complex than anticipated, requiring a solution tailored to the unique constraints of SBCs.

Initially, my approach involved exploring tools like Clonezilla for creating OS images. However, the nature of SBCs presented compatibility hurdles that made this traditional method less viable. Fortunately, my search led me to an invaluable resource on GitHub—specifically, the BackupJetson repository.

Inside this repository, I discovered two shell scripts, backup-rootfs.sh and restore-rootfs.sh, designed to streamline the backup and restoration process using Rsync. Rsync, a powerful file-syncing tool, proved to be the linchpin of this solution, offering efficient snapshot creation and restoration capabilities suited for SBC environments.

To put these scripts to the test, I executed sudo bash backup-rootfs.sh -d /recovery/ to generate a root filesystem snapshot within the designated /recovery/ directory. With this baseline in place, I deliberately disrupted the OS—tampering with SSH keys, uninstalling and installing packages—to simulate a compromised state.

With the system in disarray, I then invoked sudo bash restore-rootfs.sh -d /recovery/backup-rootfs-04-08-2024/ and initiated a reboot. This step was crucial, as it allowed for the full restoration of services and configurations essential for the OS's functionality.

Upon reboot, I was delighted to find the OS had reverted to its original, pristine state captured during the backup. This seamless restoration underscores the efficacy of the Rsync-based solution.

In conclusion, the journey to streamline OS backup and restoration on Single Board Computers has been both enlightening and rewarding. Through tools like Rsync and the BackupJetson repository, the once-daunting task of managing OS snapshots on SBCs has become accessible and efficient—a testament to the ingenuity and collaborative spirit of the open-source community.

As a Software Engineer with several years of experience, I often encounter challenges that require unique, context-specific remedies. By sharing these insights through blogging, I aim to contribute to the collective knowledge of the developer community while creating a personal repository of proven strategies.

Stay tuned for more insights and solutions as I continue to explore the fascinating intersection of software engineering and embedded systems!

Using Existing Database Connection's with Entity Framework Core

Lion The Hoon — Thu, 04 Jun 2020 13:48:44 +0000

Entity Framework Core the default ORM that powers many many projects out there. It is great ORM and does its job great.

But some projects use more than one data access libraries. The post will be demonstrating how to use an existing DbConnection with Entity Framework Core.

The following code was tested with:

Dotnet Core 3.1
Entity Framework Core 3.1.2

You could do it...

At Startup.cs

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<MyDbContext>((IServiceProvider serviceProvider, DbContextOptionsBuilder options) => {
        DbConnection connection = // Get your database connection here.
        options.UseSqlServer(connection);
    });
}

At OnConfiguring

public class MyDbContext : DbContext
{
    private readonly DbConnection connection;

    public MyDbContext(DbContextOptions options, DbConnection connection) : base(options)
    {
        this.connection = connection;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        options.UseSqlServer(connection);
    }
}

In your code

var options = new DbContextOptionsBuilder<BloggingContext>()
    .UseSqlServer(new SqlConnection(connectionString))
    .Options;

using (var context1 = new BloggingContext(options))
{
    using (var transaction = context1.Database.BeginTransaction())
    {
        using (var context2 = new BloggingContext(options))
        {
            ...
        }
    }
}

If you hit System.InvalidOperationException: A transaction is already in progress; nested/concurrent transactions aren't supported. while calling SaveChanges(), try the following

ctx.Database.UseTransaction((DbTransaction)transaction); // transaction is returned when you called BeginTransaction()

As per stated in the documentation this only works for relational database only.

Forem: Lion The Hoon

Fixing WebView2 Issues in Linux Bottles: How I Got It Working

The Problem: A Windows App That Needs WebView2 on Linux

The Usual Troubleshooting (and a Lucky Find)

The Solution: Getting WebView2 to Work in Bottles

Step 1: Install Proton GE in Bottles

Step 2: Switch the Bottle Runner to Proton GE

Step 3: Install Required Dependencies

The Result: WebView2 Working Perfectly on Linux

Final Thoughts

How I Made My AMD RX6750XT Work for Machine Learning (Despite ROCm Limitations)

The GPU Regret: AMD vs Nvidia for AI Development

Hacking ROCm Support for RX6700XT/6750XT GPUs

Step 1: Install AMD Drivers & ROCm Runtime

Step 2: User Permissions & Reboot

Step 3: The GFX1031 vs GFX1030 Spoof

Step 4: Making Sure it Works

Final Thoughts

How to Run Windows Applications on Linux Using Bottles: A Step-by-Step Guide

Why Use Bottles

Step 1: Install Bottles via Flatpak

Step 2: Configure Bottles Permissions

Step 3: Install Windows Applications

Step 4: Create Desktop Shortcuts

Conclusion

Using the Decorator Pattern with Autofac for Selective Service Registration

What is the Decorator Pattern?

Why Use the Decorator Pattern?

Registering a Decorator in Autofac

Interface Definition

Command Handler Implementations

The Decorator

Autofac Registration

Output

The Solution: Keyed Services in Autofac

Updated Output

Conclusion

Understanding Linux Shells: Interactive, Non-Interactive, and RC Files

What Are Interactive and Non-Interactive Shells?

Interactive Shell

Examples of Interactive Shells:

Non-Interactive Shell

Examples of Non-Interactive Shells:

Key Shell Configuration Files

Files for Bash

Global Files:

User-Specific Files:

Files for Zsh

How These Files Are Sourced

Interactive Login Shell (e.g., SSH or TTY Login)

Interactive Non-Login Shell (e.g., Terminal Emulator)

Non-Interactive Shell (e.g., Script Execution)

Troubleshooting and Best Practices

Scenario: Missing PATH in Non-Interactive Shell

Best Practices

Conclusion

Fixing SSR Rendering Issues with Angular Resolver for Async Pipe Data

Problem: Async Pipe Not Rendering on the Server Side

Initial Component Code

blog.component.ts:

blog.component.html:

Resulting Rendered HTML

Solution: Using Angular Resolver to Fetch Data Before Rendering

Updated Component with Resolver

blog.component.ts:

Adding the Blog Resolver

blog-resolver.service.ts:

Applying the Resolver to Routes

Final Thoughts on Angular Resolver for SSR

How to Set Up Microsoft Office on Linux Mint 21.3: A Comprehensive Guide

Why No Official Microsoft Office for Linux?

Using WinApps to Run Microsoft Office on Linux

Step 1: Install Docker on Linux Mint 21.3

Step 2: Install the Prerequisites

Step 3: Create a Windows Environment in Docker

Step 4: Install Microsoft Office Apps

Step 5: Update Windows Credentials (Optional)

Step 6: Use Microsoft Office Apps on Your Linux Desktop

Conclusion

Backup and Restore Linux OS with Rsync

`blog.component.ts`:

`blog.component.html`:

`blog.component.ts`:

`blog-resolver.service.ts`: