Code faster with Intellij IDEA live templates | Hacker News Reader

Code faster with Intellij IDEA live templates

maciejwalkowiak.pl

52 pointsjavinpaul26 comments

I use Intellij to write python and love live templates. For instance, I've set ipdb<tab> to expand to import ipdb; ipdb.set_trace(), which seems small but has probably saved me so much time. It's really a win for programming in Java, because it automates the boilerplate. There's similar functionality in other editors too, such as YASnippet https://github.com/capitaomorte/yasnippet

Similarly, I have `ni` (yes, blatant Monty Python reference) in PyCharm expand to `raise NotImplementedError("%file% %line%")`, for an ad-hoc web app breakpoint.

IntelliJ for development (alongside its plugins like RubyMine/PyCharm) is my most recommended way for anyone who starts to get up to speed and be productive quickly.

Could also be a subtle hint that the language in question (Java, Maven/XML) are too verbose. I mean, for dependencies and the like there's alternatives (for Java & co) in Gradle and SBT, or the very simple NPM and Bower formats; for build tools, see the same (and Grunt). There's no real benefit (anymore) to use XML for that kind of configuration.

Same with Java. Functional programming makes for much more expressive iteration than the iterator / for-loop pattern does, and it's much less verbose (think list.map(doSomething)).

It's useful for any language/framework, whether it's verbose or not.

The benefits of functional languages tend to not be as great as they could be because the tooling sucks (or kind of sucks). Look at Scala. The IDEs sucked for years. That's changed recently, but it was a big problem for adoption. F# is similar. Although support is baked into Visual Studio these days, the IDE support is spartan to say the least compared to C# with resharper.

There seems to be a class of developers that have a hard time understanding the enormous productivity boosts that good tooling provides.

I've heard that Clojure support is good in most popular IDEs/editors.

In general, macros, templates, and patterns are an "almost" discovery that a user needs a language (task, whatever) to have another level of abstraction or factorization for the activity at hand.

For example, the visitor pattern is easily eliminated by dispatching on multiple arguments or with a monad.

The template provides that common, low-level, way of communicating to other developers in that the resulting code is consistently formatted and is native java/c/etc.. It's a pain in the ass to deal with constructs such as conventional iterative loops, exception handling boilerplate, braces/whitespace/etc., or massively redundant structures such as XML, as a regular programmer.

My favorite example of a level of 'retardation' in a language is pattern matching.

I can either write a painful if/then/else/else/else/else/else/default/end tree or I can write something like the following.

f(0) → 0. f(1) → 1. f(<binary:01001001010101011101010><x as binary>) → x as number. f(x > 10) → 1.

Of course, this can be expressed in a number of ways. Table? Spreadsheet? Domain mapping with pretty lines?

I think we're losing information on a lot of the footpaths we should be paving by not having feedback into the use of various macros, templates, and patterns in the world.

Obligitory link to c2: http://c2.com/cgi/wiki?AreDesignPatternsMissingLanguageFeatu...

and the seminal Peter Norvig essay: http://norvig.com/design-patterns/

Hah, I was caught out repeating myself. :) I remember kvetching on that c2 page early this century.

Yes, but so what? Sometimes a little IDE love is a lot easier and more productive than changing your entire stack to use a different language/tool. Verbosity is a downside which might be more than offset by other upsides. It might certainly be beneficial to change your stack, but that's usually a very big decision that might have some serious and unforeseen consequences. Verbosity alone is rarely reason enough to make a switch.

Why the "Yeah, but so what?" rhetoric?

This is an important point, regardless. Sometimes new projects are started and it's not a matter of switching. Sometimes verbosity, and the things it negatively impacts, are worth switching. That's what.

The only way stacks evolve is if we start a dialog on how unnecessarily verbose they are, you don't just write that verbose code/configuration, you will have to read it some time in the future, your IDE might not be able to help you out then.

I still don't know what a monad is, but I agree with the "pure" functional programming crowd that this kind of boiler plate generation is expletive retarded.

If your language isn't Lisp and cannot make macros to sub in the variable bits in an otherwise redundant template pattern, you might have some other options, though.

For those of us condemned to industrial, "enterprise" languages, you might try using a DSL or (build-time!) code generator, rather than cluttering up your source code with editor generated crap.

I've been using these for years in Visual Studio.

My most commonly used one is "prop" which generates an automatic property in C#: "public string Name { get; set; }". I type "prop", then hit tab, string is selected and I can change it to any type I want, hit tab again, I can now change the name of the property, hit enter and I'm done Takes 1.5 seconds.

Idea had this back in 2001.

For vim users: https://github.com/garbas/vim-snipmate

This works really well for php on phpstorm as well (when working with bootstrap and knockout.js it's very handy).

What I would love (and if it can do it I've not found it) is to be able to do something like

koo(fooBar)<TAB> and get something like

    self.fooBar == ko.observable("");

would be amazing!.

You can create live templates yourself in intellij:

Settings -> Editor -> Live Templates -> JavaScript

And add the live template for abbreviation 'koo' and template text like:

self.$VAR$ == ko.observable("")

See http://www.jetbrains.com/idea/webhelp/live-templates.html for more information.

I already do that.

That though inserts the template and lets you tab through it.

What I'm suggesting is to pass fooBar before you expand the template so that you don't need to tab through it (similar to how zen-coding does id's and classes on html)

i.e.

func(returnFoo,$foo,$bar,$fizz,$buzz)<TAB>

becomes without having to tab through.

    public function returnFoo($foo, $bar, $fizz, $buzz)
    {
    
    
    
    }

If you use vim you can use https://github.com/SirVer/ultisnips and write python code to generate the output.

That looks awesome.

Embarrassingly for someone who has been a Linux user for more than 15 years I'm terrible with Vim (I can just about use it systems administration (though I often just use nano)) and use IDE's for most things.

If ko<TAB>fooBar is acceptable, setting the Live Template abbreviation to `ko` and the content to `self.$FOO$ = ko.observable("")` will do that.

That is what I already do but it still requires tabbing through each $FOO$ rather than been able to pass that to to the live template.

Does anybody know another resources about live-templates ( some advanced ) ?

I found the IntelliJ docs[1] handy for discovering predetermined variables like $END$ and $SELECTION$.

[1]: http://www.jetbrains.com/idea/webhelp/live-templates.html

Yes, setting up variables in the live templates is just...so BEAUTIFUL! You can create default values and tab through them, changing them as needed.

Don't know what I'd do without PyCharm.

Reply on news.ycombinator.com