What is Reddit's opinion of Groovy?

From 3.5 billion Reddit comments

Nobody cares about Groovy anymore, just look at the exciting 3.0 changelog: features to please Gradle wageslaves like Java do/while loops, Java classic for loop, Java-style array initialization, Java lambda syntax, Java try-with-resources and Java nested blocks.

Groovy is another one of them, including things like methodMissing options and other options. You basically have to understand this diagram to know what's potentially happening when calling a method on an object: http://groovy-lang.org/metaprogramming.html

It's not trivial.

There are some constructs in Groovy which are not available in Kotlin AFAIK... For example:

• map literals
• simple currying
• destructured parameters
• Built-in Trampolines

Kotlin is nice, but Groovy has far more syntactic sugar.

Yes, it's included. Try this: http://groovy-lang.org/processing-xml.html

I usually go with the XmlSlurper - but the linked article gives scenarios when you'ed want to use XmlParser instead.

XML is pretty sucky to work with compared to JSON, but if you need to use it, then this is the way to go!

Edit: Also, if you did't already know, the GroovyAPI and the GDK are really useful: http://groovy-lang.org/api.html http://groovy-lang.org/gdk.html

I don't think it's that complicated. There are some weird edge cases where Groovy is not Java, but 99% of the time "it just works".

This page on differences may help. I got bit by the inner classes differences once.

http://groovy-lang.org/objectorientation.html#_named_arguments

There is a little bit of documentation about the method argument features. Basically, default parameters should be defined last. There used to be a quip about Maps and named parameters in relation to ordering, but I think it was in an older version of the documentation. Here's the code I tried in a Groovy console that seemed to work. I had to remove the default parameter assignment to the Map, so I guess it's a special case for Closures.

def foo = { Map kwargs, ...args -> println "kwargs=${kwargs.toString()} args=${args.toString()}" }

foo(1:1, 2:2, 2, 3 ) > kwargs=[1:1, 2:2] args=[2, 3]

It got me to playing a little bit. Notice that explicitly defining a map argument caused varargs to contain the explicit map. Any "named parameters" were shuffled into the Map parameter instead of being assigned into the varargs parameter.

foo(2, 3, 4, [5:6], 7, 8:9) > kwargs=[8:9] args=[2, 3, 4, [5:6], 7]

I have created a Groovy script that pretty much copies what Wordmark.it does: GitHubGist

The script will look up all the fonts available on your system. With that information a temporary HTML file is created and launched in your default browser.

To run the script you need to have Groovy installed. Alternatively I could compile the script into a JAR which will only require Java to be installed.

Groovy has this via its various meta-programming methods. In this particular case you could use an extension module:

>An extension module allows you to add new methods to existing classes, including classes which are precompiled, like classes from the JDK.

http://groovy-lang.org/metaprogramming.html

I would suggest you look into http://groovy-lang.org/ as a scripting driver for your methods; Java is valid groovy code, and groovy can drop down to very simple code.

This will allow you to write the specific tests in Java, but have the exact steps used in each test to be expressed as Groovy scripts.

Here are some hints:

1.) Use XmlSlurper to read in the HTML file. 2.) Select and replace the HTML tag using a GPath expression 3.) Celebrate!

It's dynamical by default. This includes a decision tree that may invoke plenty of different things, see http://groovy-lang.org/metaprogramming.html This led to many shortcuts, like X.a invoking X.getA(), but only if certain conditions are present. If you switch the given class or method to static compilation, this would behave quite differently. Then you have subtle differences to Java: http://stackoverflow.com/questions/687601/valid-java-code-that-is-not-valid-groovy-code/25974513#25974513 Finally Groovy has no finished specification, there are several corner cases where the behavior of Groovy does not follow any near-complete written specification, so it is difficult for maintainers to decide if some behavior is a bug or a feature (may be changed in the next release or not).

When Groovy features are used conservatively, none of this really matters, but when developers become more adventurous, this can become an issue.

For testing RESTful API, we are using Groovy and JUnit 5 (Maven project). Groovy simplifies the code of handling JSON and XML payload. We also use Karate framework but debugging in Groovy code is much easier in IntelliJ.

I find Groovy a very nice language that layers on top of Java. You can freely mix Java and Groovy syntax. This makes it nice when cutting & pasting code from StackOverflow or other samples. But as you learn idiomatic Groovy, you can cut out a LOT of the boilerplate wordiness that straight Java requires.

Much like Python, you can write classless scripts that just do work. It is type optional, so you can slap things together quickly without worrying about types too much, and then go back and add type information to better document what's happening.

Groovy offers many syntactic shortcuts and conveniences over straight Java, but because Java source works just as well, you don't have to learn a whole new paradigm.

I'm not sure who did it first, but it seems similar to Ruby in that way: http://groovy-lang.org/semantics.html#_optionality

>But whats the point?

Usually things like that are done because the language designer(s) thought it would be better or nicer to use. Why spend time adding parentheses if they don't really do anything?

> Won't it confuse programmers that switch between languages?

Probably. As someone who has switched back and forth between Ruby, Python, and Java (with Ruby and Python being infrequent uses) I sometimes get things mixed up between Ruby and Python, but it's never been a problem - especially when going back to Java.

> Since Groovy is built on top of Java and used along Java applications, I don't understand why its different from java.

I don't really have an answer for this, but you could say this for any other JVM language that isn't Java: Clojure, Scala, Kotlin, Jython, JRuby... probably as simple as "it's not Java" (even though it kind of is at the end of the day).

This is a bugfix release that fixes a parser bug where the first argument following a clustered options was treated as a positional parameter.

Picocli 2.0 accidentally introduced a transitive required dependency on groovy-lang. This is not desirable: Java applications using picocli don’t need this dependency.

Groovy scripts using the @PicocliScript annotation also don’t need this dependency because the Groovy runtime provides it. The picocli 2.0.3 release makes groovy-lang a compile-only dependency so it doesn’t appear in the POM.

This release also includes a minor enhancement to support embedded newlines in usage help sections like header or descriptions. This allows Groovy applications to use triple-quoted and dollar slashy multi-line strings in usage help sections.

Not an Android Dev, but I do use Groovy daily. You’ll need the groovy runtime Jars which do take a few megs, but nothing terrible. You can also run groovy code dynamically and directly without a manual compile step: http://groovy-lang.org/integrating.html#integ-eval

You can evaluate groovy code loaded as a string dynamically at runtime. It also makes for a pretty good base to build a DSL.

No huge gotchas that I know of, performance is great in most cases and the ease of use and terseness is really nice. Being able to write and parse JSON without external libs is awesome, closures are way easier to work with than java 8, optional typing allows you to only worry about typing when you want to, it has mixins, and you can cast damn near everything, this is especially nice for implementing minimal parts of an interface.

It’s the basis for Spock unit testing which I believe android is already friendly with? So this might not be much of a lift. Good luck!

If you're running that in a groovy shell, then you have to use interpreterMode . Otherwise F will not be saved to the shell’s environment.

http://groovy-lang.org/groovysh.html#GroovyShell-Variables

http://groovy-lang.org/groovysh.html#GroovyShell-InterpreterMode

I believe this does what you are looking for. It's written in Groovy. The list of names and number of lines are defined directly in the script and it outputs the result to the console. This could of course easily be changed to use txt files...

If you don't have Groovy installed you can try it out here: https://www.jdoodle.com/execute-groovy-online

def names = """bob tom jerry sam kyle james""".split(/\r?\n/) as List

def lines = 10

(lines-names.size()).times { names += "" } Collections.shuffle(names)

println names.join("\r\n")

Okay, why are we saying Groovy is not funded by pivotal. I just visited their website and I see this: The Groovy programming language is supported by Pivotal and the Groovy community.