Arun Gupta, Miles to go ...: Arun Gupta's Weblog

Tuesday July 29, 2008

TOTD #39: Prototype/Script.aculo.us Autcomplete widget with MySQL, GlassFish, NetBeans

There are several JavaScript libraries that can be embedded in your webapplication to create a visually appealing interface. Script.aculo.us is one of the popular ones and is built on the Prototype JavaScript Framework. The library provides an easy-to-use, cross-browser user interface JavaScripts that allows you to create fancy effects commonly visible on web pages these days.

This blog entry gets you started by using Ajax.Autocompleter that allows for server-powered autocompleting of text fields. Basically, you type a character in a text field and suggestions for possible correct values starting with that character are shown . This is achieved by by sending an Ajax request to the data source on server, passing the typed character in the request and processing the response to display on the web page. This effect was first popularized by Google Suggest.

In this TOTD (Tip Of The Day) we will create a simple web application with a text field in a JSP page that will use Servlet as the data source. The Servlet retrieves the parameter from the RequestContext, uses Java Persistence API to query the database and return response in the expected format. We will use:

NetBeans IDE 6.1 for Web app creation/deployment
GlassFish v2 UR2 as deployment platform
MySQL database server bundled with Mac OSX 10.5.4

Let's get started!

TOTD #38 explains how to create a MySQL Persistence Unit. Please follow the steps there to create a new Web application and Persistence Unit. Follow the steps listed below after the PU is created.

In Project Explorer, expand "Source Packages", "server" and open "States" class. Add the following NamedQuery:

@NamedQuery(name = "States.findLikeName", query = "SELECT s FROM States s WHERE LOWER(s.name) LIKE :searchString"),

at the position shown below:

In "StatesServlet" class, replace the commented code in "processRequest" with the following fragment:

            String searchString = request.getParameter("autocomplete_parameter");

            List<States> list = em.createNamedQuery("States.findLikeName").
                    setParameter("searchString", searchString.toLowerCase() + "%").
                    getResultList();

            out.println("<ul>");

            for (int i = 0; i < list.size(); i++) {
                States s = list.get(i);
                out.println("<li>" + s.getName() + "</li>");
            }
            out.println("</ul>");

and fix the imports by right-clicking in editor pane and selecting "Fix Imports".

Download & Use Script.aculo.us libraries

Download latest Script.aculo.us libraries from here (version 1.8.1 as of this writing) and unzip them.
In NetBeans, right-click on "Web Pages", select "New", "Folder" and specify the folder name as "javascripts".
From the unzipped Script.aculo.us bundle, copy all files from "src" and "lib" directory to the newly created "javascripts" folder.

Expand "Web Pages" and open "index.jsp". Add the following fragment in HTML <head>:

and the following in HTML <body>:

These fragments are part of the original tutorial.

Optionally, specify a stylesheet to render the result nicely

Create a "stylesheets" folder in "Web pages".
Right -click on the newly created folder, select "New", "Other...", "Other" category and "Cascading Style Sheet" file type. Give the name "autocompleter" and click on "Finish".

Replace the generated template with the following contents:

.autocomplete {
    position:absolute;
    width:250px;
    background-color:white;
    margin:0px;
    padding:0px;
    overflow:hidden;
}
.autocomplete ul {
    list-style-type:none;
    margin:0px;
    padding:0px;
    overflow:auto;
}
.autocomplete ul li.selected { background-color: #ffb;}
.autocomplete ul li {
    list-style-type:none;
    display:block;
    margin:0;
    padding:2px;
    height:32px;
    cursor:pointer;
}

Add the following fragment in "index.jsp" in <head>:

<LINK href="stylesheets/autocompleter.css" rel="stylesheet" type="text/css">

Now the show time ... right-click the project and select "Run". This deploys the project on GlassFish v2 and brings up "http://localhost:8080/Autocomplete/index.jsp" in the default browser window. The default page looks like:

As you start typing characters in the text box, Ajax.Autocompleter sends a request to the Servlet (specified using the "/Autocomplete/StatesServlet") by passing the typed characters as query parameters. The servlet returns an unordered HTML list. Typing "A" in the text box shows the following output:

and Firebug output looks like:

Typing "C" in the text box shows the following output:

Typing "Mi" in the text box shows the following output:

A request to the Servlet is made everytime a letter is typed. The minimum number of characters that must be entered in the field before a Servlet request is made can be altered by passing the arguments to Ajax.Autocompleter function as shown below (changes highligted in bold):

            window.onload = function() {
                new Ajax.Autocompleter("autocomplete", "autocomplete_choices", "/Autocomplete/StatesServlet", { minChars: 2 });
            }

Some potential fun ideas to make this entry more meaningful:

Servlet can access data from a RESTful endpoint and transform the data to an unordered list
Autocompleter data source return data in JSON format
Autocompleter used in a HTML <form> and "afterUpdateElement" is used to process the selected entry, may be filter the data shown

Please leave suggestions on other TOTD (Tip Of The Day) that you'd like to see. A complete archive of all tips is available here.

Technorati: totd web2.0 autocompleter scriptaculous prototype javascript glassfish mysql netbeans

Posted by Arun Gupta in web2.0 | Comments[6]

|

|

|

|

|
|

Wednesday July 23, 2008

FREE Hosting for Facebook & OpenSocial Developers - Social App Program

Are you developing Facebook and/or OpenSocial applications ?

Would you like to deploy them and monetize before spending any money on infrastructure ?

Social App Program is a new collaborative offering from Sun Microsystems and Joyent that allows you to do exactly that! It allows you to leverage Scalability and Cost-effectiveness of Joyent's cloud powered by OpenSolaris on Sun's renowned reliable servers and storage for deploying critical applications. And all this completely FREE for 12 months.

This program is also accompanied with FREE Sun-Joyent Social Developer Days planned for 8 cities (San Francisco, Los Angeles, Seattle, Vancouver, Chicago, Boston, New York and Austin/Dallas) in the US later this year to learn and get hands-on experience on writing applications which can scale to million of users. Learn how to architect, develop and deploy web-scale applications on Cloud infrastructure.

All details are available here. Also read the official press release.

FREE infrastructure with FREE training for YOU to write Facebook/OpenSocial apps - cool!

Is yours a startup company and under-equipped on infrastructure ? Join Startup Essentials today for FREE and discounted enterprise-class software, discounted partner hosting & storage and much more - apply online and membership FREE! Very minimal eligibility requirements and you can join inside the US or outside the US.

Technorati: sun joyent facebook opensocial social web2.0 cloud opensolaris startup startupessentials

Posted by Arun Gupta in web2.0 | Comments[0]

|

|
|

Thursday May 29, 2008

Screencast #25: Project SocialSite - Enabling Social Network in your Application

Project SocialSite makes it easy to add social networking features to your existing web applications or community sites (running on Java, PHP or Ruby) and turn it into an OpenSocial container. It comes with a comprehensive and highly scalable implementation of social graph, integrates seamlessly with existing identity and authentication mechanism, make it easy to plug into existing directory server or other user management systems.

This screencast shows how to add social networking features such as Friends, Activities, Profile and an OpenSocial-compliant gadget to your application using NetBeans IDE.

This is a preview of the technology that will soon be released at socialsite.dev.java.net.

Enjoy it here!

Technorati: screencast glassfish socialsite web2.0 netbeans

Posted by Arun Gupta in web2.0 | Comments[5]

|

|
|

Friday May 23, 2008

Redmine on GlassFish - Ruby-on-Rails Project Management Application

Redmine is a flexible project management web application written using Ruby on Rails framework. The feature list is pretty comprehensive from the usual suspects like multiple projects, role-based control, forums/wikis/SCM for each project to enterprise level features such as LDAP-authentication and multiple languages. It is cross-platform and cross-database and deploys very nicely on GlassFish v3.

GlassFish v3 modularity and extensibility allows Rails applications to be deployed without any modification (no WARing). This blog explains the steps on how to deploy Redmine on GlassFish and shows some screenshots later. More documentation is available in Redmine Guide.

Check out the most stable release of Redmine by giving the command:

~/testbed/redmine >svn co http://redmine.rubyforge.org/svn/branches/0.7-stable redmine-0.7
Configure the database

Start your MySQL server

~/testbed/redmine >sudo mysqld_safe --user root
Starting mysqld daemon with databases from /usr/local/mysql/data
Create the database as:

~/testbed/redmine/redmine-0.7 >../jruby-1.1.1/bin/jruby -S rake db:create
(in /Users/arungupta/testbed/redmine/redmine-0.7)

Migrate the database as:

~/testbed/redmine/redmine-0.7 >../jruby-1.1.1/bin/jruby -S rake db:migrate
(in /Users/arungupta/testbed/redmine/redmine-0.7)
== 1 Setup: migrating =========================================================
-- create_table("attachments", {:force=>true})
   -> 0.2840s
-- create_table("auth_sources", {:force=>true})
   -> 0.0540s
-- create_table("custom_fields", {:force=>true})
   -> 0.0430s
-- create_table("custom_fields_projects", {:id=>false, :force=>true})
   -> 0.0080s
-- create_table("custom_fields_trackers", {:id=>false, :force=>true})
   -> 0.0500s

. . .

== 90 ChangeVersionsNameLimit: migrating ======================================
-- change_column(:versions, :name, :string, {:limit=>nil})
   -> 0.0220s
== 90 ChangeVersionsNameLimit: migrated (0.0220s) =============================

== 91 ChangeChangesetsRevisionToString: migrating =============================
-- change_column(:changesets, :revision, :string, {:null=>false})
   -> 0.0210s
== 91 ChangeChangesetsRevisionToString: migrated (0.0230s) ====================

== 92 ChangeChangesFromRevisionToString: migrating ============================
-- change_column(:changes, :from_revision, :string)
   -> 0.0130s
== 92 ChangeChangesFromRevisionToString: migrated (0.0150s) ===================

Download, Install and Configure GlassFish v3

Download GlassFish v3 from here.
Unzip the downloaded bundle.
Add the following fragment as the last line in "glassfishv3-tp2/glassfish/config/asenv.conf" file:

JRUBY_HOME="/Users/arungupta/testbed/redmine/jruby-1.1.1"

Deploy Redmine as:

~/testbed/redmine >./glassfishv3-tp2/glassfish/bin/asadmin deploy redmine-0.7
Command deploy executed successfully.

... and the GlassFish console shows:

May 21, 2008 4:58:30 PM com.sun.enterprise.rails.RailsDeployer registerAdapter
INFO: Loading application redmine-0.7 at /redmine-0.7
May 21, 2008 4:58:30 PM
INFO: Starting Rails instances
May 21, 2008 4:58:37 PM
SEVERE: JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
May 21, 2008 4:58:42 PM com.sun.grizzly.jruby.RubyObjectPool$1 run
INFO: Rails instance instantiation took : 11979ms
May 21, 2008 4:58:42 PM com.sun.enterprise.v3.deployment.DeployCommand execute
INFO: Deployment of redmine-0.7 done is 12091 ms

That's it, your application is ready to be used! Here are some screen snapshots from my trial run:

Rails powered by the GlassFish Application Server provides all the good reasons on why you should consider using GlassFish instead of the traditional deployment models for Ruby-on-Rails applications.

This application is also covered in LAB 5539 as part of FREE 20-week Ruby-on-Rails course by Sang "with Passion" Shin.

Technorati: web2.0 rubyonrails jruby ruby glassfish redmine

Posted by Arun Gupta in web2.0 | Comments[17]

|

|
|

Thursday May 22, 2008

Socialsite @ Enterprise 2.0 Conference - Add social networking to your community

Sun Microsytems is a sponsor of Enterprise 2.0 Conference (Jul 9-12, 2008, Boston).

The conference has regular tutorials, keynotes and general sessions, multiple tracks and pavilion (even a free pavilion pass). They also have Launch Pad that allow companies developing new social networking products to compete for the chance to present them in front of the largest audience in the Enterprise 2.0 community.

There are 8 companies in Round 2 and each one of them has submitted a video highlighting their offering. One of the semi-finalists is Project Socialsite - an offering from Sun Microsystems.

Project SocialSite makes it easy to add social networking features to your existing web applications or community sites (running on Java, PHP or Ruby) and turn it into an OpenSocial container. It comes with a comprehensive and highly scalable implementation of social graph, integrates seamlessly with existing identity and authentication mechanism, make it easy to plug into existing directory server or other user management systems.

The submitted video shows how easy it is add social networking features (such as Profile, Friends and Activity) to MediaWiki by adding simple tags. We hope you like the functionality shown and give us a higher rating to help us qualify for finals :)

Follow the conference blog, Facebook group or participate using conference wiki.

Technorati: conf enterprise2.0 socialsite web2.0

Posted by Arun Gupta in web2.0 | Comments[3]

|

|
|

Tuesday May 20, 2008

FREE 20-week Ruby-on-Rails Programming Course - with Passion!

Sang Shin and Brian Leonard are starting a new free online course of "Ruby, JRuby and Rails Application Development (with Passion!)". The course is taken online and will start from Jul 15, 2008.

The objective of this course are "This course will go through briefly the basics of Ruby (and JRuby) programming language first. The rest of the course will be devoted to learning Rails functionality such as Active Record, Active Controller, and Active View. Attendees will acquire sufficient knowledge in order to write reasonably sophisticated Rails application upon completion." Read more details here.

In this course, you'll learn various NetBeans and GlassFish tricks for Ruby-on-Rails development and deployment.

Read the Registration FAQ and send a blank email to ruby-on-rails-programming-with-passion-subscribe@googlegroups.com to register.

This course runs very much like a regular college course in which the students are expected to do weekly homework after studying the learning material and doing the hands-on
lab. By registering with the email address above, students can ask/answer questions. Some quick links ...

It is FREE and can be taken online, so what are you waiting for - register now!

Technorati: rubyonrails jruby ruby glassfish netbeans web2.0

Posted by Arun Gupta in web2.0 | Comments[4]

|

|
|

Monday May 19, 2008

Benefit of using JRuby-on-Rails: Using Java 2D power within Rails

One of the main advantages of using JRuby-on-Rails instead of Ruby-on-Rails is to harness the power of Java libraries available in the Java platform. The Java 2D API is a set of classes for advanced 2D graphics and imaging, and provides extensive support for image compositing and alpha channel images, a set of classes to provide accurate color space definition and conversion, and a rich set of display-oriented imaging operators.

Jennifer published a new blog showing image-filtering effect (negative, grayscale, brigthen, sharpen). Read the complete entry.

A more comprehensive tutorial for JRuby-on-Rails on GlassFish v3 TP2 (also Jennifer's work) is available here.

Technorati: rubyonrails ruby jruby glassfish v3 java2d web2.0

Posted by Arun Gupta in web2.0 | Comments[0]

|

|
|

Saturday May 17, 2008

Ask The "JRuby + NetBeans + GlassFish" Experts

NetBeans and GlassFish have changed the landscape of Ruby, JRuby and Rails development and deployment. Code completion, debugging, similar development and deployment environment and many other features (NetBeans, GlassFish) together make it a compelling offering.

Tor Norbye, Brian Leonard and Charles Nutter are fielding questions on Ruby/JRuby/Rails support in the NetBeans IDE and GlassFish in a week-long Ask The Expert session (May 19-23). A complete archive of the Q&A will be available later. You can submit your question here.

If "Ask The Expert" window is missed, the questions can always be asked on user@jruby.codehaus.org, users@glassfish.dev.java.net and users@ruby.netbeans.org.

Technorati: ruby jruby rubyonrails netbeans glassfish web2.0

Posted by Arun Gupta in web2.0 | Comments[0]

|

|
|

Wednesday May 14, 2008

WAR-based Packaging and Deployment of Rails on GlassFish - Goldspike, RailServlet, Warbler, Rack, ...

WAR-based packaging and dispatching of Rails application on Java Application Servers is going through third iteration based what is used for packaging and dispatching:

Goldspike + RailsServlet: The first iteration was WAR-packaging of Rails app as defined by Goldspike plugin (nee Rails-integration) and using RailsServlet (part of Goldspike) for dispatching.
Warbler + RailsServlet: The second iteration (slightly short lived) overcame the shortcomings of Goldspike (packaging with sane defaults, fast, light-weight, and flexible configuration) by using Warbler for packaging. It decoupled packaging and dispatching by doing only packaging and allowing for pluggable dispatching mechanism. RailsServlet continues to be the default Servlet binding mechanism. This is the version currently supported by GlassFish v2 Update Center.
Warbler + Rack: Nick released JRuby-Rack (JRuby version of Rack, also see Introducing Rack and Docs) last week. And so the third iteration is using Warbler packaging and Rack-based dispatching. JRuby-Rack provides a more seamless connection between the Servlet environment and Rack.

The JRuby-Rack wiki says "JRuby-Rack is a lightweight adapter for the Java servlet environment that allows any Rack-based application to run unmodified in a Java servlet container. JRuby-Rack supports Rails, Merb, as well as any Rack-compatible Ruby web framework.".

This means that, other than Rails, conceptually Merb applications (which also use Rack for deployment) can now also be deployed on GlassFish. This blog entry explains how to deploy a simple Rack-based Rails application.

Install Rails and JRuby-Rack (as part of Warbler) as:

~/testbed/jruby-1.1.1 >bin/jruby -S gem install rails warbler --no-ri --no-rdoc
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
Updating metadata for 289 gems from http://gems.rubyforge.org/
..............................................................................................................................
..............................................................................................................................
.....................................
complete
Successfully installed activesupport-2.0.2
Successfully installed activerecord-2.0.2
Successfully installed actionpack-2.0.2
Successfully installed actionmailer-2.0.2
Successfully installed activeresource-2.0.2
Successfully installed rails-2.0.2
Successfully installed warbler-0.9.9
7 gems installed

Create a template Rails app as:

~/testbed/jruby-1.1.1/samples/rails >../../bin/jruby -S rails hello -d mysql
      create
      create app/controllers
      create app/helpers
      create app/models
      create app/views/layouts
      create config/environments
. . .
      create doc/README_FOR_APP
      create log/server.log
      create log/production.log
      create log/development.log
      create log/test.log

Disable database access from the application by uncommenting line 21 (remove "#" at the beginning) from "config/environment.rb" as:

config.frameworks -= [ :active_record, :active_resource, :action_mailer ]

Create a WAR file as:

~/testbed/jruby-1.1.1/samples/rails/hello >../../../bin/jruby -S warble
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
jar cf hello.war -C tmp/war .

The generated WAR file can be easily deployed on GlassFish.

Download and Install GlassFish v2 UR2 from here.

Start GlassFish Application Server as:

Deploy the WAR on GlassFish as:

~/testbed/jruby-1.1.1/samples/rails/hello >~/testbed/glassfish/v2ur2/glassfish/bin/asadmin deploy hello.war
Command deploy executed successfully.

The output in the GlassFish console looks like:

The default Rails page is now visible at "http://localhost:8080/hello" as shown below:

Add some functionality to the application to show Servlet and Rack integration

Add a Controller and View as

~/testbed/jruby-1.1.1/samples/rails/hello >../../../bin/jruby script/generate controller home index
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
      exists app/controllers/
      exists app/helpers/
      create app/views/home
      exists test/functional/
      create app/controllers/home_controller.rb
      create test/functional/home_controller_test.rb
      create app/helpers/home_helper.rb
      create app/views/home/index.html.erb

Change the "index" helper method in "app/controllers/home_controller.rb" as:

def index
        @greeting = "Hello from Rack!!"

        # access Servlet Context
        @server_info = $servlet_context.get_server_info
        # alternative way to get Servlet Context
        #@server_info2 = request.env['java.servlet_context'].get_server_info

        # access Servlet Request
        @method = request.env['java.servlet_request'].get_method
        @request_uri = request.env['java.servlet_request'].get_request_uri
        @protocol = request.env['java.servlet_request'].get_protocol
        @port = request.env['java.servlet_request'].get_server_port
end

Add the following fragment as the last line in "app/views/home/index.html.erb":

<%= @greeting %><br><br>
Hosted on "<%= @server_info %>" on port "<%= @port %>"<br>
<%= @method %> <%= @request_uri %> <%= @protocol %>

Re-create and deploy the WAR file

Re-create the WAR file as explained in step 4.
Re-deploy the WAR file as explained in step 5.3.
Now "http://localhost:8080/hello/home/index" shows the output as:

The magic fragment in "tmp/war/WEB-INF/web.xml" is:

<filter>
    <filter-name>RackFilter</filter-name>
    <filter-class>org.jruby.rack.RackFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>RackFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<listener>
    <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
</listener>

And also "WEB-INF/lib/jruby-rack-0.9.jar" is bundled in the WAR.
Let us know if you try Rack-based deployment of Merb applications on GlassFish.

Technorati: rubyonrails jruby ruby rack merb glassfish web2.0

Posted by Arun Gupta in web2.0 | Comments[1]

|

|
|

Sunday May 04, 2008

GlassFish v3 Gem 0.2.0 released

A newer version of GlassFish v3 Gem for Ruby on Rails is now available.

What's new ?

Codebase aligned with GlassFish v3 Technology Preview 2
Previous version (0.1.2) had some packaging issues which increased the size but now it's back to sweet 2.8 Mb.

Check if previously installed by using the following command:

~/testbed/jruby-1.1.1 >bin/jruby -S gem list glassfish

*** LOCAL GEMS ***

glassfish (0.1.2)

If already installed (as indicated by the list of gems) then uinstall it using the following command:

~/testbed/jruby-1.1.1 >bin/jruby -S gem uninstall glassfish
Successfully uninstalled glassfish-0.1.2-universal-java
Remove executables:
glassfish_rails, asadmin, asadmin.bat

in addition to the gem? [Yn] y
Removing glassfish_rails
Removing asadmin
Removing asadmin.bat

And then install it again as:

~/testbed/jruby-1.1.1 >bin/jruby -S gem install glassfish
JRuby limited openssl loaded. gem install jruby-openssl for full support.
http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
Successfully installed glassfish-0.2.0-universal-java
1 gem installed

Updating the gem is giving unpredictable results (mostly not updating) and will be investigated later.

Rails powered by the GlassFish Application Server explains why GlassFish is a better deployment option for Rails applications.

All the latest information about the gem can be found at GlassFish JRuby wiki or JRuby wiki.

Please use the gem and send us feedback on GlassFish forums, dev@glassfish or gem mailing list.

Technorati: rubyonrails jruby ruby glassfish v3 gem

Posted by Arun Gupta in web2.0 | Comments[1]

|

|
|

Saturday May 03, 2008

JRuby 1.1.1, Rails 2.0.2, Warbler now in GlassFish v2 Update Center

Vivek updated JRuby module in GlassFish v2 UR2 Update Center. It now contains JRuby 1.1.1 + Rails 2.0.2 and Warbler (instead of Goldspike) for packaging the app.

Read all details on how to download, install and getting started here. The image below shows a snapshot of Update Center with the latest module selected:

After following all the steps (had to manually set executable perms on jruby-1.1.1/bin/jruby), your application is now hosted at "http://localhost:8080/HelloWorldRailsApp/say/hello" and shows the following output:

The generated "HelloWorldRailsApp.war" is approx 8.5 Mb and could quickly grow depending upon the gems installed and other factors. As an alternative, you can consider shared deployment as explained in each sample's GLASSFISH_README.txt.

Send us feedback at Forums or webtier@glassfish.

Technorati: rubyonrails jruby ruby glassfish updatecenter

Posted by Arun Gupta in web2.0 | Comments[1]

|

|
|

Monday April 21, 2008

JRuby and GlassFish v2 - Another successful deployment @ WorldxChange Communication NZ

From proof-of-concept to production in 8 weeks, WorldxChange Communication NZ's online billing system is another succes story of JRuby and GlassFish v2. The portal is designed solely using NetBeans 6.1 IDE.

Here are some of the quotes from the completed questionnaire:

From my perspective, the main advantage was that I could deploy my JRuby project war file directly to Glassfish, allowing me to develop and test our online ViewBill portal using a production grade, scalable web server.

From a geek perspective, we love that Glassfish combined with JRuby and allowed us to integrate many different disparate systems to create a seamless interface for our customers to use.

started using the Glassfish v3 gem for final testing of new code releases and to check functionality prior to production deployment.

I do not believe that I could have developed this project any faster using different toolsets or technologies and have been massively impressed with the combination of Glassfish and JRuby.

Read more details here.

Rails powered by the GlassFish Application Server explains why to use GlassFish for powering your Rails applications.

You can find all all about JRuby and GlassFish efforts on the GlassFish wiki or JRuby wiki.

Technorati: glassfish netbeans rubyonrails jruby ruby stories

Posted by Arun Gupta in web2.0 | Comments[1]

|

|
|

Friday March 21, 2008

Ajax World East 2008 - Day 2 Report

I delivered my Maki as an Ajax Mashup Framework talk and the slides are available here. Lots of attendees came by afterwards and told me that they enjoyed the demo. The talk showed how jMaki Webtop provides a lightweight mashup framework that runs in the browser. Here is a pictorial representation of the demo shown:

GlassFish jMaki Webtop

jMaki Webtop is basically a jMaki widget that can be embedded in a JSP or PHP page. This widget provides the framework for managing widgets and users, ability to persist the Webtop on client-side using Google Gears or server-side using backend database, layouts and other functionality. In JSP case, the widget uses JPA for performing all the CRUD operations with the back-end MySQL database. The resulting WAR file is deployed on GlassFish (can be any other Servlet container as well). If you are interested in a Java version of Webtop then the recommended path is:

Create services & widgets using NetBeans
Deploy them on GlassFish
jMaki webtop for widget deployment & customization

It really is an evolution of jMaki - using all the infrastructure that has built over 2 years. You can experience it yourself at jmaki.com/webtop which is running a PHP version of the app. See the coverage here. The code will be available soon!

I attended few more talks and took notes in some of them to share:

See below for notes from some of them.

Can we fix the Web ?

This was an early morning talk (7:30am) and I reached few minutes late. But it was basically talking about JavaScript vulnerabilities such as

Script injection
No difference between user & guest scripts
Scripts exempt from same-origin policy
No modularity (global access to everything on the page)

And also DOM vulnerability because every node in the tree has access to every other node. This lacks modularity and causes a potential security risk.
Doug recommended 3-step plan to fix the Web:

Safe JavaScript subset

JSLint.com provides a safe subset of JavaScript that removes all features that are unsafe or suspect such as no global vars or functions
Google Caja & Cajita provide a similar subet but they use transformation instead of validation

Minor browser improvements

Scripts are exempt from same-origin policy. This allows a dynamic <script> tag to make a GET request from a server. Instead use JSONRequest (part of json.org).
ES4 (the upcoming JavaScript standard) is not good enough because it maintains backwards compatibility and adds complexity.

Major browser improvements

Replace JavaScript & DOM in browsers. The approach is to start with JSLint and add safe features as required.
The Object Capability System (where objects are given explicit access to be used) needs to be enforced to make it secure.

In Doug's opinion, if the Web is not fixed then JavaFX, Silverlight & AIR (all vastly superior but lacking adoption) will displace the web.

The second talk was on Accelerate Ajax development with Appcelerator by Appcelerator CEO.

The talk started with a "not too long back" introduction of the technology space. Well, it started with 1991 and the timeline (and associated technology advances in that year) kept shuffling 1995, 1989, 2001 .... and so on. Jeff talked about how/why Tim Berners Lee invented WWW and covered a myriad of terms after that including but not limited to - Web 1.0, Netscape, Mosaic, marc Andreeeseen (sp?), Java, java Web Start, Applets, W3C, CGI, J2EE, JCP, C#, JBoss, SOA, JavaFX, Silverlight, AIR and many others. For a 50 minute talk, that was quite a long introduction.

After that introduction, he word "Ajax" was mentioned almost 30 minutes (8:51am to be precise) in the talk. And then the word "Appcelerator" was mentioned at 9:06am. Finally, I realized that I'm in the right talk ;)

Appcelerator like to pitch themselves as RIA + SOA company and allows true decoupling of the rich client from it's services. Their services is very similar to jMaki but they use event handling + Ajax + DHTML to achieve it. They also run on Ruby, PHP, Java and other languages.

All in all, it was a good walk through the memory lane!

The next one was REST & Ajax Reconciled.

The talk explained the basic concepts of REST - Resource, URI, Representation, URL & Methods (GET, PUT, POST & DELETE). It also explained the idempotency and safety of each method type. Overall a good decent introduction.

Then it explained the limitations with current web-based forms:

The URIs in the action attribute cannot be changed dynamically
Most browsers recognize only GET/POST methods
Limited ecodings - for example generating JSON encoding requires extra work.

It provided a REST framework checklist:

Does it have resource-based approach ?
Acknowledges existing of representation ?

need multiple of them

Solid engineering & community support ?

The three frameworks discussed in the talk were:

Apache Cocoon - based on XML pipelines & URL patterns, powerful but steep learning curve
RESTlet - Like Servlet for REST, good for existing model
Apache Sling - Based on JCR with server-side scripting support

The talk did not mention anything about Jersey which is turning out to be a great implementation and very well meets all the critieria mentioned above.

The speaker recommended Apache Sling with µjax for all REST + Ajax needs. But I'd strongly encourage you to have a look at Jersey. The JSON representation generated out of Jersey can now be directly consumed by jMaki as described here - a true combination of REST & Ajax :)

And then the last talk where I took notes is Understanding the Top Web 2.0 Attack Vectors. I'll provides notes from the last 5 slides of the talk which essentially captured the essence. These slides talked about fundamental issues with Ajax and described concerns and possible attacks in each issue. I'll need to understand some of these attacks better myself but at least I have a list to begin with :)

Here you go:

Client-side

Concerns

Transparency
Cross-domain communication
Exposed business logic (View Source)
Local & Offline data storage

Attacks

Cross-site scripting, DNS Rebinding
Business logic bypass
Variable tampering
Protocol hijacking
Function clobbering
JavaScript hijacking

Protocols

Concerns - new protocols on top of HTTP

SOAP
XML-RPC
REST

Attacks

Traditional

Man-in-the-middle

Spoofing

Recursive Payloads
Schema Poisoning

Information Sources

Concerns

Integrity
Transient
Diverse (RSS, Blogs, Email, ...)

Attacks

Untrusted content
Poisoned Cache (HTTP Response Splitting Vulnerability)
DNS Issues

Information Structure

Concerns - Variations of data structure

RSS
Atom
JSON
Serialized data

Attacks

Malicious injection
Parser implementations

Server-side Issues

Concerns

Architecture Weaknesses
Multiple languages & implementations
Increase & fragmented attack surfaces
Unknown request origin
Authorization & Authentication in complex environment

Attacks

Traditional

Information disclosure, Logical attributes, Denial-of-service
Command Injection

LDAP, SQL, XPath etc.

OpenAjax Alliance talk about Gadgets & Widgets was nice. The alliance is working on creating standards for widget metadata, communication across widgets and other similar tasks. The goal is to enable successful adoption of open and interoperable Ajax-based Web technologies.

Dave Ferraiolo (from OpenAjax) particularly expressed thanks to jMaki for deriving the first set of Open Ajax Data Model specs from jMaki data models.

That's it!

Check out some of the pictures:

The complete album is available at:

I had to leave at the end of Day 2 because of unfavorable health condition. But I'm glad at least I could deliver my talks :) Now I need to be back-in-shape before my upcoming trip next Tuesday!

Technorati: conf ajaxworld newyork glassfish netbeans ria sun web2.0 jmaki

Posted by Arun Gupta in web2.0 | Comments[2]

|

|
|

Tuesday March 18, 2008

Ajax World East 2008 - Day 1 Report

Ajax World East 2008 started earlier today.

I delievered my "Web 2.0 Application development using jMaki" and the slides are available here. There were several demos shown in the talk (using NetBeans and GlassFish) and they are all accessible at the links mentiond below:

Several other related demos are available here. Luckily I could deliver without much hassle inspite of having a high fever and cough! I hope I can hold at least until tomorrow morning when the big preso is scheduled @ 11:35am.

Anyway I attended 3 more talks today and took notes to share:

See below for notes from each talk.

The first talk I attended was: Picking the Right Technology for Enterprise Rich Internet Applications. I got little late and the session was packed with attendees standing way outside the room so I joined them.

The session talked about AIR, Silverlight & JavaFX as three possible technologies for Enterprise RIA. Per the talk, here are the basic criteria for RIA tools requirement:

Seamless deployment on client
High penetration of runtime
Web browser independence
Fast client/server communication protocol
Robust security

Of course, this session was given in Ajax World so pros/cons of Ajax were dicussed:

Pros of Ajax	Cons of Ajax
No deployment required	Ajax apps are browser depdendent
100+ Frameworks	100+ Frameworks
Open Source, no need to purchase software license	Expensive due to long cycle, skilled developers demand top rate
	JavaScript is an interpreted language, entire source code can be viewed using "View Source"
	Network communication speed is not optimizedf for Ajax requests

And then basically it talked about the three technologies and their pros & cons are well captured in the slides.

The second session I attended was Performance Tuning your Ajax Applications. This was an interesting session and I learned a few tricks. Interstingly we have implemented quite a few of these performance enhancements in jMaki already.

Improving the performance of Ajax applications require tuning the following parameters:

Number of requests

Reduce number of JavaScript files that are loaded. This is the most important since each request to the backend adds extra cost. Even when the scripts are cached, the browser still makes a request (unless Since-Modified header is set correctly).
Typical approaches are to concatenate the files at dev time or at runtime based upon request.
Dev time approaches

Ant - concat all JS files using <concat> task
Dojo - Run Rhino over all provide/requires and then concatenate the files
Command-line

Run time approaches - Concatenation happens depending upon the request. Cons are:

Server-side dependent
Makes it harder to distribute code
Server is loaded as concatenation happens on server (mitigated with caching)
Works for <15 JS files
Does not track dependency

Size of requests

Remove white spaces and comments (Packer, Dojo, YCompresser, SafeCompress, ShrinkSafe are some of the tools)
Shorten the variable names
Gzip the code
Semicolon is optional but needed if you remove EOL (careful when compressing the code)

Drastically reduces the file size (e.g. Apache XAP reduced the file size from 330 kb to 70 kb)
Lots of gzip tools
Need to put appropriate headers so that browsers recognize gzipped content

Coding Style

Single line "if" and "for" do not need "{ }"
Combine var declarations into a single var such as var x=1, y = 2;
Use JavaScript style object

Time of requests
Time of initial code completion

Minimize the time that is executed @ start up
Bring the data once the initial page is loaded
Show images telling users that something is going on

Distracts user from the time it's taking

Other tips

Don't write your own parser - use the native parsers
"If" statement optimization
Use the native facilities like getElementById() or getElementByTagName()
Consider different approaches of DOM creation

Tail Recursion
Setting the value in innerHTML

Consider JSON over DOM for object graph traversal - JSON could be much faster

Similar tips can be used for CSS as well.

My third talk of the day was Performance Paradigm of a Mashup World.

This talk given by Vice President of Webmetrics and laid a special emphasis on "Collaborative Monitoring" for performance measuring any mashup. This process involves not only monitoring your own application, but also setting up agents that measure performance with other services being invoked in the mashup, their further partners and so on. It also talked about a layered approach of using:

Standard monitoring - HTML page load time, DNS request processing time, etc.
Pixel Mapping monitoring - required mainly for GUI intensive application
Web services monitoring - Used for partner monitoring

This was further clarified using a 6-step process:

Know your apps
Learn where the points are in your ecosystem
Measure your perspective
Monitor your APIs
Collaborate within your organization
Collaborate with your partners & customers

That's it!

Check out some of the pictures:

The expo hall opens tomorrow and Sun's booth is right between the ballroom and the main door to expo hall, can't miss us ;)

The complete album is available at:

The Internet connection at the Roosevelt hotel is painfully slow inspite of charging $14.95/night where as most of the "modern" hotels offer free wireless :(

Technorati: conf ajaxworld newyork glassfish netbeans ria sun web2.0 jmaki

Posted by Arun Gupta in web2.0 | Comments[1]

|

|
|

Tuesday February 19, 2008

Screencast #23: Social Software for GlassFish - Blogging, Tagging & Content Rating

Social Software for GlassFish provides an integrated suite of Blogging, Tagging and Content Rating on GlassFish. More details about this suite are available here.

This screencast explains how this integrated suite of software can be easily downloaded using GlassFish Update Center, how different components are seamlessly integrated and can be used.

Enjoy it here!

More screencasts focused on each individual topic are available here.

An offline version (downloadable zip file) of this screencast is available here. A complete list of screencasts is available on GlassFish wiki.

Technorati: screencast web2.0 social glassfish roller slynkr blogging tagging contentrating

Posted by Arun Gupta in web2.0 | Comments[8]

|

|
|