msol https://msol.io msol • a blog made of words Sat, 15 Jun 2019 04:50:13 -0700 Mac productivity tips for developers https://msol.io/blog/tech/work-more-efficiently-on-your-mac-for-developers/ Sat, 15 Jun 2019 04:50:13 -0700 https://msol.io/blog/tech/work-more-efficiently-on-your-mac-for-developers/ 
-- Mike Solomon @msol 2019

local log = hs.logger.new('main', 'info')
DEVELOPING_THIS = false -- set to true to ease debugging

HYPER = {'ctrl', 'shift', 'alt', 'cmd'}

-- App bindings
function setUpAppBindings()
  hyperFocusAll('w', 'React Native Debugger', 'Simulator', 'qemu-system-x86_64')
  hyperFocusOrOpen('e', 'Notes')
  hyperFocus('i', 'IntelliJ IDEA', 'IntelliJ IDEA-EAP', 'Xcode', 'Android Studio', 'Atom', 'Code')
  hyperFocusOrOpen('a', 'Finder')
  hyperFocusOrOpen('x', 'Calendar')
  hyperFocusOrOpen('m', 'Messages')
  hyperFocusOrOpen('r', 'Slack')
  hyperFocus('t', 'Safari')
  hyperFocusOrOpen(';', 'iTerm2')
  hyperFocusOrOpen('s', 'OmniFocus')
  hyperFocus('f', 'Google Chrome', 'Firefox')
  hyperFocusOrOpen('space', 'Sublime Text')
end

-- Window management
function setUpWindowManagement()
  hs.window.animationDuration = 0 -- disable animations
  hs.grid.setMargins({0, 0})
  hs.grid.setGrid('2x2')

  function mkSetFocus(to)
    return function() hs.grid.set(hs.window.focusedWindow(), to) end
  end

  local fullScreen = hs.geometry("0,0 2x2")
  local leftHalf = hs.geometry("0,0 1x2")
  local rightHalf = hs.geometry("1,0 1x2")
  local upperLeft = hs.geometry("0,0 1x1")
  local lowerLeft = hs.geometry("0,1 1x1")
  local upperRight = hs.geometry("1,0 1x1")
  local lowerRight = hs.geometry("1,1 1x1")

  hs.hotkey.bind(HYPER, 'l', mkSetFocus(fullScreen))
  hs.hotkey.bind(HYPER, 'h', mkSetFocus(leftHalf))
  hs.hotkey.bind(HYPER, "'", mkSetFocus(rightHalf))
  hs.hotkey.bind(HYPER, "y", mkSetFocus(upperLeft))
  hs.hotkey.bind(HYPER, "b", mkSetFocus(lowerLeft))
  hs.hotkey.bind(HYPER, "u", mkSetFocus(upperRight))
  hs.hotkey.bind(HYPER, "n", mkSetFocus(lowerRight))

  hs.hotkey.bind(HYPER, "up", hs.window.filter.focusNorth)
  hs.hotkey.bind(HYPER, "down", hs.window.filter.focusSouth)
  hs.hotkey.bind(HYPER, "left", hs.window.filter.focusWest)
  hs.hotkey.bind(HYPER, "right", hs.window.filter.focusEast)
  -- hs.hotkey.bind(HYPER, "v", hs.window.filter.focusNorth)
  -- hs.hotkey.bind(HYPER, "c", hs.window.filter.focusSouth)
  -- hs.hotkey.bind(HYPER, "j", hs.window.filter.focusWest)
  -- hs.hotkey.bind(HYPER, "p", hs.window.filter.focusEast)
  hs.hotkey.bind(HYPER, "q", hs.hints.windowHints)
  -- HYPER "d" -- Bound in Karabiner to Cmd+Tab (application switcher)
  -- HYPER "k" -- Bound in Karabiner to Cmd+` (next window of application)

  -- throw to other screen
  hs.hotkey.bind(HYPER, 'o', function()
    local window = hs.window.focusedWindow()
    window:moveToScreen(window:screen():next())
  end)
end

-- focus on the last-focused window of the application given by name, or else launch it
function hyperFocusOrOpen(key, app)
  local focus = mkFocusByPreferredApplicationTitle(true, app)
  function focusOrOpen()
    return (focus() or hs.application.launchOrFocus(app))
  end
  hs.hotkey.bind(HYPER, key, focusOrOpen)
end

-- focus on the last-focused window of the first application given by name
function hyperFocus(key, ...)
  hs.hotkey.bind(HYPER, key, mkFocusByPreferredApplicationTitle(true, ...))
end


-- focus on the last-focused window of every application given by name
function hyperFocusAll(key, ...)
  hs.hotkey.bind(HYPER, key, mkFocusByPreferredApplicationTitle(false, ...))
end


-- creates callback function to select application windows by application name
function mkFocusByPreferredApplicationTitle(stopOnFirst, ...)
  local arguments = {...} -- create table to close over variadic args
  return function()
    local nowFocused = hs.window.focusedWindow()
    local appFound = false
    for _, app in ipairs(arguments) do
      if stopOnFirst and appFound then break end
      log:d('Searching for app ', app)
      local application = hs.application.get(app)
      if application ~= nil then
        log:d('Found app', application)
        local window = application:mainWindow()
        if window ~= nil then
          log:d('Found main window', window)
          if window == nowFocused then
            log:d('Already focused, moving on', application)
          else
            window:focus()
            appFound = true
          end
        end
      end
    end
    return appFound
  end
end


function maybeEnableDebug()
  if DEVELOPING_THIS then
    log.setLogLevel('debug')
    log.d('Loading in development mode')
    -- automatically reload changes when we're developing
    hs.pathwatcher.new(os.getenv('HOME') .. '/.hammerspoon/', hs.reload):start()
    hs.alert('Hammerspoon config reloaded')
    log:d('Hammerspoon config reloaded')
  end
end

function setUpClipboardTool()
  ClipboardTool = hs.loadSpoon('ClipboardTool')
  ClipboardTool.show_in_menubar = false
  ClipboardTool:start()
  ClipboardTool:bindHotkeys({
    toggle_clipboard = {HYPER, "p"}
  })
end

-- Main

maybeEnableDebug()
setUpAppBindings()
setUpWindowManagement()
setUpClipboardTool()
Then run Hammerspoon (or "Reload Config" from the menu bar icon). The configuration file is pretty easy to read with a little effort. If you set up the [Hyper key][hyper-tip], then this file should just work for you, and I find these particular settings to be very useful. ## 3: Tap shift to move over words I find that moving my cursor word-by-word is very useful even outside my text editor. OS X provides line-editing shortcuts similar to [Readline][readline]/[Emacs][emacs], for example Control+a to jump to the beginning of a line and Control+e to jump to the end (which I recommend you use). Even better is to do this without a modifier key! Inspired by a [similar idea about parens][tap-parens] from Steve Losh, notice that tapping your shift key normally does nothing, and you rarely do so. Instead, why not tap left-shift to move one word to the left, and tap right-shift to move one word to the right? I find this very useful for moving short distances in text of all kinds, and it soon becomes second nature. ### Setup First install [Karabiner Elements][karabiner-install]. Then, install [this karabiner configuration](karabiner://karabiner/assets/complex_modifications/import?url=https://msol.io/files/karabiner/shift.json). Alternatively, you can download [this file](https://msol.io/files/karabiner/shift.json) and add it by hand to the complex modifications section of `~/.config/karabiner/karabiner.json`. ## 4: Right-thumb control key How often do you use the right-side command key? Never. Instead of wasting that key, why not turn it into a control key? Control is very useful if you spend time in the terminal ([iTerm2][iTerm2] is great) so you can do e.g. control+p to get the previous command, or control+r to search previous commands. You press this key by curling your right thumb. It may feel unnatural at first, but before long the relief on your left pinky will be palpable. ### Setup First install the excellent [Karabiner Elements][karabiner-install]. Command-R to Control-L configuration Then open it and under "Simple Modifications" change the "From key" `right_command` and the "To key" to `left_control`. Done! ## 5: Ctrl+W deletes the previous word When you make a typing mistake, it is often faster to rewrite the entire last word than to repeatedly press backspace to erase the typo. I find this to be much more efficient overall. Emacs users will already be familiar with the choice of Ctrl+W. ### Setup First install [Karabiner Elements][karabiner-install]. Then, install [this karabiner configuration](karabiner://karabiner/assets/complex_modifications/import?url=https://msol.io/files/karabiner/ctrlw.json). Alternatively, you can download [this file](https://msol.io/files/karabiner/ctrlw.json) and add it by hand to the complex modifications section of `~/.config/karabiner/karabiner.json`. This works especially well with the [right thumb control key][right-thumb-tip]. ## 6: A better shell with [oh-my-zsh][oh-my-zsh] Most people use Bash for their shell. Assuming you spend some time in the terminal, you probably already know your way around Bash pretty well. Sadly, Bash has limited capabilities, especially for command completion. Other shells, like [Zsh][zsh], offer more but can be unfamiliar. Enter [oh-my-zsh][oh-my-zsh]: a layer of frosting on top of the powerful Z-shell that makes it Bash-compatible and adds a self-updating system of [plugins][omz-plugins] and [themes][omz-themes]. You will find your autocomplete much improved as well as available niceties like changing directories by typing directory names without `cd`, and a very nice default prompt. Oh-my-zsh also opens the door to more powerful customizations, and boasts an active community of people who have often already implemented features you wish your shell had. ### Setup First install Zsh. If you use [Homebrew][homebrew]---which I hope you do---then simply `brew install zsh`. You will also need Git (`brew install git`). Then just run the [curl-to-shell command][omz-install] from oh-my-zsh's setup instructions, open up `~/.zshrc` and enable a few [plugins][omz-plugins] by adding them to the `plugins=( ... )` array you'll see in that file, and you're done! Be sure to open a new terminal window to see your changes. ## 7: Syntax highlighting in the terminal I love syntax highlighting because it lets me catch errors in my code as I type. Why not have the same thing for my bash commands in the terminal? Terminal syntax highlighting screenshot This syntax highlighting makes valid commands yellow, invalid commands red, highlights strings, and underlines valid file paths. ### Setup This one requires [oh-my-zsh][omz-tip] as seen in the previous tip. Syntax highlighting is an oh-my-zsh plugin, but it doesn't come bundled by default. Run the commands 
mkdir ~/.oh-my-zsh/custom/plugins
git clone git://github.com/zsh-users/zsh-syntax-highlighting.git ~/.oh-my-zsh/custom/plugins/zsh-syntax-highlighting
to install the plugin. Then open up `~/.zshrc` and add `zsh-syntax-highlighting` to the end of the `plugins=( ... )` array. Open up a new terminal and enjoy your syntax highlighting! ## 8: Faster key repeat OS X defaults to a very slow key repeat rate, but it also doesn't let you lower it enough to please me in System Preferences. This often comes in handy for moving short distances in text. ### Setup You can customize this by running commands in your Terminal. Here are the settings I use, that I got from somewhere online (fractional values do not work). You may need to log out and back in to see them applied. 
defaults write -g InitialKeyRepeat -int 10 # normal minimum is 15 (225 ms)
defaults write -g KeyRepeat -int 1 # normal minimum is 2 (30 ms)
## 9: File-searching aliases Many terminal users set up aliases to shorten common tasks, such as `alias gc='git commit'` so that the whole command doesn't need to be typed. You should of course set up custom aliases, but there are two in particular that I find useful quite often. The first is `f`, which searches the current directory subtree for files with names containing a string (ignoring case). `f png` would find all PNG files in the current subtree, as well as "PNGisMyFavorite.txt" and so forth. The second is `r`, which recursively greps the current directory subtree for files matching a pattern. `r HTTP` would grep for files containing that exact string, while `r '"http[^"]*"' -i` would search for double-quoted strings starting with "http", ignoring case. ### Setup We will actually implement these as Bash (or Zsh) functions or aliases in `~/.bashrc` or `~/.zshrc`. Just add these lines anywhere in the file appropriate to your shell: # Software Some of these improvements require software. Here are some of the most important. ### [Karabiner Elements][karabiner] Karabiner lets you rebind keys, key combinations, trackpad gestures, set key delays, and more. It allows customization through a GUI, or a configuration file which lives at `~/.config/karabiner/karabiner.json`. ### [Hammerspoon][hammerspoon] Hammerspoon is a macOS swiss army knife. I mostly use it for window management, not unlike other tools like Divvy or SizeUp. It lets you arrange, resize, switch between, and open applications and windows on one or more monitors, among many other things. It can be customized through a Lua file at `~/.hammerspoon/init.lua`. ### [Oh My Zsh][oh-my-zsh] Oh My Zsh makes it easy to get a great shell configuration, making your work in the terminal much better. It is community maintained and has many plugins. # More resources I tried to hit high-value improvements that I don't think most people already have, but there is a whole world of deeper customization out there. Here are some links to resources I've found useful: * [Toward a more useful keyboard](https://github.com/jasonrudolph/keyboard), Jason Rudolph * [A Modern Space Cadet](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/), Steve Losh * [Holman does dotfiles](https://github.com/holman/dotfiles), Zach Holman * [Hammerspoon documentation](https://www.hammerspoon.org/docs/index.html) * [Karabiner Elements][karabiner] options [emacs]: https://www.gnu.org/software/emacs/ [homebrew]: http://brew.sh/ [hyper-tip]: #1-the-hyper-key--transform-caps-lock-into-escape [hyper]: http://stevelosh.com/blog/2012/10/a-modern-space-cadet/#hyper [iterm2]: http://www.iterm2.com/ [karabiner-install]: #karabiner-elements [karabiner]: https://pqrs.org/osx/karabiner/ [oh-my-zsh]: https://github.com/robbyrussell/oh-my-zsh [omz-install]: https://github.com/robbyrussell/oh-my-zsh#setup [omz-plugins]: https://github.com/robbyrussell/oh-my-zsh/tree/master/plugins [omz-themes]: https://github.com/robbyrussell/oh-my-zsh/wiki/themes [omz-tip]: #a-better-shell-with-oh-my-zshoh-my-zsh [readline]: https://cnswww.cns.cwru.edu/php/chet/readline/rltop.html [hammerspoon-tip]: #2-managing-windows-with-hammerspoon [hammerspoon]: https://hammerspoon.org [hammerspoon-download]: https://github.com/Hammerspoon/hammerspoon/releases [right-thumb-tip]: #4-right-thumb-control-key [software]: #software [space-cadet]: http://en.wikipedia.org/wiki/Space-cadet_keyboard [tap-parens]: http://stevelosh.com/blog/2012/10/a-modern-space-cadet/#shift-parentheses [zsh]: http://www.zsh.org/ ]]> 2019-06-15T04:50:13-07:00 Nietzsche would write clickbait https://msol.io/blog/thoughts/nietzsche-would-write-clickbait/ Fri, 08 Jan 2016 07:24:05 -0800 https://msol.io/blog/thoughts/nietzsche-would-write-clickbait/ Nietzsche's style is outrageous. He [denies morality and immorality][dawn-103]. He criticizes popular religions like Christianity and Judaism, popular moral philosophies like utilitarianism, and popular virtues like modesty[^immodest]. His language is evocative and exaggerated. As Higgins & Solomon[^higgins-solomon] point out: > ... it is evident that he was willing to be misunderstood if that was the price of attracting our attention. {: .display-table} and go on to cite Nietzsche's biblical tone in *Thus Spoke Zarathustra* among other things. That sounds as close to clickbait as things got in the 19th century. And spreading new ideas, generating ad revenue---what's the difference, anyway? [dawn-103]: https://www.gutenberg.org/files/39955/39955-h/39955-h.html#Sect_103 [^immodest]: [gutenberg.org/files/4363/4363-h/4363-h.htm](https://www.gutenberg.org/files/4363/4363-h/4363-h.htm), § 265 [^higgins-solomon]: p. xxv, Introduction to *Thus Spoke Zarathustra*, Barnes & Noble 2005. ISBN 978-1-59308-278-9. I have no relation to Robert C. Solomon. ]]> 2016-01-08T07:24:05-08:00 Dirt-cheap client-encrypted online backups with Raspberry Pi https://msol.io/blog/tech/dirt-cheap-client-encrypted-online-backups-with-raspberry-pi/ Thu, 07 Jan 2016 01:01:51 -0800 https://msol.io/blog/tech/dirt-cheap-client-encrypted-online-backups-with-raspberry-pi/ 
root@mycroft:/my-nas/Photos /home/pi/nas/Photos fuse.sshfs      user,delay_connect,noauto,_netdev,uid=1000,gid=1000,idmap=user,allow_other,reconnect 0 0
root@mycroft:/my-nas/write /home/pi/nas/write fuse.sshfs      user,delay_connect,noauto,_netdev,uid=1000,gid=1000,idmap=user,allow_other,reconnect 0 0
And test it with `sudo mount /home/pi/nas/Photos`, verifying that the files appear in that directory as expected. I recommend that your create a second partition directory on your NAS (separate from that which you wish to back up) to store Duplicity's local cache and log files. Otherwise, you are likely to quickly fill your Raspberry Pi's local storage. This directory is called "write" in my examples. Run `touch /home/pi/nas/write/.useThisWriteDir` after it is mounted to use with the script below. ### Set up GPG and your encryption keys GPG is supported by Duplicity for encryption, and provides a high level of security. Run `sudo apt-get install gnupg`. Then run `gpg --gen-key` and follow the prompts, choosing the defaults. Be sure to choose a long (ideally random) passphrase and to write it down (preferably in a password manager). You won't be able to read your backups without the generated keys, so be sure to [back that up][back-up-gpg] as well. We will need the fingerprint of the newly-generated key to tell Duplicity to use it. Run `gpg --fingerprint` to see it. `gpg --fingerprint | grep pub | grep -P "(?<=/)\\w{8} "` should highlight the 8-character fingerprint you require. ### Set up [Duplicity][duplicity] and the backup script on your Raspberry Pi These instructions assume you use [Raspbian][raspbian]. They should be adaptable for use on other Linux (or Linux-like) systems. Install duplicity by running `sudo apt-get install duplicity`. A simple backup script is needed to store credentials and run the backup. I store it along with the files I wish to backup (Photos), but you could do something more secure instead. 
#!/bin/sh
# stored in Photos, the directory I wish to back up

export SRC=/home/pi/nas/Photos
export DEST=gs://<your Google Cloud Storage bucket name>/Photos

export FTP_PASSWORD="<password>"
export GS_ACCESS_KEY_ID="<your Google access key>
export GS_SECRET_ACCESS_KEY="<your Google secret>"

export KEY="<your GPG key fingerprint (8 characters)>"
export PASSPHRASE="<your GPG passphrase>"

# Locking is handled by cron. This has helped it restart after problems.
killall duplicity
find /home/pi/nas/write/.cache/duplicity/ | grep lockfile.lock | xargs rm

# make sure we're using the right write dir.
# remote mounting issues can otherwise cause problems
if [ ! -f /home/pi/nas/write/.useThisWriteDir ]; then
  echo "write directory does not appear to be mounted"
  exit
fi

duplicity \
  --sign-key $KEY \
  --encrypt-key $KEY \
  --log-file /home/pi/nas/write/duplicity.log \
  --archive-dir /home/pi/nas/write/.cache/duplicity/ \
  "$SRC" "$DEST" 2>&1 >> /home/pi/nas/write/duplicity-foreground.log
Run the backup script on a small test directory to make sure it's all set up properly. ### Scheduling backups with cron The last step is to run this backup automatically. Cron can do this for us, and is built-in. We will use a [simple perl script][solo.pl] to keep things from running multiple times. Download it to `/home/pi` and make it executable with `chmod u+x /home/pi/solo.pl`. Run `crontab -e` and add these lines: 
# m h  dom mon dow   command
* * * * * grep -qs '/home/pi/nas/write' /proc/mounts || /home/pi/solo.pl -port=3386 mount /home/pi/nas/write
* * * * * ls /home/pi/nas/write || /home/pi/solo.pl -port=3386 sudo umount -f -l /home/pi/nas/write
* * * * * grep -qs '/home/pi/nas/Photos' /proc/mounts || /home/pi/solo.pl -port=3385 mount /home/pi/nas/Photos
* * * * * ls /home/pi/nas/Photos || /home/pi/solo.pl -port=3385 sudo umount -f -l /home/pi/nas/Photos
* * * * * grep -qs '/home/pi/Drive' /proc/mounts || /home/pi/solo.pl -port=3384 mount /home/pi/Drive
* * * * * /home/pi/solo.pl -port=3383 sh /home/pi/nas/Photos/backup.sh > /dev/null 2>&1

# optional: automatic reboots and software updates to keep things well-oiled
0 5 * * * ssh mynasuser@mynas 'reboot'
0 5 */2 * * sudo /sbin/shutdown -r +1
0 6 * * * sudo rpi-update
0 7 * * * sudo apt-get update -y && sudo apt-get upgrade -y
0 10 * * * sudo apt-get autoremove -y && sudo apt-get autoclean -y && sudo apt-get clean -y
This will start a new backup as soon as the last completes. This works well for my use case, adjust as necessary. Be sure to test your backups to ensure you can restore in a disaster! `duplicity verify` may help you here. ## Future improvements This could be improved with emails about failed backups, or when backups haven't run for some time. The overall process could also be simpler. Ideas? Let me know in the comments and I can update the article with them! [back-up-gpg]: /blog/tech/back-up-your-pgp-keys-with-gpg/ [backblaze]: https://www.backblaze.com [duplicity]: http://duplicity.nongnu.org/ [gpg]: https://www.gnupg.org/ [nearline]: https://cloud.google.com/storage/docs/nearline [raspbian]: https://www.raspbian.org/ [solo.pl]: https://timkay.com/solo/ [^bb-no-relation]: I have no affiliation with Backblaze. ]]> 2016-01-07T01:01:51-08:00 Pro-style testing https://msol.io/blog/tech/pro-style-testing/ Sat, 10 Oct 2015 09:47:07 -0700 https://msol.io/blog/tech/pro-style-testing/ 100` You should test 100, but also 99 because it is at the boundary of the change. Even better, write a property test. Remember to test each equivalence class exactly once. # More about testing ## Property-based tests Property-based tests (also called property checks) are a different way to think about testing. The basic idea is to assert that some law holds about the code under test, and then let the test framework generate test cases in an attempt to disprove the law. When it does so, it will try to find a minimal failing case to help you find your bug. It is worth writing property checks if you can, despite the initial learning curve. They allow you to declare laws and let the computer worry about coming up with cases that are likely to fail. They encourage writing reusable Generators that improve readability and reuse. Property-based tests are most useful in unit tests. In Scala there is [ScalaCheck](https://www.scalacheck.org/) and more can be found online. ## Large tests Large tests are your last line of defense before production (or "reported by users"). Not all tests are equally useful at this level. Test "happy path" behavior. This makes sure that the system works end-to-end in the real environment. Depending on your setup, you may be able to run this in a staging environment as well as the production environment. Test for regressions in known high-level bugs. If you can write a Small or Medium test for this, prefer that instead. However, make sure each regression gets a test, and sometimes this means a Large test. Don't attempt to test every way in which your system can fail. For example, if you have a suite of validations that are already tested in Small tests, do not repeat every test at the Large (or Medium) level. Instead, test one representative validation to ensure that the validations are wired in. Even better, test at the Medium level. ## Refactoring tests It can be hard to refactor your tests, because unlike your production code, you don't have tests (for your tests). One good strategy is to refactor your test code after manually (and temporarily) breaking the production code. This gives you some confidence that your tests fail when they ought to fail (showing their level of Fidelity). * [Refactoring tests in the red](http://googletesting.blogspot.com/2007/04/tott-refactoring-tests-in-red.html) # Reading and resources ## More terminology ### Box colors * __Black box__: Knows nothing of internals--testing the interface's contract, not implementation * __White box__: Testing the internals--testing the implementation, not the interface * __Grey box__: Testing interface's contract as in black box, but sets up state beforehand with knowledge of internals ### Subtypes of tests * __Regression__: did a bug we fixed reappear? * __Performance__: how fast is the code? is it fast enough? * __Security/Privacy__: will this leak data or allow unwanted access? * __Code quality__: does the code meet standards we can automatically (statically) measure? * __Acceptance__: Does it conform to specifications? * __Stress__: How does it handle being put under increasing loads, up to failure? ## Good resources * Google's [Testing Blog](http://googletesting.blogspot.com/), including [Testing on the Toilet](http://googletesting.blogspot.com/search/label/TotT) * *Clean Code* by Robert C. Martin * [Writing testable code](http://misko.hevery.com/code-reviewers-guide/) ## Short but valuable reading * [What makes a good test?](http://googletesting.blogspot.com/2014/03/testing-on-toilet-what-makes-good-test.html) * [Test behavior, not implementation](http://googletesting.blogspot.com/2013/08/testing-on-toilet-test-behavior-not.html) * [Risk-driven testing](http://googletesting.blogspot.com/2014/05/testing-on-toilet-risk-driven-testing.html) * [Effective testing](http://googletesting.blogspot.com/2014/05/testing-on-toilet-effective-testing.html) * [Know your test doubles](http://googletesting.blogspot.com/2013/07/testing-on-toilet-know-your-test-doubles.html) * [Testing state vs. testing interactions](http://googletesting.blogspot.com/2013/03/testing-on-toilet-testing-state-vs.html) ]]> 2015-10-10T09:47:07-07:00 You're probably wrong about caching https://msol.io/blog/tech/youre-probably-wrong-about-caching/ Sat, 05 Sep 2015 05:22:40 -0700 https://msol.io/blog/tech/youre-probably-wrong-about-caching/ There are only two hard things in Computer Science: cache invalidation and naming things --Phil Karlton Caching is a great tool. Lots of useful data fits easily in memory--so cache it! Improve your latencies, ease the load on your database, reduce your hardware costs! Can you spell free lunch? Many of the costs of caching aren't paid up-front. This makes caching seem very attractive--and to be clear, there are many situations where caching your data is a great option--but if you're just looking to pick up some "quick wins," caching is a bad place to start. I believe we, as software developers, have a very strong tendency to underestimate the complexities and issues caching brings along with it, *especially* when we look at oh-so-seductive early results of exploratory caching atop our data sources. In turn, I believe we often cache before the benefits actually outweigh the costs. ## Fine, why do you think caching is so hard? I'm glad you asked. ### Reasoning about cached data is harder Caching fundamentally means that you no longer read from your source of truth. Whenever you see something unexpected in your data (say, while debugging during an incident), you now must ask "does this data match our source of truth?" Every read or write to a piece of cached data is subject to mismatch with the source of truth and this must often be taken into account when tracking down issues. ### A new class of perspective bugs are possible with cached data Not all data appears in the same way to all users. For example, a list of "Best Articles" on a news site might depend on which user is logged in. A classic caching mistake is caching these perspective-dependent values and serving them to users who should have a different perspective. This is avoidable enough once, but is easy to mistakenly introduce later on. This can lead to serious privacy or even security issues. ### Reproducing behavior involving caching is harder When you introduce caching, you also introduce a new layer in which behavior can differ from your expectations. New race conditions are possible where they weren't before: items can expire from the cache when you don't expect them to, which objects are cached depends on access patterns that can vary by time of day or other factors. This means that issues can appear, but it is not obvious how to reproduce them to assist in fixing them. ### Access pattern changes can subtly lower cache hit rates which damages performance When access patterns change, so can performance. A special case of this can occur when data is fronted by a cache and access patterns change. As cache misses increase, latency increases and throughput can drop. However, traffic levels may stay the same, masking the cause, and potentially overloading the underlying data source. Like any issue, this can be dealt with, but it makes dealing with certain incidents more difficult. ### In-process caching in garbage-collected languages increases GC pressure[^gc-pressure] This only applies to certain scenarios, like in-process caches on the JVM, but it serves as another example of how caching can introduce unexpected issues. In this case, large numbers of long-lived cached objects can get promoted into older generations of the garbage collector and increase both the run time of individual collections and the frequency at which they must happen. ### Recovering from a failed cache is hard Caches can let you scale up your serving capacity past what your underlying data source could serve alone, which is one reason to cache. Unfortunately, when your cache machines go down (or are unreachable on the network, or unresponsive, or...) you cannot simply bring them back online, as all data stored in memory will already be lost. You must warm your caches by reading from the underlying store while still trying to serve production traffic. Often your only choice will be to deny all but a fraction of traffic, slowly ramping up the amount you serve as your caches warm. ## Is it worth it? It depends; the tradeoffs are yours to choose between. But before you choose, consider that many of the downsides won't manifest themselves right away. Don't forget how easy it is to ignore these downsides and focus only on the benefits--the payoff is immediate, but the costs must be paid constantly throughout the cache's lifetime. [^gc-pressure]: Garbage collector (GC) pressure happens when your application (running on the JVM, CLR, V8, and other garbage-collected runtimes) allocates then releases memory for many objects. The runtime must occasionally collect this garbage by walking through your memory graph to determine which objects are still needed, and which can be freed. When your application produces and discards many objects in a short amount of time--say, from an in-memory cache--the garbage collector needs to interrupt your running code and collect dead objects more frequently, and each collection can take longer. ]]> 2015-09-05T05:22:40-07:00 Ruby on Rails: Don't delete, tombstone https://msol.io/blog/tech/ruby-on-rails-dont-delete-tombstone/ Tue, 18 Aug 2015 11:32:38 -0700 https://msol.io/blog/tech/ruby-on-rails-dont-delete-tombstone/ 
module Mixins::Tombstoneable
  extend ActiveSupport::Concern

  included do
    default_scope { where(deleted: false) }
    scope :include_deleted, -> { unscope(where: :deleted) }
    scope :deleted, -> { include_deleted.where(deleted: true) }
  end

  def destroy
    update_attribute(:deleted, true)
  end

  def delete
    destroy
  end

  def undelete
    assign_attributes(deleted: false)
  end

  def undelete!
    update_attribute(:deleted, false)
  end
end
Nice! The magic is in the `included` block. We augment the default scope to always look for records that have not been deleted. If we wish to include deleted records as well, we can use the `include_deleted` scope: 
User.include_deleted.find(...)
Or if we wish to only select deleted (tombstoned) edges, we can do that too: 
User.deleted.find(...)
## Now mix it in We never finished actually mixing this in to a model. Let's assume we have a model called User. Only one line is needed to mix in the tombstoning behavior: 
class User < ActiveRecord::Base
  include Mixins::Tombstoneable
  ...
## And add the column We also need to make sure the database has a column to track which records have been deleted. This will be necessary for each model we wish to make tombstonable. From the command line: 
rails g migration AddDeletedToUser deleted:boolean
Then modify the generated file to add a default and make the column `NOT NULL`: 
class AddDeletedToUser < ActiveRecord::Migration
  def change
    add_column :users, :deleted, :boolean, null: false, default: false
  end
end
And run the migration: 
rake db:migrate
## That's it! I have found this to be a useful practice. Let me know how your experiences go (or have gone previously) in the comments. Enjoy your not-quite-deleted records! ]]> 2015-08-18T11:32:38-07:00 How I doubled my Internet speed with OpenWRT https://msol.io/blog/tech/how-i-doubled-my-internet-speed-with-openwrt/ Tue, 10 Mar 2015 15:09:10 -0700 https://msol.io/blog/tech/how-i-doubled-my-internet-speed-with-openwrt/ 
config route 'default_wan2'
  option interface 'wan2'
  option target '0.0.0.0'
  option netmask '0.0.0.0'
  option gateway '192.168.1.1'
  option metric '20'
Normally this last step is not necessary, but for some reason mwan3 seems to need it to work with wireless networks. Submit your changes. ## Check it! Go to `cgi-bin/luci/admin/network/mwan` and you should see both networks green! At least you will if you're the luckiest person ever. More likely you'll run into problems, check out the [mwan docs][mwan3] and Google around. Another good test is to a website that [tells you your IP][my-ip] and refresh several times and ensure you see two different IP addresses. Good luck! [openwrt]: https://openwrt.org/ [router]: https://wiki.openwrt.org/toh/buffalo/wzr-hp-ag300h/ [hardware]: https://wiki.openwrt.org/toh/start [spoof]: https://www.google.com/webhp?q=how%20to%20spoof%20mac%20address#q=how+to+spoof+mac+address&qscrl=1 [mwan3]: https://wiki.openwrt.org/doc/howto/mwan3 [my-ip]: https://duckduckgo.com/?q=what+is+my+ip ]]> 2015-03-10T15:09:10-07:00 Keybearer: Decrypt a secret using M of N keys https://msol.io/blog/tech/keybearer-decrypt-a-secret-using-m-of-n-keys/ Sat, 07 Mar 2015 09:02:56 -0800 https://msol.io/blog/tech/keybearer-decrypt-a-secret-using-m-of-n-keys/ 2015-03-07T09:02:56-08:00 Host your own web fonts https://msol.io/blog/tech/host-your-own-web-fonts/ Sat, 07 Mar 2015 04:45:10 -0800 https://msol.io/blog/tech/host-your-own-web-fonts/ 
<link
  href='//fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic'
  rel='stylesheet'
  type='text/css'>
To self-host, the process is slightly different. First, we must download the files and put them in a folder, such as `fonts`. Ideally we want to have each font variant (regular, bold, italic, bold + italic) in three formats: `.woff` for modern browsers, `.eot` for old Internet Explorer, and `.ttf` for other browsers. Font Squirrel has an [online tool][webfont-generator] to convert easily between them if you're missing any. Now it's just a matter of some simple CSS: 
/* Normal */
@font-face {
    font-family: 'Lato';
    src: url('fonts/Lato-Regular.eot');
    src: url('fonts/Lato-Regular.eot?#iefix') format('embedded-opentype'),
         url('fonts/Lato-Regular.woff') format('woff'),
         url('fonts/Lato-Regular.ttf') format('truetype');
    font-style: normal;
    font-weight: normal;
    text-rendering: optimizeLegibility;
}

/* Italic */
@font-face {
    font-family: 'Lato';
    src: url('fonts/Lato-Italic.eot');
    src: url('fonts/Lato-Italic.eot?#iefix') format('embedded-opentype'),
         url('fonts/Lato-Italic.woff') format('woff'),
         url('fonts/Lato-Italic.ttf') format('truetype');
    font-style: italic;
    font-weight: normal;
    text-rendering: optimizeLegibility;
}

/* Bold */
@font-face {
    font-family: 'Lato';
    src: url('fonts/Lato-Bold.eot');
    src: url('fonts/Lato-Bold.eot?#iefix') format('embedded-opentype'),
         url('fonts/Lato-Bold.woff') format('woff'),
         url('fonts/Lato-Bold.ttf') format('truetype');
    font-style: normal;
    font-weight: bold;
    text-rendering: optimizeLegibility;
}

/* Bold + Italic */
@font-face {
    font-family: 'Lato';
    src: url('fonts/Lato-BoldItalic.eot');
    src: url('fonts/Lato-BoldItalic.eot?#iefix') format('embedded-opentype'),
         url('fonts/Lato-BoldItalic.woff') format('woff'),
         url('fonts/Lato-BoldItalic.ttf') format('truetype');
    font-style: italic;
    font-weight: bold;
    text-rendering: optimizeLegibility;
}
Your fonts should now be available. Be sure to adjust the `url` paths if you place your fonts in a different directory. ## Applying your font Simply apply your font in CSS as usual (this will also work with Google Fonts or Typekit): 
body {
  font-family: Lato, 'Helvetica Neue', Helvetica, Arial, sans-serif;
}
Now you're good to go! ## Extreme optimization If you really want to get fancy, Google Fonts has a feature called subsetting that lets you strip unused characters out from the font before transmitting it to clients, saving bandwidth. You basically have two options if you want to do it yourself. The easy way is to use FontSquirrel's excellent [Webfont Generator][webfont-generator], and use the subsetting options there. The hard way is complicated and you will need to work out the exact details, but a basic setup would be: 1. Determine what characters you use If you have a static website, you might be able to do this fairly easily, perhaps by finding every character displayed on any page (accounting for HTML encoding). 2. Set up a pipeline to subset your fonts [fontTools'][fonttools] [subset.py][fonttools-subset] is probably the best way to do this, or the related version in [Google Font Directory][gfonts-subset]. 3. Use the generated files as above Before going down this route, you probably want to measure your maximum possible speed improvement and see if it's actually worth the trouble. [gfonts]: https://www.google.com/fonts/ [typekit]: https://typekit.com/ [lato]: http://www.latofonts.com/lato-free-fonts/ [gfonts-lato]: https://www.google.com/fonts/specimen/Lato [webfont-generator]: http://www.fontsquirrel.com/tools/webfont-generator [fonttools-subset]: https://github.com/behdad/fonttools/blob/master/Lib/fontTools/subset.py [fonttools]: https://github.com/behdad/fonttools [gfonts-subset]: https://code.google.com/p/googlefontdirectory/source/browse/tools/subset ]]> 2015-03-07T04:45:10-08:00 How to win when you're small https://msol.io/blog/thoughts/how-to-win-when-youre-small/ Wed, 04 Mar 2015 12:23:55 -0800 https://msol.io/blog/thoughts/how-to-win-when-youre-small/ Battlefield Blotto Enemy A 4 5 B 4 5 C 4 5 Despite this disadvantage, Blotto can still succeed:
Battlefield Blotto Enemy
A 6 5
B 6 5
C 0 5
This is our first bit of insight: picking your battles (and picking which to sacrifice) is unquestionably more effective given limited resources. This is hardly earth-shaking news, but it is good to see that our model bears out conventional wisdom. In fact, there is a common application of this in politics: gerrymandering. By [carefully choosing districts][gerrymandering], politicians have learned to win elections without the popular vote. Now, the obvious objection is that an Enemy with superior resources could easily reallocate troops to guarantee victory on a majority of battlefields---this is unfortunate for Blotto, but it reveals a second insight: the Enemy doesn't have enough resources to win at everything! Unless the Enemy has a truly overwhelming number of resources, Blotto has a good shot at winning at least some battlefields, just as a small business can often outperform larger competitors in a few key areas by focusing on filling needs unmet by those larger competitors. ### Fighting at a major disadvantage But what can an outgunned Blotto do in a situation where the enemy has many more resources?
Battlefield Blotto Enemy
A 2 4
B 2 4
Even if our good Colonel allocates all troops to one battlefield, the Enemy has enough resources to prevent a Blotto victory on either battlefield. So why not add more battlefields?
Battlefield Blotto Enemy
A 3 2
B 1 2
C 0 2
D 0 2
By adding new battlefields to the game, Blotto is able to be victorious on one battlefield despite having half the troops. Of course this isn't allowed in the game theory version (and Blotto still hasn't won!), but it uncovers a third insight: adding new areas to compete in is advantageous for the underdog. Doing one thing (or a few things) well is a better strategy for small companies, and it can be a great advantage in a career as well. This applies even more in situations where a victory on one battlefield may be sufficient to win--imagine a small company suddenly competing on grounds no other company knew existed. ## The math behind the maxim We have seen a few good insights suggested by Colonel Blotto that can be rephrased as more conventional wisdom: 1. Pick your battles. If you spread your resources too thin, you are easily defeated. 1. Know thy enemy. If you know how your opponents will use their resources, you can pick the right battles. 1. The underdog can win too. It's easy to get disheartened, but remember that you can win even with fewer resources. 1. If you can't win, cheat. Add a new dimension to the game, a new product, a new battlefield. It might just be the edge you need. [blotto-wiki]: https://en.wikipedia.org/wiki/Blotto_games [gerrymandering]: http://www.washingtonpost.com/blogs/wonkblog/wp/2015/03/01/this-is-the-best-explanation-of-gerrymandering-you-will-ever-see/ ]]> 2015-03-04T12:23:55-08:00 Back up your PGP keys with GPG https://msol.io/blog/tech/back-up-your-pgp-keys-with-gpg/ Sun, 19 Oct 2014 12:10:00 -0700 https://msol.io/blog/tech/back-up-your-pgp-keys-with-gpg/ 
gpg --armor --export > pgp-public-keys.asc
gpg --armor --export-secret-keys > pgp-private-keys.asc
gpg --export-ownertrust > pgp-ownertrust.asc
Done! Remember that your private key should be kept, well, private. Even with a passphrase, revealing your secret key reduces the security of your PGP key to just that passphrase. Speaking of that, while you're backing up your keys, you may also want to generate a [revocation certificate][revocation.cert]: First, note your key ID in the second column after the slash: 
gpg --list-keys
Then, generate the certificate. You will prompted several times, but you probably want to choose "1 = Key has been compromised" as your reason: 
gpg --armor --gen-revoke [your key ID] > pgp-revocation.asc
## Restore your keys 
gpg --import pgp-public-keys.asc
gpg --import pgp-private-keys.asc
gpg --import-ownertrust pgp-ownertrust.asc
## Revoke your certificate If your key is compromised, you can revoke your certificate in the same way: 
gpg --import pgp-revocation.asc
Be sure to upload your revocation certificate to any keyservers you have uploaded your public certificate to! ## Where should I back up my PGP key? One great method is to [print it as a QR code][paperkey], but printing the plain text files generated above is also reasonable. Storing it with your backups is not the best choice if encrypt your backups with the same PGP key you are trying to back up. Uploading to a cloud service is the most convenient, but you are obviously implicitly trusting that provider with your private keys. [revocation.cert]: https://www.gnupg.org/faq/gnupg-faq.html#define_rev_cert [paperkey]: http://www.jabberwocky.com/software/paperkey/ ]]> 2014-10-19T12:10:00-07:00 Create a self-signed SSL Certificate with OpenSSL https://msol.io/blog/tech/create-a-self-signed-ssl-certificate-with-openssl/ Tue, 30 Sep 2014 13:15:13 -0700 https://msol.io/blog/tech/create-a-self-signed-ssl-certificate-with-openssl/ 
openssl genrsa -out key.pem 2048
openssl req -new -sha256 -key key.pem -out csr.csr
openssl req -x509 -sha256 -days 365 -key key.pem -in csr.csr -out certificate.pem
openssl req -in csr.csr -text -noout | grep -i "Signature.*SHA256" && echo "All is well" || echo "This certificate will stop working in 2017! You must update OpenSSL to generate a widely-compatible certificate"
The first OpenSSL command generates a 2048-bit ([recommended][rsa.key.size]) RSA private key. The second command generates a [Certificate Signing Request][csr], which you could instead use to generate a CA-signed certificate. This step will ask you questions; be as accurate as you like since you probably aren't getting this signed by a CA. The third command generates a self-signed x509 certificate suitable for use on web servers. This is the file you were after all along, congrats! The check at the end ensures you will be able to use your certificate beyond 2016. OpenSSL on OS X is currently insufficient, and will silently generate a SHA-1 certificate that will be [rejected by browsers][sha1.rejection] in 2017. Update using your package manager, or [with Homebrew][homebrew.openssl] on a Mac and start the process over. ## More about self-signed SSL certificates Self-signed SSL certificates provide all of the encryption benefits of a certificate signed by a Certificate Authority (CA), but essentially none of the authentication benefits. This is obviously still useful, and I find them particularly nice for staging sites, in the early stages of a project, and for use [behind CloudFlare][cloudflare.ssl]. Due the the lack of authentication, web browsers will display a warning to users attempting to connect to your site. If this is a production site or you don't want this warning, you must get a certificate signed by a CA. Google "free SSL certificate" and you'll easily find a free 1-year certificate. ### ECC certificates While I would not recommend an ECC (elliptical curve) certificate, I have a guide to [create a self-signed ECC certificate][self.signed.ecc]. ECC is a relatively new kind of key, and can be used as an alternative to RSA which we used above. [sha1.rejection]: https://developer.mozilla.org/en-US/docs/Web/Security/Weak_Signature_Algorithm [homebrew.openssl]: https://solitum.net/openssl-os-x-el-capitan-and-brew/ [cloudflare.ssl]: https://blog.cloudflare.com/origin-server-connection-security-with-universal-ssl/ [rsa.key.size]: https://www.emc.com/emc-plus/rsa-labs/standards-initiatives/key-size.htm [csr]: https://en.wikipedia.org/wiki/Certificate_signing_request [self.signed.ecc]: /blog/tech/create-a-self-signed-ecc-certificate/ ]]> 2014-09-30T13:15:13-07:00 More useful shell aliases https://msol.io/blog/tech/more-useful-shell-aliases/ Sun, 30 Mar 2014 14:35:33 -0700 https://msol.io/blog/tech/more-useful-shell-aliases/ 
alias gcurrbranch='git rev-parse --abbrev-ref HEAD'

function gpull() {
    echo "git pull origin $(gcurrbranch)"
    git pull origin $(gcurrbranch)
}
You can see that I use both an alias and a function to accomplish what I want. There is some duplication that would be nice to get rid of and it would be great to have a general way to print what I am executing without that duplication. ## Pretty-print and 'eval' The most obvious thing to print to the terminal is a string. Bash and Zsh let you use `eval` to execute a string (this is [dangerous][bash-eval] if you `eval` user data in your commands, including file names and contents--please be aware of the security risk). First let's try out a using a string for our command: 
alias gcurrbranch='git rev-parse --abbrev-ref HEAD'

function gpull() {
    command="git pull origin $(gcurrbranch)"
    echo "${command}"
    eval "${command}"
}
That's a bit better, but we can extract the print-and-eval logic into a separate function. While we're doing that, let's make it print in white so it's easily distinguishable: 
function print_and_eval() {
    echo "\e[0;37m$1\e[0m"
    eval $1
}

alias gcurrbranch='git rev-parse --abbrev-ref HEAD'

function gpull() { print_and_eval "git pull origin $(gcurrbranch)" }
Command-R to Control-L configuration Now we have commands that print in white and we've removed the duplication! There are some drawbacks to this approach. There are [security concerns][bash-eval], we lose syntax highlighting for the commands in the editor, and the printing is imprecise with non-printable escapes (such as in certain `sed` commands). Even so, I find this very useful for my git aliases (among others). But please, be careful and do not use commands that could execute user data (including file names). [bash-eval]: http://mywiki.wooledge.org/BashFAQ/048 ]]> 2014-03-30T14:35:33-07:00 Dvorak–QWERTY ⌘ on Mac, Windows, and Linux https://msol.io/blog/tech/dvorak-qwerty-on-mac-windows-and-linux/ Wed, 26 Mar 2014 02:15:46 -0700 https://msol.io/blog/tech/dvorak-qwerty-on-mac-windows-and-linux/
Layout Download
Dvorak Simplified (normal) Source Binary
Programmer Dvorak Source Binary
## Linux Back when I used desktop Linux, I used [dvorak-qwerty][dvorak-qwerty] to swap my keyboard layout. I found this to be the least reliable layout between the three operating systems, but I never found a better way than this program which rebinds at the X11 level. [pd]: http://www.kaufmann.no/roland/dvorak/ [ahk]: http://www.autohotkey.com/ [dvorak]: https://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard [qwerty]: https://en.wikipedia.org/wiki/QWERTY [dq-mac]: /blog/tech/programmer-dvorak-with-qwerty-shortcut-keys-on-os-x/ [apple-dqc]: http://support.apple.com/kb/PH6528 [dvorak-qwerty]: https://code.google.com/p/dvorak-qwerty/ ]]> 2014-03-26T02:15:46-07:00 Programmer Dvorak with QWERTY shortcut keys on OS X https://msol.io/blog/tech/programmer-dvorak-with-qwerty-shortcut-keys-on-os-x/ Mon, 17 Mar 2014 15:30:51 -0700 https://msol.io/blog/tech/programmer-dvorak-with-qwerty-shortcut-keys-on-os-x/ ` element: Then press ReloadXML in the upper-right corner of Karabiner, and check the "Use Programmer Dvorak -- Qwerty Keyboard Layout" box. Enabling Programmer Dvorak -- QWERTY ⌘ Command in Karabiner That's it! If you want to further customize the behavior, edits to the XML should be reasonably straightforward. ## My Programmer Dvorak experience I sometimes get asked if it is worth learning to type in Programmer Dvorak. My short answer is no. My longer answer is that while I find it more comfortable than QWERTY, I do not find that I type faster or see a strong daily benefit (I alone am too small a sample size to say anything useful about RSI). It also requires work to maintain things like shortcut keys, and it inhibits both my ability to work on other people's computers as well as other people working on mine. It also has decreased my QWERTY typing speed, especially with numbers and symbols. That said, I have largely solved these problems for myself, and I will continue to use Programmer Dvorak day-to-day. [pd]: http://www.kaufmann.no/roland/dvorak/ [dvorak]: https://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard [ukelele]: http://scripts.sil.org/ukelele [karabiner]: https://pqrs.org/osx/karabiner/ ]]> 2014-03-17T15:30:51-07:00 Android: Convert Drawable to Bitmap https://msol.io/blog/android/android-convert-drawable-to-bitmap/ Thu, 13 Mar 2014 02:20:13 -0700 https://msol.io/blog/android/android-convert-drawable-to-bitmap/ 
public Bitmap convertToBitmap(Drawable drawable, int widthPixels, int heightPixels) {
    Bitmap mutableBitmap = Bitmap.createBitmap(widthPixels, heightPixels, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(mutableBitmap);
    drawable.setBounds(0, 0, widthPixels, heightPixels);
    drawable.draw(canvas);

    return mutableBitmap;
}
First we create a mutable Bitmap object of the correct size in pixels. I recommend you use ARGB_8888 instead of another Bitmap configuration unless you have a specific reason not to. Then we create a new [Canvas][canvas] backed by that bitmap, set the bounds appropriately on the drawable, and draw the Drawable onto the Canvas. This is when the Drawable actually gets mapped onto the pixels represented by the Bitmap. We now have a Bitmap suitable for use elsewhere. I have found this to be a useful technique for masking images with Path objects when antialiasing is required. ### Write Bitmap as a JPEG image If you want to write a Bitmap (or a Drawable that has been converted to a Bitmap) as a JPEG image, you can use this simple technique: 
public void writeJpegImageToFile(Bitmap bitmap, FileOutputStream jpegFileStream) {
    // use JPEG quality of 80 (scale 1 - 100)
    bitmap.compress(Bitmap.CompressFormat.JPEG, 80, jpegFileStream);
}
[drawable]: http://developer.android.com/reference/android/graphics/drawable/Drawable.html [bitmap]: http://developer.android.com/reference/android/graphics/Bitmap.html [canvas]: http://developer.android.com/reference/android/graphics/Canvas.html ]]> 2014-03-13T02:20:13-07:00 Bitshifting by example https://msol.io/blog/tech/bitshifting-by-example/ Sun, 02 Mar 2014 02:50:13 -0800 https://msol.io/blog/tech/bitshifting-by-example/ >` operators in many languages shift bits (usually in integers) around and that there are some techniques to isolate certain blocks of bits out for reading, but you haven't actually _tried_ these techniques. Let's fix that by example. ### Bitshifting Bitshifting is actually pretty simple. Take the 32 bit unsigned integer 232 - 1, which is represented by all ones. I have separated it into octets (8-bit bytes). 
                 0xffffffff
<-- most significant ... least significant -->
     11111111 11111111 11111111 11111111
      byte 1   byte 2   byte 3   byte 4
Let's represent this in some C code: 
uint32_t field = 0xffffffff;
It is convenient to represent this value using hex notation, since there is a 1:1 mapping between hex and the resultant bits. This is the same value from above, just written in hexadecimal notation instead of binary. Here is a quick table to convert hex to binary, in case you are unfamiliar or out of practice:
0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7
0000 0001 0010 0011 0100 0101 0110 0111
0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf
1000 1001 1010 1011 1100 1101 1110 1111
Now let's bitshift this left 4 bits: 
field = field << 4; // equivalently, field <<= 4
which results in: 
             0xfffffff0
11111111 11111111 11111111 11110000
If each `1` were a buffalo and each `0` a plot of empty land, then we just forced 4 buffalo off of the left hand cliff in order to make more empty land on the right hand side. The rule is simple: when you bitshift left, shift all the bits to the left and pad the right with zeros. For some reason this makes me think of hunting by [buffalo jump][buffalo.jump]. #### Bitshift right Bitshifting right is much like bitshifting left--in fact, it is identical **unless** you are using signed integers, in which case things get implementation-specific in some languages (basically, sometimes you get padded with the [sign-bit][sign.bit] instead of always 0). Today, let's just worry about unsigned integers. Continuing with our result from before, a small bitshift right 
field = field >> 1;
results in 
             0x7ffffff8
01111111 11111111 11111111 11111000
Notice that since `field` is unsigned we pad with a `0` on the left, and that everything else has been shifted right by one location. ### UUIDs Let's look at a time when all this bitshifting might come in handy. [Universally Unique IDentifiers][uuid.wikipedia] are 128-bit identifiers that are often displayed in 36-character strings rendered thusly: `63afa317-ef9e-4127-93a8-a8996d99d5ee` But what do UUIDs have to do with bitshifting? As it happens, there is an [RFC][uuid.rfc] to standardize UUIDs and set certain bits in order to identify a given 128 bit object as a UUID and to specify which variant it is. The UUID specification breaks apart integers into fixed-width fields within each integer and assigns different meanings to each field. The RFC gives us this diagram showing each field and is split into 4 vertically-stacked 32-bit ints: 
0                   1                   2                   3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                          time_low                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|       time_mid                |         time_hi_and_version   |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|clk_seq_hi_res |  clk_seq_low  |         node (0-1)            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         node (2-5)                            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
It's time to use our new skills. Let's try reading time_hi_and_version since it's one of the more complicated fields. #### Simple field-reading by double bitshifting A simple way to read such a field is to first "shift off" all of the bits we don't care about that are to the left of the field of interest, and then to shift that same field as far right as we can go without shifting that field "off the edge." This technique leaves the field we care about in the least significant bits, where it can be easily interpreted as an integer. Let's take the second 32-bit integer, the one that includes time_mid and time_hi_and_version. 
              0x11223344
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0001000100100010 0011001101000100   |
|     time_mid    |time_hi_and_version|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
We can extract the version field out of this. The RFC describes this field: > The version number is in the most significant 4 bits of the time > stamp (bits 4 through 7 of the time_hi_and_version field). Counting from most to least significant (left to right) we can see that those are bits 20 through 23. We should first shift out the 19 most significant bits we don't care about: 
field <<= 19;
leaving us with 
              0x9a200000
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 1001101000100000 0000000000000000   |
|     time_mid    |time_hi_and_version|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Now we want to remove everything but the 4 bits we care about: 
field >>= 28;
yielding 
              0x00000009
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0000000000000000 0000000000001001   |
|     time_mid    |time_hi_and_version|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Looking this up in the table given in the RFC, we see that this is not a valid version for a UUID! The first bit must be zero, but we can clearly see that it is not. #### Summary It turns out that bitshifting isn't as hard as it seems. This simple technique won't cover every case (in particular, [bitmasking][bitmasking] may be useful in related situations) but it is a tool that is occasionally useful to have. [uuid.wikipedia]: http://en.wikipedia.org/wiki/Universally_unique_identifier [uuid.rfc]: http://www.ietf.org/rfc/rfc4122 [buffalo.jump]: http://en.wikipedia.org/wiki/Buffalo_jump [sign.bit]: http://en.wikipedia.org/wiki/Sign_bit [bitmasking]: http://en.wikipedia.org/wiki/Mask_(computing) ]]> 2014-03-02T02:50:13-08:00 Know each system’s responsibilities https://msol.io/blog/tech/know-each-systems-responsibilities/ Sun, 06 Oct 2013 07:56:13 -0700 https://msol.io/blog/tech/know-each-systems-responsibilities/ 
err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
Unfortunately, when I tried to run the code against my database (Postgres) the parameters weren't getting substituted in. I quite literally spent hours pouring over the Go documentation and searching the Internet for anything that could tell me what was wrong. The two examples in the Go documentation were very minimal but seemed to suggest that I was simply using the functions as expected. My search ended when I finally realized that the substitution *didn't take place in Go*. The Go package I was using forwarded the query and parameters along to Postgres, which in retrospect is perfectly natural because Postgres knows how to substitute parameters appropriately, while the Go code doesn't need to know the specifics. The problem still isn't immediately obvious---shouldn't Postgres substitute the parameters correctly? Well, it turns out that Postgres doesn't support question mark syntax for parameter substitution; it instead uses numbered parameters such as $1, $2, .... The Go examples simply chose a common (yet not universal) parameter substitution convention. The point is that if I had understood which system was responsible for the action I was concerned about -- parameter substitution -- then I would have saved an immense amount of time debugging. Instead of searching for a solution in Go documentation, I would have checked how Postgres expected it to be done and found an answer in minutes. Next time you have trouble figuring out why a system's behavior doesn't match your expectations, make sure you are examining the right system---it could be you are looking at the client and not the provider. [flesh]: https://github.com/Chandler/flesh [go.sql]: http://golang.org/pkg/database/sql/ [sql.injection]: http://en.wikipedia.org/wiki/SQL_injection ]]> 2013-10-06T07:56:13-07:00 Create a self-signed ECC certificate https://msol.io/blog/tech/create-a-self-signed-ecc-certificate/ Sun, 06 Oct 2013 02:25:13 -0700 https://msol.io/blog/tech/create-a-self-signed-ecc-certificate/ 
openssl ecparam -genkey -name prime256v1 -out key.pem
openssl req -new -sha256 -key key.pem -out csr.csr
openssl req -x509 -sha256 -days 365 -key key.pem -in csr.csr -out certificate.pem
openssl req -in csr.csr -text -noout | grep -i "Signature.*SHA256" && echo "All is well" || echo "This certificate will stop working in 2017! You must update OpenSSL to generate a widely-compatible certificate"
The first command is the only one specific to elliptic curves. It generates a private key using a standard elliptic curve over a 256 bit prime field. You can list all available curves using 
openssl ecparam -list_curves
or you can use prime256v1 as I did. The second command generates a [Certificate Signing Request][csr] and the third generates a self-signed x509 certificate suitable for use on web servers. The check at the end ensures you will be able to use your certificate beyond 2016. OpenSSL on OS X is currently insufficient, and will silently generate a SHA-1 certificate that will be [rejected by browsers][sha1.rejection] in 2017. Update using your package manager, or [with Homebrew][homebrew.openssl] on a Mac and start the process over. ### More on ECC If you're interested in elliptic curve cryptography, Wikipedia has a [good introduction][ecc] that includes the math behind it, as well as more specific information on [ECDSA][ecdsa.wiki] in particular. As usual, there are good links from there to learn more. [sha1.rejection]: https://developer.mozilla.org/en-US/docs/Web/Security/Weak_Signature_Algorithm [homebrew.openssl]: https://solitum.net/openssl-os-x-el-capitan-and-brew/ [ecdsa.schneier]: https://www.schneier.com/crypto-gram-9911.html#EllipticCurvePublic-KeyCryptography [csr]: https://en.wikipedia.org/wiki/Certificate_signing_request [ecc]: https://en.wikipedia.org/wiki/Elliptic_curve_cryptography [ecdsa.wiki]: https://en.wikipedia.org/wiki/Elliptic_Curve_DSA [self.signed.openssl]: /blog/tech/create-a-self-signed-ssl-certificate-with-openssl/ ]]> 2013-10-06T02:25:13-07:00 Sending links with custom URL schemes through e-mail https://msol.io/blog/tech/sending-links-with-custom-url-schemes-through-email/ Sun, 21 Jul 2013 03:39:13 -0700 https://msol.io/blog/tech/sending-links-with-custom-url-schemes-through-email/ 
<a  href="my-app://deep-link"
    href="http://example.com/backup-link"
    href="my-app://deep-link"
>Link Text</a>
By bracketing the backup link with the desired link, browsers (at least those I've tested) will ignore the backup link, except when the desired links have already been stripped out by Gmail. ### The backup link Obviously, the backup link can be whatever you want. I chose a link that goes to a dynamically-generated page (that I host) with a simple piece of logic. If the user is on an iOS device ([by user-agent][ua-sniffing]), then return a 301 or 302 HTTP Redirect to `my-app://deep-link`. If not, then return a 301 or 302 HTTP Redirect to some sane location, such as the app's website or App Store page. The behavior of this link is slightly less desirable that the direct link. The backup link requires an Internet connection, and even when one is present the link first loads an intermediate page before the app which is both slower and presents another opportunity for failure. Even so, this is acceptable given that the direct link was removed on our behalf. ### Less than perfect The astute reader may notice that there are still several situations in which a user can click a link that has no apparent effect. I think that this is totally acceptable given the context in which the link is presented, but this method tries to ensure that the link is always clickable, even if the destination is unavailable. [register-url-scheme]: http://developer.apple.com/library/ios/#documentation/iphone/conceptual/iphoneosprogrammingguide/AdvancedAppTricks/AdvancedAppTricks.html#//apple_ref/doc/uid/TP40007072-CH7-SW20 [ua-sniffing]: http://stackoverflow.com/a/9039885 ]]> 2013-07-21T03:39:13-07:00 2019-06-15T04:50:13-07:00