LastPass Alternatives

I’m not entirely happy with the Logmein purchase of Lastpass. I’m looking at alternatives.

I need passwords on my laptop, my employer’s laptop, and my cell phone. I’d like access

to them when I use a web browser elsewhere, but I could refer to my cell phone data.

I need sync across platforms. I need 2 factor authentication (2FA).

Current thinking: LastPass sure is convenient, and maybe they do a better job than me, but they are an appealing target for hackers. KeePass looks to me to be the most secure product that meets my requirements, but it is awfully DIY. I’d like a product that will sync 2 Windows machines and a Mac and an Android and an iPad via WiFi, so that my data stays within my boundaries.

• Blank means OK; ? means unknown/unresearched; N means not available.
• Comparison matrix from someone else at http://www.asecurelife.com/dashlane-vs-lastpass-vs-1password-vs-roboform-vs-keepass/
• See big review at http://thenextweb.com/apps/2013/10/06/10-of-the-best-multi-platform-password-managers-for-ios-android-and-the-desktop/
• Note that LastPass (and others, maybe) stay logged in on your cell phone unless you manually logout. If someone gets your phone and you don’t have a strong PIN on the phone, your LastPass data is at risk.
• ‘KeePass’ includes KeePass desktop, (SyncThing or Google Drive or Dropbox), (KeePassDroid or Keepass2Android or MiniKeePass).
  • See http://www.guidingtech.com/29652/sync-keepass-android/
  • This can get weird for 2FA on Android. See https://www.tomaz.me/2013/10/24/my-password-manager-setup-keepassx-keepassdroid-yubikey-spideroak.html
  • More on 2FA with KeePass: http://nidkil.me/2014/12/10/adding-two-factor-authentication-to-keepass-keepass2android/
  • This can get weird for web access. See http://sourceforge.net/projects/webkeepass/
  • Here are setup instructions for WebKeePass: http://blog.sukria.net/2013/08/27/webkeepass-or-how-to-build-your-own-cloud-aware-keyring/
• One Password: See https://agilebits.com/onepassword
• ‘Chrome’ means the browser, saving passwords. There is no 2FA here. Browsers also allow sites to forbid auto-fill.
• ‘Firefox’ means the browser, saving passwords. There is no 2FA here. Browsers also allow sites to forbid auto-fill.
• Enpass uses Dropbox (and similar services) or your own WebDAV server.

a.k.a. MacBook Pro Retina locks up internal keyboard and touchpad

Every now and then, my MacBook Pro Retina locks up the keyboard and the touchpad. Plugging in a mouse and clicking somewhere recovers it. This is reportedly due to Android File Transfer, which I do use. I removed AFT from my auto-started applications and killed it.

If this doesn’t fix it, I’m going to add a mouse jiggler to my carry kit. (USB device that moves a mouse a few pixels every few seconds to defeat screen saver.) Small and and easy to use recovery device.

If you see a word in a clojure program (e.g. apply, map, defn…) you can use Google to find out what it means. Just search for “clojure” and the word. Try that with something like curly braces or #’ or ‘( or… This makes it tough for a beginner to read code written by someone at a higher skill level.

This is a list of the non-word character sequences which have a special meaning in Clojure that I had to look up at one time or another.

• "xyz"
  • string containing xyz
• #"
  • Regular expression. e.g. #”[A-Z]+” is a regular expression for a string of one or more upper-case letters.
• '
  • It designates a literal. If you put it before something, it means don’t evaluate it. The literal may be referred to as being escaped.
  • e.g. '(1 2 3) gives you a list with 1, 2, and 3 instead of attempting to call the function 1 with arguments 2 and 3)
• {}
  • map (or some might call it a hash table). e.g. {:a 1, :b 2, :fat "tuesday"}
• #{}
  • set. e.g. #{:a :b :c}
• []
  • Vector
  • Arguments to a function are indicated as a vector, so you could be looking at formal parameters if you’re inside a function definition.
• ()
  • A list or a sequence. Often escaped. e.g. '(1 2 3)
  • Or you could be looking at a function call. e.g. (str "a" "b")* #(...)
  • Define an anonymous function. e.g. #(str "a" "b" %)
• %
  • A single argument in an anonymous function
  • e.g. #(str "a" "b" %)
• .
  • It might indicate a Java function call. e.g. (.toUpperCase "hello")
• ->
  • thread-first macro. Take the first argument and run it through a each of the listed functions as the first argument. e.g. (-> [9 1 2 4] sort str) returns “(1 2 4 9)” (because sort returns a seq, rather than the type of its arg)
• ->>
  • thread-last macro. Take the first argument and run it through a each of the listed functions as the last argument.

I’m an intermittent programmer. I program for a while, then I work on other things, then I do some more programming. I may take a break of months or even years between programming sessions. I need a text editor, suitable for programming, that doesn’t require intense familiarity with it in order to be moderately productive.

Years ago, I was pretty good with emacs. I can do simple text editing with vi today. For both of these editors, my skills have a tendency to quickly fade to such a level that I just can’t be productive. They are great editors – if you use them daily.

I’m currently learning Clojure, and I really want an environment that supports source-code debugging, with breakpoints and variable inspection, when I invoke a function from the REPL.

The Clojure Summary Before the Details:

• Atom is a decent Clojure editor, but no source-level debugging.
• Cursive is irksome; it has opinions about how to enter code which don’t sit well with me, but it has a working debugger.
• Visual Studio Code with ‘Clojure Code’ shows promise. It is a good editor. The debugger is twitchy; it might be really good soon or it might remain twitchy.
• None of the others come close.

If you are going to use a debugger, your options are Emacs, Eclipse, Cursive, or Video Studio Code. The only debugger which is close to prime time, in an editor I can bear, is Cursive.

What I need:

• Plain text editing.
• Syntax highlighting for most, if not all, languages. If an obscure, new language piques my interest, I want my editor to support it.
• REPL support (for suitable languages). I don’t want to have to manually copy/paste between my editor and my REPL.
• Fast load time. (That pretty well rules out Eclipse.)
• Enough menu/prompting support that I don’t have to be current in my use of the editor. (This rules out vi and emacs.)
• Rainbow paren support. Yup. I do Lisps. I need to see which paren I missed.
• Windows and Mac. Linux is nice too. Windows version should run from a flash drive, so I can run it on work machines where I’m not allowed to install software.
• Some sort of file browser. Show me the directory/file tree of my project folder. (Show/hide capability necessary.)
• Stable. You can still be adding features, but I need my copy of it to be rock-solid.
• Not real expensive. I wouldn’t mind spending $100 once, but I can’t pay a recurring charge since I use it infrequently. If it is non-free, I need a full-featured trial period long enough to decide to commit to it.
• Attractive (subjective) gets bonus points, but it is not a requirement.

At the moment, I’m interested in Clojure, so that gets a little weight, but I’ll need good Python support, plus dozens of others. I don’t want a Clojure-only environment. Desired Clojure REPL integration:

• Load file in REPL
• Switch REPL to namespace of current file
• println output to REPL
• Execute selected code in REPL
• REPL is conveniently located/accessible
• Don’t make me go through something terribly awkward to send code to the REPL
• Source code debugging (e.g. breakpoints, examine variables, etc.)

Candidates in the running:

• Eclipse - way too slow to start. Has good REPL integration. Rainbow parenthesis (via Clockwise). I might have to overlook the slow start. (It takes 10 seconds!)
  • Windows: Has to be installed, but I’m allowed to install this on work computers.
  • Clojure: It supports breakpont debugging for Clojure. I tried it. I didn’t care for it. It said a variable was null when it had been set; when I added a later use of the variable, it was able to show the value. I think it might just be agressive about discarding variables when they are no longer used. The debug perspective doesn’t include the REPL output pane. It does not have parinfer.
• Light Table 0.8-alpha - maybe… It is rough around the edges. It sure has nice REPL support for Clojure. Configure-by-editing-config-files knowledge will go stale quickly.
  • Rainbow paren - see https://github.com/LightTable/Rainbow. It doesn’t really seem to work well. I see adjacent parens getting the same color.
    • Try https://groups.google.com/forum/#!topic/light-table-discussion/NfVDHYoXRjM
    • With both of those applied, it seems to work
    • Supports Clojure, Python (2 and 3), JavaScript. ‘Real-time’ feedback as you edit. Abandoned by its creator as of January 2016. Open sourced to GitHub.
  • It does support parinfer via a plugin.
  • Windows: Looks like it runs ‘portably’ from any directory, including a flash drive.
• Sublime Text 3 build 3083 - looks adequate. Starts fast. Clojure REPL seems a little weird with its use of load-string. Configure-by-editing-config-files knowledge will go stale quickly.
  • Reportedly has rainbow paren support. I can’t find it.
  • Windows: Portable edition exists

• Atom - Linux, Windows, Mac. Syntax highlighting for most languages. Many plugins.

  • Clojure
    • I occasionally have to restart it when it starts throwing errors in the REPL.
    • Using these plugins, its is a very usable environment, but it does NOT have a debugger:
      • language-clojure
      • tool-bar
      • proto-repl
      • ink
      • See: http://worace.works/2016/06/14/good-enough-clojure-setup/
• Visual Studio Code
  • Clojure with the ‘Clojure Code’ extension (a.k.a. jamesnorton.continuum).
    • Looks interesting. The debugger is marginably usable, but looks more like a proof-of-concept right now. It works if you get it just right, but it gives stack traces instead of messages like ‘unable to set breakpoint because I cannot find your source file.’
    • The developer is responsive and helpful via gitter.
    • The debugger crashes if you don’t add a :source-paths ["src" "src/main/clojure"] to project.clj.
    • I had to often manually kill the leiningen process which backs the debugger. If it errors off, you can’t stop and restart it from the IDE.
    • It’s a nice editor. It opens fast and it is multi-platform.

• Cursive

  • I finally got the debugger to work. It got confused because I copied core.clj to backup-core.clj. It compiled and loaded both, and since they both implemented the same functions in the same namespace, thins went poorly.
  • Learning: There is no way to view the value of a lazy seq in the Clojure debugger because you can’t evaluate expressions at a breakpoint and the lazy seq isn’t ‘realized. UPDATE: There is an Evaluate Expression icon on the right end of the Debugger panel’s toolbar. (It looks like a little calculator.) You can use “(first lazy-seq)” or similar functions to realize the lazy seq.
  • Learning: Paste behaves in unexpected ways, converting newlines into “\n”, among other things. Swap the key bindings for Past and Paste Simple in order to get the expected behavior on Paste.
  • At one point, it started reporting a dependency loop and refusing to load files into the REPL. I closed IDEA, deleted the .idea and the .iml files/directories, and re-opened the project directory with IDEA, and it created a new project. Same problem. I deleted everything from the target folder too. No good. I created a new project in a new directory and copied files to recover. I think this may have been the result of changing namespaces in my test files. I had to do that because I tried to make some functions private (via “defn-“) and then I had to be in the same namespace in the test file in order to use them. Learning: “defn-“ is an advanced subject. Learning 2: Cursive likes to ‘understand’ the code and that can bewilder me. This is similar to the core.clj to backup-core.clj problem mentioned above. This “understand the code” philosophy of Cursive is a risk – when it fails, it fails hard. It may be the case that File » Invalidate Caches/Restart was part of the solution.

  Candidates that did not make the cut:

• emacs - too hard to remember after 12 months off. Emacs is a great tool if you use it every day, but I’m an intermittent coder and the keystroke memory fades too quickly. If and only if you’re already a heavy Emacs user, the CIDER plugin is the right tool for Clojure.
• JEdit: REPL - basic support is there; not full-featured. I don’t see rainbow paren.
• Komodo Edit - no REPL support
• SciTE: REPL = no; rainbow paren = no
• Sublime Text 2 - REPL gap. SublimeREPL stopped working with this version.
• vi - too hard to remember after 12 months off. For Clojure, use the Fireplace plugin. See this guy’s writeup on the Clojure vim toolchain.

Things I hated while working on a Clojure project:

• Atom - I used Atom for a couple of weeks, several hours a day. Extensions: parinfer, proto-repl, language-clojure.

  • At first, I hated parinfer. Then it became a must-have feature.
  • Every once in a while, the REPL started throwing an Ink exception on each enter key. I can’t reproduce it on demand, but it made me have to restart.
  • I really, really want a source-code debugger. Other than that, this is a decent environment.

• Cursive - I used Cursive for several days.

  • I can’t disable “Emacs Tab” behavior. I bound the Tab keystroke to the Tab action. I unbinded the Emacs Tab behavior. I still get Emacs Tab behavior when I press Tab. This is because parinfer mode (which I love) overrides Tab to make it be Emacs Tab. I emailed with the developer and Cursive overrides the Tab action, not just the tab key, so you can’t even do something like binding ^T to the tab action. Settings » Keymap » Editor Actions » Emacs Tab – this simply doesn’t work for disabling Emacs Tab with Cursive.
  • Up-arrow is a little wonky in the REPL. It is easy to move it up through a multi-line expression, and then accidentally jump to the previous command in the history.
  • It tries really hard to understand the code. When it works, it is impressive. When it fails, it fails hard. I’ve twice been nailed by it compiling things and merging them into its ‘mental model’ which I didn’t intend. This is high risk of project-blocking issues.
  • It is really nice, but also really frustrating.
• Visual Studio Code - with “Clojure Code” extension.
  • The debugger is not ready for non-hacker users. I think it works, but it is touchy and it simply crashes when an error message would be appropriate.
  • I’m all the time having to “killall java” to kill off broken REPLs running in the background.

• Eclipse with Counterclockwise. I used this for a few hours.

  • It starts really slow. I could get over that.
  • It uses Ctrl-P and Ctrl-N to move up/down the REPL command history (instead of the up/down arrows, like everyone else).
  • It doesn’t do parinfer. (It does paredit.)
  • Eclipse is the GUI Emacs. So many obscure actions and keystrokes, so hard to find and remember.
  • I couldn’t get dark color themes to apply to anything except the editor pane. I want to change the colors of all those other panes too. (I’m using stand-alone Counterclockwise; maybe this works with full Eclipse?)

This is apparently an issue of dogma. Here’s a workaround, if you don’t care about the dogma.

Go to Settings -> Window Manager -> select Daloa. This gives you thicker window borders.

• Variables don’t vary.
• Don’t use global variables or global constants.
• Don’t iterate. Use a higher order functions.

I downloaded a PDF book. It looks like someone added a footer to each page of the original, and that pushed the content up on each page so that the first half inch of each page’s isn’t visible.

I fixed the PDF by:

• Downloading and installing the brew (homebrew) package manager. (I use a Mac.)
• Running “brew install ghostscript”.

• Running

  gs -sOutputFile=output.pdf -sDEVICE=pdfwrite -sPAPERSIZE=a4 -dCompatibilityLevel=1.4 -dNOPAUSE -dBATCH -dPDFFitPage input.pdf

See http://ghostscript.com/doc/7.07/Use.htm#Known_paper_sizes

Or use “-dDEVICEWIDTHPOINTS=w -dDEVICEHEIGHTPOINTS=h” where w is width and h is height, in 1/72” (points).

OS X Preview can show you the page size via Tools > Show Inspector. Then multiply the dimensions in inches by 72 and round up to an integer.

Note: I don’t give choices here. If you’re a beginner, you don’t know enough to choose an option. Sometimes choice is a bad thing because it overwhelms.

Check to be sure you have Java.

java -version

“java” only comes with the JDK. You can add Java to your browser, but without the JDK, you don’t get the “java” command-line command.

If you get “No Java runtime present, requesting install”, you can dismiss the dialog and google for “Java SE Development Kit”. Go to Oracle and download and install the latest Java SE development kit. It should be a 64-bit .dmg file. Open the .dmg and run the installer.

Install Leiningen:

    cd ~/bin
    curl -O https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
    chmod +x lein

• If ~/bin is not already on your path, edit ~/.bash_profile and add it to your path. Then run” ` . ~/bash_profile`”
• Execute the command “lein” once (for the first time) to install Leiningen
• Helpful lein command lines:
  • Start the Clojure “repl” (command-line interpreter)
    • lein repl
  • Create a new application (as opposed to library) project
    • lein new app my-project-name
  • Search clojars
    • lein search $TERM
  • Run the project in the current directory
    • lein run
  • Run tests
    • lein test

Learn Basic Clojure:

I found these helpful:

• http://www.amazon.com/Living-Clojure-Carin-Meier-ebook/dp/B00W4DTCSW - If you already know how to program and you want to acquire Clojure efficiently and effectively.
• https://www.cis.upenn.edu/~matuszek/Concise%20Guides/Concise%20Clojure.html - reminders of what you read in Living Clojure. (This was a little too terse for me, without Living Clojure to help.)

Install an IDE (or an editor and use leiningen projects to build jars (and auto-download Clojure as needed) – I haven’t decided yet):

• Light Table - I’m sure this could be a wonderful IDE/editor. When I tried a Clojure “instarepl”, it exposed a bug in displaying the intermediate results. I found the solution online, which was to update the Clojure plugin. Of course, the directions said to click “upgrade”, which didn’t exist. I eventually did a Command window search and found a command to search for plugin updates, which revealed the missing “update”. After I updated the Clojure plugin, I started seeing a bunch of “Invalid behaviors file” messages in the console. The solution to that is to “just build from source”. No thanks. I didn’t really want to build an editor – I just wanted to try editing a little Clojure code.

Some Notes on Clojure

• Note that these may not be strictly accurate. They are approximations/abbreviations/incantations to help remember some of Clojure.

• Comment: semicolon (;) through end of line
• Data:
  • Integer = 123
  • String = “abc”
  • Ratio = 1/2
  • Decimal = 12.3
  • Keyword = :abc
  • Character = \a
  • Boolean = true
  • Nothing = nil
    • (true? nil) is false; (false? nil) is false; nil is logically false, but it doesn’t satisfy “false?”; (not nil) is true.
  • List = ‘(1 2 3)
  • Vectior = [1 2 3]
  • Map = {:one 1, :two 2, :three 3}
    • Commas are whitespace
  • Set = #{ 1 2 3}
• Functions:
  • Function call = (funcName arg1 arg2)
  • Global var = (def aVar aVal)
  • Local var = (let [aVar1 val1 aVar2 val2] expr1 expr2)
  • A function to return a function = (fn [parm1 parm2] expr1 expr2)
  • Abbreviated function to return a function = #(…) = (fn [arg1 arg2] (…))
    • There must be a function to call as the first item in … (See this explanation.)
    • Args within the function definition are %1, %2 (or just % for a single arg)
  • Name a function = (def funcName (fn [parm1 parm2] expr1 expr2))
  • Name a function tersely = (defn funcName [parm1 parm2] expr1 expr2)
  • A set can be treated as a function which takes a value and returns that value if it is found in the set. e.g. “(#{1 2 3} 2)” returns 2, but “(#{1 2 3} 4)” returns nil.
• Visibility - Visibility is controlled by namespaces:
  • Qualify a variable with its namespace name via a “/” = namespaceName/varName
  • Change/define namespace = (ns newSpaceName)
  • Variable with current namespace name = ns
  • Load a namespace = (require ‘namespaceName)
  • Load a namespace and rename it = (require ‘[namespaceName :as newName])
  • Change namespace and load another namespace into it = (ns newSpaceName (:require [anotherSpace :as af]))
• Misc functions:
  • identity returns its argument. e.g. (identity 42) returns 42
  • quote = do not evaluate this. e.g. (quote aName) returns aName and does not evaluate it
  • Terse quote (apostrophe) = ‘aName
  • Is predicate true for each member of a collection = (every? predicate collection). e.g. (every? (fn [x] (= x :cigar)) [:cigar :cigar])
  • Is predicate true for NO members of a collection = (not-any? predicate collection). e.g. (not-any? (fn [x] (= x :goodRepublican)) [:republican1 :republican2])
  • Is predicate true for some members of a collection = (some predicate collection)
  • (if expr1 expr2 expr3)
  • (if-let [var1 val1, var2 val2] expr2 expr3)
  • (when expr1 expr2) – This is just like (if expr1 expr2)
  • Multi-conditional = (cond bool1 expr1 bool2 expr2 bool3 expr3))
  • select…case on a single variable = (case var val1 result1 val2 result2 val3 result3 resultForNoMatch)
  • (println var1 var2)
  • Sorta like BEGIN/END in Pascal: (do (expr1)(expr2))
  • (for [var1 [val1 val2]] …)
  • (for [var1 [val1 val2] :let [var3 val3 var4 val4] ] …)
  • (for [var1 [val1 val2]] var3 [valA valB] …) = val1+valA, val1+valB, val2+valA, val2+valB
• Destructuring:
  • (let [a 1] …) = normal let
  • (let [[a b][1 2]] …)
  • (let [ [ a b :as orig] [1 3 5]] (println orig))
  • (let [{flower1 :flower1 flower2 :flower2} {:flower1 “red” :flower2 “blue”}] …)
    • The left side looks backwards, but think of it as assigning the :flower1 value to the var flower1.
  • (let [{flower1 :flower1 flower2 :flower2 :or {flower1 “missing1” flower2 “missing2”} } {:flower1 “red” :flower2 “blue”}] …)
  • (let [{:keys [flower1 flower2]} {:flower1 “red” :flower2 “blue”}] …)
• Idioms:
  • Instead of “(not (empty? aCollection))” use “(seq aCollection)”. It is OK to use “(empty? x)” – just not “(not (empty? x))”.
  • ”?” at the end of a function indicates that it returns a boolean (is a predicate). e.g. true? nil? empty?
  • Multi-conditional = “(cond bool1 expr1 bool2 expr2 :else expr3))” is idiomatic for “(cond bool1 expr1 bool2 expr2 true expr3))”
  • Variable name meaning “I don’t care about this value” = “_”.
• Definitions
  • Predicate (paraphrased from Wikipedia): A statement that may be true or false depending on the values of its variables. An operator or function that returns either true or false.

• For short-form anonymous functions, %1 %2 %3… represent positional parameters. % is equivalent to %1.
• apply - takes a seq and passes the elements to a function. i.e. If you have something that looks like (f [1 2 3]) and you want (f 1 2 3) then you should (apply f [1 2 3])

I’m revising my to-do process again. My employer cancelled its full-time work-at-home program, so I need to use web-based tools, so I can get to them from work and home.

Some givens:

• I have 20-30 active projects (‘cases’) at work. (“Projects” in the normal sense, not in the GTD sense.)
• Dropbox and Evernote are blocked by the firewall at work because work doesn’t like “file sharing” sites.
• I have a tendency to carry items on my task list that I’m not really committed to completing. (i.e. I’m over-committed.)

Primary tool: Nirvana

• Everything is sequential - unless manually Active Starred
• You don’t have to put all your projects actions on the Next lists – just the ones that you’ll worry about, or you won’t do without this reminder.
• Having a short list of actions to choose from helps ensure that you make progress on the important things that matter “right now.”
• Don’t use Nirvana for tracking what I did. Put that stuff elsewhere. Nirvana is just for doing.

Weekly Review:

• Occurs Friday, Saturday, or Sunday afternoon. If I don’t get it done Friday or Saturday, Sunday’s is a must-keep appointment.
• For each project, spend some time thinking about the project as a whole. What is the project goal? What is the project status? Is it moving forward? What have we accomplished? Review all sub-projects.
• Adjust technique to address what worries you most. The goals are to get stuff off your mind and to work on the right things.
• Visit each task and ensure it complies with Task Urgency, Task Decomposition and Tags - documented elsewhere on thispage.
• Is the Someday list too long? Do I need to add tags for undecided and not-doing?

Task Urgency:

• Star: Today. Committed to work on this today and to stay up late if necessary.
• Next: This week. Consequential if I don’t work on it this week. (This week = through Monday after my next weekly review.)
• Later: Soon. Not this week, but genuinely committed to get it done or expensive if not done. Use a due date to drag it back to consciousness if appropriate. (Due date = the date to consider moving it to Next, not the genuine deadline.)
• Someday: Maybe. Look at it again in a month. Use a due date to drag it back to consciousness if appropriate. (Due date = the date to consider moving it to Next, not the genuine deadline.)

Task Decomposition:

• Sub-projects: Create a “task” under the project, and use Nirvana “inline checklist” for subproject tasks. If I’m ready to work a checklist item, move it up a level (make it a task in the main proj). [When do I mark it complete in the checklist?]
• Next-actions must be fully decomposed.

Tags:

• kpk (area)
• att (area - use this only for things that my employer wants, or things that impact my performance review or resume)
• rec (covers personal intrinsically enjoyable and work-don’t-wanna-do-anything-productive)
• subproj (this item is a sub-project, contained within a parent project)
• Maybe use “undecided” and “not-doing” tags for Someday?

Stylish:

I used Stylish to

• Rename Later to Soon.
• Rename Someday to Maybe.
• Rename Focus to Today.
• Rename Next to This Week

See attached file.