New Adventures in Technology

I made a few tweaks to my crontab builder yesterday. It’s one of a few vibe-coded applications I created just to see what’s possible, and it’s something that actually works quite well for someone who doesn’t use cron often, so needs to read the manual every time. This is exactly where generative AI is really useful; creating simple web applications that help people use their computer more effectively.

For creating things like this I use Github CoPilot within Visual Studio Code, and then Github pages to host the results. It’s all things that are either free or that I get for free because I work in education, so is a setup that many other people could put together easily. It doesn’t require a powerful computer or a fast internet connection, so if you can run Visual Studio Code then working in this way is definitely an option.

It strikes me this morning that it’s now possible to self-publish almost anything, and that the tools to do so are getting easier to use every day. Creating ebooks is trivial using Pandoc, and they can be sold (or given away for free) on Amazon. Distributing music on Bandcamp is equally straightforward, with the ability to collect revenue via Paypal, and also set up a subscription, which is very basic crowd funding. WordPress has always been great for self-publishing writing, but now we also have things like Github Pages, where a whole source-controlled website can be hosted for free. I suspect if this technology had existed 20 years ago then I’d never have started using WordPress in the first place.

It’s 20 years since my oldest blog post was written, but not quite 20 years since I built the blog itself. In that time it’s moved from a box under my desk to a couple of different hosting providers, and it’s been a very interesting experiment to track certain aspects of my life over that time. I’m now also mirroring the whole thing on a Github Pages site, partly for resilience, but also as an interesting experiment to see if I can automate my content publishing pipeline with more than one end-point.

All of this would be possible with true self-hosting, but it would be a lot of work that I don’t have time for right now, and increased responsibility for security in a world where there are more threats that ever. I think the balance between having control over my content and having a straightforward way to publish it is right for me at the moment, but it’s good to be developing the skills to do it a different way if required at a later date.

While Time Machine is an excellent backup solution for macOS, external drives aren’t always the most convenient option—especially if (like me) you already have a Linux server with plenty of storage. By configuring Samba on your Linux server, you can use it as a network Time Machine destination, allowing automatic wireless backups without needing to plug in an external drive. Here’s how I set mine up (I used Ubuntu, but have put in commands for other distros as well).

On Linux

1. Install Samba on the Linux Server

# Ubuntu/Debian
sudo apt update
sudo apt install samba avahi-daemon

# RHEL/CentOS/Fedora
sudo dnf install samba avahi

2. Create a Directory for Time Machine Backups

sudo mkdir -p /mnt/timemachine
sudo chown your_username:your_username /mnt/timemachine
sudo chmod 755 /mnt/timemachine

3. Configure Samba

Edit the Samba configuration file:

sudo nano /etc/samba/smb.conf

Add this configuration at the end:

[TimeMachine]
   comment = Time Machine Backup
   path = /mnt/timemachine
   browseable = yes
   writable = yes
   valid users = your_username
   create mask = 0600
   directory mask = 0700
   spotlight = yes
   vfs objects = catia fruit streams_xattr
   fruit:aapl = yes
   fruit:time machine = yes

4. Set Up Samba User Password

sudo smbpasswd -a your_username

5. Restart Samba and Avahi

# Ubuntu/Debian
sudo systemctl restart smbd nmbd avahi-daemon
sudo systemctl enable smbd nmbd avahi-daemon

# RHEL/CentOS/Fedora
sudo systemctl restart smb nmb avahi-daemon
sudo systemctl enable smb nmb avahi-daemon

6. Configure Firewall (if needed)

# Ubuntu/Debian with ufw
sudo ufw allow samba

# RHEL/CentOS/Fedora with firewalld
sudo firewall-cmd --permanent --add-service=samba
sudo firewall-cmd --reload

On the Mac

1. Connect to the Share

Open Finder and press Cmd + K, then enter:

smb://server_ip_or_hostname/TimeMachine

Enter your username and password when prompted.

2. Enable Time Machine to Use Network Drives

If the share doesn’t appear in Time Machine preferences, you may need to enable unsupported volumes:

sudo tmutil setdestination /Volumes/TimeMachine

Or directly set it:

sudo tmutil setdestination smb://username@server_ip/TimeMachine

3. Configure Time Machine

1. Open System Settings → General → Time Machine
2. Click the + button to add a backup disk
3. Select your network share
4. Start the backup

Tips and Considerations

• Space Requirements: Ensure you have enough space on the Linux server (Time Machine typically uses 1-2x your Mac’s storage)
• Performance: Network backups are slower than local ones, especially for the initial backup
• Reliability: Use a wired connection for the first backup if possible
• Size Limits: You can set a quota using Samba or filesystem quotas to prevent Time Machine from using all available space

Optional: Set a Size Limit for Time Machine

On your Mac, create a sparse bundle with a maximum size:

sudo tmutil setdestination /Volumes/TimeMachine
hdiutil create -size 500g -type SPARSEBUNDLE -fs "HFS+J" 
  -volname "Time Machine Backups" 
  ~/Desktop/TimeMachine.sparsebundle

Then move this to your network share and use it as the backup destination.

I’m currently using a Mac as my main computer, but also have a Linux machine that I use for heavy lifting, but also for backups. Setting up SSH key-based authentication allows rsync to work seamlessly without password prompts, making backing up and file synchronisation much more convenient. This is particularly useful for automated scripts and frequent manual transfers. It’s what I use to ensure that I have a second copy of every file I download, and to keep my music collection in sync, and helps maintain that illusion that all my computers are actually one computer.

Configuration

1. Generate SSH Key on Mac (if you don’t have one)

First, check if you already have an SSH key:

ls -la ~/.ssh/id_*.pub

If you don’t have a key, generate one:

ssh-keygen -t ed25519 -C "your_email@example.com"

Press Enter to accept the default file location, and optionally set a passphrase (leave empty for truly passwordless, or use ssh-agent for security with convenience).

2. Copy Your Public Key to the Linux Server

Use ssh-copy-id to copy your public key to the server:

ssh-copy-id username@server_hostname_or_ip

You’ll need to enter your password one last time. This command copies your public key to ~/.ssh/authorized_keys on the server.

Alternative method (if ssh-copy-id isn’t available):

cat ~/.ssh/id_ed25519.pub | ssh username@server "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

3. Test the Connection

Try connecting via SSH without a password:

ssh username@server_hostname_or_ip

If it works without asking for a password, you’re all set.

4. Use rsync

Now you can use rsync without password prompts:

# Example: sync a local directory to remote server
rsync -avz /path/to/local/directory/ username@server:/path/to/remote/directory/

# Example: sync from remote server to local
rsync -avz username@server:/path/to/remote/directory/ /path/to/local/directory/

Common Options for rsync

• -a : archive mode (preserves permissions, timestamps, etc.)
• -v : verbose output
• -z : compress data during transfer
• -h : human-readable output
• --delete : delete files in destination that don’t exist in source
• --exclude='pattern' : exclude files matching pattern
• -n or --dry-run : show what would be transferred without actually doing it

Troubleshooting

If you still get password prompts:

1. Check permissions on the server:

   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/authorized_keys

2. Verify SSH config allows key authentication (on server):
   Check sshd_config for:

   PubkeyAuthentication yes

3. Check SELinux (if applicable on server):

   restorecon -R -v ~/.ssh

I finished reading How Bad Are Bananas? by Mike Berners-Lee this week. I’ve read bits of the first edition before, but this is my first full reading of the revised edition that takes into account a lot of the recent technological advances. It’s good to know that I’m on the right lines with the way I live my life, but there were definitely some learning points.

Most of the emissions from electrical devices come from the way they are made, not from how they are used. So the biggest positive impact we can have is to use devices for as long as possible, and only replace them when they no longer work. This makes devices that can be upgraded/repaired extra valuable, because it means that their lifespan can be prolonged by adding a new hard drive or some memory. The book was talking about trying to keep computers for 10 years, phones for 5, and televisions/monitors for longer.

Every little helps, but so many things that people concentrate on (sending less emails, using less paper) are really just yak-shaving compared to the things that make a real difference, such as not flying, eating a plant-based diet, and using renewable energy where possible. Transport and food are where most people can make the most difference, so it’s a really good place to start.

Cycling is a great way to travel, but we also need to think about how we fuel that cycling. The book talked about cycle commuting powered purely by cheeseburgers as being no better for the planet than driving a petrol car, and it’s definitely something I need to start thinking more about. It was also interesting to find out that when you take fuel into account, an e-bike is slightly better because it requires less energy from the rider, and therefore less fuel from food. Coupled with a renewable energy source, it it probably the best way to commute.

Both of the ways I commute are relatively good for the planet, so I shouldn’t feel guilty about taking the Brompton onto the train sometimes. It costs money, but requires me to eat less, and also allows me to read and listen to music or podcasts during the train part of the commute. Sometimes that is what I need, and in the scheme of things it’s still a really good travel choice (as is buying a bike that will likely outlive me).

Bananas are a good sourced of fuel in the scheme of things, so I shouldn’t worry about the amount of them that I eat. They have long been one of my main cycling snacks, and I’m glad that the book doesn’t suggest I should stop this.

I was reading this blog post by Emily Webber last week, which nicely compliments the Team Topologies book, and is something I think might add some value in my organisation. It puts enabling teams on a more level footing, defines who they enable, and also records whether a team is long-lived or temporary. This would allow organisations to record project teams in the same way as long-lived teams, and might better help highlight people who are in too many teams, as well as teams that don’t have a clear purpose.

I think mapping existing operating models in this way would be a good first step towards designing new operating models.

I would like to get my personal profiles idea off the ground soon. It’s like team charters/APIs, but for individuals. I think it’s really important to understand how each person in a team works, especially if you are in that team, and so much friction that I see between individuals would likely be reduced if each person had something written down about what they are responsible for, how they like to work, and how best to get in touch with them. I think this is likely something I will just have to try myself to see how it works, before suggesting that other people adopt it, but it definitely works for me on a theoretical level.

Over the last few months I have been involved in building an Agile Community of Practice at my workplace. It’s up to over 150 members and is going well. This post attempts to collate some of the resources we used, and blog posts that proved insightful when deciding what we wanted to do.

We started with Emily Webber’s blog, and also her excellent book Building successful communities of practice. But there were a few other websites that we also found useful:

• https://www.gov.uk/government/publications/community-development-handbook/community-development-handbook
• https://opensource.com/open-organization/20/2/building-community-practice-5-steps
• https://communitiesofpractice.work/#tools
• https://hellotacit.com/building-successful-communities-of-practice/

I hope to add more to this list as I read up more on the subject.

This is what I’m listening to this weekend. All of these were released or re-released during the last 3 weeks. It’s only February, but there’s already so much great new music this year.

• Wish Defense by FACS
• Reservoir of love by Shannon Wright
• House of the Fat and The Unwilling Astronaut by Joeyfat
• Goat Skull Table by Moundabout
• End of the Middle by Richard Dawson
• Mr. Luck and Ms. Doom by The Delines
• The Purple Bird by Bonnie “Prince” Billy