I have been running a homegrown NAS with Ubuntu for a couple of years now. It basically serves as filestorage for media, including photos taken over a number of years. Previously, I had a Synology Diskstation, but I was lacking some of the flexibility in running a fullfledged server - I wanted more control over my storage and backups.

Up until now, I've been running everything manually, by installing packages, running scripts etc., but it seemed to me I lost a lot of historical data that way. If I at one point have to reinstall my NAS, I'd have to go through all the motions again, reading up on installations of NFS, SnapRaid etc.

So, I decided to try out an automated solution, documenting my setup in the process.

Picking the right tool for the job

There's a bunch of configuration management tools outthere, as the field has grown over the last years, making it a lot harder to pick one without doing some detailed research.

Thankfully, there's a lot of material on the subject, like Ansible vs. Chef and even this one, covering even more.

Personally, I've had my hands on Chef and Puppet over the years, but at certain points they both seem cumbersome to me - at least for small-scale projects like the one I wanted to try it out on.

About Ansible

Ansible is an automation engine, written in Python and YAML, used for automating configuration management and deployment. Instead of having a client/server setup like Puppet for instance, it relies solely on a client (in this case that would be my Mac) and an SSH connection to the server you want to setup, making it a perfect suit for smaller, simpler setups like a personal NAS etc.

The syntax seems very simple to me, using YAML makes most playbooks very readable and the commands easily understandable.

In general, there's a lot of easily accessible playbooks for most things (Just try searching on GitHub for Ansible), like setting up NFS, running Apache etc., so Ansible is very easy to get started on, especially if you've tinkered with configuration files previously.

Getting started on the setup

I've personally stolen a few things from Alex - or more specifically, his serversetup, as he had some configurations for handling SnapRaid etc.

As I already have a server running, I'll be introducing Ansible all over, one service at a time - eventually transforming all the manual setups into Ansible ones. I haven't yet found a service that could magically transform an existing setup into an Ansible one (not properly, at least) - but again, that would probably have kept me from actually learning the proper syntax.

You can follow the work on my Ansible playbook for my NAS while I'm building it on GitHub

As you may recall, I used Karabiner and Seil to remap my Caps Lock previously, allowing me to use it for Alfred or OmniFocus.

However, Karabiner no longer works in macOS Sierra and the alternative Karabiner-Elements has yet to support multiple keystrokes for a single key.

My muscle memory caused some issues on this after upgrading to macOS Sierra, as I've grown kinda used to using Caps Lock for OmniFocus, suddenly requiring me to skip that habit.

Karabiner-Elements?

Karabiner-Elements is a new set of sub commands from the original Karabiner, for now basically a scaffold for the next version of Karabiner.

Even though it doesn't (yet!) support firing multiple keystrokes on a single key, Karabiner-Elements is not all bad, as it allows for rebinding Caps Lock to some F-keys not usually used on the Mac keyboard (Specifically F13-20), which will allow for remapping Caps Lock to fire something which you wouldn't normally use.

After installing Karabiner-Elements, open it up and setup the following:

This gets us part of the way, but not quite. We still need to trigger something on pressing the F18 button.

Hammerspoon to the rescue

I recently discovered Hammerspoon, as it's popped up a few places as being the next big thing for automation geeks on macOS.

Hammerspoon is basically a software-bridge between the lower levels of macOS (using the Accessibility API in macOS) and a Lua scripting engine. This means you can monitor and automate behavior, based on things like WiFi available, screens connected etc. However, it also allows you to do systemwide shortcuts, which is what we'll use here.

In this case, we want to remap F18 into firing a combination of the Option key (alt) and Space, effectively doing what Karabiner-Elements currently cannot.

I won't go into the details on installing Hammerspoon here, they have a pretty decent introduction on the site. Once it's installed, Hammerspoon looks for init.lua in the .hammerspoon directory in your home directory, to determine the rules and shortcurts you've set up. To avoid confusion, I won't include all of my init.lua here, but this is basically what you would need to include, in order to allow F18 to fire alt + space. The reason for the additional check on other keys, is to allow for using Caps Lock as an additional modifier key, allowing for more bindings using it, if needed:

-- Enter Hyper Mode when F18 (Caps Lock) is pressed
pressedF18 = function()
  k.triggered = false
  k:enter()
end

-- Leave Hyper Mode when F18 (Caps Lock) is released,
--   fire alt + space if no other keys are pressed.
releasedF18 = function()
  k:exit()
  if not k.triggered then
    hs.eventtap.keyStroke({"alt"}, 'SPACE')
  end
end

-- Bind the Hyper key
f18 = hs.hotkey.bind({}, 'F18', pressedF18, releasedF18)

Once you have the code in your init.lua, reload Hammerspoon (If it's not set to do that automatically), and you're good to go, Caps Lock should now fire alt + space!

Good luck on hacking your keyboard in macOS Sierra - I guarantee that Hammerspoon will be a rabbithole, if you're into automation ;)

Usually, once every year (around New Years) I do spring cleaning of my GTD setup. Normally, this includes a complete rundown of all my GTD activities to eliminate any dead projects as well as clearing my head of any new ideas, getting them into my flow.

However, this year, New Years came early. Over the course of the last year, I've been having different issues with my workflow, my projects and my contexts, leaving me with a partially broken GTD flow - but more on that in a later post.

Suffering from "overanalysis"

During the last few months, it's become clear to me that I've spent too much time on categorizing my projects, fitting them into very specific boxes, instead of acting on the steps needed to complete them. I tend to attribute this to my work as a developer, as I'm used to taking apart problems into tiny pieces, and to constantly optimize on how I solve things. Usually, this is a good thing, but when it comes to GTD, you might end up in a rabbithole of trying to optimize your setup.

Evolving to handle new roles

One of the other things I need to address, is that life changes. What worked for me a few years ago, will no longer work. Things have changed, I now have a lengthy commute to work every day, I have different priorities as a developer, as a coworker, as a familyman. All of these play into what's coming up in my new workflow over the next weeks.

TL;DR: I basically just removed every single project and every single context in OmniFocus. Will rethink my entire GTD flow, as it no longer fits my needs.

At work we have a few API services that are called from our clientside applications.

Most of these have some specific setups for our production, some of which are the CORS (Cross-origin resource sharing) headers that the API services provide, to ensure that the asynchronous calls are verified from our domains.

However, this also means it's a pain to test the API services, when called from JavaScript, as our setup requires the clientside requests to run from our development setup, meaning you can't test from your own workstation.

However, it's possible to disable the CORS enforcement in Chrome for instance, to avoid the CORS checks (but also, in the process, worsen your browser security), by starting Chrome with the following arguments (This is example is for a Mac, using a standard terminal):

open -a Google\ Chrome --args --disable-web-security

This will start Chrome without the CORS enforcement for the sessionm, and disable the CORS checks, allowing you to test cross-domain requests without the security issues. To enable CORS checks again, quit and restart your browser as usual.

So, Jay Z and friends just bought their way into streaming, by starting Tidal. I'm not signing up yet, and I'll explain why.

The basic problem on free streaming

Apparently artists like Taylor Swift do not like the fact that services like Spotify have a free, ad-based service, as they think this is basically just giving away their music.

Spotify commented on this, in this blogpost back in November 2014, explaining that they see the ad-based, free subscription (which still pays royalties to the artists) as a way to avoid piracy, which pays the artists nothing at all, and also as a way to convince users to actually pay for their music, by letting them have a taste of the convenience Spotify offers.

Even though I pay for Spotify Premium, and have never used their ad-based version, I'm kinda on the side of Spotify here.

Fixing the Spotify revenue model

This is an issue, I think is more important to me, as a consumer of music, than the way the most popular artists are paid.

To me, as a consumer of a lot of music not on the top 10 (Or top 100) list of Spotify, the revenue sharing model they use, is broken.

Using the model, Spotify promotes, means that artists are paid by the streams played (and thus, the percentage of total plays they represent), not by the people playing them. This means that, if you're able to have millions of plays, you'll get paid by the people who never listens to your music, but have fewer plays on relatively unknown artists.

In the pre-Spotify era where all my music was bought on CD's, this would be the equivalent of me going to a store to buy an album by an upcoming metal band, and inadvertently paying 90% of the price to Rihanna, only due to the fact that more people listened to her music.

The New Yorker had an article on this back in 2013 on this issue, and to me, this is the biggest issue in the streaming models used today.

As far as I've seen, Tidal's revenue sharing model is based on playbacks as well, meaning that upcoming bands and labels are still not supported the way I'd like.

When a service appears, where my 99 DKK (that's 14.53 USD - yeah, we get screwed over in Denmark) for my premium, musicstreaming service is actually distributed among the artists I've listened to - I'll switch in a heartbeat.

Until then, my money stays with Spotify - and with supporting artists by buying concert tickets and merchandise (which is a more direct way to support the artists anyway).

This year, I'll be attending the Google I/O conference in San Francisco, on May 28 - 29.

This is actually one of the few conferences left, I'm still interested in, as it represents the bleeding edge of everything Google does, and its focus on development of solutions. I've attended a lot of developer conferences over the years, and most of them tend to be on a overly simple level to be really useful. However, I/O seems to have multiple levels, which makes it a perfect fit for me.

Also, I'm usually quite fond of Apple, and would still like to attend WWDC, but I must admit Google is growing on me. Having worked with them on our support for Chromecast at TV 2 PLAY, it's clear that they've moved quite a bit beyond producing webservices, and towards doing a lot to get developers excited about their platforms.

I'm looking forward to meeting some of the people working on the Google Cast technology, which I think is one of the most promising technologies in media streaming at the moment - due to its simplicity in implementation, and its ease of use for consumers. And hopefully get at glimpse of the next generation in Cast and Android TV ;)

Anyway, if you're attending I/O or you're in the neighborhood and want to discuss something - let me know!

Docker has been growing in popularity among developers and sysadmins for the last few years, but it wasn't until recently I decided to look into it for some of the projects I run in my sparetime, and try it out for myself.

What is Docker?

Docker is an open-source engine that automates the deployment of any application as a lightweight, portable, self-sufficient container that will run virtually anywhere.

Docker ships applications using containers, containing any requirements for running the application, ensuring that the application runs in the same manner in production as in development. The use of containers also makes the systems isolated, enabling developers to run applications and their requirements inside a virtual machine, instead of having to install requirements on the workstation.

This means that getting a development environment up and running Rails, Wordpress etc., is now a matter of getting the right image from the Docker repository, and Docker will set up all requirements (application, database, webserver etc.)

There is one catch though, on Mac: It uses technology that doesn’t work natively on Mac. However in recent versions, it's become pretty easy to handle, as Docker has a lightweight Linux VM, which allows it to run on Mac.

Getting started

We'll start off by installing Virtualbox, as it's needed to run the Linux VM. I usually use Homebrew Cask for installing apps, so this is based on you having Homebrew and Homebrew Cask installed on your Mac. Cask is an addon for Homebrew for installing Mac binary packages via the command line. This allows you to install applications like Chrome, OmniFocus, Alfred etc. through command line, rather than having to locate them and download the apps. manually.

Anyway - as mentioned previously, running Docker on a Mac requires VirtualBox, so install that:

brew cask install virtualbox

Then install Docker and the addon boot2docker:

brew install docker
brew install boot2docker

boot2docker installs the VM that Docker needs, in order to run on the Mac. The following will download and install the VM, and setup the daemon that Docker needs to run:

boot2docker download
boot2docker init
boot2docker up

Note: If boot2docker tells you to set DOCKER_HOST manually in order to connect to Docker, you may need to run the command given from the command line (It should look like this export DOCKER_HOST=tcp://localhost:4243).

The docker command line tool should now be ready to talk to the daemon, and you should be able to start up a Docker instance.

I had some issues with port forwarding, when I launched my first Docker instance on my laptop - as I needed to explicitly forward the ports needed for access through VirtualBox. This is a known issue on Mac, which a lot of developers experience. There's a solution here

More reading

To learn more about Docker, and get started on a simple Docker container, Docker has a simple "Hello World" example, located here

To find containers already configured for a specific purpose (like running Rails, Wordpress etc.), Docker has an index of preconfigured containers

In 2014, I'm switching jobs. In the course of this decision, I was asked by a former colleague, what motivated me in a position, as I've had quite a few over the years. Here's my top 5 list, starting by debunking a pretty big myth.

Money isn't everything

One of the most common misunderstandings of developers I've met over the years, is that we are in an industry that pays high salaries, and that's the reason for us being in the game. Furthermore, I've met a lot of middle-managers, who think developers are overpaid and spoiled "nerds" with no life.

During my years as a developer, I've met 5% that work as developers for the money, and 100% of those were poor developers, with basic skills and no professional integrity. The reason is, basically, that learning development purely for the money is a bad investment. Most developers with a high skillset will have invested years of sparetime into learning and perfecting their craft, years with little or no pay for the most part.

But then, what motivates developers?

1. Success and "winning" spirit

Most developers are competitive, proud people, who try to deliver the best possible result.

Feeling like a part of a team, with a clear, common goal is probably the most motivating thing for any developer. Convince them that everyone is determined on reaching the same goals, and show them what their role is in the big picture, and most of the time, they will be the ones working like crazy, while others complain about late hours.

On the other hand - being forced into writing poor, unmaintainable code, is one of the worst things you can do to a developer who loves his craft. You wouldn't ask a construction worker to build your house using the worst possible materials, while being blindfolded.

If you have limited time, cut down on features, not on "doing things the right way". Delivering a successful product in a developers mind is more than just "launching on time" - if the technical platform is not up to the standards of the developer, they will see it as a failure, on time or not.

2. Making a difference

Developers are commonly fueled by the desire to change the world. Sometimes by automating stupid, human behaviour that waste precious lives, but most commonly by the desire to make everyones lives a bit easier and pleasant.

Most of the time, a developer will choose a position based on the reach of his work: If it affects millions of people, or helps someone, they will choose it over a position that pays a bit more. At the end of the day, developers are pleasers and problemsolvers.

3. Excellent management

No micro-management. The best way to manage a team of software developers, is to present a challenge, encourage independent thinking and shield the team from any disturbances, while not getting in the way of the development process.

The worst mistake made as a manager, is probably to demean the work done by developers. Don't tell them their estimates are "way off", unless you're a developer yourself, and know how a feature should be implemented. Instead, encourage them by explaining the impact of the feature, and the difference it will make for the company, not telling them it "should be easy to implement".

4. Being heard

Developers are on the frontline, when it comes to the services and systems running the company - and they're usually the first to know when something is not working. If a system crashes after a developer pointed out the flaws or shortcomings of the platform, over a period of time, he will take it personally if noone listened to the warnings.

The most basic rule - if a developer speaks, you should listen. If more developers agree, you should act.

5. Learning and being challenged

Chances are if you're hiring a developer that have 10 years of professional experience, you can count on them having at least 2-3 additional years of sparetime invested in their knowledge, and they did that for a reason.

As developers, the world we work in keep changing. Developers need to stay up-to-date, and most will do that on their own, if the challenges of the job require it. Just don't expect a developer to stay in a position, if the tasks are the same as they were last year.

Now what?

Are you a developer? Take a look at the list, and try to figure out which points are present in your current job, and which aren't. From my own world, points #1, #2 and #5 are some of the main reasons I'm looking forward to my new job. Are you pleased with your own result?

Are you a manager? Try asking the developers how they feel about the points in this post. Are they satisfied with all points, or are some lacking?

When developing on the Mac, using Git as your version control system, one of the first things you'll notice is that Git adds .DS_Store files to your repository.

This is not needed, as .DS_Store basically just handles settings on the directory it's in, and as such it's useless to share this with other developers. You can ignore the files per repository, but the best approach is usually to ignore it on a global level. Here is how to do it.

How to ignore files globally in Git

First, you'll need a global exclude file. This is created by entering the Terminal, and enter the following:

git config --global core.excludesfile ~/.gitignore

This sets up a global ignore file, ready to ignore file matches. It works by adding matches on a seperate line, causing Git to ignore these, when listing / committing changes. The file may be edited using your favorite editor, or you may simply add .DS_Store to it by entering the following in Terminal:

echo .DS_Store >> ~/.gitignore

And that's basically it. Just remember, that .DS_Store files already in repositories, will not be removed automatically from the repository.

During the last weekend I decided I wanted to upgrade to OS X Mavericks. It's free, it's fast and it's the new black.

Anyway, I experienced something I haven't experienced before on OS X: It wouldn't upgrade my system.

The install ran as it should, until it reported that it had failed. It then asked me to reboot, and even though the first thing I saw was a Mavericks setup screen, it just wouldn't run - and just kept asking me for the same information (Language, keyboard settings etc.). So, I finally gave up and ran a clean reinstall from scratch - after a few issues with getting my data off the system drive. Now, this may be due to the fact that my system has massive user-specific changes (I install a lot using homebrew and have a bunch of ruby versions and gems for instance).

Things I've learned:

ALWAYS have a backup handy

I use Crashplan for maintaining backup of my Macs, and I've had to use it a couple of times. This gives some security as to not lose everything in the process. However, in this case, it was faster to do a disk-to-disk backup instead of having to fetch my projects, documents etc. from "The Cloud".

Keep an old version of OS X on a USB drive

One of the things that took time when the issue with updating, was the fact that my main system drive wouldn't boot.

The primary issue here, was getting my data off the system drive, as I knew the updater would not overwrite those (And thanks for that feature Apple, your installers are getting pretty good). I could remove the primary disk from my Mac and put it inside an enclosure to backup the data before cleaning the disk, but fortunately I had an old disk running OS X Lion lying around - which I just booted from using USB, and got the data away from my primary, internal disk.

Alternatively, you could keep a rescue disk around when updating, Mac OS even allows you to create one.

Check your dotfiles frequently

Most developers on Mac and Linux have a dotfiles repo nowadays - I do too. No, you can't see it (yet - right now it unfortunately has personal data). But as you actually only use these on an infrequent basis, they tend not always to be updated.

One of my main issues was the fact that most of my software wasn't documented in my repo - causing me to have to install some parts manually (Eww, manually!). However, on the plus side of things, I now have a more complete Rakefile for setting up new accounts on servers I get access to.

I recently made a clean install of my Mac, including MacVim and Command-T.

This didn't go quite as expected on my clean Mavericks Mac, and as I've been unable to find the fix anywhere (And the crash reported make little sense unless you have experienced this before), I figured I might as well provide the fix I just made on my setup.

The challenge with Command-T on Mavericks

Command-T is great, but it requires compilation of a few dependencies, in which the ruby version used for running this, must match the version vim/MacVim uses (this is mentioned on https://github.com/wincent/Command-T ).

In previous versions of Mac OS X, Apple used Ruby 1.8.7 per default as the system Ruby. The vim/MacVim community has made use of this fact, as it basically just required MacVim to be linked to the same version, to enable easy building of Command-T.
However, in Mavericks, the default Ruby is now 2.0.0p247 (you can check this by running ruby --version), which means that the default Ruby and the one MacVim (And the system vim) is built towards, is not the same.

Now, according to the official Command-T docs, apart from installing the bundle, you must build the Ruby extension like this:

cd ~/.vim/bundle/command-t/ruby/command-t
ruby extconf.rb
make

But if this is done using the system Ruby, the version will not be the same as vim/MacVim uses, causing vim/MacVim to crash by throwing the following message:

Vim: Caught deadly signal TRAP
Vim: Finished

As mentioned previously - not exactly a precise error message. But I just happen to know this is caused by the Ruby versions diverging.

Have no fear - debugging is here!

The main concern now, is the fact that apparently vim uses Ruby 1.8.7, and this is not available, as the system Ruby used by Apple is 2.0.0. However, the "old" Ruby versions are actually available to Mac OS, you just need to know where to look.

Figuring out the Ruby version vim uses

First up, to figure out the location of Ruby 1.8.7, I used MacVim - regular vim might be able to do the same. Anyway, by calling mvim --version, I get the details of the compilation, ending like this:

Compilation: cc -c -I. -Iproto -DHAVE_CONFIG_H -DFEAT_GUI_MACVIM -Wall -Wno-unknown-pragmas -pipe  -DMACOS_X_UNIX -no-cpp-precomp  -g -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1     -I/System/Library/Frameworks/Tcl.framework/Headers  -D_REENTRANT=1  -D_THREAD_SAFE=1  -D_DARWIN_C_SOURCE=1
Linking: cc   -L.   -L.    -L/usr/local/lib -o Vim -framework Cocoa -framework Carbon       -lm  -lncurses -liconv -framework Cocoa   -fstack-protector -L/usr/local/lib  -L/System/Library/Perl/5.16/darwin-thread-multi-2level/CORE -lperl -framework Python  -F/System/Library/Frameworks -framework Tcl -framework CoreFoundation /System/Library/Frameworks/Ruby.framework/Versions/1.8/Ruby

Now, the end of the string tells me that OS X stores different Ruby versions in /System/Library/Frameworks/Ruby.framework. So, by looking through /System/Library/Frameworks/Ruby.framework/Versions/1.8, I quickly figure out that /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby is the 1.8.7 ruby executable I am looking for.

Compiling using the correct Ruby

Now that the correct version of Ruby is located, it's simply a matter of using the correct Ruby executable when compiling. So, instead of the initial instructions from Command-T, do like this:

cd ~/.vim/bundle/command-t/ruby/command-t
/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby extconf.rb
make

And voilá! Vim works with Command-T

During the last few years, I've picked up photography as one of my pastime activities.

Up until recently, I was using Jekyll with a gallery gem to manage my galleries online, for my family and friends.

However, as flickr recently changed their service, by upgrading all users to 1Tb free space, as well as improving the design and functionality a lot, I decided to move all of my public galleries to flickr.

Why use flickr instead of pure jekyll/octopress?

There are some clear advantages to hosting the imagery yourself, including full control over all images, and not having to bother with flickr's API's.

However, I saw these advantages:

1. flickr provides an excellent categorizing tool, allowing for collections/sets, tagging etc.
2. You don't need a seperate copy of the images locally, just for octopress. In my case, I shoot exclusively in RAW, and generate 3000x2000 px. images for web. That quickly takes up space
3. flickr is probably better / faster at serving images than my own server.
4. Yet another (free) off-site backup option is sweet.

There are other jekyll/octopress plugins out there

Neil did a great Octopress implementation for simplifying flickr integration into Octopress, available here: https://github.com/neilk/octopress-flickr. This allows you to insert a single Liquid tag on a jekyll/octopress page, and it will show a set or a photo based on the properties you set.

However, as I wanted more control over how the implementation is handled, I started out by forking his repo, and eventually ended up creating somewhat of a hybrid between Neil's idea and a page generator.

The main challenge

The main reason for creating my own jekyll/octopress Generator is, as mentioned previously, that I wanted more control over the HTML generated for a set.

Also, I wanted to generate a complete gallery, containing all my flickr sets in one single inde page, instead of having to set up single pages myself, containing the sets individually.

Previously I used jekyll gallery generator, which does this, so I basically wanted the same approach, only using the images through flickr's API instead of having them locally.

My approach consists of the following setup:

• A template file for an index of all sets / galleries for a given user
• A template file for the actual set you're browsing
• A few helper functions, based on Neil's work and the excellent flickraw gem for handling interaction with the API
• The generator plugin itself

Introducing jekyll-flickr-generator

I've just pushed the jekyll-flickr-generator project to GitHub, so I'm not going to go into specifics about the generator, however it does the following:

• Allows for generating an index of all, public sets of a flickr user
• Creates a "gallery" page for each set, using simple Liquid templates, which allows for logic
• It applies a specific sorting method, allowing for grouping of sets in collections.

Anyway, you can read more about it at the official GitHub repo

You can see a demo of it running here at our own photo site

Yes, that's me jumping around in a suit. Yes, I drank alcohol. No, you probably don't understand the labels in danish. Yes, my language has funny letters.

I'm currently running a setup at home, which involves having a Synology DiskStation in my home office, and streaming media to the rest of the appartment from there.

In our living room, I have a Mac Mini that have been using SMB/CIFS mounts to handle media mounts from the Synology for some time, but I've experienced some issues with playback, especially in regards to 1080P HD streams, so I decided to switch to NFS mounts instead, as the performance is supposedly better for continuous streaming.

Please note before you continue: Finder won't show these mounts by default, and so you'll have to access them through Command+G and typing the path. So, if you're using NFS for browsing through Finder, this may not be for you. This is meant for automating purposes, like getting Plex to stream from a remote NAS.

Why automounting?

There's a bunch of guides for simple mounting of NFS shares, and even an app called NFS Manager to make the process simpler.

However, as I don't want to manually mount the Synology shares everytime my Mac Mini is rebooted, or everytime my Synology has been shut down, automatically mounting the shares is a must.

Also, before Mountain Lion, Apple's own Disk Utility supported setting up NFS shares, but as that feature has been removed, another solution was required.

Creating a mount point

To get moving, we need a local mountpoint where the NFS shares will be mounted by Apple's own automount service. Apple usually mounts NFS under /Network, but I prefer having my shares accessible through /Volumes, as that's the location external drives are mounted as well. So, let's create a Shares folder in /Volumes, by firing up the Terminal and typing

mkdir /Volumes/Shares

Adding a master map

automount has it's own configuration, which determines the directories handled through automount. This is located in /etc/auto_master

Now, there's basically 2 ways to handle the configuration. Either do it inline in the /etc/auto_master file, or delegate it to a seperate configurationfile for a given directory.

This allows you to seperate different mounts from eachother, and makes the main auto_master file less crowded, so fire up /etc/auto_master and add the following line to it:

/Volumes/Shares      auto_shares

Now, your /etc/auto_master file should look like this:

#
# Automounter master map
#
/Volumes/Shares		auto_shares
+auto_master		# Use directory service
/net				-hosts          -nobrowse,hidefromfinder,nosuid
/home				auto_home       -nobrowse,hidefromfinder
/Network/Servers	-fstab
/-					-static

Mapping the new shares

So, now auto_master assumes /etc/auto_shares is available, and will look to that, to figure out what to do when you access a diretory within /Volumes/Shares. Now, I have an NFS share called video on my Synology, which I want to mount at /Volumes/Shares/video

So, create the /etc/auto_shares file, and add the following line:

video	-fstype=nfs,soft,intr,rsize=32768,wsize=32768,noatime,timeo=900,retrans=3,proto=tcp <hostname/ip of the NFS server>:/video

Now, there's a few things to this:

• The line above assumes anonymous access is allowed on the share. If you have to use a password, the mount part of the line would look like this: username:password@<hostname/ip of the NFS server>/video
• You'll notice that there's a lot of options in that line. I'm not going to go over all of them, but they are there for improving performance of the share. In the bottom of the post are a couple of resources on the details of improving NFS performance.

Activating the mounts

Whenever you change automount's configuration, you'll need to load them through the service:

sudo automount -vc

And that's basically it! Your Mac should now mount the volume when your scripts/Plex/etc. access the directory associated with it.

More resources on NFS tuning

Tune NFS Performance

Tuning NFS for better performance

Update: PCKeyBoardHack and KeyRemap4MacBook are now called Seil and Karabiner - the screenshots still reflect the old names though.

Let's face it. Caps Lock is useless. Unless you're in the habit of writing all-caps e-mails, you'll probably only use Caps Lock when hitting it by accident.

For the last couple of years, I've made a habit out of disabling my Caps Lock, or changing it to do something better. The key itself is useful, its size make it easy to hit, and it's easily accessible.

What you'll need

On the Mac, there's a few handy apps that allow you to modify your key layout.

Seil

Seil allows you to change the keycode your keys are firing. This will be useful later on. To do so, either follow the simple guide on the website or do the following:

1. Download and install Seil
2. Start up the application
3. Enable "Change Caps Lock" as shown below, and set it to keycode 110. Keycode 110 is called PC application key on a PC keyboard, but is not used on a Mac. So, for now your Caps Lock key does nothing. So far so good.

Also, Mac OS per default limits the responsiveness of Caps Lock. Which is nice, as it hinders a lot of accidental Caps Lock use, but if we want to actually use Caps Lock for somthing, we need to make it faster. This is done by entering System Preferences -> "Keyboard" -> "Modifier Keys", and setting Caps Lock to "No Action" as shown below.

Mapping the key with Karabiner

Next up, we want the key to do something else. As you remember, I remapped it to PC Application Key, but I really want it to fire a key combination, like Option + Space (Which, in my example is what I use for OmniFocus - Per default this key combination triggers Spotlight).

So, onto the scene comes Karabiner, which allows for keycodes like PC Application Key, to fire a key combination. To map the PC Application Key (i.e. Caps Lock) to fire Option + Space, do the following:

1. Download and install Karabiner.
2. Start it up
3. You'll notice a looong list of keys to remap. However, you can search this list as shown below, and only show the mapping options for PC Application Key for instance.
4. As you'll notice below, it's possible to map the key to a lot of different options, for instance "Application Key to Option_L+Space", which in this case fires - Yep, you guessed it: Option + Space.

When this is done, your Caps Lock should now fire the wanted key combination, and you can use Caps Lock for something useful, like triggering Quick Entry in OmniFocus, triggering Alfred etc.

Starting from OS X 10.7 (Lion), running the Disk Utility app. to fix disk permissions, doesn't include fixing the file permissions on a user level, only the System specific files (Like the global Library etc.).

This may cause issues, when installing 3rd-party apps. to the user home directory, as your local Library is just as prone to incorrect permission settings as the global one.

Repairing permissions in Lion and beyond

As the functionality is no longer in Disk Utility, how do you fix permissions beyond Lion ? Now, the feature is located inside boot Repair Utilities. Here’s how to access it.

1. Restart (Mountain) Lion and while booting, hold down the Command and R keys.
2. You Mac should now boot into Repair Utilities mode.
3. In the topmenu of the screen that appears, click the Utilities item then select Terminal.
4. A Terminal window should appear, type resetpassword into it and hit Return.
5. The Password reset utility launches, however we're not really interested in resetting the password or anything like that. Instead, click on the icon for your Mac’s hard drive at the top. From the drop-down positioned just below it, select the user account where you are having issues.
6. At the bottom of the window, you should see ‘Reset Home Directory Permissions and ACLs’. Click the Reset button, and the application will reset all ACL's in the home dir to default, repairing all Library permissions etc.

Once the repair is completed, you should be able to restart, using the Apple top menu.