Java Interface

We’ll start with a simple Java interface:

interface JavaInterfaceExample{
  int add(int a, int b);
}

Compile it using

javac JavaInterfaceExample.java


Implement the Java Interface in JRuby

We will implement this method in JRuby. When importing interfaces from Java code, you should use the Java namespace as in include Java::JavaInterfaceExample. The signature is important since JRuby is dynamically typed. If it isn’t specified, the parameters will be a Java Object.

require 'java'
class JrubyAdderImpl
  include Java::JavaInterfaceExample
  java_signature 'int add(int, int)'
	def add(a, b)
		a+b
	end
end

Compile it using:

jrubyc --javac -cp . JrubyAdderImpl.rb


Creating a Java class calling a JRuby method

Then let’s create a Java class which calls the jruby method:

class JavaCallerApp {
    public static void main(String[] args) {
	    JrubyAdderImpl jrubyImpl = new JrubyAdderImpl();
	    System.out.println("Adding 3+5=" + jrubyImpl.add(3,5)); // Display the string.
    }
}

Compile it:

javac -cp /usr/local/jruby/lib/jruby.jar:. JavaCallerApp.java


and run it:

java -cp /usr/local/jruby/lib/jruby.jar:. JavaCallerApp


Output:

Adding 3+5=8


Downside

While this works, it’s not a very optimally solution for calling JRuby code from Java. When you compiled JrubyAdderImpl.rb, it created a JrubyAdderImpl.java file which runs a JRuby runtime layer against the JRuby script file. I imagine this isn’t very performant.

I recommend using Duby or Scala as alternative JVM languages for greater interoperability with Java.

I placed the code on a github repo.

Apps

I created two native iPhone apps(voodoo doll and tweet show) with a few friends a year ago. Both are free and relatively simple. TweetShow actually hit the “Featured” page when it was named “TwitterTime.” It lets you watch tweets hands-free(ie. if you are eating).

For Android development, i used the Android 2.1 sdk with Eclipse. Android lets you use any IDE or even develop in the console as all of the build tools are command line-based. I made a useful Android app called Pastedroid which allows you to copy a piece of text(address, phone number, etc) to your phone. With the Pastedroid app installed, users go to pastedroid.com or use the javascript bookmarklet, copy text there and it’ll appear in the pastedroid Android app. It’s more similar to pastefire on the iPhone rather than tapbot’s awesome and more full featured paste helper, Pastebot.

Development Comparison

UI: iPhone

iPhone’s built-in UI makes it really easy to make an app good looking and consistent. Android on the other hand makes it really easy to make a horrible looking app. The iPhone interface builder even lets you drag/drop elements whereas the Android doesn’t.
Android Eclipse has a strange interface builder. It’s easier to edit the XML directly but making it look nice is difficult. Editing Android UI feels like the pre-css HTML days where table tags ruled.

UI Interaction: Android

To connect a ui button to your code, it’s a multi-step process in the iPhone sdk.
In the interface builder, click and drag an outlet to its file owner.
Then in the header file, define the outlet:

@property (nonatomic, retain) IBOutlet UISearchBar* tweetSearchBar;

Then in the code file, i can use the object.

Developing interactions is easier on Android. Just name the button in the UI xml file and you can access it in the code using:

refreshButton = (ImageButton) findViewById(R.id.refreshButton);

To make an event call a method, just set the method handler in the XML UI file.

Documentation: iPhone

I tend to learn by examples and it was definitely an easier time to find iPhone help and code examples. For Android code samples, beware of which version the help/code examples are targeted for. Not sure how true this is, but it felt the iPhone API changes were more stable than Android over the different versions.

Publishing: Android

Wow. I cannot believe how easy it is to publish an app on Android compared to iPhone. It literally took 5 minutes to get an app signed and published on the Android. I remember the first time I published an iPhone app, it took at least 5 hours of debugging various problems in the signing and build configuration.

I can just use ._1 and ._2 on each tuple but it isn’t very readable. If someone else is reading the code, will they know what ._1 is for?

scala> wordCount.map(wc => wc._1+":"+wc._2)
res4: List[java.lang.String] = List(a:1, b:2)

We can use case classes to the rescue:

scala> wordCount.map(case(word,count) => word+":"+count)
:1: error: illegal start of simple expression
wordCount.map(case(word,count) => word+":"+count)
^

Opps, as dpp mentioned on the scala mailing list, case is a partial function so this syntax won’t work.

What is a partial function you ask?

Partial functions allow you to specify a subset of the parameters in a function. Imagine this trivial case where you have an add function.

scala> def add(t1:Int,t2:Int) = t1+t2
add: (t1: Int,t2: Int)Int

You can create a partial function addByOne which will have one parameter bounded and another unbounded.

scala> val addByOne = add(1,_:Int)
addByOne: (Int) => Int =<function1>


Then you can evaluate addByOne by specifying the unbounded parameter:

scala> addByOne(10)
res5: Int = 11


case: a Partial Function

Back to our original example why calling map with parentheses doesn’t work.
case is a partial function which will only be called if the isDefinedAt method is true. If it was a Function, it would throw a MatchError when no case matches are found.


scala> val myPartial:PartialFunction[Any,String]= {case(word,count) => word+":"+count}
myPartial: PartialFunction[Any,String] = <function1>


We can apply the partial function to each tuple explicitly:

scala> wordCount.map(x => myPartial(x))
res14: List[String] = List(a:1, b:2)

or with the implied argument:

scala> wordCount.map(myPartial)
res15: List[String] = List(a:1, b:2)

We can also pass the partial function as an anonymous function(or closure):

scala> wordCount.map({case(word,count) => word+":"+count})
res16: List[java.lang.String] = List(a:1, b:2)

and remove the the extra parentheses:

scala> wordCount.map {case(word,count) => word+":"+count}
res17: List[java.lang.String] = List(a:1, b:2)

Thanks to dpp for bringing partial functions to my attention.

You can perform queries like:

science research grants

It’s still a rough prototype right now. It only has the NSF grants but I think even the current incarnation is doing a better job than the ‘official site.’

ResearchWatch provides faceted search interface and content aggregation. The content aggregation can quickly tell you the distribution of funds and location.

I’ll be using it to implement some search ideas, mainly query segmentation and entity recognition. Let me know if you have any suggestions to improve the system!

If the method has no parameters, you must call it without the parentheses unless the method declaration was defined with empty parentheses.

If you are new to Scala, you’ll probably see this manifest when using iterators.

scala> val wordListIter = wordList.iterator()
:9: error: wordList.iterator of type Iterator[(java.lang.String, java.lang.String)] does not take parameters
scala> val wordListIter = wordList.iterator
wordListIter: Iterator[(java.lang.String, java.lang.String)] = non-empty iterator
scala> val lines= Source.fromPath(filename).getLines
:6: error: missing arguments for method getLines in class Source;
follow this method with `_' if you want to treat it as a partially applied function
Error occured in an application involving default arguments.
val lines= Source.fromPath(filename).getLines
scala> val lines= Source.fromPath(filename).getLines()
lines: Iterator[String] = non-empty iterator

It would have been helpful if the empty parens are listed for the getLines scalaDocs

The convention ensures the uniform access principle. This convention is unlike languages like Ruby where you can call parameter-less methods with or without parentheses.

This except from page 212 of Programming in Scala explains the rationale:

instead of:
def width(): Int
the method is defined without parentheses:
def width: Int

Such parameterless methods are quite common in Scala. By contrast, methods defined with empty parentheses, such as def height(): Int, are called empty-paren methods. The recommended convention is to use a parameterless method whenever there are no parameters and the method accesses mutable state only by reading fields of the containing object (in particular, it does not change mutable state). This convention supports the uniform access principle which says that client code should not be affected by a decision to implement an attribute as a field or method.

I’m using IntelliJ IDEA 9.0.1 with the Scala plugin.
To get Processing working in IntelliJ:

1. Download the processing.org jars
2. Create a Scala project.
3. Add them to your libraries list in the modules setting.
4. Create a new scala object example below.

How is this useful? Scala’s syntax and its core data structures allow processing of data in a much more concise and understandable manner. Imagine you want to visualize xml or csv files with the Processing/Scala combo. Scala makes this easy with its xml and string manipulation libraries.

This example code is from Ben Fry’s Visualizing Data Book

import processing.core._
object Draw extends processing.core.PApplet {

  override def setup() {
    size(200, 200)
    noStroke( )
    fill(0, 102, 153, 204)
  }

  override def draw() {
    background(255)
    rect(width-mouseX, height-mouseY, 50, 50)
    rect(mouseX, mouseY, 50, 50)
  }

  def main(args: Array[String]) {
    val frame = new javax.swing.JFrame("Draw")
    frame.getContentPane().add(Draw)
    Draw.init

    frame.pack
    frame.setVisible(true)
  }
}

You may have noticed a lot of websites take advantage of this to enhance a service. Instapaper’s “Read Later” saves the current page and Pastefire’s “Pastefire this” saves the selected text.

To make your own, just write javascript inside a link tag as a one liner. Then just ask users to click and drag the link to the bookmark toolbar.

Here’s an example for my Next Sprocket site which will start you on a new open source task with the title and description partially filled out:
Sprocket it!


<a href="javascript:(function(){location.href='http://nextsprocket.com/tasks/new?task[title]='+encodeURIComponent(document.title)+'&task[description]=More details at '+encodeURIComponent(window.location.href)})()">Sprocket it!</a>


The task was for making gettext rails 3.0 compatibility and providing a sample Rails 3.0 app. Check out the solution here.

If you have a gem that you need upgraded or any open source problem, please post the task on Next Sprocket. Someone will get it done and it will be an open source benefit.

MongoDB For Natural Development

There were a few examples from Tim Morgan’s presentation at the LaRubyConf2010 that resonated how ActiveRecord can be a source of many headaches. I wager this is because the ActiveRecord ORM adds complexity to mapping from ruby objects to SQL world. The mapping isn’t one to one and complexity is the unfortunate byproduct.

On the other hand, MongoDB’s data modeling naturally maps to today’s popular programming languages. Essentially, most data are hashes(or associative arrays/dictionaries) and hashes are the basic data model for MongoDB. By having such a similar data representation, the ORM complexity level is extremely minimal compared to a typical ORM designed for SQL.

So use MongoDB because it can reduce the amount of complexity and bugs in your system.

So I started Next Sprocket with my buddy Nitin. Next Sprocket is the Open Source Developer’s Marketplace.

The basic idea is for any developer to post a task for a reward, let others contribute to the money pot and allow other developers to solve the problem. All the transactions are done via Paypal’s Adaptive Payments API.

You can help by posting a task up or you can vote for us in the Paypal Developer Challenge. The PayPal Developer Challenge voting ends on March 5. The top 10 will be judged by the likes of Marc Andreessen, Scott Cook and many others for the winner.