Jeff Kreeftmeijer

It's definitely my favorite git client! It looks great and provides a very nice macOS like experience and and gives access to all git features I need. Especially I like the interface for single-line-staging and managing submodules. I use it everyday. It's not and IDE as you do not edit your code inside Tower but just use it for staging/committing/push/pull. It also has support for git-flow [1] but I am not using that. [1]: http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/

I've tried relative numbers a few times in Vim, but always found it hard to adjust. But recently Jeff Kreeftmeijer wrote up a way to get the best of both worlds[1]: relative numbers in command mode and absolute numbers in insert mode or if Vim loses focus. Just another option to consider. [1] http://jeffkreeftmeijer.com/2012/relative-line-numbers-in-vim-for-supe…

Then the follow up: http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/ and the code: https://github.com/nvie/gitflow

Hey David, I really like what you have done, a nice twist on the ol' like button. And its a pretty cool looking site as well. One thing does, well, concern me a bit, and its that you haven't given credit where credit is due (http://jeffkreeftmeijer.com/2010/experimenting-with-node-js/). There is no doubt that this is very similar to Jeffs blog post, and although it takes the idea a step further, I do think you should at least add a link to any and all code which inspired you and which you took ideas from, if it be Jeffs previous post, or a Node Knockout project. Best of luck with getting Valves attention, and you have my pointers vote :)

> What's the best way to rapidly move around without having to count lines? oooh. I have a treat for you! Check out "hybrid line numbers". I thought they would be weird when I heard about them, but they're awesome, and I never need "absolute line numbers". But the linked article shows you how to set up toggling if you need them. Basically, they look like this: 3 Lorem ipsum dolor sit amet, 2 nunc in iaculis ipsum. 1 Suspendisse dapibus odio erat, 98 non varius nulla porttitor at. // <-- You are here 1 Nullam in convallis elit. 2 Sed nec venenatis ligula. 3 consectetur adipiscing elit. 4 Sed hendrerit ac ante sed viverra. In this example, your cursor is at line 98 and so shows the absolute line number. The other lines are relative to your current line. If you want to go down to the line that starts consectetur, you see that it is below you 3 lines. You have to type 3j. If you need to find a specific line number, say 24, type :24 Here's an article on them: https://jeffkreeftmeijer.com/vim-number/

No matter how often you want to review code, I think it could work for your team like this: - dev works on a feature branch, making multiple commits and pushes - once ready, squash all the commits and submit it to gerrit [- perhaps have hudson/jenkins run the unit tests at this point automatically] - have the code review in gerrit - once the review is done, gerrit would merge it into the develop or master branch (depending on your git workflow) That approach blends in nicely with git-flow (1). If you want to be sure that no single dev is pushing to the develop or master branches you'd need to setup per-branch permissions, which can be done with gitolite (2). Too bad github (even the self-hosted version) doesn't support per-branch permissions, which forces organizations that use it and only want gerrit to be able to push into the main branch to do excessive repo forking instead of using feature branches. Also I'd love to be able to do ad-hoc code reviews in github, as the interface is the most beautiful of all imo. [1] http://nvie.com/posts/a-successful-git-branching-model/, https://github.com/nvie/gitflow, http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/ [2] https://github.com/sitaramc/gitolite

50,000 ft overview: Rspec: Behavior Driven Development Framework. It is essentially a different approach to testing than the test/unit (which Rails uses by default). In Rspec you are more interested in testing the side effects of your code, i.e. its behavior, you are less concerned with the internals. This doesn't mean you should write huge methods, and in the end your specs and tests will look pretty similar. My company uses Rspec on our main project. http://gist.github.com/649417 People will argue the value of the different styles until they're blue in the face. I liked Rspec's syntax more so thats where I started, but in the end I know both and think they each have their own merits and its probably a total wash. Recently with things like shoulda and other tools both approaches are rapidly converging on the same feature set. Cucumber: Integration framework. This tests your whole stack end-to-end. Depending on what you are building this may be the only way to test it, and for a lot of people they are just doing Unit + Integration tests and not writing any controller tests. You write in Gherkin (http://github.com/aslakhellesoy/cucumber/wiki/gherkin) which is a special subset of English. You can also use Steak (http://jeffkreeftmeijer.com/2010/steak-because-cucumber-is-for-vegetar… which lets you write your story in pure Ruby. Either way, this story is broken out in to steps and then some driver follows those steps, either driving or emulating a web browser. The…

> The page gives "5k 12j" as an example, there's no way in the world it's faster for me to figure out that "12" is the right number faster than through other means. If you add `set relativenumber` to your .vimrc, then the nth line up and the nth line down from from your current line will each have an n on the left-hand side. This lets you see at a glance which motion (e.g., `5k` or `12j`) will take you to a given line. https://jeffkreeftmeijer.com/vim-number/

I achieve that same consistency with virtually zero configuration by simply setting the colors in my terminal and forgetting about it. Stopped all the fiddling with color schemes quite a while ago. Good explanation: https://jeffkreeftmeijer.com/vim-16-color/

Instead of counting, you can use :set relativenumber (vim/neovim builtin) to quickly see how far away lines are. (see https://jeffkreeftmeijer.com/vim-number/)

It also sounds like you don't have relative line numbers enabled, which makes highlighting or jumping some number of lines quickly pretty trivial: https://jeffkreeftmeijer.com/vim-number/ A Vim truism: if what you're doing requires too many keystrokes or otherwise seems cumbersome, there's another way to do it that faster and requires fewer keystrokes. It's just a matter of whether you're interested in learning and not assuming you have it all figured out.

True. You do have to fix all the true conflicts. But you have to do it only once. If you merge your master, you have to resolve conflicts every time you merge from the master. git rerere could be potentially useful here. Even more importantly rebase allows you to resolve conflict at individual commit level. During conflict, you can see the exact commit that is causing it, making it much easier to resolve it. See: http://jeffkreeftmeijer.com/2010/the-magical-and-not-harmful-rebase/

I prefer hybrid line numbering. This way, you can see the true number of the line you are on, while all the other lines on the screen are numbered relative to your position. http://jeffkreeftmeijer.com/2013/vims-new-hybrid-line-number-mode/

A nice simple solution. Thanks! Here's something a little more complicated, which may or may not be more useful: http://jeffkreeftmeijer.com/2012/relative-line-numbers-in-vim-for-supe…

You might be interested in git-flow[1] which is a formalization of this workflow. [1] http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/

http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/ https://github.com/nvie/gitflow

It works similarly if you're using the gitflow extension: https://github.com/nvie/gitflow http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/ Or doing that manually. Git is pretty flexible.

This is a really nice implementation, but here's how I did it a couple of months ago (with an explanation on how to do it yourself): http://jeffkreeftmeijer.com/2010/experimenting-with-node-js ;)

Seems like this has been done before: http://jeffkreeftmeijer.com/2010/experimenting-with-node-js/ Using Node.js. The node js example even provides the code to replicate it. Is this person using node or some other websocket approach?

You can also use Steak: http://jeffkreeftmeijer.com/2010/steak-because-cucumber-is-for-vegetar…

It's interesting to compare this example with the somewhat similar example written with node.js: http://jeffkreeftmeijer.com/2010/experimenting-with-node-js/

> vi in Unix highlights the amount of time you spend watching the screen as you cursor around with hjkl vi is four decades old. It's not the pinnacle of keyboard-driven interface design, vast improvements have been made since then. For example, I use vim-sneak, which lets you jump to anywhere on your screen in 3 keystrokes flat 99% of the time (and the 1% of the time where you miss, well, 99% of those times, just one more keystroke is all it takes to get to the right spot): https://github.com/justinmk/vim-sneak I also use relative line numbers, so I can select or delete most blocks of text in 3 or 4 keystrokes, for example d4j deletes the current line and the next 4 lines (5 lines total), or d23k deletes the current line and the previous 23 lines (24 lines total): https://jeffkreeftmeijer.com/vim-number/ Obviously number of keystrokes isn't the only factor that determines operation speed. This is actually exemplified by my second example, commands like "d23k" actually work out-of-the-box even in original vi, the problem is that counting 23 lines by eye is way slower than selecting 24 lines with a mouse by eye, which is solved by relative line numbers.