Links

node.x: JVM framework for event based, highly scalable applications

What is Node.x?

* A general purpose framework that uses an event based style for
building highly scalable applications
* Runs on the JVM.
* Everything is asynchronous.
* Embraces the style of node.js and extends it to the JVM. Think
node.js/on steroids/. Plus some.
* Polyglot. The same (or similar) API will be available in multiple
languages: Initially Ruby (JRuby), Groovy and Java and going
ahead... JavaScript (Rhino/Nashorn), Python (Jython), Clojure, Scala
etc.
* Goes with the recent developments with InvokeDynamic in Java 7 and
bets on the JVM being the future premier runtime for dynamic languages.
* Enables you to create network servers or clients incredibly easily.
* True threading. Unlike node.js, Python Twisted or Ruby EventMachine,
it has true multi-threaded scalability. No more spinning up 32
instances just to utilise the cores on your server.
* Incredibly simple concurrency model. Write your code as single
threaded like node.js, watch it scale across multiple cores (unlike
node.js)
* Understands multiple network protocols out of the box including:
TCP, SSL, UDP, HTTP, HTTPS, Websockets
* Sendfile support for writing super scalable web servers
* Will provide plugins for talking AMQP, STOMP, Redis etc
* Provides an elegant api for composing asynchronous actions together.
Glue together HTTP, AMQP, Redis or whatever in a few lines of code.

https://github.com/purplefox/node.x

GroovySparql: SPARQL API for Groovy

A simple SPARQL API for Groovy, based on "Groovy-izing" the Jena/ARQ interface,
and exposing common operations to accept closures, create DSLs for RDF, and
much much more!

https://github.com/AlBaker/GroovySparql
http://linkedjava.blogspot.com/2011/06/announcing-groovy-sparql.html
http://linkedjava.blogspot.com/2011/07/groovy-sparql-02-available.html
http://linkedjava.blogspot.com/2011/07/linked-data-microframework-linked.html

Node.x: asynchronous, event-based server framework for the JVM similar to node.js

What is Node.x?

* A general purpose framework that uses an asynchronous event based style for building highly scalable network or file system aware applications
* Runs on the JVM.
* Everything is asynchronous.
* Embraces the style of node.js and extends it to the JVM. Think node.js on steroids. Plus some.
* Polyglot. The same (or similar) API will be available in multiple languages: Ruby, Java, Groovy, (Python?, JS?, Clojure?), etc
* Goes with the recent developments with InvokeDynamic in Java 7 and bets on the JVM being the future premier runtime for dynamic languages.
* Enables you to create network servers or clients incredibly easily.
* True threading. Unlike node.js, Python Twisted or Ruby EventMachine, it has true multi-threaded scalability. No more spinning up 32 instances just to utilise the cores on your server.
* Understands multiple protocols out of the box including: TCP, SSL, UDP, HTTP, HTTPS, Websockets, AMQP, STOMP, Redis etc
* Provides an elegant api for composing asynchronous actions together. Glue together HTTP, AMQP, Redis or whatever in a few lines of code.

https://github.com/purplefox/node.x/
http://purplefox.github.com/node.x/

Gremlin: graph traversal language in Groovy

(download)

Click here to download:

Gremlin_graph_traversal_langua.zip (57 KB)

LinkedIn Glu: deployment automation platform

GLU is a deployment automation platform. It has been built and deployed at LinkedIn in early 2010 and then released as open source in November 2010. The goal is to be able to automate the deployment of any kind of applications accross many nodes. Although written in groovy/java, the type of applications that can be deployed through GLU is not limited to java applications. GLU is a platform and the way it was architected and designed allows you to pick and choose which part you want to use... Check the docs folder (and soon the wiki) for more documentation on GLU.

https://github.com/linkedin/glu/

Groovy PowerPoint DSL

Groovy PowerPoint DSL supports the following features:

* Slides with titles
* Bullets, which can be added to the slides
* Textboxes, which are large text area's
* Imageslides, which are slides consisting of only images. This is to support all the 'Beyond Bullet Points' lovers ;-)

Example:

builder.slideshow(filename:'Test.ppt') {
slide(title: 'Introduction') {
bullet(text: 'Bullet 1')
bullet(text: 'Bullet 2')
}
slide(title: 'Slide 2') {
bullet(text: 'Bullet 3')
bullet(text: 'Bullet 4')
}
slide(title: 'Example') {
textbox("""This is a slide
With a lot of extra lines
Which make no sense
At all""")
}
imageslide(src:'background.png')
}

http://dontmindthelanguage.wordpress.com/2009/02/27/groovy-powerpoint-dsl/

YouDebug: Java program that lets you script a debug session through Groovy

Here is the problem; your program fails at a customer's site with an exception, but you can't (or don't want to) reproduce the problem on your computer, because it's too time consuming. If only you could attach the debugger and collect a few information, you can rapidly proceed on fixing the problem. But running a debugger at a customer's site is practically impossible; if the user isn't a techie, it's out of question. Even if he is, you'd still need the source code loaded up in the IDE, then you have to explain to him where he needs to set breakpoints and what to report back to you. It's just too much work.

That's where YouDebug comes into play. YouDebug is a Java program that lets you script a debug session through Groovy. You can think of it as a programmable, non-interactive debugger --- you can create a breakpoint, evaluate expressions, have it dump threads, and a lot more, without requiring any source code. Your customer can just run the tool with the script you supplied, without any knowledge about Java.

YouDebug uses the same Java Debug Interface that IDEs use, so from the point of view of your program, YouDebug behaves as a debugger. Therefore you need not do anything special with your program.

In this way, the troubleshooting of your program gets a lot easier.

http://youdebug.kenai.com/

Gaelyk tutorial

http://gaelyk.appspot.com/tutorial/

Groovy Testing

GroovyChart

https://groovychart.dev.java.net/images/first_groovychart.png
 
 
Groovy Builder that simplifies creating charts from the Groovy language. GroovyChart is based on the Groovy builder paradigm, and applies it to the well known JFreeChart library.
 
https://groovychart.dev.java.net/
 
Example code:

import com.thecoderscorner.groovychart.chart.ChartBuilder
import groovy.swing.SwingBuilder
import java.awt.BorderLayout as BL
import javax.swing.JFrame
import java.awt.Color
import java.awt.Dimension
import org.jfree.chart.ChartPanel
 
ChartBuilder cb = new ChartBuilder();
def pieChart = cb.piechart3d(title: "Simple Pie Chart") {
  defaultPieDataset {
  Series1(40.0f)
  Series2(30.0f)
  Series3(30.0f)
  }
  antiAlias = true
  backgroundPaint(Color.WHITE)
}
 
def sb = new SwingBuilder()
def fr = sb.frame( title : 'Simple Pie Chart', size:[600, 400],
  defaultCloseOperation: JFrame.EXIT_ON_CLOSE) {
  widget(new ChartPanel(pieChart.chart), constraints: BL.CENTER)
}
fr.pack();
fr.show();