Securely Access All of Your Files from Anywhere

remotely iconRemotely lets you access all of the files on your Mac from your iPhone – from anywhere – with zero network setup. It’s available for free on the iTunes App Store and Mac App Store.

While we were building Remotely, we kept 2 things sacred: we wanted zero network setup, and we wanted the app to be incredibly secure.

Zero Network Setup

We know through experience just how complicated and inconsistent network setup can be. Typically, you might need to “login to your router”, “forward ports,” or even “setup a network bridge.” And if you’re part of the 99.99% who have no idea what any of that means, then you’d just be SOL. But with Remotely, when we say zero network setup, we really mean zero network setup.

To get Remotely working, the only thing you need to do is download the app. That’s it. It’s that simple. After you download the iOS and Mac apps, your iPhone will automatically find your Mac, setup a secure connection, and let you browse all of your files. There is quite literally nothing easier.

Keeping Your Files Safe

With great power comes great responsibility. When you use a 3rd party service to access your files, that means you have to sync your files to their servers. Not so with Remotely.

With Remotely, the only person that can access your files is you. We went to great lengths to make sure that the connection from your iPhone to your Mac is always secure and can never be snooped on. This means that even us – the makers of Remotely – have no way to view your files or access your computer. The only person that can access your files is you.

So how does this work?

In order to setup a secure point-to-point connection between your iPhone and Mac, a small bit of meta-data needs to be exchanged. Remotely uses your private and secure Apple iCloud account to transfer that metadata and setup the connection. After the connection is established, all of your file information is transferred 100% encrypted and independent of iCloud.

What’s all that mean?

It means that even the us – the developers of Remotely – can’t connect to your Mac. No one can access your files except you. There’s no need to sync your files to a 3rd party server. You are the only person who has a secure connection direct to your Mac.

Get the app

You can download the iOS app on the iTunes App Store, and you can download the Mac app on the Mac App Store. For more information, checkout

Loose Leaf 2.0 with iPad Pro and Apple Pencil support!

It’s been a long time, but it’s never too late for a great app update! Lots to love in this 2.0 release!

1. iPad Pro support
2. Apple Pencil support
3. Full page PDF import
4. New pen, marker, and highlighter tools
5. Delete scraps by dragging off left
6. Lots of bugs fixed!

The new Apple Pencil support makes Loose Leaf even better for taking notes and organizing your thoughts.


Staying Sane with Git

You might have seen it – @kkuchta christmas tree gif making the rounds these past holidays:


For a short story, that sums up my early experience with git with surprisingly accuracy!

For anyone else who’s struggled with git over the years, here’s a bit of my process to help me stay sane with git:

1. Where I am in the tree?

I use the command line to make new commits, pull, merge, etc, and when I first started using git I had a lot of trouble understanding just where I was in the repo at any given time. After branching a few times, I’d get lost pretty easily and forget which branch I was currently on. A simple fix – I added the following line to my .bash_profile:

# Put Git branch name it shell prompt
parse_git_branch() {
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
PS1='\W$(parse_git_branch)\$ '

This simply printed out my current location in my console’s prompt:


Now I felt comfortable git add branch-nameing and git checkouting as often as I needed without getting lost.

2. Where I can go in the tree?

Now that I knew my location in the tree, I still wasn’t sure where I was in relation to all the other branches. For that, I use a GUI app called GitX-dev: It’s a fantasic and incredibly simple app that shows the history, branches, and tags of your git repo.


It’s incredibly handy for easily seeing at a glance where I am in relation to all of the other branches, both local and remote.

3. Where is the remote?

Speaking of remote – there’s been more than once where I’ve worked on a fork of a primary repo, so I needed to keep track of both the upstream original repo and the fork repo.

For that, two simple commands help me know what’s what:

# lists all of the remote repositories and their names
get remote -v


# fetches all of the branches and tags from the remote repo
git fetch remote-name

These two commands let me know if my local branch was still simply an ancestor of the remote branch – if so, I could git pull without fear of an ugly surprise merge.

If my local branch had diverged from the remote, then I could look through the recent commits for that remote branch in GitX, and then decide if I wanted to a) git rebase my local changes onto the end of the remote branch with:

git rebase branch-name remote-name/branch-name

or b) have more context going into the merge with git pull.

4. Where is my bug?!

Here’s the real gem that I’ve only recently started using to great effect: git bisect.

Git bisect is a magical tool that will help you find the exact commit that caused the bug you’re trying to track down. Simply put, it does a binary search through your commit history until it finds the exact commit where the bug appeared.

Assuming your repo is currently showing your bug, you can start the process with a simple:

$ git bisect bad
You need to start by "git bisect start"
Do you want me to do it for you [Y/n]? Y

Confirm the prompt with a Y, and then checkout a commit that you know doesn’t show the bug:

$ git checkout old-branch-that-worked

And then mark that bugless commit as the 'good' commit.

$ git bisect good

And now the magic has started! You’ll see something like the following show up soon:

Bisecting: 4 revisions left to test after this (roughly 2 steps)    
[uglycommithash] an old commit message

Git has started its binary search through your tree, and all you have to do now is tell it whether the bug shows up in this commit with git bisect bad or if it’s bug free with git bisect good. Just keep going until you finally see:

ugly-commit-hash is the first bad commit
commit ugly-commit-hash
Author: Definitely Not You

And that’s it! Now you know precisely where the bug is and have a much better chance of tracking down its root cause. At this point I usually git branch bug-name just so I have a temporary flag in GitX for me to look for.

Note: At the end of your git bisect, even though it’s shown you the offending commit, you’ll technically still be in bisect mode.

# at this point after a bisect, your git status will be:
$ git status
HEAD detached at 4751a0a
You are currently bisecting, started from branch 'master'.
  (use "git bisect reset" to get back to the original branch)

To return to git business as usual, simply:

$ git bisect reset

And Tada! You’re back at your original branch as if nothing had happened. It’s an absolutely invaluable way to quickly narrow down a tricky to find bug.

A little goes a long way

This writeup barely scratches the surface of what’s possible in git – there’s huge swaths of functionality I haven’t even touched on – but if I had to choose only a handful of features, this would be it. This is 99% of what I use when I’m interacting with a repo, and I wish I’d seen it when I first made the switch to git many years ago.

Google Author link
Page 2 of 5012345...102030...Last »