I know that Spring Tool Suite is optimized for Spring development and Groovy/Grails is optimized for Groovy/Grails development. Is there any practical reason why a Groovy/Grails developer would want to use the Spring Tool Suite for Groovy Grails applications even though the developer will not be developing any Spring applications?
If you want to work with Groovy and Grails only, I would recommend to download and use GGTS. If you want to work with Spring, I would recommend to use STS. If you want to work with both from within the same IDE, I would recommend to start with the STS distribution and install the Groovy-Grails parts into it from the dashboard. That way you get the features of both.
STS and GGTS are both based on Eclipse and extend it with plugins. You can use STS or even a bare-bones Eclipse install, but since it has no Grails support by default you'd have to install that yourself. That's easy enough to do, but having it all preconfigured in GGTS saves you the hassle of doing that yourself.
Likewise, there are some plugins installed in STS that aren't preinstalled in GGTS, but those are also freely available, so you could install any of those that you want.
Related
Bazel is a multi-language build tool from Google that acts as a replacement for things like Maven, Gradle, Make, etc. There are articles written on how to migrate from Gradle to Bazel, for instance. But I wonder if this tool works with Grails.
Grails is a web app framework that uses Gradle, but from what I've seen it's a bit more than that. For lack of a better term, Grails itself acts as a "wrapper" for common tasks such as building an app as a WAR or JAR file, running the app locally with different profiles, or scaffolding new files and features. Popular IDEs such as IntelliJ have Grails plugins available to run these Grails commands. So it seems to me like it's perhaps tightly coupled to the Gradle build script that backs it.
It also seems to me that just because Bazel says it supports Gradle projects doesn't necessarily imply that it supports Grails projects, because of all these reasons regarding Grails being more than just Gradle. But I wanted to ask the community if my assumptions are true, or if, in fact, people are already using Bazel as a substitute for Gradle inside Grails projects. Can it be done?
Bazel could in theory be used to build grails projects as it is fundamentally agnostic to the type of thing being built. That said, grails probably works well with gradle out of the box and you'd have to re-implement a number of things yourself again and probably is not worth the effort. If you are a large shop and have multiple other languages that you need to support however, it may be worth investing in the effort.
https://github.com/pubref/rules_maven supports using a gradle file to determine transitive maven dependencies if you want to investigate further.
I am building my first Grails app and would like the build to be managed by Gradle. I see that there is a Grails-Gradle plugin and many online searches indicate that it is not possible to build a Grails app using Gradle without this plugin.
My question is: why? Why (specifically) is this plugin necessary in order for Gradle to be able to build a Grails app? What functionality does this plugin provide that is otherwise missing?
I don't know why you think it's impossible to build a Grails app without the plugin. It's possible to issue commands to the grails shell from Gradle without the plugin, but it's not very clean.
That's what this plugin does. It cleans up that process, and makes it much Groovier with a DSL. It also makes your Gradle script more portable to other projects and persons.
If you browse the source code you will see all the inner workings of the plugin and realize what it's setting up in your Gradle script. What it offers is a lot of access to Grails in a very standard and portable manner.
I'm looking at various options(IDE's - Rails specific) that can be used for Ruby on Rails development with TFS for SCM. I'm currently working on a Rails 2.1 app which uses Ruby 1.8.7 and I consider it important to mention this explicitly because I need an IDE that could support the Ruby and Rails versions mentioned above(In the meanwhile I'll be checking this from my end as well).
With some amount of research I've found that one can have an Eclipse IDE along with the below two plugins for RoR development
TFS Plugin that's provided by Teamprise as suggested in this question .
Aptana Studio plugin for Eclipse .
I just wanted to confirm if a setup as mentioned above can coexist ?.It'll also be great if one can relate their experience(the pros and cons) of using both these plugins within the Eclipse IDE for day to day Rails development?
Thank you.
I am working with a team that develops a Java application using the following well-established toolchain for automated building, testing and continuous integration:
OS: Ubuntu
IDE: Eclipse
Build tools: Ant
Testing framework: JUnit
Source control: Subversion
CI server: Jenkins
A typical Jenkins job will grab the Java source from Subversion, and run Ant targets to build the code, run automated tests and create deployment artifacts.
We are now considering writing a .Net plugin for Windows clients to access our application's API from MS Excel. We will probably write it using either C# or F# - it's early days, and we haven't settled on a language yet, but F# seems as if it may offer some benefits in terms of being able to express API actions using a combinator-based DSL.
We would like to do as much of this work as possible on Linux, using Mono, and to use our existing CI infrastructure to build and test our software.
My first impression is that the toolchain will look something like this:
OS: Linux
IDE: Monodevelop / VIM (Eclipse support for Mono, and especially for F#, seems lacking)
Build Tool: NAnt
Testing framework: NUnit
Source control: Subversion
CI server: Jenkins, with NAnt plugin
Does anyone have any experience of developing with this kind of toolchain? The two questions I would like answered are:
What are the main pitfalls in this approach for developers used to the Java ecosystem?
Are there better alternatives to NAnt and NUnit for building and running automated tests, especially for F#?
Using F# with MonoDevelop on Linux seems like the way to go if you're developing cross-platform or server-side applications that can be developed on Linux (and occasionaly tested on Mac/Win).
However, I don't think that you'll be able to develop Excel plugin on Linux if you're targeting Windows users. You'll definitely need to run Excel on Windows and to test things, you'll probably also need to do (a part of) the development on Windows (I suppose the integration is the tricky bit - though you could develop & test some core functionality on Linux).
On Windows you can use free Visual Studio Shell with F#. The MonoDevelop integration for F# is (hopefuly) quite good, but Visual Studio gives you probably better experience and you'll need to use Windows for quite a few tasks anyway...
What are the main pitfalls in this approach for developers used to the Java ecosystem?
You are using a Linux operating system to develop an extension for Excel, which is primarily Windows. The Mono Platform is pretty excellent - but you could run into bugs - either with C# or F#. It's not as big of an issue as it was a few years ago, but worth considering. If you do decide to stick on the Mono / Linux platform - MonoDevelop is the way to go.
Are there better alternatives to NAnt and NUnit for building and running automated tests, especially for F#?
Take a look at FsUnit if you plan on going with F#. It has some nice syntax assertions, etc. It's complimentary to NUnit, so you won't be in uncharted waters.
This has been very upsetting for me up till now. Here is what I am trying to do:
IDE I'm using is Intellij IDEA.
Building a grails application.
Grails application specifies two dependencies on in house grails plugins also being developed in IntelliJ as separate grails plugin projects.
Now to make any changes to plugins, I update the source code in plugin projects and use mavan-install (Maven Publisher plugin) to deploy to local Maven repository.
I have to uninstall the plugin in core grails project. Delete the plugin cache from ivy and then run the core grails project which gets the latest copy of plugin from local maven repository.
What's the effective and ideal way to achieve this? A single change makes me do some 5 minutes of labour work to even test and run core application.
Any recommendations/ best practices?
Use inline plugins for this - see section "Specifying Plugin Locations" in http://grails.org/doc/latest/guide/12.%20Plug-ins.html#12.1%20Creating%20and%20Installing%20Plug-ins
By specifying the plugin project directory with grails.plugin.location.<plugin-name> as the location of the installed plugin, you can edit the real files and the changes will affect the test application, and there's no need to sync anything up.