Weiqi Gao's Observations - grails tag

Jeff Brown's Probability Quiz: What Are The Chances ...

Tue, 04 Aug 2009 02:40:08 GMT

... Jeff is of course talking about Grails, SpringSource, and Clojure. Near the end of the post, Jeff challenged his readers with a probability brain teaser:

Jeff Brown: I am honestly not sure how many technologists work for SpringSource but for the sake of having a number to work with, lets say there are 50. Lets also say that Clojure is interesting enough that 15% of JVM developers are interested in learning more about it. I can't back that number up with any research, lets just go with it. If 15% of JVM developers are interested in the language and you take a random group of 50 JVM developers (the 50 in question are certainly not 50 random developers, these are the edge cutters which probably makes them more likely to be interested in keeping an eye on what is new, but work with the idea that they are random)... Do the math. No, really... Do the math. Do the math to figure out the likelihood that 3 of the 50 would be interested in Clojure. I challenge you to do the math in Clojure and post your solution in a comment here. Do it in Scala, Do it in Groovy. Pick a JVM language and do the math.

My answer got a little bit too long for a comment on Jeff's blog. So I'm putting it here.

First of all, Jeff, its probability, not mathematics. They branched off a long time ago, just like computer science branched off more recently. It's nevertheless an interesting problem to ponder about in a Saturday morning. It also helps that I'm married to a statistician. Here's how the conversation went:

Me: Jeff Brown blogged about an interesting probability problem. (Reading the problem)
Her: The problem is not complete. He didn't mention how many JVM developers there are. The answer probably depends on it.
Me: For the sake of argument, let's say there are 100 of them.
Her: OK. Then the problem is equivalent to the following:

Problem: There is a jar of 100 balls. Among them 85 balls are black, and 15 balls are read. A batch of 50 balls are selected at random from the jar. A group of 3 balls are selected at random from the batch. What is the probability that all 3 balls in the selected group are red?

Me: That sounds like a probability problem the students could tackle.
Her: You analyze the scenario into more concrete cases: What if the batch of 50 contains no red balls? 1 red ball? 2? 3?, ... Use the Law of Total Probability. Here's the book!

(Saturday morning turned into Sunday evening, and we finally have a chance to work the problem out.)

We'll solve the probability problem by hand and reduce it to a computation problem that is as simple as possible, and then use the computing machinery.

Solution: We use the following letters to denote the various quantities:

n—the total number of balls
r—the number of red balls
m—the number of balls in the batch
k—the number of balls in the group

The event of selecting a batch of m balls and then selecting exactly k red balls from the m can be decomposed to:

selecting a batch of m balls containing exactly k red balls and then selecting exactly k red balls from the m
selecting a batch of m balls containing exactly k + 1 red balls and then selecting exactly k red balls from the m
...
selecting a batch of m balls containing exactly r red balls and then selecting exactly k red balls from the m

The law of total probability dictates that the probability of out target event is the sum of the products of the probabilities of each of the successive events in the above list:

P = Σ_{i = k}^r P(n, r; m, i) P(m, i; k, k)

where P(n, r; m, i) is the probability of selecting m balls from a jar of n balls containing r red balls and having exactly i red balls in the selected batch. The probability of this event is given by the formula

P(n, r; m, i) = C(r, i) C(n - r, m - i) / C(n, m)

where C(r, i) is the binomial coefficient.

With the problem thus solved, I went ahead to "Pick a JVM language and do the math." Guess which language I picked? Java. Yes, Java. Not Clojure. Not Scala. Not Groovy, but the old dependable Java. "Why?" you ask. Because doing it in any other language would have taken me longer to get the results out.

Here are the classes I wrote:

Foo.java

1    public class Foo { 
2      private int n; 
3      private int r; 
4      private int m; 
5      private int k; 
6     
7      public Foo(int n, int r, int m, int k) { 
8        this.n = n; 
9        this.r = r; 
10       this.m = m; 
11       this.k = k; 
12     } 
13    
14     public static double C(int n, int k) { 
15       System.out.println("C(" + n + ", " + k + ") called."); 
16       double prod = 1.0; 
17       for (int i = 1; i <= k; i++) { 
18         prod *= ((double) (n - i + 1)) / ((double) i); 
19         System.out.println("\tIteration " + i + ": prod = " + prod); 
20       } 
21       System.out.println("\tReturning " + prod); 
22       return prod; 
23     } 
24    
25     public static double P(int n, int r, int m, int i) { 
26       System.out.println("P(" + n + ", " + r + ", " + m + ", " + i + ") called."); 
27       double retVal = C(r, i) * C(n - r, m - i) / C(n, m); 
28       System.out.println("\tReturning " + retVal); 
29       return retVal; 
30     } 
31    
32     public double P() { 
33       double sum = 0.0; 
34       for (int i = k; i <= r; i++) { 
35         sum += P(n, r, m, i) * P(m, i, k, k); 
36       } 
37       return sum; 
38     } 
39   } 
40

Main.java

1    public class Main { 
2      public static void main(String[] args) { 
3        Foo foo = new Foo(100, 15, 50, 3); 
4        System.out.println(foo.P()); 
5        System.out.println(Foo.P(100, 15, 3, 3)); 
6      } 
7    } 
8

According to my calculation, the probability of the event that Jeff described is 0.0028138528138528123 or 0.28% assuming there are 100 JVM programmers.

There are two points that's worth mentioning:

The condition of there being 50 SpringSource programmers can be actually shown to be superfluous. And the calculation can therefore be simplified to merely that of P(100, 15; 3, 3)
It can be shown that P(n, r, k, k) tends to (r/n)^k as n and r grows to infinity while the ratio r/n is kept constant.

(Now it's Monday morning. After staring at the 0.28% probability for a while, I realized something...)

What I calculated is not what Jeff wanted. He clearly said he wanted "the likelihood that 3 of the 50 would be interested in Clojure", or, in our language, "the probability of selecting 50 balls that contains exactly 3 red balls." That's P(100, 15; 50, 3), which is 0.009392308830476828 or 0.94%.

A simple experiment suggests that as n and r grows to infinity while the ratio r/n is kept constant, the probability tends to 3.19%.

(It's Monday evening now. And I again have doubts about if I solved the right problem.)

Did Jeff mean "the likelihood that at least 3 of the 50 would be interested in Clojure"? After all, from the description of the story I can't infer that the other 47 are not interested in Clojure.

The probability of that would be

&Sigma_{i = 3}¹⁵ P(100, 15; 50, i)

which turns out to be 99.8%.

(I think I'll turn my work in now. Or I'll start doubt my solution again tomorrow morning.)

Java News Brief (JNB): Introduction to Grails

Tue, 06 Mar 2007 17:49:08 GMT

The March issue of the Java News Brief (JNB) is out. Jeff Brown gives an introduction to Grails—the "framework for agile web development using Groovy and Java."

Jeff Brown: Grails is a remarkably flexible framework while maintaining an ease of use that is unparalleled by other web application frameworks targeted for the JVM. Use the exercises in this article as a jump start with Grails and have fun exploring the possibilities.

Jeff Brown: An Introduction To Building Groovy Web Applications With Grails

Fri, 15 Sep 2006 04:15:01 GMT

I'll try to live blog today's St. Louis JUG meeting. I have done this for the OCI internal Java and C++ lunches in the past. Since the auditorium at One City Place, where the JUG meets, has excellent WIFI, I thought I'll try to do the live blog here.

The JUG usually starts with a Q&A session:

Q: What's new in Java?

Kyle Cordes: We are on the other side of the adoption curve. There are enormous amount of money to be made. Scripting languages is a playground where you can learn some of the new constructs, like closures. These constructs are coming to a future version of Java.

Jay Meyer: The scripting support in Java 6 allows me to setup an enterprise ready server where you can deploy your applications written in a scripting language, such as Groovy, or JavaScript. Now you have transactions, you have security, etc.

Q: What is a good Java job?

Kyle Cordes: Software product work is more prestigious than IT work. There are good jobs in both categories here in St. Louis.

Jeff Brown is on stage to give today's Grails presentation. First person is Jeff now.

Ruby on Rails is new and fun. A lot of Java developer looked into Ruby on Rails and asked if it is possible to duplicate it in the Java platform. Grails meets that challenge.

Groovy is not a perfect programming language. But there are a lot of things in groovy that's cool.

(Jeff starts Eclipse.) Let me warn you that the Groovy plugin for Eclipse is flaky on a good day.

Groovy

In groovy, everything is an object. The number 5 is an object, you can call times on it:

class GroovyTest {
  static void main(args) {
    5.times { println it }
  }
}

In Groovy strings are surrounded in single quotes. Groovy also has GStrings. They are surrounded by double quotes. You can do variable substitution within GStrings.

Groovy support named parameter lists:

class GroovyTest {
  String firstName
  String lastName
  Integer age

  static void main(args) {
    def gt = new Groovytest(firstName: 'Jeff', lastName: 'Brown')
    println gt.firstName
  }
}

All the places where your IDE will generate getter and setter code for you are suspicious. In Groovy you don't need the boilerplate code. When you declare a field, a getter and a setter is written for you.

I can still write a getter, but only if I want to do something different.

There are no package level members in groovy.

No semi-colon is required.

There is a really easy way to generate markups.

Grails

All right, on to the meat of the presentation. What is Grails? It's a MVC web framework for web apps. It exploits the awesome power of Groovy. It leverages proven staples: Hibernate, Spring, and Sitemesh. It is excellent for those apps in the sweet spot. And it is Fun, Fun, Fun

The user mailing list is very active. They are not hostile to Rails at all. The communities are awesome.

In the spirit of fun, I'm going to give away an early access copy of a book that has not yet been written—Grails In Action, by Graeme Rocher, the main developer of Grails, to be published by Manning in January 2007. Four early access chapters are available already. [I completely messed up the details here. See Jeff Brown's comment at the end of this post for the correct information. My apologies to Jeff and Craeme. –Weiqi]

Famous people loves grails.

John Lennen:

"Imagine no config files
It's easy if you try
No action mappings
Man, that Grails is going to be fly."

(Jeff runs a command "grails create-app" and things flow on the command shell. Jeff then runs "grails create-domain-class" and entered "Person" and a class is generated.)

Apparently Rails does something that makes it difficult to create your own domain classes.

(Jeff runs the "grails create-controller" and entered "PersonControler".)

One of the things that is created is Eclipse project files. (Jeff then imports the whole thing into Eclipse.)

I'm going to add some attributes to Person. (Jeff adds firstName, lastName and age.) I'm going to add an attribute called scaffold

def scaffold = true

This tells grails to generate our controller at runtime.

(Starting Jetty web server, surfing to localhost:8080/javasigdemo, and things appear.) Just like JSPs, the pages in Grails are written in GSPs, Groovy Server Pages. They also need to be compiled the first time they are executed, just like JSPs.

(Mario Aquino: Jeff, are you using a database?) I'm using HSQL DB. I'll get to it in a moment.

(Jeff adds several persons in the web app.)

(Audience Member: What about the mixture of statically and dynamically typed variables? Jeff Grigg: Static types makes the code run faster.)

Famous people loves grails.

Batman and Robin:

"Holy productivity Batman! What are we going to do with the free time."

The scaffolding in Grails is interesting. The one we have been using all happens at runtime and are just like magic. I can also tell Grails to generate all, in which case it will generate all the code beforehand.

Looking at the controller: All the code blocks are mapped to actions:

def list = { [personList: Person.list(params) ] }

These code blocks are closures.

The "M"

The "M" in MVC are the domain classes.

In your domain class, you can stick with POGOs (plain old Groovy objects. You want your domain class to be free of view stuff. However you may want validation logic in your domain classes.

(Audience Member: When you change the code, what changes can be automatically picked up by the application?) Grails will dynamically pick up a lot of changes in your application. But not everything is picked up. Domain model changes are not picked up.

(Jeff shows validation at work. Invalid fields are highlighted.)

The "C"

The "C" (controller) is the traffic cop. It defines actions and navigates to the views.

We don't see anything in the list code block that tells us where to go. By convention, we go to list.gsp. If you don't want the automatic thing to happen, you can call redirect. (Jeff shows the URL associated with the delete button, something like http://localhost:8080/javasigdemo/person/delete/42)

(Kyle Cordes: Doing a GET on your delete URL deletes stuff. Doesn't that make you go eeeeh?)

The "V"

The "V" is GSP—Groovy Server Page.

In GSP you can easily define custom tags. You just define a closure. And the tag can be used in your GSP pages. No taglib XML files.

Sitemesh is at play here. Grails uses Sitemesh to layout the pages.

There are a lot of tags built into Grails. Logical, iterative, Ajax, form, etc.

Famous people loves grails.

Mr. T:

"I pity the fool who has to maintain all of those TLD files."

Hey Dude, Where Is My Data?

Grails generates configuration files *DataSource.groovy where * are: Development, Production, Test

Grail uses HSQL DB's in memory relational database as the default database. This can be easily changed.

You can use a ApplicationBootStrap.groovy class to to populate the database with sample data.

Grails hooks your domain objects with Hibernate, which in turn hooks up with the actual database. You don't have to write your Hibernate config files.

(Jeff writes an ApplicationBootStrap class.) This class is picked up when the application starts. It populates the database.

GORM is Groovy Object Relational Mapping. Currently it is Hibernate based. JPA support slated for 0.4.

Questions And Other Tidbits

(I asked about production or public websites running Grails.) Every 7 minutes somebody asks this question on the mailing list. It doesn't really make sense. If what you need is in there, you can use it. If not, not.

Grails 0.3 will be out in a month or so. It will have Sprint 2.0 integration.

(Kyle Cordes: How do you measure the relative merits of Grails vs. JRuby on Rails?) Groovy runs on the JVM, you can access all the Java core classes, leverage to use all the java classes you have written. JRuby is a tool that allows Ruby to be run on the JVM. Having alternatives is good.

(Jeff Grigg: There is a mismatch between Ruby and the JVM. The JRuby guys have to do a lot of tricky things to support Ruby language features such as adding methods to classes at run time.)

Just this week, at Sun days, according to one source, Sun announced that Groovy is going to be a module in Java 7.

Jeff wrapped up by giving away four ebooks on Grails. First person is Weiqi now.

What To Think

I think Jeff's talk is excellent. The audience participation makes it that much more interesting and lively.

I'm a little bit surprised by me own reaction. I came into the meeting thinking Grails is nothing but a knock-off of Ruby on Rails, and my reaction to Ruby on Rails hasn't been all that positive ("Rails is full of magic that I don't understand, will fall down somehow, etc.")

However, after the talk, I feel that Grail is a reasonable web framework that learned a lot from Ruby on Rails yet remained true to the Java platform. It makes use of the best ORM and other frameworks that the Java platform has to offer. And has a reasonable chance of picking up mind share among the rank and file Java developers. And it has a reasonable chance at succeeding with what it attempts to do.

To be sure, Groovy is not the cleanestly designed language. However it does mesh well with Java. And it does offer features that makes Grail possible. And most importantly, someone did something nice with Groovy.