Alfresco SDK 2.0-beta-4 released in Maven Central!

It’s with extreme pleasure that, thanks to the great support from the Order of the Bee and the Community at large, we have released the Alfresco SDK 2.0.0-beta-4 … this time in Maven Central!

And 2.0.0 release is on the way, definitely out for you to use at the Alfresco Summit!

If you just can’t wait, check out a full tutorial and overview of new hot reloading features and IDE integration in this video (kudos to Ole for putting this together):

If you check out docs and release notes, I hope you’ll be gladly surprised by the number of enhancements and bug-fixes that went in this release, which, without any doubt, is to date the greatest ever achievement in ergonomics, productivity, quality and automation of Alfresco development! This represents a major step towards driving the Alfresco Community to become an organic, self sustained, proactive ecosystem of extensions and plugins for our favorite platform, Alfresco!

There are so many new features in this release, some of them very notable and I’d like to share them with you:

  • Compatibility with Alfresco Community 5.0.a+ (and soon with the upcoming Alfresco Enterprise 5.0.x). For 4.2 and below, you still need to use the SDK 1.x (see full SDK / Alfresco compatibility matrix here)
  • Availability on Maven central (see screenshot below)! Any Maven developer can just run a simple mvn archetype:generate and quickly create Alfresco projects directly from Maven Central! Is this JUST awesome?
Generate Alfresco Projects from Maven Central!
Generate Alfresco Projects from Maven Central!
  • True IDE integration with Eclipse, Idea and Netbeans (just Import Maven Projects) with rapid development support, by hot reloading of your Java classes, Web resources, webscripts, freemarker templates, using Spring Loaded and advanced Tomcat7 features (check out again the video above, you likely need to see it twice to believe it 🙂, to get all excited and farewell to all those ugly slow Alfresco restarts 🙂
  • Unit and integration testing support, with remote JUnit testing features to avoid context reloading and run unit tests (from your IDE) in seconds (or less)
  • Easy new starter setup and run scripts in each archetype. Just create the project, execute ./run.sh and off you go!
  • Updated SDK 2.x docs (separate from SDK 1.x docs)
  • rm profile (enable with -Prm) in the all-in-one archetype to enable Records Management development
  • Multiple bug fixes and stabilization

The feedback we got is that this new version is just AMAZING and enables levels of productivity never seen before on Alfresco project. And, for those of you that have followed me in this journey started 6 years ago, this shouldn’t be anything less than mind-boggling.

I really wish you will experience the same and I’d love to hear your feedback and contributions. I’d welcome comments here, issues or pull requests on the SDK project, or even emails on the Maven Alfresco mailing list. Also, stay tuned, since 2.0.0 final is targeted to introduce new juicy features, like easy Selenium functional testing,  even easier configuration of Community / Enterprise artifacts via a simple profile and integration of the Alfresco Technical Validation tool to ensure quality of your extensions.

And if this is getting you half as excited as I am right now, make sure you come to the next month’s Alfresco Summit (in San Francisco or London) where, together with Maurizio, we’ll extensively present how, in just 50 minutes, you can leverage the Alfresco SDK to get your project from inception to its first release and how, using Alfresco Boxes, you can consume this release and deploy arbitrarily complex architectures, on premise or in the cloud, in FULL automation.  Now that’s what I call an overarching vision

And if you really want to become a Guru, come join the Maven Alfresco training that Maurizio will run in both venues, one very worth day spent to save days of sub-optimal development 🙂

Stay tuned and send us your feedback!

[Maven is not so evil] Avoid webapp redeployment with hot reloading of your Maven project in Eclipse and IDEA. For free? Yes, with Spring-loaded and Tomcat7 :)

This might be the most important feature we have ever added to the (Maven) Alfresco SDK, which explains why we are getting such an amazing feedback following yesterday Tech Talk Live, where we presented the fully hot reloading (no webapp-context reload) early 2.0 version of the SDK.

BTW, if you are an Alfresco Developer and you have missed the talk, I (and not just myself) really recommend you take a hour of your time and check out the recording of the talk and / or the slide deck, because, if you are used to the sometimes frustrating world of WAR reloading (especially with a 100M+ webapp like Alfresco), I really do hope the demo of the new SDK will be no less than mind boggling for you…

Or, well, at least half as excited as I was when I first saw Ole‘s early attempts and when I finally got it working integrated in the SDK just a couple of days ago. Eureka! was my reaction to say the least (and in honor of my Sicilian past, a reference to Archimedes never hurts :).

I figured though that it’s not only Alfresco Developers that can benefit from this new approach, but more in general the community at large of Java developers using Maven to develop J2EE webapps in conjunction with an IDE (tested on Eclipse, IDEA, Netbeans).

And I know first hand the pain it takes to wait for neverending reloads, being this one of the main concerns around Java development with respect to newer / interpreted frameworks which make RAD (Rapid Application Development) their mantra.

So I figured I shared with all of you, eager blog readers, the couple of (simple) tricks that we used to define what, hopefully once and for all, can become the standard de facto to boost rapid develop Java webapps on Maven, in a completely IDE independent (but integrated) way and without the need for proprietary tools like JRebel.

So here we go. Assuming you have a WAR project, follow this steps to forget once and for all lengthy and boring WAR reloading (and contextually drink less coffeee!):

  1. The first building block is spring-loaded, a library from Spring.io (used to provide hot reloading to the GRails2 framework). This library (free of charge) provides a JVM agent which, transparently, provides class files reloading. All you need to do is get the spring-loaded.jar (e.g. from here) and then run your build with the agend enabled as such:
    MAVEN_OPTS="-javaagent:/path/to/downloads/springloaded-1.2.0.RELEASE.jar -noverify" 
mvn <goals>
  2. The second building block is based on the Tomcat7 VirtualWebapp features. This allows to: configure, via webapp context.xml, your webapp to dynamically load classpath resources (with the and webapp Loader component) and web resources (via ResourcesVirtualDirContext)  from outside a physical WAR / exploded folder. This way it’s very easy to configure your Maven <war> packaging project to automatically load classpath and web-resources directly from where Maven (or your IDE) would compile them, i.e. ${project.build.outputDirectory} (for your classpath resources) and ${project.build.directory}/${project.build.finalName} for your webapp resources. Basically you just need to create a context.xml file in your Maven project (e.g. in this example in the ${project.basedir}/tomcat folder that looks like this:
    <?xml version="1.0" encoding="UTF-8"?>
    <Context docBase="${alfresco.client.war.folder}" path="${alfresco.client.contextPath}">
      <Resources className="org.apache.naming.resources.VirtualDirContext" 
      extraResourcePaths="/=${project.build.directory}/${project.build.finalName}" />
    <Loader searchVirtualFirst="true" className="org.apache.catalina.loader.VirtualWebappLoader" virtualClasspath="${project.build.outputDirectory}" />
    </Context>
  3. Once the two building blocks are in place, you just need to wire this in the Maven pom.xml for your war packaging project. You could use Cargo but my dark memories of pain using that plugin suggest that a better, easier and more maintained route is to use the shiny tomcat7-maven-plugin. All you need to do is telling tomcat to use the previously defined context file by specifying:
     <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>run-embedded</id>
            <goals>
              <goal>run</goal>
            </goals>
            <phase>pre-integration-test</phase>
            <configuration>
               <useSeparateTomcatClassLoader>true</useSeparateTomcatClassLoader>
               <contextFile>${project.basedir}/tomcat/context.xml</contextFile>
            </configuration>
          </execution>
        </executions>
      </plugin>

    NOTE: this is going to bind the tomcat7 plugin to run your WAR, with the RAD configuration, during the pre-integration-test phase.

  4. Now you can run your build with:
    mvn clean integration-test

    and you will see your webapp run in Tomcat7. Nothing spectacular yet, but go the next point 🙂

  5. Now import your Maven project in Eclipse (Luna has already the Maven integration by default) or IDEA and there the fun begins! If you make a change to an existing Java class or web resource, all it takes is for you to hit refresh on your browser and AUTOMAGICALLY changes are there! No more webapp reloads, no more waiting time, just have fun!
  6. If you want an example of how this approach can save you huge amounts of time (and hairloss :P) check out the video below:

Hope you enjoyed what you see and hope you can leverage this ASAP! Feedback and comments are welcome, but in the meanwhile a nice collective farewell to silly webapp reloads 🙂

(Maven) Alfresco SDK migrated to Github!

+  =

As anticipated, I have today completed the migration of the (Maven) Alfresco SDK to the Alfresco Organization in Github.

The new location for the project is https://github.com/Alfresco/alfresco-sdk. Issues and code are already there, let me know if I missed something obvious or if you don’t have the right access to the project.

After 6 years in Google Code, we decided to move to Github to foster even more contributions and an ever growing flourishing community around the Alfresco SDK! I’m excited! 🙂

The old Google Code project location is temporarily still there for a limited amount of time, but I plan to close it for good and redirect to the Github location.

So, what else can I say?

Well, FORK US 🙂

What’s happening with the Maven Alfresco SDK? Get ready for 2.x!

After about 10 (really very busy) months of silence in this blog, I think I owe everyone an update of what’s going on with the Maven Alfresco SDK and more in general with Maven and Alfresco.

Lots happened, and it’s still happening, so here’s an update so that

So first things first, from the Alfresco side:

  • As you know, the long journey of Mavenizing the Alfresco build is ended. After Cloud, now Community and soon Enterprise are building with Maven
  • Alfresco Community 5.0.a is out and it’s fully built with Maven. Took about 5 years, but we made it, so get finally ready for a fully orchestrated ecosystem here 🙂
  • Highly likely the old Java / Eclipse SDK is going to be EOL’d, leaving the Maven SDK as the one and only standard de facto best practice to develop on Alfresco
  • We (and Mau specifically) are developing a Maven + Alfresco training that will be delivered at both Alfresco Summits in London and San Francisco. On this note, did you already sign up for Summit US or EMEA? If not, what are you waiting for? The schedule is, once again this year, just A M A Z I N G!

On the SDK side instead we plan to do the following:

  • Move the SDK project to Github, consolidating it in the Alfresco organization. The rationale here, apart from consolidation, is to move to a more modern SCM system which would foster even more visibility and community contributions. Pretty excited about that 🙂
  • We are preparing the SDK release 2.x, which will be compatible with Alfresco 5.x. In the meanwhile you might want to check out the latest 2.0.0-SNAPSHOTS which are increasingly compatible with 5.0.a (disclaimer: YMMV!). Here all the issues we are targeting to resolve, so some work is still required
  • We are seeing community momentum in the SDK like never before, mostly thanks to Ole’s great community help. In particular, Ole has Mavenized already all the samples of the old Java/Eclipse SDK, so we plan to release those together with the new 2.x SDK release and in general make those the reference examples for Alfresco development. Neat isn’t it?
  • If you are interested please help us testing the snapshots, opening issues or even provide contributions. Don’t be shy!

Stay tuned, as we plan to wrap up all this work by Summit, so less than 2 months away. I will then going to be presenting together with Maurizio on a full end to end process to manage Alfresco process, from development and release with the Maven SDK to continuous delivery and deployment with Alfresco Boxes, in a session called “Get Your Alfresco Project from Zero to Hero with Maven Alfresco SDK and Alfresco Boxes“.

 

           See you there?

            Sign up Here 🙂

Maven Alfresco SDK 1.1.0 is out and supports Rapid Application Development!

 

 

 

 

Just in time for the Alfresco Summit in Barcelona, we are proud to announce that the Maven Alfresco SDK 1.1.0 is out!

In this release (tested with Alfresco 4.2.e Community and supported with Alfresco 4.2.0 Enterprise) we have focused to make the development experience even faster, on top of keeping all process oriented and automation SDK features.

Key features that you might be interested in (and hopefully very excited about) are:

  • JRebel integration to allow zero redeployments when developing Alfresco Java components
  • Support for running JUnit test on a running Alfresco instance, in fractions of a second, not minutes. This leverages junit-remote and requires JRebel to hot reload classes
  • A new profile ‘-Prad’ to enable the 2 aforementioned features
  • Jetty replaced with Tomcat7 embedded, for improved supportability
  • Multiple fixes and improvements in the Eclipse integration
  • Works with Alfresco 4.2.e Community and Alfresco 4.2.0 Enterprise

This release represents a major improvement towards a full supportability of the SDK when working with Alfresco Enterprise, as well as providing a way to develop customizations in minutes, not hours.

Hope you enjoy it, feedback and contributions more than welcome, here or in the Google Code project!

EDIT: Slides are available on the Summit website. Apologies to everyone who asked before for not having uploaded them before the presentation!

Maven Alfresco SDK 1.0.2 is out and ready for your enjoyment :)

Just a quick update for the Alfresco Mavenistas, as yesterday we released the Maven Alfresco SDK 1.0.2!

This is a (major) maintenance release for our preferred Alfresco SDK (see full 1.0.2 release notes), and I wanted to stress a couple of fixes who went in there which might drastically improve your development experience:

  1. As I described in my last post, if you are a Linux/Mac SDK user, then your build is probably going to speed up 5x to 10x times. This is thanks to a fix using the plexus-archiver…I look forward to hear your wows from here 🙂
  2. The latest MMT fixes are in there. This should fix any weird issues of your build in case you were overriding Alfresco resources

You can find official documentation and artifacts on the Alfresco Artifacts repository.

And BTW, I suggest you stay tuned on this channel as I have worked hard in the last months on a plan for a full Mavenization of Alfresco…and you all know what that would mean for the functionality and “coolness” of our SDK 🙂

[Maven is not so evil] Plexus-archives 2.3 is a life saver

Maven is very good with J2EE WARs. Resources, packaging, overlays.

I admit that if it wasn’t for the great features and clean development model imposed by the maven-war-plugin, I would not even probably looked at Maven in the first place when I developed the first version of the Maven Alfresco SDK.

Lately though, especially working with large WARs overlays like Alfresco (120MB) and Share (40MB), I have seen all my efforts for standardized development falling badly short on the rapid development side. Suddenly (on my Mac, or I assume on any Unix/Linux environment) my WAR overlays started to take minutes to complete, with a big so long to the quick dev-fix-test cycle. As a Java performance expert, I decided to debug it and understand where it was actually wasting time.

Turns out that for each and every unpacked resource from WAR overlays the Maven unarchiver would fork a chmod process, to modify some file permissions!!! (Windows users, you can stop reading here 🙂

Leaving out that I’m not sure of the original reason for this, I later found out (also thanks to Samuel, kudos!) that this was due to a misconfiguration of the plexus-archiver package, which instead of using native JVM chmod capabilities was forking the process. All details unfolded in a related maven-dependency-plugin issue, MDEP-368.

Basically turns out this properly fixed in plexus-archiver-2.3 (the Maven shared component used by plugins to manage ZIP & co. archives), where no process is forked and the overall WAR packaging / overlay time is reduced drastically. And now the fix, and later the wow effect (I hope) :)))

Luckily enough the fix is pretty simple and only requires to have your plugins (unless they do it already) depend explicitly on plexus-archiver version 2.3. In other words just add the following snippet (the example is for the maven-war-plugin, but you can use the trick for the maven-dependency-plugin and any other plugin you see poorly performing on resource unpacking) to your pom.xml:

 <plugin>
     <artifactId>maven-war-plugin</artifactId>
     <dependencies>
         <dependency>
             <groupId>org.codehaus.plexus</groupId>
             <artifactId>plexus-archiver</artifactId>
             <version>2.3</version>
         </dependency>
     </dependencies>
 </plugin>

EDIT: This is fixed in the maven-war-plugin version 2.4 (and you don’t need the explicit plexus-archiver dependency anymore), see related issue MWAR-280).

Just to give you an idea how the performance improvements with this little fix, I will use as an example the Maven Alfresco All-In-One Archetype, which allows to develop and run an Alfresco Repository, Share, Solr and an AMP in the same Maven multi-module project. The SDK currently does NOT use plexus-archiver 2.3 (there is an issue for it), so it’s extremely (and unnecessary) slow in the Alfresco and Share overlays.

After I created the project from the archetype as per docs, here’s the output of a simple

mindthemac:alfresco-parent mindthegab$ mvn clean install -DskipTests
...
[INFO] Reactor Summary:
[INFO]
[INFO] Quickstart of Alfresco and Share with DB and runner embedded  SUCCESS [0.978s]
[INFO] Alfresco AMP Module ............................... SUCCESS [11.271s]
[INFO] Alfresco Repository and Explorer Client ........... SUCCESS [4:10.599s]
[INFO] Alfresco Apache Solr customization ................ SUCCESS [6.504s]
[INFO] Alfresco Share Client ............................. SUCCESS [4:08.038s]
[INFO] Alfresco and Share Runner ......................... SUCCESS [0.045s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8:41.062s
[INFO] Finished at: Thu Jun 20 14:54:35 CEST 2013
[INFO] Final Memory: 38M/782M
[INFO] ------------------------------------------------------------------------

What? 8m41s total build time? 4 minutes for each WAR? On my very decent Mac 8GB RAM+SSD?

Such a slow cycle is just going to kill the Maven Alfresco Community, to be a little dramatic 🙂

And now, get ready for the wow…after applying the little plexus-archiver fix above (in the parent POM <plugins> or <pluginManagement> sections) this is the amazingly improved performance of the vary same build:

mindthemac:alfresco-parent mindthegab$ mvn clean install -DskipTests
...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Quickstart of Alfresco and Share with DB and runner embedded  SUCCESS [0.848s]
[INFO] Alfresco AMP Module ............................... SUCCESS [5.630s]
[INFO] Alfresco Repository and Explorer Client ........... SUCCESS [35.372s]
[INFO] Alfresco Apache Solr customization ................ SUCCESS [5.054s]
[INFO] Alfresco Share Client ............................. SUCCESS [23.945s]
[INFO] Alfresco and Share Runner ......................... SUCCESS [0.019s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1:13.143s
[INFO] Finished at: Thu Jun 20 15:56:43 CEST 2013
[INFO] Final Memory: 44M/496M
[INFO] ------------------------------------------------------------------------

WOW!!!  Only 1m13 total build time…a neat 85.96% build speed up 🙂

I think it’s really worth making sure this trick is known as it’s going to be a life saver to the Maven Alfresco SDK and I’m also using it to speed up our internal Alfresco Maven builds.

Hope you find this useful, to the next tip of this newly born Maven post series!

Embrace change. Out of the comfort zone. Panta rhei. Agile life.

In life like in software, changes should not be feared but just embraced, as a potential opportunity for improvement and a way to augment your personal cultural level, learn new things and generally train your brain to be flexible and responsive to new conditions.

This might sound obvious to all of you, but there are many more aspects of our lives (or at least mine) which, instead of driving me to change and constant improvement of my and other selfs, would be much better off if we were “constantly” stable and predictable.

Think about it, our governments would love to have all of us adhere to perfect statistics, being as controllable and predictable as a mass.  Same goes for a discreetly successful love relationship. Our minds, or at least them, once in a comfort zone, tend to naturally relax and search for common solutions to problems already solved. Even our parents, in many cases, would love for us to do the most conservative choice possible for our lie, i.e. stick with what they know and with what they thinks it’s safe for you, in many cases ignoring the world is “actually” changing.

Read more Embrace change. Out of the comfort zone. Panta rhei. Agile life.

A wonderful deja vu of my future past

Last 5 days have been amazing. A total quantum leap in a sweet & sour mix of past and future.

Thanks to Codemotion & the great organization of the Alfresco Rome’s meetup by Jeff (as usual!!!) and our partner Sourcesense, I had the opportunity for the 2nd year in a row to go back to my University and be on the other side of the desk! (twice actually, if we count also the Maven SDK quick preso I gave at the meetup).

But it wasn’t only the emotion of talking to young students and experienced software engineers that is giving me this wonderful sense of fulfillment.

And it’s not only seeing that Codemotion (organized by one of my closest friends, Chiara) is growing year after year in relevance & resonance, quality of sponsors and speakers network.

But mostly the fact I had the chance to meet with so many good friends from my academic past and see how sooner or later we will cross again in our professional future. A so much past oriented trip, but still surprisingly focused on discussing the next killer app with the guys…like in the good old college times 🙂

When I finally met one of my ex-professors, Paolo Merialdo, almost “bragging” on how good our generation of engineers (taught by him) is, i.e. that bunch of great engineers that came out of Roma3 University around 2004/2006, I fully understood what I was up to. Re-discovering my roots to leverage them in the making of my future.

And for how great changes happened in my life, and more, even bigger will hopefully come soon, I will always be connected to those guys I studied with in Rome (and now all over the world). Not only by technology, but by a same way of interpreting life, business and daily challenges. Almost like entangled.

And yes, we will finally end up creating our own startup, one it’s going to fail, and then we’ll make another one, and maybe it’s gonna succeed then 🙂

But in substance we will have fully lived the dream of this crazy field we work in.

The dream of who feels capable to build something that will succeed, something that will be remembered, something that might even change the world. Check Liquid Feedback and the whole Italian 5 Star movement to get a hint of what I’m saying.

Talk soon, hopefully with some updates, on where we stand on making the dream come true 🙂

Talk e Alfresco Meetup @ Codemotion Roma … OMG e’ domani!

Il mio primo post in Italiano? Ebbene si’, l’occasione era cosi’ importante che ho deciso di aggiungere, almeno per lo spazio di un post, una terza lingua a questo blog 🙂

Da domani, all’Universita’ di Roma Tre, comincia una conferenza che sta rapidamente diventando una delle piu’ importanti in Europa, per quanto riguarda il mondo open source e dell’innovazione tecnologica: sto parlando di Codemotion, la conferenza (internazionale ma da una idea totalmente italiana) dedicata a tutti i linguaggi e piattaforme del mondo open source, che quest’anno comincia la sua stagione a Roma, ma che si spostera’ a Maggio a Berlino e ad Ottobre a Madrid.

Oltre a i tanti sponsor e track interessanti, da Arduino a Domain Driven Design, da metologie agili a buzzword piu’ recenti come mobile e big data, quest’anno sono felice ed orgoglioso di annunciare che Alfresco sara’ sponsor della conferenza e sara’ presente in maniera massiccia per legare con la comunita’ italiana e per condividere il messaggio innovativo della piattaforma leader nello spazio dell’ECM ibrido.

Vi segnalo i diversi modi in cui potete mettervi in contatto con noi durante la conferenza:

  • Passate a visitarci al nostro stand se volete sapere quanto sia cool la nostra tecnologia, ma anche rockstars della nostra community come Jeff Potts (Chief Community Office) o il nostro consulente tecnico Maurizio Pillitu … ah si, e ci saro’ anch’io 🙂
  • Venite ad uno dei due talk che presenteremo nei track della conferenza:
  • Domani pomeriggio, accorrete numerosi all’Alfresco Rome Meetup che si terra’ sempre a Roma 3 e nel quale uniremo topics strettamente tecnici (come CMIS e Maven SDK) a presentazioni dei nostri partner e clienti. La maniera perfetta per capire come Alfresco possa migliorare i vostri processi e flussi di informazioni. Il programma dettagliato e’ pubblicato sul blog di Jeff.

E come se non fosse abbastanza eccitante, il tutto si svolge nell’Universita’ che mi ha cresciuto e fatto diventare l’ingegnere (un po’ strano per carita’) che sono adesso. E’ sempre una sensazione strana, ma bellissima, trovarsi dall’altro lato della cattedra …

Un tuffo nel passato per dare uno sguardo al futuro…vi aspetto numerosi!

EDIT:

Le slide del talk sono pubblicate sul mio slideshare. Spero che il talk vi sia piaciuto!