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)).
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.
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.
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.
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 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.
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.
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)
{
}
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.
