Monthly Archives: November 2010

Eclipse Project Natures

I recently made the horrible, horrible mistake of adding JavaScript support to my eclipse project.  After a bit of searching around I found absolutely no help on how to reverse this.  The answers I found basically said that once a kind of support/nature is added to a project, you are just up the creek.  Reversing it is nigh on impossible.

Not so!  Rejoice!

Here is my project file that gave me so much trouble:

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
  <name>blah blah blah</name>
  <comment></comment>
  <projects>
  </projects>
  <buildSpec>
    <buildCommand>
      <name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
      <arguments>
      </arguments>
    </buildCommand>
    <buildCommand>
      <name>org.eclipse.jdt.core.javabuilder</name>
      <arguments>
      </arguments>
    </buildCommand>
  </buildSpec>
  <natures>
    <nature>org.eclipse.jdt.groovy.core.groovyNature</nature>
    <nature>org.eclipse.jdt.core.javanature</nature>
    <nature>org.eclipse.wst.jsdt.core.jsNature</nature>
  </natures>
</projectDescription>

Okay, kids. Can you take a SWAG at what to remove?  Yeah, I thought so.  You are now one up on official responses from the Eclipse project.

I removed the obvious buildCommand element-block (…javascriptValidator) as well as the jsNature nature element.  A rebuild of my project no longer brought eclipse to its knees.

On another note, a super cool thing is that when I created this project, it did not have Groovy support.  Guess what I did to add that.  Of course, this isn’t official, and certainly not supported.  But it worked because I have the necessary plug-ins installed.

As a side note, it very well may be the case that there is detritus left behind.  Simply removing these elements may not completely clean up what “Right-Click-on-project | Configure | Convert to JavaScript Project…” may have added for files.  However it turned off eclipse from doing a lot of extra parsing and compiling that caused garbage collection and loop errors.  (Yep, I tried fixing those errors first, but it seems that with the volume of js files I have that eclipse just cannot handle that.)

Advertisements

Groovy, Grails, and Gradle. Oh My!

My long silence has largely been due to unemployment followed by starting a new job. I have a draft post waiting in the wings regarding some technology I observed during the interview process. Things certainly have changed since the last time I interviewed for jobs, and not just since I interviewed for my first technical job.

I am going to abstain from mentioning my company, but I can talk about some of the technology pretty freely. I have moved from working with EMC|Documentum products to working with eCommerce tools. It is still content management in some ways, but I am now more focused on making a product work as apposed to installations and integrations. In doing this, I am also working with Groovy, Grails, and Gradle. They are pretty neat technologies which I sorely underestimated. I should have started using these in my last job!

Groovy: It is Java with many additions. It isn’t some poor little scripting language, but definitely takes Java programming to a new level. You simplify a lot of what you are doing, add the power of closures, and do away with specific declarations when you don’t really care what the object is that you are working with. That is pretty nice. I’ve decompiled some of the classes created with “groovyc” and it is crazy what happens to permit the many assumptions to be made about what a class might do. This doesn’t result in compact byte-code, but it makes coding a lot easier!

Grails: Maybe this could have been used. It is a bit light weight for a full-blown web server, but for a development environment it is pretty cool. The integration of unit, integration, and functional tests is darn nice. It helps to promote a test-driven development model.

Gradle: This really blows my mind. It takes ANT to a whole new level where you can do Groovy coding in your build script to improve the build process. Let’s say you have some modules you need to build in one order, and then clean up in a reverse order. That is a nuisance with ANT, but with Gradle you can declare an array and then iterate over it in the appropriate direction in the appropriate target. Very nice!

So, yeah. My technology juices are flowing again. Hooray!