DEV Community: Andreas Sander

Ferrico - Taking My Bookmarks Back Home with Tauri and Rust

Andreas Sander — Mon, 15 Jun 2026 20:25:56 +0000

Hello developers,

Today I would like to talk about a tool I have been building in the open: Ferrico. It is a desktop bookmark manager, but the interesting part is where your bookmarks live - and it is not in someone else's cloud.

The itch was a very ordinary one. My bookmarks were scattered across three browsers, two devices and one read-it-later service that had quietly started rate-limiting my free account. Every one of them wanted an account, sold me sync as a feature, and politely held my own links hostage behind a login. So I did what I always end up doing: I built my own thing and learned a lot on the way.

What does "local-first" even mean?

Before we dive into code, let us define the term, because the whole project hangs on it:

Local-first software [...] gives users full agency over their own data. [...] The availability of another computer should never prevent you from working.
-- Ink & Switch, "Local-first software"

That is the whole pitch. Ferrico stores everything in a single SQLite file on your machine. No account, no telemetry, no Ferrico-operated backend anywhere. The network is something you can opt into, never something you depend on.

Why build my own (again)?

Let us be honest - the world does not need another bookmark manager. But I wanted three things at once, and nothing on the market gave me all of them:

Ownership: my links in a file format I can read, back up and grep ten years from now.
A native footprint: not a 300 MB Electron app idling at 400 MB of RAM to show me a list.
Something to learn: I had been itching to write real Rust instead of toy examples.

That third point is the honest one. Just like with Back2Roots, my home-grown static site generator, half the motivation was simply to get my fingers dirty with a stack I wanted to understand better.

The stack

Layer	Technology
Shell	Tauri 2 (Rust)
Frontend	React 19, TypeScript, Vite, Tailwind 4
Storage	SQLite via `rusqlite`
Extension	A loopback `axum` server
Tooling	Bun for the JS side

Tauri is the star here. Instead of bundling a whole Chromium like Electron does, it uses the operating system's own webview and ships a small Rust binary next to it. You write your UI in plain web tech, and anything that touches the disk, the database or the OS goes through Rust commands. The result is an installer measured in single-digit megabytes instead of hundreds.

A single file you actually own

The data layer is intentionally boring, and that is the point. One SQLite database, in the place your OS expects it:

Linux    ~/.local/share/ferrico/ferrico.db
macOS    ~/Library/Application Support/ferrico/ferrico.db
Windows  %APPDATA%\ferrico\ferrico.db

Because it is just SQLite, fuzzy search across titles, URLs and page content is a query, not a service. Import and export are lossless JSON snapshots, so you are never locked in - and for the migration day there is Netscape HTML, OPML and CSV on top. A bookmark manager whose export button actually round-trips: revolutionary, I know.

The browser extension problem

Here is the part I found genuinely fun to solve. A bookmark manager is useless if saving the current tab means alt-tabbing to a separate app. You want a button in the browser. But the browser and a native Tauri app live in two different worlds and cannot just call each other.

The trick: Ferrico runs a tiny HTTP server inside the Rust process, bound to loopback only.

// Bound to 127.0.0.1 - never reachable from the network.
let listener = TcpListener::bind("127.0.0.1:59432").await?;
axum::serve(listener, app).await?;

The Manifest V3 extension then POSTs the current tab to http://127.0.0.1:59432, authenticated with a token you copy out of the app's settings. Two important properties fall out of this:

It never leaves your machine. The socket is bound to 127.0.0.1, so nothing on your LAN - let alone the internet - can reach it.
It is explicit. No pairing handshake, no account; the extension only works once you paste the token.

Loopback-only plus a shared secret is a humble pattern, but for a one-user desktop tool it is exactly the right amount of security: enough to stop a random page from talking to your library, not so much that you need a login server to manage it.

Optional, never required

Two features deliberately sit outside the local core, and both are off by default.

Cloud sync is a lossless JSON snapshot in your Google Drive, using OAuth credentials you create, scoped to drive.file so the app can only touch its own files. Conflict resolution is deliberately dumb - last write wins, one machine at a time. No clever CRDT, no Ferrico server in the middle. You own the OAuth app; I never see a byte.

AI features lean on the Claude CLI if - and only if - it happens to be on your PATH. Natural-language search, auto-sorting the inbox, mapping messy CSV columns on import. When you explicitly invoke one of these, the relevant bookmark metadata is handed to your local claude binary, which talks to Anthropic on your behalf. No invocation, no network call. The intelligence is a guest in the house, not the landlord.

Let us be honest about the trade-offs

No free lunch, as always:

Sync is primitive on purpose. Last-write-wins means if you edit on two machines between syncs, one set of edits loses. For a personal bookmark stash that is a fine trade; for a shared team tool it would not be.
Local-first means you own the backups too. There is no magical cloud safety net unless you switch one on. Your file, your responsibility.
It is young. Ferrico is happily sitting at v0.x (currently v0.9.0). Desktop runs on macOS, Linux and Windows; Android is still very much a work in progress.

But for me the deal is worth it. My bookmarks are a file I can see, search instantly, back up however I like, and read without asking anyone's permission.

It is open-source!

Ferrico is published on GitHub under the GPL-3.0-or-later license, and there is a live demo if you would like to click around before installing anything. Want to build it yourself? It is the usual two lines:

bun install
bun tauri dev

Feel free to fork it, file an issue, or send a feature request. And if you have been looking for an excuse to write some Rust - this is a very welcoming one.

Cheers,

Andi 🔖

[Boost]

Andreas Sander — Tue, 12 May 2026 23:16:08 +0000

DigitalOcean for DigitalOcean

May 12

Python Decorators: From Basics to Real-World Use Cases

#ai #python #tutorial #learning

11 min read

A Letter to My Younger Self

Andreas Sander — Thu, 15 Jan 2026 17:15:09 +0000

This could be a letter to my younger self as a starting frontend developer, sharing insights and lessons learned over the years. But maybe it could also be a letter to anyone starting out in the field, offering encouragement and advice.

Dear Younger Me,

I hope this letter finds you well. As I sit down to write this, I am reflecting on the journey I have taken as a frontend developer. It has been a transformative experience, and I am grateful for the lessons I have learned along the way.

Embrace A Healthy Portion of Curiosity

Curiosity and willingness to explore new technologies and approaches are essential traits for any developer due to the nature of software development. Don't be afraid to experiment with things outside your comfort zone, but keep it on a healthy level. Don't get lost in the endless sea of new frameworks and libraries; instead, focus on mastering the fundamentals first. In the beginning the fear of missing out (short FOMO) can be overwhelming, but remember that true growth comes from deep understanding, not just surface-level knowledge of the latest trends.

Focus on Fundamentals

During your career you will ALWAYS come back to the fundamentals. Whether it is a specific piece of code of a framework that you are using, or a general concept like accessibility or performance optimization, the fundamentals will always be your foundation. Invest time in understanding HTML, CSS, and JavaScript deeply. These are the building blocks of everything you will create. And believe me that browsing MDN Web Docs will always bring new HTML tags, CSS properties, and JavaScript functions to your attention. For fun and learning you can try something like Powerpoint karaoke: Pick a random MDN article and talk about it for a few minutes as if you were teaching it to someone else – The WorkingDraft "Gluecksrad" is your friend here.

Build Side Projects Whenever Possible

Side projects are invaluable for learning and growth. They allow you to apply what you've learned in a practical way and explore new ideas without the constraints of a work environment. Don't be afraid to start small; even simple projects can teach you a lot. Over time, these side projects will become a portfolio that showcases your skills and creativity. You will never imagine that a weekend project will end up in a tool used by thousands of developers worldwide.

Network and Connect with Others

Go to meetups, join conferences and try to keep in touch with those people you meet and feel connected to. The developer community is full of talented and passionate individuals who are eager to share their knowledge and experiences. Building a network of peers can provide support, inspiration, and opportunities for collaboration. Don't hesitate to reach out to others for advice or mentorship; most people are happy to help. Especially if you are an introvert like me, try to push yourself a little bit out of your comfort zone. The connections you make can lead to new opportunities and friendships that will enrich your career and personal life.

Between meeting offline, consider also joining online communities like Dev.to, Hashnode where you can engage in discussions, ask questions, and share your own experiences.

Use AI as a further tool in your toolbox

Instead of vibe coding all the way down, be eager to learn how AI can help me. Use it as a further tool in your toolbox, not as a replacement for your own skills. Also review with care and always keep understanding of what is generated. But be open to embrace AI tools as any other tool that can help you as a developer.

Have a counterpart outside of coding

In the tech industry it is easy to get lost in the code and the next big thing, especially when you work remotely where boundaries between work and private life can blur.

Your private life and human, non-digital interactions are essential for your well-being and overall happiness. Make sure to nurture relationships outside of work, pursue hobbies, and take time to disconnect from screens. Your back, eyes and in general your body will thank you.

A balanced life will not only make you a happier person but also a more effective and creative developer.

Desk work is poison for your body

Remember to take care of your physical health. Sitting for long hours can lead to various health issues. Make it a habit to take breaks, stretch, and move around regularly. Consider incorporating exercise into your routine, whether it's a daily walk, having a big garden or hitting the gym. Following this in your 20s and 30s will pay off in your 40s and 50s.

Self-hosting a Mastodon Instance on a Hetzner Server

Andreas Sander — Sun, 10 Aug 2025 20:23:07 +0000

Running your own Mastodon instance gives you full control over moderation, data storage, and community tone. This guide walks through the basic steps to deploy Mastodon on a Hetzner virtual server using a generic domain such as example.social.

1. Prepare the server

Provision an Ubuntu 22.04 LTS VPS at your provider of choice.
Update packages and install the dependencies listed in the official installation guide:

   sudo apt update && sudo apt upgrade -y
   # install packages as described in the docs

Create a dedicated user and switch to it:

   sudo adduser mastodon
   sudo usermod -aG sudo mastodon
   su - mastodon

2. Install Mastodon

Clone the repository and install Ruby/Node dependencies.

git clone https://github.com/mastodon/mastodon.git live
cd live
# checkout latest stable tag
git checkout $(git tag -l | grep -v rc | tail -n 1)

# install Ruby gems
gem install bundler
bundle config set deployment 'true'
bundle config set without 'development test'
bundle install

# install JS packages
yarn install --frozen-lockfile

3. Configure environment variables

Copy the example configuration and adapt it:

cp .env.production.sample .env.production

Edit .env.production and set values for your instance:

LOCAL_DOMAIN=example.social

DB_HOST=/var/run/postgresql
DB_USER=mastodon
DB_NAME=mastodon_production
DB_PASS=change-me

REDIS_URL=redis://localhost:6379/1

# Optional: object storage
S3_ENABLED=true
S3_BUCKET=example-bucket
S3_ENDPOINT=https://us-east-1.example-object-storage.com
S3_HOSTNAME=files.example.social

4. Database and assets

Set up the database and precompile assets:

RAILS_ENV=production bundle exec rails db:setup
RAILS_ENV=production bundle exec rails assets:precompile

Tip: If asset compilation fails due to lack of memory, add swap:
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

5. Systemd services

Create service files for the three Mastodon processes (mastodon-web, mastodon-sidekiq, mastodon-streaming) as documented in the official guide. After placing the files under /etc/systemd/system/, reload and start them:

sudo systemctl daemon-reload
sudo systemctl enable --now mastodon-web mastodon-sidekiq mastodon-streaming

You can manually restart them at any time:

sudo systemctl restart mastodon-web mastodon-sidekiq mastodon-streaming

Logs are available via journalctl:

journalctl -u mastodon-web -f

6. Nginx and TLS

Create an Nginx config in /etc/nginx/sites-available/mastodon and link it to sites-enabled.
The config should proxy requests for example.social to the Mastodon services and optionally expose an alias such as files.example.social for object storage.

Enable HTTPS with Let's Encrypt:

sudo certbot --nginx -d example.social -d files.example.social

Certificates renew automatically via a cron job, but you can trigger it manually with certbot renew.

7. Backups

Combine regular PostgreSQL dumps with BorgBackup to create encrypted, deduplicated archives.

Install Borg and initialise a repository on remote storage:

   sudo apt install borgbackup
   export BORG_REPO=ssh://user@backup.example.com/~/mastodon-borg
   borg init --encryption=repokey $BORG_REPO

Create a backup script (/root/backup-mastodon.sh):

   #!/bin/bash
   set -euo pipefail
   DATE=$(date +%Y-%m-%d)

   pg_dump --username=postgres --format=c mastodon_production > /tmp/db.dump

   borg create --compression zstd,3 \
     $BORG_REPO::${DATE} \
     /home/mastodon/live/.env.production \
     /tmp/db.dump \
     /home/mastodon/live/public/system

   borg prune --keep-daily=7 --keep-weekly=4 --keep-monthly=12 $BORG_REPO
   rm /tmp/db.dump

Schedule it nightly via cron:

   sudo crontab -e
   0 1 * * * /root/backup-mastodon.sh

This script dumps the database, backs up configuration and media files, prunes old archives, and removes temporary dumps. Store a .pgpass file in /root to avoid interactive passwords.

8. Automated cleanup

Ricard Torres suggests running periodic tootctl tasks to purge unused media and cache files. Create /home/mastodon/cleanup.sh:

#!/bin/bash
RAILS_ENV=production /home/mastodon/live/bin/tootctl accounts prune
RAILS_ENV=production /home/mastodon/live/bin/tootctl statuses remove --days 4
RAILS_ENV=production /home/mastodon/live/bin/tootctl media remove --days 4
RAILS_ENV=production /home/mastodon/live/bin/tootctl media remove --remove-headers --include-follows --days 0
RAILS_ENV=production /home/mastodon/live/bin/tootctl preview_cards remove --days 4
RAILS_ENV=production /home/mastodon/live/bin/tootctl media remove-orphans

Run it weekly with cron:

crontab -e
0 3 * * 0 /home/mastodon/cleanup.sh

These commands reclaim disk space by pruning remote accounts, old statuses, cached media, and orphaned files.

9. Useful links

With the basics in place, you can now invite users, theme your instance, or automate maintenance tasks. Happy federating!

Nice #howto #article on how to clear #systemd journal #logs https://linuxhandbook.com/clear-systemd-journal-logs/

Andreas Sander — Mon, 14 Jul 2025 19:51:45 +0000

Exploring HTMX Integration with Go Backend

Andreas Sander — Wed, 17 Jan 2024 21:01:38 +0000

Hello developers,

Let's dive into the practicalities of combining HTMX with a Go backend for web development. This approach aims to provide a practical, balanced enhancement to web applications.

Getting Started

HTMX introduces simplicity and effectiveness to web development. Integrating it with a Go backend can offer a responsive user experience. We'll go through the setup, exploring how these technologies can be employed together.

Example Demo on GitHub

For those eager to experiment, there's a simple demo available on GitHub. The repository contains code snippets and configurations, offering a hands-on experience to understand the integration process.

YouTube Overview

Additionally, there's a brief overview on YouTube, providing insights into HTMX. While it's not a tutorial, it serves as an introductory glimpse into what HTMX brings to the table.

Why HTMX with Go?

Streamlined AJAX Integration: HTMX simplifies AJAX integration directly into HTML, reducing reliance on complex JavaScript.
Leveraging Go's Concurrency Model: Utilize Go's concurrency model to efficiently handle multiple connections, ensuring a responsive user experience.
Maintainability and Readability: Combining HTMX with Go results in clean, readable code, facilitating collaboration and scalability.

Conclusion

In summary, the combination of HTMX with a Go backend shows promise for web development. The GitHub repository provides a simple demo for practical exploration, and the YouTube overview offers a glimpse into HTMX's capabilities. Feel free to adapt and integrate these technologies as needed for your projects. Happy coding!

Bridging Communities: An Overview of the WordPress ActivityPub Plugin

Andreas Sander — Thu, 26 Oct 2023 13:00:00 +0000

Bridging Communities: An Overview of the WordPress ActivityPub Plugin

In a world constantly growing more interconnected, online communities are flourishing on various platforms. As a byproduct of this digital evolution, there's a rising need for diverse platforms to interact seamlessly with each other. This is where protocols like ActivityPub play a pivotal role by promoting cross-platform interactions. For WordPress, a platform that powers a significant portion of the web, integrating with ActivityPub through plugins is a strategic advancement. This post delves into the WordPress ActivityPub plugin, highlighting its features, installation process, and the benefits it brings to the table.

What is ActivityPub?

ActivityPub is a decentralized social networking protocol that enables various platforms to communicate with each other. Through ActivityPub, users on one platform can follow, update, and interact with users on another platform seamlessly. This interoperability breaks down silos and cultivates a more inclusive digital ecosystem.

WordPress Meets ActivityPub

The WordPress ActivityPub plugin transforms your WordPress site into a federated social network member. Once installed and activated, your website can interact with other platforms that support the ActivityPub protocol, like Mastodon, Pleroma, or PeerTube.

Features of the WordPress ActivityPub Plugin

1. Cross-platform Communication:

The primary advantage is the ability to communicate across different platforms, expanding your site's reach and engagement.

2. Follow and Be Followed:

Users can follow your WordPress site and receive updates, and vice versa.

3. Comment Synchronization:

Comments can be synced between your WordPress site and federated networks, maintaining a cohesive discussion thread.

4. Customizable Activity Streams:

Tailor the information you share and receive by customizing your activity streams.

Installation Process

Installing the WordPress ActivityPub plugin is straightforward. Navigate to the 'Plugins' section in your WordPress dashboard, click on 'Add New', and search for 'ActivityPub'. Click 'Install' and then 'Activate'.

The Bigger Picture

The integration of ActivityPub in WordPress via this plugin is more than just a technical enhancement; it's a step towards a more open and interconnected digital community. By bridging the gap between WordPress and the Fediverse, website owners can now partake in a larger, diversified conversation, fostering a sense of global digital camaraderie.

The WordPress ActivityPub plugin is a testament to the open-source spirit, embodying the ethos of community, collaboration, and freedom that the digital realm can aspire to.

As digital landscapes continue to evolve, the incorporation of protocols like ActivityPub will increasingly become the norm rather than the exception, paving the way for a more inclusive and interactive web.

Automatic Minimum Size of Flex Items

Andreas Sander — Wed, 11 Oct 2023 14:07:00 +0000

Today I would like to talk about flexbox and the automatic minimum size of flex items, means how the flexbox algorithm is internally calculating the minium size of flex child elements aka. flex items.

Example

Let us start looking at some example code:

<section>
  <div>
    Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
    eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
    voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
    clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit
    amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam
    nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed
    diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
    clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit
    amet.
  </div>
</section>

section {
  display: flex;
  flex-direction: column;
}

div {
  flex: 0 1 50px;
}

What do you think? How much will the height be of the div flex child? It will be the minimum size the content will need to be rendered.

Example (Overflow container)

Let us adjust the example by making the flex-child element a scroll container on its own:

div {
  flex: 0 1 50px;
  overflow-y: scroll;
}

What will the height be now? It will be the flex-basis of 50px.

Explanation

Why is that you my ask and I asked that myself several times. Having a look into the official specs can be helpful here:

To provide a more reasonable default minimum size for flex items, the used value of a main axis automatic minimum size on a flex item that is not a scroll container is a content-based minimum size; for scroll containers the automatic minimum size is zero, as usual.
-- W3C spec

Thus this means:

For non-scroll containers, flexbox automatically increases the main axis minimum size to fit the content's needs
For scroll containers, flexbox sets the minimum size to zero

Summary

Flexbox is a great standard for flexible layouts. But especially on column based layouts I always have to remember myself about the situation shown above, that I need to specify a min-height to make sure that the element is not increasing its height to fit the content. It always sounds counter intuitive to me, thus it is always good to read again through the specification in such kind of situations.

I hope this was also helpful to you.

Greets,

Andi

Container Queries in CSS: The Cool New Kid on the Block

Andreas Sander — Sun, 08 Oct 2023 19:30:00 +0000

Hey there, web design fans! Have you ever pulled your hair out trying to make a design look great on every screen size? Well, guess what? The web design world is abuzz with something new and exciting, and it's about to make your life a whole lot easier. Say hello to container queries in CSS!

What's the Big Deal About Container Queries?

Let's break it down. In the past, if you wanted to change how something looked based on the size of the browser window, you'd use media queries. They were like magic wands for making sites look good on any device. But they were more like a one-size-fits-all solution.

Now, container queries have come onto the scene, and they're more like having a tailor-made suit. Instead of looking at the whole browser window, container queries look at the size of the container an element is in. That means you can have more control and flexibility.

A Quick Peek at How They Work

Here's a super simple example:

.container {
  resize: both;
  overflow: auto;
  contain: layout inline-size;
}

@container (min-width: 500px) {
  .child {
    background: lightblue;
  }
}

With this, the inside element gets a fancy light blue background if the container is at least 500px wide. Cool, right? It's all about that contain property, making things all nice and tidy.

Why Should You Care?

1. Rocking the Component-Driven Design

Imagine building blocks that adapt themselves no matter where you put them on the page. That's what container queries can do. They make building reusable, flexible components a breeze.

2. No More Spaghetti Code

Say goodbye to messy CSS that’s harder to untangle than a plate of spaghetti. With container queries, everything's more organized, like a neatly packed lunch box.

3. Unleashing Your Inner Designer

Feel like an artist? Now you can paint even more intricate layouts without having to rely on global viewport sizes. Unleash your creativity and let your designs shine.

Browser Support: The Not-So-Cool Part

Okay, so here's the kicker: container queries are still pretty new, and not all browsers have gotten on board with them. But trust me, once they see how cool this is, they'll catch up.

Wrapping It Up

Container queries are like the cool new kid on the block who everyone wants to hang out with. They're all about giving you more control, letting you write cleaner code, and just making everything more fun.

Whether you're a seasoned pro or just getting started with responsive design, give container queries a whirl. They might just become your new best friend in web development.

So what are you waiting for? Dive in and start playing with container queries. Who knows what amazing things you'll create? Happy coding! 🎉

The ugly part of CSS-in-JS

Andreas Sander — Thu, 28 Sep 2023 20:12:26 +0000

One often-overlooked aspect of CSS-in-JS is its "dark side"—the "JS" part. What does this mean? Essentially, when you're writing your styles within JavaScript, you expose yourself to the quirks and intricacies of JS itself.

The Issue Illustrated

Consider the following example:

You might notice that the styles defined in IBreakStyles aren't applied as expected. Digging into the element with your development tools reveals a complete absence of styles.

The Root Cause

The culprit is a stray closing curly bracket within the template literal:

const IBreakStyles = styled.p`
  padding: ${({ $count }) => $count + "px"}}; /* <-- The offender */
  color: red;
  background-color: blue;
`;

What happens is that the CSS-in-JS library (in this case, styled-components) interprets the template literal in a specific way. This leads to parsing the CSS via JavaScript, and the stray curly bracket disrupts the intended behavior—likely closing some parent block in the JS logic.

The Silent Problem

The real issue is the absence of any alert mechanism: no errors are thrown, and no red squiggly lines appear in your editor to warn you. If you're fortunate, your editor's CSS-in-JS tooling might catch this, but that's not a guarantee.

A Thought to Ponder

Given these complexities, it's worth questioning if a separation of concerns—CSS in CSS files and JS in JS files—might not be a more foolproof approach, much like the "good old times."

Best regards,

Andi

The Evolution of Remote Work: Insights from Eight Years of Experience

Andreas Sander — Sun, 27 Aug 2023 10:16:58 +0000

Evolution of Remote Work: While the Covid-19 pandemic popularized remote work, some professionals had already been working remotely for years. The article offers insights from nearly eight years of remote work experience.
Challenges and Best Practices: Remote work presents challenges like blurring work-life boundaries and missing face-to-face interactions. Best practices include designating a separate workspace, understanding core working hours, using video calls for better communication, and emphasizing asynchronous communication.
Not a Universal Solution: While remote work offers flexibility and has proven viable during the pandemic, it's not suitable for everyone. A company's success is determined more by its culture than its work model, as highlighted in an external Forbes article.

During the height of the Covid-19 pandemic, remote work became the norm. Numerous companies transitioned to offering remote work options, and many continue to do so.

However, some of us, including myself, had the privilege of working remotely long before the pandemic hit. In this article, I'll share my reflections on nearly eight years of remote work and the lesser-discussed aspects of it.

The Importance of Work-Life Boundaries

The pandemic forced many to adapt to working from unconventional spaces like kitchens and living rooms. While this shift posed physical challenges, it also blurred the lines between personal and professional life. The omnipresence of work can be overwhelming.

If feasible, both financially and spatially, it's beneficial to designate a separate workspace within your home. In countries like Germany, having a dedicated workspace can also have tax and insurance implications.

Understanding Core Working Hours

While remote work offers flexibility in terms of where and when you work, there are often unspoken expectations about core working hours. Your employer likely has a window of time during which they expect you to be available.

The beauty of remote work is the ability to weave in personal errands or appointments, but this flexibility varies based on your role and company culture. Over time, you'll become attuned to your colleagues' schedules and availabilities.

Building Connections: Turn on Your Camera

Remote work lacks the nuances of face-to-face interactions. In a physical office, subtle cues like facial expressions provide context. When working remotely, video calls can bridge this gap.

It's beneficial for team members to have their cameras on during meetings. This fosters better communication and understanding. Additionally, in-person meetups and retreats can strengthen team bonds.

The Power of Asynchronous Communication

In a remote setting, you can't just walk over to a colleague's desk for a quick chat. Asynchronous communication becomes crucial. Document everything—from decisions to meeting minutes—and ensure they're accessible to the team. Whether it's a wiki, a ticketing system, or a chat platform, consistency in documentation is key.

Remote Work Isn't One Size Fits All

While the pandemic highlighted the viability of remote work, it's not suitable for everyone or every job. Some may struggle with the isolation, miss casual office interactions, or find it challenging to maintain discipline.

Remote work is a testament to the adaptability of the modern workforce, but it's not the ideal setup for everyone. As highlighted in this Forbes article, a company's success isn't solely based on its work model but its culture.

Setting Up a Node CLI with ChatGPT

Andreas Sander — Tue, 15 Aug 2023 17:52:42 +0000

Hey devcommunity! 🚀

I've been diving into setting up a Node CLI using a ChatGPT account account. Apart from the intricacies of the access token, I found the process to be pretty straightforward. If anyone's interested, I just built up this very fast sample repo that might be helpful as a starter.

On a related note, for those looking into automatic access token generation, I stumbled upon openai-token. It seems to work with a username/password combo. Has anyone tried this or have any thoughts on it?

Would love to hear your experiences or any tips you might have building ChatGPT CLIs via TypeScript! 💡