Carbon Five Blog

> The best developers and engineers I’ve known all used Neovim. Coincidence?

Generally I rather advise we not do this!! This is a baiting question & one built around superficial narrow-dimensional assessments of "best". But sure, Friday, I've got summer hours: why not write a little homage to what I think is compelling & makes vim such a life-long joy to ongoingly immerse myself into, let's talk some about why I think vim makes some users feel unmatchedly free in a way they would never put down:

Vim's origins as the most user-hostile text-editor known to man (ed) is an interesting origin story. Ed excelled at automation, at writing little scripts to modify programs, in a non-interactive fashion.

This excellence as an automated text editing system stems, in my view, from Ed/Vim's notion of Text Objects, ed/vim's way of telling the editor about where you want to go/what you want to select in a file. The editor as a bunch of buffers (opened files), named registers (which is basically a 1-dimensional (many points) rather than 0-dimensional (point) clipboards), text-objects that can select spots in buffers ("lines 4-7", "the first two characters of this line"), and commands that can be run on text-objects is an incredibly powerful set of general purpose abstractions for doing any variety of text processing task, and there's a nice break down of responsibilities for what does what in this system.

The shake out is cool. Macros in this system are nothing but a stream of…

No, they all suck. Here is a graph rendering of a simple ClearCase repository:

https://svn.apache.org/repos/asf/subversion/developer-resources/guis/pics/ClearCase-lsvtree-4.gif

ClearCase is 20 years old or so, but no git gui comes close.

The reason is git's peculiar object model. It has nodes (commits), edges between nodes (parent references) and references (pointers to commits) but no branches. That means it is not in general possible to tell which branch a particular commit belongs to. Asking a question like that just doesn't make sense i git's world. Therefore visualizing complicated branching scenarios, in ways that makes sense to users, becomes almost impossible. This is why people advocate rebasing https://blog.carbonfive.com/2017/08/28/always-squash-and-rebase-your-git-commits/ The idea is to "lie" to the vcs because otherwise your history becomes a hodge-podge mess of merges. :)

Btw, all other features of ClearCase were just horrible and brain-damaged. But the branch visualizer kicked ass.

This is a nicely consumable lightweight summary of how the node event loop works. In my experience this is one of the hardest things for new JS developers to actually understand, especially those coming to the language with a limited asynchronous programming background. Here's a good link to how the browser event loop works for those interested: http://blog.carbonfive.com/2013/10/27/the-javascript-event-loop-explained/

IMHO, there's just a few things you need to understand to start getting productive with js fast, #1 on the list is to know how the event loop in the browser/node works and this is a really good intro to the node side of things. #2 is event bubbling/capturing in the DOM (http://javascript.info/tutorial/bubbling-and-capturing), and #3 would be everything about functions / function scoping.

Those are the parts I always try to explain first to devs I've mentored who were just jumping in to javascript.

- If I have to choose a Ruby tech, I would go for Rails, no Sinatra, no Padrino, nop. Whatever you think is simple now it will change in the future. So start with what you know well and has everything you might need, even if you're not using it now. I've seen many "small" services being rewritten in Rails for this reason and that's painful and a waste of resources.

- Nowadays I have several reasons not to use Rails for new projects (https://blog.jaredfriedman.com/2015/09/15/why-i-wouldnt-use-rails-for-a-new-company/). But I actually I have more reasons to use Elixir instead (https://medium.com/@kenmazaika/why-im-betting-on-elixir-7c8f847b58#.guroqbfmf) (http://blog.carbonfive.com/2016/04/19/elixir-and-phoenix-the-future-of-web-apis-and-apps/). And yes, it's fun, incredibly robust and scalable. :D

> That means it is not in general possible to tell which branch a particular commit belongs to.

That's because commits can belong to multiple branches, which is by design.

> Therefore visualizing complicated branching scenarios, in ways that makes sense to users, becomes almost impossible.

There a reason users need to visualize complicated branch scenarios?

> This is why people advocate rebasing https://blog.carbonfive.com/2017/08/28/always-squash-and-reb... The idea is to "lie" to the vcs because otherwise your history becomes a hodge-podge mess of merges. :)

Rebasing/cherry-picking isn't lying, it's avoiding the mess of a merge at the expense of being a tad more difficult.

Seems you have a very concrete idea of what you think a VCS is, and git disagrees with you, thus they "all suck".

Here's a blog article by Carbon Five on dependency injection in Elixir that I quite liked...

https://blog.carbonfive.com/2018/03/19/lightweight-dependency-injection-in-elixir-without-the-tears/

For context, Elixir (which includes Erlang) is a compiled language, but it doesn't/can't catch a lot of compile time type errors that you'd only uncover at runtime. For example, one process can send a message of any type to another process. There just isn't a great way (for the Elixir compiler) to catch that at compile time. It gives you more flexibility, but you can't have confidence that it'll work just because it compiled. Dependency injection with tests is a really helpful tool in Elixir.