Tag Archives: technology

How to Fix the GC IPL Error in Dolphin When Using RetroBat

Gaming, Retro, , , , , , , ,

If you’ve ever tried launching a GameCube game through Dolphin and been greeted with the dreaded “GC IPL file could not be found” error, you’re not alone. This issue can be frustrating, especially when everything else seems to be set up correctly. But don’t worry—there’s a simple fix, and we’ll walk you through it.

🧩 What Causes the GC IPL Error?

The error typically stems from a missing or incorrect BIOS file (also known as the IPL file) required for the GameCube boot animation. While the game itself may be perfectly fine, Dolphin attempts to load the BIOS sequence before launching the game—and if it can’t find the right file, it throws an error.

✅ Fixing the Error in Dolphin (Standalone)

If you’re running Dolphin directly (not through RetroBat), you can bypass the BIOS boot sequence entirely by tweaking a simple setting:

  1. Locate your dolphin.ini configuration file.
  2. Open it in a text editor.
  3. Find the line that says SkipIPL.
  4. Set it to True.

ini

[Core]
SkipIPL = True

This tells Dolphin to skip the BIOS animation and jump straight into the game—no IPL file needed.

🔄 Fixing the Error in Dolphin via RetroBat

If you’re using RetroBat as your frontend, the fix is slightly different. RetroBat tends to overwrite Dolphin’s configuration files each time you launch a game, so editing dolphin.ini manually won’t stick.

Instead, you need to configure RetroBat itself to skip the BIOS:

  1. Launch RetroBat and press Start to open the Main Menu.
  2. Navigate to: Game Settings > Per System Advanced Configuration
  3. Select the console you’re working with (e.g., GameCube).
  4. Go to: Emulation > Skip Bios
  5. Set it to Yes.

This ensures that RetroBat tells Dolphin to skip the IPL sequence every time, avoiding the error altogether.

🎮 Final Thoughts

The GC IPL error might seem like a showstopper, but it’s really just a BIOS boot hiccup. Whether you’re using Dolphin standalone or through RetroBat, skipping the IPL sequence is a quick and effective workaround. Now you can get back to what matters—playing your favorite GameCube classics without interruption.

Got other emulation quirks you’re trying to solve? Drop them in the comments or reach out—I’m always up for a good retro tech fix.

Comprehensive Guide to Helping an Ai Coding Agent Identify and Avoid Common Coding Bad Practices

Ai, Coding, Development, How To, , , , , , , , , , , ,

Introduction

In large projects, subtle anti-patterns can slip through reviews—like importing modules mid-file or conditionally. These non-standard import placements obscure dependencies, make static analysis unreliable, and lead to unpredictable runtime errors. This web article dives into that practice, outlines a broader set of coding bad practices, and even provides a ready-to-use AI coding agent prompt to catch every issue across your codebase.

What Is Non-Standard Import Placement?

Imports or require statements buried inside functions, conditional branches, or midway through a file violate expectations of where dependencies live. Best practices and most style guides mandate that:

  • All imports sit at the top of the file, immediately after any module docstring or comments.
  • Conditional or lazy loading only happens with clear justification and documentation.

When imports are scattered:

  1. Static analysis tools can’t reliably determine your project’s dependency graph.
  2. Developers hunting for missing or outdated modules lose time tracing hidden import logic.
  3. You risk circular dependencies, initialization bugs, or runtime surprises.

A Broader List of Coding Bad Practices

Below is a table of widespread anti-patterns—some classic hygiene issues and others that modern AI agents might inject or overlook:

Bad PracticeDescription
Spaghetti CodeCode with no clear structure making maintenance difficult.
Hardcoding ValuesEmbedding constants directly instead of using config or constants.
Magic Numbers/StringsUsing unexplained literals instead of named constants.
Global State AbuseOverusing global variables causing unpredictable side effects.
Poor Naming ConventionsUsing vague or misleading variable and function names.
Lack of ModularityWriting large monolithic blocks instead of reusable functions.
Copy-Paste ProgrammingDuplicating code rather than abstracting shared logic.
No Error HandlingIgnoring exceptions or failing to validate inputs.
OverengineeringAdding unnecessary complexity or abstraction.
Under-documentationFailing to comment or explain non-obvious logic.
Tight CouplingMaking modules overly dependent on each other.
Ignoring Style GuidesNot following language-specific conventions or style guides.
Dead CodeLeaving unused or unreachable code paths in the codebase.
Inconsistent FormattingMixing indentation styles or inconsistent code layout.
Not Using Version Control ProperlyCommitting broken code, poor commit messages, ignoring branching.
Non-standard Import PlacementPlacing imports mid-file or conditionally instead of at the top.
Missing Security ChecksOmitting authentication, authorization, or input sanitization.
Inefficient AlgorithmsUsing suboptimal logic that hurts performance.
Hallucinated DependenciesReferencing non-existent libraries or methods from AI suggestions.
Incomplete Code GenerationLeaving functions or loops unfinished due to AI cutoffs.
Prompt-biased SolutionsGenerating code that only fits the prompt and fails general cases.
Missing Corner CasesOverlooking edge cases and error conditions in logic.
Incorrect Error MessagesProviding vague or misleading error feedback to users.
Logging Sensitive DataWriting confidential information to logs without sanitization.
Violating SOLID PrinciplesBreaking single responsibility or open/closed design rules.
Race ConditionsFailing to handle concurrency leading to unpredictable bugs.

Crafting an AI Coding Agent Prompt

To ensure an AI auditor doesn’t skip files, ignore edge cases, or take shortcuts, use the following prompt. It instructs the agent to comprehensively scan every line, record each finding, and tally occurrences of every bad practice.

## Prompt

You are an expert AI code auditor. Your mission is to exhaustively scan every file and line of the codebase and uncover all instances of known bad practices. Do not skip or shortcut any part of the project, even if the code is large or complex. Report every finding with precise details and clear remediation guidance.

## Scope
- Analyze every source file, configuration, script, and module.
- Treat all code as in-scope; do not assume any file is irrelevant.

## Bad Practices to Detect
- Spaghetti Code
- Hardcoding Values
- Magic Numbers/Strings
- Global State Abuse
- Poor Naming Conventions
- Lack of Modularity
- Copy-Paste Programming
- No Error Handling
- Overengineering
- Under-documentation
- Tight Coupling
- Ignoring Style Guides
- Dead Code
- Inconsistent Formatting
- Improper Version Control Usage
- Non-standard Import Placement
- Missing Security Checks
- Inefficient Algorithms
- Hallucinated Dependencies
- Incomplete Code Generation
- Prompt-biased Solutions
- Missing Corner Cases
- Incorrect Error Messages
- Logging Sensitive Data
- Violating SOLID Principles
- Race Conditions

## Analysis Instructions
1. Traverse the entire directory tree and open every file.
2. Inspect every line—do not skip blank or comment lines.
3. Identify code snippets matching any bad practice.
4. For each instance, document:
   - File path
   - Line number(s)
   - Exact snippet
   - Bad practice name
   - Explanation of why it’s problematic
   - Suggested refactoring

5. Keep a running tally of occurrences per bad practice.

## Output Requirements
- Use Markdown with a section per file.
- Subheadings for each issue.
- End with a summary table listing each bad practice and its total count.
- If the repo is too large, process in ordered batches (e.g., by folder), confirming coverage before proceeding.
- Do not conclude until every file has been reviewed.

Begin the full project audit now, acknowledging you will not take shortcuts.

Next Steps

  • Integrate this prompt into your AI workflow or CI pipeline.
  • Pair it with linters and static analyzers (ESLint, Flake8, Prettier) for automated, real-time checks.
  • Enforce code review policies that catch both human and AI-introduced anti-patterns.

By combining clear style guidelines, automated linting, and an uncompromising AI audit prompt, you’ll dramatically improve code quality, maintainability, and security—project-wide.

How to fix a noisy GPU fan

uncategorised, , , , , , , , , , , , ,

If you have an old GPU and you have noticed it is creating more noise now than when it was first installed, it may be because the bearing is no longer sufficiently lubricated.

A new fan off EBay, or new to you, might not be a sound investment. This is true assuming you can even find a replacement. Luckily most GPU fans can be serviced.

To Lubricate the Fan Bearing:

Remove the GPU from your computer.

Spin the fan manually. If it is not mostly silent, then there is a problem with the bearing. More than likely, there is just insufficient lubricant.

Carefully peel back the sticker on the top of the fan to expose the bearing. If access to the bearing is not provided on the top of the fan, then remove the fan from the GPU housing. Peel back the sticker on the back of the fan. If you see a yellowish mark on the inside of the sticker where the bearing is, this confirms the lubricant has leaked somewhat. If access to the bearing is not provided at the bottom of the fan either then very carefully try to remove the blade.

Once the bearing is exposed apply a small drop of light machine oil or sewing machine oil to the bearing. Singer oil is a good choice.

Rotate the fan manually to work the oil into the bearing.

Replace the sticker or use a small piece of tape to cover the bearing.

Before reinstalling the GPU, you might consider also applying fresh thermal paste to the GPU processor. This will help keep temperatures down, giving the fan less work to do.

How to add Android as a separate platform in Daijisho

Android, Gaming, Retro, , , , , , , , , ,

Copy the text below and save it as Android.json

{
    "databaseVersion": 8,
    "platform": {
        "name": "Android",
        "uniqueId": "android",
        "shortname": "android",
        "description": null,
        "acceptedFilenameRegex": "^.*$",
        "scraperSourceList": [
            "RAW:Android"
        ],
        "boxArtAspectRatioId": 0,
        "useCustomBoxArtAspectRatio": false,
        "customBoxArtAspectRatio": null,
        "screenAspectRatioId": 0,
        "useCustomScreenAspectRatio": false,
        "customScreenAspectRatio": null,
        "retroAchievementsAlias": null,
        "extra": ""
    },
    "playerList": [
        {
            "name": "android - activity component player",
            "description": "Android activity component player",
            "acceptedFilenameRegex": "^$",
            "amStartArguments": "-n {android.activity}\n",
            "killPackageProcesses": false,
            "killPackageProcessesWarning": true,
            "extra": ""
        }
    ]
}

Open Daijishou > Settings > (Under All settings) Library > Import Platform > Select the Android.json file.

Now go to the Android Platform > Path > Sync

Note: It is not an official platform and you can flag whether an app is a game or not if you go to daijisho apps section and then long press on an app and mark it as a game/not a game. It will show up in this android platform after syncing. By default the emulators themselves will likely be wrongly flagged as games.

Android TV Sticks, the time is now!

Android, , , , , , , , ,

So what am I talking about?

Potentially the future of how we surf the web while sat on the couch.

Android TV Sticks (aka Android Mini PCs, aka Android TV Dongles) are about the size and shape of an overfed USB flash drive but they don’t just store files.

Android TV Stick example

They’re actually tiny computers in themselves that run an Android operating system, generally version 4.2, and accept input from USB, SD cards and Bluetooth devices like mice, keyboards and gamepads. Plug the stick into your TV via the HDMI port and you can run Android apps on the big screen.

To clarify they’re essentially powerful phones/tablets without the display (which is the expensive bit) making them really cheap, around $70. The thumb sized MK802, was first brought to market in May 2012 but I held back as the hardware was pretty underwhelming for the work the device would have to do.

But that’s changed with the very recently released quad-core processor models (think 4 brains instead of 1) capable of outputting Full HD display smoothly and powering through graphically intensive games.

(To give you an idea of performance I recently downloaded and installed a 1 GB game while watching an episode of Breaking Bad stored on a flash drive with no issues.)

So why is that cool?

Well think about the apps out there on Google play, you have Facebook & Twitter, Netflix, VLC & MX Player, Spotify, Apollo & Double Twist, Youtube, Chrome & Firefox, Quickoffice NOT TO MENTION ALL THE GAMES THAT ARE FREE TO PLAY!!!

This magical little box turns your TV into a web browser, media player and games console (and if you like looking at spread sheets and word docs on a screen while sat across the room, you can use it for the traditional boring PC stuff too).

You’re effectively making your TV smart (really smart) without spending the extra few thousand clams. And think about this, your big flat screen full HD TV is a capital purchase, that bad boy is going to be bolted to your living room wall for a few years at least. But computers stop being at the forefront of technology within a couple of weeks. Spend a small fortune on a Smart TV and by the end of the year it’ll probably start to seem pretty stupid.

But, so far, Android TV Sticks have proven to be so cheap you can get the next model in six months time which will probably have doubled in brain power. I’m already looking forward to getting my hands on one of the next octa-core models.

So why haven’t you heard of these awesome little contraptions before?

Currently there is lack of big player interest from the likes of Google, Samsung, LG etc. (If anything these relatively new and mysterious devices work against the product portfolios of the big boys).

Production is cornered mainly by little known or unnamed Chinese manufacturers, shrouded in oriental mystery . . . for legal reasons . . . using the Chinese rockchip processor. Some of the devices don’t even ship with any branding. Possibly a legal thing (the eyes of g-oo-gle are ever watchful) or perhaps the manufactures just want to pass the savings of sparse branding onto the customer. Some company names you may have heard batted about though (if you hang out with tech nerds) are Rikomagic and Tronsmart which would be considered reputable (by said nerds).

Another possible reason you might not have heard of these “things” is nobody seems to know what to call them! So here’s my attempt at making a name stick (WORD PLAY!), Android TV Sticks, shall be henceforth known as A.T.S’s.

A.T.S. sounds kinda like TV jargon don’t ya think? Like VHS, DVD or AV cable.

Let’s take it for a spin:

  • I got a new 4.4 ATS.
  • The video playback on this new ATS model is awesome.
  • I’ve put my old ATS in the microwave to see if it explodes.

Yep ATS sounds right.

So you may have heard of the Google Chromecast, so what’s the difference?

Although visually similar, Chromecast and Android sticks have little in common. The Chromecast is simply a receiver. It enables you to transmit/mirror your Chrome tab from your computer or broadcast certain apps from your Android or iOS device to your TV.

That’s all.

The Chromecasts currently retail at around $35 and the ATS’s start at around $70 but if you’re thinking the ATS’s are expensive by comparison you’re forgetting you’re getting an entirely separate computer you can use independently.  It would be like comparing the price of a set of tyres to the price of car. In the same way tyres don’t get you from A to B without the rest of the vehicle the chromecast displays nothing unless you have a device to transmit to it.

Conclusion

I think ATS’s make a pretty compelling argument for themselves. If you have a few clams to spare and you know how to set up an android phone you should give one a try.