projectile

ckaging system (with MELPA) is far more satisfying and modern than my old pathogen + git repo setup for vim. I think this is getting better in vimland too, though. As far as specifics go: The best thing for me is autocompletion, I used YouCompleteMe in Vim which (don't know if this is still the case) used to block UI rendering all the time. I remember it being particularly irritating for JS development using Tern, which works great with the relevant Emacs plugins. CIDER[1] is amazing for Clojure development (this is actually why I switched). Magit[2] is much more pleasant than Fugitive IMO, though they accomplish much the same thing. For what it's worth I was never really sold on Fugitive (I just use the console...), but I tried briefly. I find myself using Magit more and more (in particular for inline diffing, "Oh what changed here since commit X" sort of stuff). The old joke that Emacs is 'basically an OS unto itself'. I actually appreciate this. There seems to be more of a culture of developing "apps" for Emacs, things like helm-spotify[3], which are actually pretty fun/useful. I know there are mail clients too, for instance. Being able to open a console in the project dir with `SPC-'` is something I enjoy vs using TMUX. I think, in general, I prefer Emacs' more ambitious approach when it comes to windows/buffers within the app itself. This is a difference in philosophy. Projectile[4] is another plugin I very much enjoy using. Don't know if this is personal preference/maybe I never put in the required effort in vim-land, but I never came across anything as satisfying, simple, functional to use. I have heard nothing but great things about Org mode[5], though I have yet to jump in there. Again I feel like I need to invest a little time into it before it becomes useful. I have appreciated (certainly in the GTK version) that Emacs supports a slightly more rich display than Vim did (Images, bullet points etc). This is just eye candy, though. Also comes with the caveat I never tried GVim, maybe it is also capable of these things somehow. The single most frustrating thing is my current inability to tame the auto-indent algorithm, as well as TAB's behavior. I don't know if this is Spacemacs specific. 1. https://github.com/clojure-emacs/cider-nrepl 2. https://github.com/magit/magit 3. https://github.com/krisajenkins/helm-spotify 4. https://github.com/bbatsov/projectile 5. http://orgmode.org/

ation), you press a key binding, it automatically jumps to that fine. For example, I have a file "Document/test.txt". In "src/feature1/test.c", it only mentions "test.txt". I want that when cursor is on "test.txt", and if that file is the only file in my project, I jump to it instantly; otherwise, it gives me a list of potential candidates. And this must work in any file, even plain ASCII text file. If the text at point is a directory path, I expect with a single key stroke, my editor returns all files that contain that path. > So it depends whether you want to compare the richness of the ecosystem or the core capabilities of the editor. Both. After all, Emacs is a Lisp interpreter at its core. It's a computing environment more than a text editor; text editing is just a subset of it. That's why it is so easy to write tools for Emacs, despite a much lesser user base than other editors. Emacs has many hidden things that I can never find in other editors. For example, it has an advanced calculator and mathematical tool roughly based on the HP-28/48 : http://www.gnu.org/software/emacs/manual/html_mono/calc.html > I honestly don't know; it doesn't that by default, though there might be some plugin to that effect; when I use compiled languages, I prefer a linter-like approach to showing compilation errors, so I don't use this kind of plugins in my own environment Emacs supports coloring compile output by default, built-in. Emacs also has a syntax check plugin for wide array of languages, called flycheck: https://github.com/flycheck/flycheck (see the homepage for a simple demo). And here is GDB inside Emacs: tuhdo.github.io/static/c-ide/gdb-many-windows.gif Every change you make to a value, all other panes update as well, when relevant. You can also have an integrated memory debugger inside Emacs. You can even do remote debugging with Emacs. > yes, this is supported, though I personally switched to Dash (http://kapeli.com/dash) recently, which is similar but much more powerful than just man, as it allows to cache and index documentation from dozens of programming environment and frameworks, taking care of the different formats, etc. So for instance with the same shortcut I can get the help for a POSIX function from its man page, or a Boost class method from their official documentation, and everything is blazingly fast because of local cache and index, so my computer doesn't need to go to boost.org to show that page. Emacs has support for Dash as well, and you can view it inside Emacs: https://github.com/areina/helm-dash > You can do that in Sublime, but you need to define a project (which, in its most basic form, is just a "save project" command after having opened a directory); at that point, you have a shortcut to switch between projects with fuzzy completion, and each project keeps the full workspace, ALSO including unsaved modifications to files (which sounds crazy but I love it) as it means that you can do it without even thinking once. Emacs can do that as well. You can switch between projects, and Emacs remembers window layout of each project you are working on with Projectile: https://github.com/bbatsov/projectile. You can see more Projectile demos in my guide (demos at top): http://tuhdo.github.io/helm-projectile.html What I said is very different. You think each Emacs window is like a perspective in Eclipse. Each window layout can have different purposes: it can be a layout of 4 smaller code buffers, or it can be a debug view, or it can hold many documentation panes... You can arrange arbitrary window layouts, save and restore in future sessions. You can group many window layouts (or "perspectives") inside a workspace, and you can also have many workspaces like that. Each workspace can be a project, each has many different layouts for different purposes. > Generally speaking, I don't think there's a world of difference. I find vim harder to replicate in its more advanced features, with its approach to command combinations which is totally different from anything else; but emacs introduced to the world the concept an extendible editor based on complicated, targeted commands (which is the one in widespread usage today), so I think that any sufficiently advanced editor can get very close to emacs in most features. Vim is now a proper subset of Emacs. Evil is the best Vim emulator out there, said Vimmers who switched to Emacs. See Spacemacs: https://github.com/syl20bnr/spacemacs > If look at Atom for instance, they introduced a concept where the editor window is not simply line-based, but they can open graphical windows within it, which is a paradigm shift which might introduce unique features, very hard to replicate. See for instance their nested CSS editing feature, which is very nice because it helps my brain limit the context switching a lot. Yet Atom cannot work in terminal, which is essential for working remotely. Emacs can live to this day because it has 30 years of accumulating vast amount of different uses cases. Someday someone will add such capacities to Emacs, when it is really needed. For now, graphic is cute but it mostly satisfies web development. If I have 10 or 20 local VMs (with only terminal), it would be crazy without Emacs to manage all of them effortlessly.

of which also tend to have the same filenames. So if you wanted to visit the header template for site1 you would fire up projectile, type in "site1/wp-content/themes/header.php" or some such and you'd probably get a hit. If you just typed in "header.php" you'd end up with a bunch of different hits, including Wordpress framework files, multiplied by the number of sites. Projectile has a mechanism for ignoring files[1], which is nice for omitting framework code, but I wanted a workflow that was "On keystroke, prompt me for sitename and open a projectile prompt that autocompletes files for that site only". Turns out this is really easy. While Projectile will normally use git to determine its project root, you can actually add a .projectile file to any directory and that directory then becomes a project root. From there it's easy to write an interactive elisp function that will ask you which projectile project to load, then fire up the autocomplete. Bind that to a global key and it becomes really easy to break down your large-ish codebase into logical sub-projects and get to business quickly. (Haha, I just realized how emacs-y that tip was.) Lastly, if you find your .emacs configuration becoming unwieldy, or if you are like me and originally broke out mode specific configuration into distinct files (php.el, ruby.el, web.el) I can't recommend enough switching your config to one big org-mode + babel[2] file. Doing so was my first foray into org-mode and literate programming and I can't recommend it enough, if only for keeping your Emacs configuration sanely documented. I used this config as an example for getting started: https://github.com/larstvei/dot-emacs/blob/master/init.org [1] https://github.com/bbatsov/projectile#ignoring-files [2] http://orgmode.org/worg/org-contrib/babel/intro.html

("marmalade" . "http://marmalade-repo.org/packages/") ( "melpa" . "http://melpa.milkbox.net/packages/"))) after that run M-x list-packages and choose from around 1000 packages > 2. Project Sessions there are many modes that support that if you want it. I personally don't like it though. "projectile" is pretty nice though: https://github.com/bbatsov/projectile > 1. Ctrl+P - GotoAnything: helm is what you would use on Emacs: https://github.com/emacs-helm/helm it's awesome