HN Theater @HNTheaterMonth

I’d encourage you to apply the three-step process presented in [0] (there’s also a video [1]), which is actually not specific to Vim:

1. While you are working with software tools, keep an eye out for actions you repeat and/or spend quite a bit of time on.

2. Find out if there is a command (or macro facility etc.) that will do this action quicker. Read the documentation, ask a friend, or look at how others do this.

3. Train using the command. Do this until your fingers type it without thinking.

This means that you can learn new commands only as the need comes up by observing what you do. Which commands you will want to learn thus depend on the operations you are frequently doing and/or that cost you a lot of time.

As I said, that strategy is applicable in general. Tools however differ in how well they support it, e.g. in terms of available commands and facilities.

You could start applying that strategy in VSCode (which I’m not familiar with, by the way). If it works well enough, great. If you find it limiting, switch to Vim, Emacs, or some other IDE that serves your needs better.

[0] https://moolenaar.net/habits.html

[1] https://youtu.be/eX9m3g5J-XA

This video of a talk that Bram Moolenaar (the author of vim) gave at Google in 2007 has some pretty good advice.

https://www.youtube.com/watch?v=eX9m3g5J-XA

Mainly the idea is to not try and learn everything about vim, but instead pay attention to how you use it, and find things that are inefficient or could be easier, and then go figure out how to make vim do that thing more efficiently.

Google Talk with Bram Moolenaar from 2007

7 Habits For Effective Text Editing 2.0: https://www.youtube.com/watch?v=eX9m3g5J-XA

I'm not sure this is an answer for you, as you ask for "tools like LXC for virtualizing a production environment", but have you looked at Vagrant? I don't use OS X myself, but AFAIK it should work fine on OS X, see eg:

  "Django project deployment with vagrant and fabric"
  http://www.youtube.com/watch?v=O3-MNsowgHc

and maybe:

  https://github.com/simeonwillbanks/vagrant-up-django-app-server

As for "vim-elite" -- that really isn't what vim is about at all -- I recommend having a look at:

  "7 Habits For Effective Text Editing 2.0"
  http://www.youtube.com/watch?v=eX9m3g5J-XA

As for window management on OS X -- again, I don't really use OS X -- but maybe something like:

  http://lifeoutthewindow.com/2012/04/divvy/

can help?

edit: Added titles for video links, additional vagrant link.

⬐ FireBeyond

Definitely looked at a few virtualization options (we use Citrix XenServer at work), but my rationale for LXC was making the most use of limited hardware (rather than being forced to commit, say, 2GB for VM A, 2 for VM B, and so on, instead having up to the full server resources available - this isn't strictly the "best practice" for a mock production environment but will suffice).

"vim elite" may not have been the best phrasing - my intent wasn't to imply superiority and condescension, merely "text editor power user".

Divvy is a nice tool, which I do use, and does make life a little easier, and if my preference deep down is that of a largely maximized world and Windows, so be it.

I do really want to investigate Vagrant, and will check out your links, cheers!

⬐ e12e

Ah, I didn't think you'd be interested in LXC as I thought you'd be running your VMs under OS X?

If you're considering running VirtualBox (Vagrant) under Linux/Solaris, VirtualBox does support a limited form of overcommitting RAM (not under OS X, however):

  https://www.virtualbox.org/manual/ch04.html#idp18673360

I believe you can use this with Vagrant via:

  http://vagrantup.com/v1/docs/config/vm/customize.html

You still have to dedicate RAM to VirtualBox -- but you no longer have to dedicate it to each VM.

If you are already using Citrix, the Xen Server product has supported a limited form of overcommit since version 5.6:

  http://support.citrix.com/article/CTX124972

I would think spending time automating deployment to the same environment as you use for production would be better than having a separate technology for development? I don't know what your internal politics are like, but setting up a dedicated server with a few tens of gigs of RAM for development and testing should be a worthwhile investment -- and running the same software there as in production should be good both for knowledge transfer and avoiding surprises going from testing to production (and vice versa).

Finally, I've been a impressed with vmware's new open source project, CloudFoundry.com/.org -- if not so impressed with their documentation for the free/open version. Apparently you can use that with VirtualBox as well:

  http://matschaffer.com/2011/04/cloudfoundry-virtualbox/

Note that Vagrant is in the process of being refactored with the goal of adding support for other hosts than just VirtualBox in the (relatively) near future.