DEV Community: Rafał Garbowski

Automate copying text from web browser using Bookmarklet or Tampermonkey

Rafał Garbowski — Sat, 11 Jul 2026 14:59:40 +0000

We all have those tiny repetitive tasks that take only a few seconds but somehow add up over time.

For me, one of them is copying GitHub issues into my Obsidian notes. I usually want the following Markdown format:

[Issue title](https://github.com/org/repo/issues/123)

Doing this manually means selecting the title, copying it, copying the URL, and formatting everything. Not difficult—just repetitive.

Option 1: Bookmarklet

A bookmarklet is simply a browser bookmark that runs JavaScript instead of opening a webpage.

Simply select from main menu: Bookmarks -> Manage Bookmarks (Ctrl+Shit+O).
Then right click on Bookmars Toolbar and add new bookmark titled, e.g. "Copy to Obsidian", in URL paste:

javascript:(async()=>{
  const title = document.querySelector('bdi')?.textContent?.trim()
             || document.title.replace(/ · .*$/, '');

  await navigator.clipboard.writeText(
    `[${title}](${location.href})`
  );
})();

Click the bookmark in toolbar while viewing a GitHub issue or pull request, and the formatted Markdown link is immediately copied to your clipboard.

The nice thing is that it works even for private repositories because it operates on the page you've already opened.

Option 2: Tampermonkey

Using Tampermonkey, you can bind the action to a keyboard shortcut.

Here is full script that works for me:

// ==UserScript==
// @name         GitHub -> Obsidian Task
// @namespace    obsidian
// @version      1.0
// @match        https://github.com/*/*/issues/*
// @match        https://github.com/*/*/pull/*
// @grant        GM_setClipboard
// ==/UserScript==

(function () {
    'use strict';

    function getTitle() {
        return document.querySelector("bdi")?.textContent.trim();
    }

    function copyTask() {
        const title = getTitle();
        const url = location.href;

        if (!title) {
            alert("Couldn't find issue title");
            return;
        }

        GM_setClipboard(`[${title}](${url})`);
    }

    document.addEventListener("keydown", e => {
        if (e.ctrlKey && e.altKey && e.key.toLowerCase() === "c") {
            e.preventDefault();
            copyTask();
        }
    });
})();

Now pressing Ctrl+Alt+C copies exactly what I need.

Why I Prefer Tampermonkey

I like bookmarklets because they're simple and require no extensions.

However, I prefer Tampermonkey for small personal automations because:

scripts are easier to organize and maintain,
they can be limited to specific websites,
adding shortcuts or UI elements is straightforward,
they can grow with your workflow without becoming browser bookmark clutter.

One thing I particularly appreciate is that Tampermonkey is a Recommended Extension in Firefox. Mozilla reviews recommended extensions for security, code quality, and privacy, which gives me more confidence than installing a random browser add-on.

OCP 17 Exam passed!

Rafał Garbowski — Sat, 11 Jul 2026 14:49:04 +0000

I finally passed the OCP 17 exam! 🎉

Link to badge

It took me about 1.5 years from start to finish, with plenty of shorter and longer breaks along the way. 😉

Looking back, I think I could have spent less time reading the OCP Study Guide and more time solving practice questions. However, one of my motivations for reading the book was to start an OCP book club at work.

I didn't complete all the practice questions, and my mock exam results weren't great. Still, it was enough to pass. In my opinion, the mock exams were more difficult than the real exam.

I also had two stressful moments on exam day.

Just before the exam, Windows decided to install three updates in a row, each requiring a restart. 😅 I was worried I'd be late.
During the exam, my webcam suddenly stopped working. It was probably a glitch in the exam software because the camera shutter was open, but the indicator light was off. I lost about five minutes explaining the situation to the proctor and was afraid I might lose my exam attempt.

In the end, everything worked out, and I passed! 🚀

What Solving Hundreds of OCP Questions Taught Me

Rafał Garbowski — Sat, 11 Jul 2026 14:48:40 +0000

🧠 1. Think Like the Compiler, Not Like a Developer

As developers, we naturally focus on business logic.

The compiler doesn't.

It doesn't care that your algorithm is correct if:

a variable is declared twice,
a local variable isn't initialized,
you're calling an instance method from a static context,
an abstract class is instantiated,
an overridden method throws a broader checked exception.

Some examples that caught me during preparation:

int value = 1;
int value = 2;   // duplicate local variable

public static void main(String[] args) {
    print();      // print() isn't static
}

abstract class Animal {}
new Animal();     // doesn't compile

One habit helped me a lot:

Before trying to predict the output, always ask: "Does it compile?"

🚫 2. Compilation Always Comes Before Runtime

This sounds obvious.

Yet I repeatedly made the same mistake.

I'd spend a minute calculating the output only to discover that the code didn't even compile.

Sometimes I'd immediately think:

"This throws an exception."

Only to notice later that there was already a compilation error a few lines above.

The OCP exam loves hiding compilation errors inside otherwise perfectly valid code.

👀 3. Read Every Single Word

Some of my mistakes had nothing to do with Java.

I simply didn't read the question carefully enough.

Examples include:

Choose two answers.
Which statement is NOT true?
Which methods can be removed so the code compiles and runs?
Which answer is always correct?

I also remember selecting a perfectly valid answer...

...only to notice afterwards that the question asked for "Compiles and runs", not "Produces the same output."

One word changed everything.

🎭 4. The Exam Loves "Almost Correct" Code

This is probably one of Oracle's favorite tricks.

Everything looks correct except for one tiny detail.

For example:

interface A {
    void test() { }     // missing default
}

record Person(String name) {
    int age;            // instance fields are not allowed
}

@Override
void read() throws Exception { } // broader checked exception

The code looks almost perfect.

That's exactly why it's easy to miss.

🔍 5. Don't Trust Familiar APIs

Many APIs on the exam look familiar.

That's the trap.

Examples I remember getting wrong:

confusing peek() with poll(),
using a class that doesn't actually exist in java.time,
forgetting that Stream.min() returns Optional<T>, while IntStream.min() returns OptionalInt,
mixing up Period and Duration.

Whenever I wasn't 100% sure an API existed, I stopped guessing.

⚠️ 6. Pay Attention to Words Like "Always", "Must", and "Never"

These words completely change the meaning of a sentence.

For example:

constructors must start with this() or super()? (only if they're explicitly called)
default is always required? (not necessarily)
a method must never throw an unchecked exception when overriding? (false)

One word often decides whether the answer is correct.

❌ 7. Eliminate Wrong Answers First

One of the biggest improvements in my exam strategy was learning to eliminate answers before searching for the correct one.

Sometimes I couldn't immediately identify the right option.

But I could confidently reject others because:

the code doesn't compile,
the API doesn't exist,
the modifier isn't legal,
the exception cannot occur.

That was often enough to find the correct answer.

📚 8. Small Language Rules Matter More Than You Think

The OCP exam rewards precision.

Some examples that repeatedly appeared during my preparation:

Duration vs Period
Month.MARCH vs 3
List.of() returns an immutable list
PriorityQueue always removes the smallest element
switch case labels must be compile-time constants
try-with-resources always closes resources before entering catch

None of these rules are difficult.

The challenge is remembering them all under time pressure.

😴 9. Fatigue Creates More Mistakes Than Lack of Knowledge

This was one of the biggest surprises.

After solving many questions in a row, my error rate increased—not because the questions became harder, but because I became less careful.

Typical mistakes included:

missing Choose three answers,
stopping halfway through the code,
assuming indentation affected execution,
overlooking a single final keyword,
forgetting to check every answer because I thought I had already found the correct one.

Sometimes taking a five-minute break was more valuable than solving another twenty questions.

💡 10. Every Question Exists to Test One Rule

Eventually, I stopped asking:

"What's the correct answer?"

Instead, I started asking:

"What rule is Oracle trying to test?"

That small shift completely changed the way I studied.

Instead of memorizing questions, I focused on understanding the language rules behind them.

Once I understood the rule, similar questions became much easier.

🚀 Final Thoughts

Preparing for the OCP exam taught me something unexpected.

The hardest part wasn't learning more Java.

It was learning to slow down.

To read carefully.

To think like the compiler before thinking like a developer.

Ironically, the more experience you have, the easier it is to make assumptions because your brain automatically fills in missing details.

If I could give one piece of advice to anyone preparing for the OCP exam, it would be this:

Slow down. Read every line. Think like the compiler. Only then think like a programmer.

Why I'm Taking the OCP Java 17 Exam in 2026

Rafał Garbowski — Sat, 11 Jul 2026 14:44:39 +0000

Last year I spent a lot of time reading the OCP study guide. I don't want to leave it unfinished, so my goal for 2026 is to finally pass the exam.

These are my reasons.

🧠 I want to finish what I started

I already spent many hours reading the book and solving questions. It would be nice to finish this journey.

🧱 I want to organize my Java knowledge

The exam covers many Java topics. Some of them I use every day, some I don't.

Preparing for the exam helps me refresh what I already know and learn things I have forgotten.

🎯 I want the satisfaction

Passing the exam won't magically make me a better developer.

But I know I'll feel proud after passing it. It is also a nice milestone in my Java journey.

📈 It may help my career

The job market is not as easy as it was a few years ago.

Having an OCP certification won't guarantee a new job or a promotion, but it can help your profile stand out. In a competitive market, every advantage counts.

🤯 It teaches you to read code carefully

The part I like the least is remembering small details from the Java API.

But after solving many practice questions, I think the exam is more about reading code carefully than memorizing everything.

With AI writing more code every day, being able to understand and review code is still an important skill.

💪 It helps me practice focus

After work, I often lose concentration after 4 or 5 PM.

Preparing for the OCP is also a way to practice staying focused for an hour and carefully reading code.

These are my reasons for taking the OCP in 2026.

Maybe they will also convince you to give it a try.

AssertJ custom representation of asserted object

Rafał Garbowski — Sat, 17 Jun 2023 10:13:38 +0000

I really enjoy asserting collections with AssertJ.
Usually it's safer and simpler to use containsExactlyInAnyOrder rather than asserting individual elements (collection.get(0)) - even if there is only one element, because it may change in the future.
The challenge starts when asserting collection containing complex objects, because constructing an entire object as expected element can be tedious.
To extract only certain properties, we can use .extracting(Foo::field1, Foo::field2).

        var players = List.of(
            new Player("Michael Jordan", new Team("Bulls")),
            new Player("Kobe Bryant", new Team("Lakers")));

        assertThat(players)
            .extracting(Player::name, player -> player.team().name())
            .containsExactly(
                tuple("Michael Jordan", "Bulls"),
                tuple("Kobe Bryant", "Lakers"));

However, I tend to concatenate properties to string because I wasn't fond of working with tuples:

        assertThat(players)
            .extracting(player -> player.name() + " | " + player.team().name())
            .containsExactly("Michael Jordan | Bulls",
                "Kobe Bryant | Lakers");

The reason is that, by default, AssertJ provides a generic "tuple" representation in the "actual" section.
When copied, this has to be manually adapted to Java code, which can be inconvenient.

For example:

Expecting actual:
  [("Michael Jordan", "Bulls"),
    ("Kobe Bryant" "Lakers")]

What I want is an "easy-to-copy" representation of the asserted object:

Expecting actual:
  [tuple("Michael Jordan", "Bulls"),
    tuple("Kobe Bryant" "Lakers")]

Fortunately, there's an easy way to globally fix this in 3 simple steps.

Define a custom representation:

class CustomAssertJRepresentation extends StandardRepresentation {

    static final CustomAssertJRepresentation INSTANCE = new CustomAssertJRepresentation();

    @Override
    protected String toStringOf(Tuple tuple) {
        return "tuple" + super.toStringOf(tuple);
    }
}

Then add it to the global configuration:

public class CustomAssertJConfiguration extends Configuration {

    @Override
    public Representation representation() {
        return CustomAssertJRepresentation.INSTANCE;
    }

    @Override
    public String describe() {
        return "CustomAssertJConfiguration applied";
    }
}

Lastly, register the global config in this file: /src/test/resources/META-INF/services/org.assertj.core.configuration.Configuration which will contain:

my.package.CustomAssertJConfiguration

Refer to the official documentation for more information: https://assertj.github.io/doc/#assertj-core-representation

Introducing safe-eyes-cli: strict break reminder based on YAD

Rafał Garbowski — Sat, 08 Apr 2023 16:33:07 +0000

I'm excited to share with you a new tool that I've been using to help protect my eyes while working on my computer. It's called safe-eyes-cli and it's inspired by the popular Safe Eyes application.

It's a "strict" break reminder based on YAD.

A "strict break reminder program" is a software application designed to remind users to take regular breaks from their computer work. It enforces strict rules for breaks, such as locking the screen, displaying full-screen reminders, or disabling input devices during the break period. This ensures that users take breaks and rest their eyes, helping to prevent eye strain, repetitive stress injuries, and promoting overall wellbeing.

The tool is customizable, allowing to set the frequency and duration of breaks.

One of the great things about safe-eyes-cli is simplicity. It's a shell script, that anyone can easily modify and adapt for special needs. Another killer feature is that it can automatically pause during calls, so you don't have to worry about interruptions while you're on an important call.

If you're interested in trying out safe-eyes-cli for yourself, you can find it on GitHub at https://github.com/RG9/safe-eyes-cli. The installation instructions are straightforward and easy to follow.

Let me know if you have any questions or feedback!

Three ways to configure HTTP Proxy in Playwright

Rafał Garbowski — Thu, 23 Mar 2023 23:26:40 +0000

TL;DR

In fact, in Playwright v.1.31.1 there are three ways to configure an HTTP proxy:

chromium.launch
browser.newContext
page.setExtraHTTPHeaders, but works only on Firefox

Today I was struggling with proxy setup for Browserless ...

Official docs says:

Both browserless, and Chrome itself, support the usage of external proxies. In order to fully utilize a 3rd-party proxy you'll need to do two things:

-   Specify the address of where the proxy is with the `--proxy-server` switch.
-   Optionally, you'll also need to send in your username and password if the proxy is authenticated.

Ok, so I need to set --proxy-server. I was using a Docker image to run Browserless locally. I discovered that there is an environment variable called PROXY_URL:

podman run --rm -p 3000:3000 -e "PROXY_URL=my-proxy-url" browserless/chrome:latest

Fine, but how do I pass on the username and password?
Docs say there are two methods:

## Using username and password
### Method 1: page.authenticate
### Method 2: page.setExtraHTTPHeaders

I'm using playwright-java and there is no method page.authenticate, so page.setExtraHTTPHeaders left, I thought.

page.setExtraHTTPHeaders(Map.of("Proxy-Authorization", "Basic "  
   + new String(Base64.getEncoder().encode("username:password".getBytes()))));

Unfortunately, it does not work. I received the following strange error: net::ERR_INVALID_ARGUMENT. Besides there was no errors in container's logs. What's the hack?

Google's top two results for playwright Proxy-Authorization:

I quickly checked the first link. The answer says that there are two ways. I didn't read further, because I thought that I know these ways - one is method I'm struggling with and second chromium.launch, right? :) Later it turned out that I was wrong!

The second link looks like what I need. However issue was closed without any conclusion. The alternative shown, was one that I already knew:

browser = await playwright.chromium.launch(
    proxy={"server": "localhost:8080", "username": "user", "password": ""},
)

The case was that I didn't want to lanuch browser, but rather connect to one created inside container.

I dug even deeper and found another similar issue in Playwright project:
# [Feature] Directly set Proxy-Authorization in Chrome without configuring any other proxy settings

The problem (in Chrome/Chromium anyway) is that Proxy-Authorization may not be set explicitly via extraHTTPHeaders. If you do this and then try to navigate to any page Chrome will give you the following error: net::ERR_INVALID_ARGUMENT.

I was lost, considering changing my approach...

Fortunately, my teammate assisted me by showing some examples of where I found a missing piece:

Browser.NewContextOptions options = new Browser.NewContextOptions()  
   .setProxy(new Proxy("my-proxy-url")  
      .setUsername("username")  
      .setPassword("password"));  
BrowserContext context = browser.newContext(options);

Ta da! As simple as that! 😃

I checked the playwright docs and it appears to be possible:

Proxy can be either set globally for the entire browser, or for each browser context individually.

Unluckily there is no example, so it's hard to spot.

I also double-checked node.js - How do I authenticate a proxy in playwright - Stack Overflow and configuring proxy via browser.newContext was actually there, but I missed it (confused by Browserless docs?):

const browser = await chromium.launch({
    proxy: { server: 'per-context' }
});
const context = await browser.newContext({
    proxy: { server: 'http://myproxy.com:3128' }
})

Getting to the point:
Festina lente ("hurry slowly") and read comprehension!

JUnit's @CsvSource.quoteCharacter

Rafał Garbowski — Sat, 18 Feb 2023 16:40:14 +0000

@CsvSource used with text blocks is really awesome! Similarly to validation files, it can be used to create easily readable tests with readily visible inputs and outputs placed side by side.

For example:

    @ParameterizedTest
    @CsvSource(delimiterString = "->", textBlock = """
        ABC -> abc
        Abc -> abc
        """)
    void toLowercase(String input, String expected) {
        assertThat(input.toLowerCase())
            .isEqualTo(expected);
    }

What recently confused me was the following error:

org.junit.jupiter.api.extension.ParameterResolutionException:
No ParameterResolver registered for parameter [java.lang.String arg1] in method [void MyTest.test(java.lang.String,java.lang.String)].

It came out that it was caused by a parameter value starting with a single quote ', that wasn't closed by another ' at the end of value. In my case the culprit was 'S-GRAVENHAGE, which is Belgian street name.

The solution is to set parameter quoteCharacter to double quote ", provided we are using text block. This way we can test empty string with "".

Example:

    @ParameterizedTest
    @CsvSource(quoteCharacter = '\"', delimiterString = "->", textBlock = """
        'S-GRAVENHAGE -> 's-gravenhage
        "" -> ""
        """)
    void toLowercase(String input, String expected) {
        assertThat(input.toLowerCase())
            .isEqualTo(expected);
    }

I hope it was helpful, cheers!