Rob's Musings

Midterm Progress Update

2009-07-16T01:31:00.001-04:00

Progress has been slow and steady. I'm on track to finish however! What's done:

Reports can be entered, saved, and the values entered will be reloaded into the proper form fields. If edited and if the values have changed -- the old values are voided and new values are saved (retaining the old values in the database for auditing purposes).

What's left:

Management pages See this and this for what it will ultimately look like.
Still need to get the "View Only" pages working; in theory it should work. The "View Only" will be the answers but no form fields present.
The UI to create the report, questions, sections, etc.

Ultimately, I think this shouldn't be too bad.

The overdue progress report

2009-06-21T00:00:00.008-04:00

Apologies for not blogging as much as I should. I've focused on getting what needed to be done, done.

Tasks that have been completed thus far with a target milestone of using a mock Form, enable persistence of Questions and Values to the database:

Mock out a report form using the domain classes
Using the mocked up schema, generate a simple report form
Design the SQL Schema (for just FacilityDataValue and FacilityDataQuestion)
Write Hibernate Mapping files (for just FacilityDataValue and FacilityDataQuestion)
Write Data Access layer (for FacilityDataValue and FacilityDataQuestion)
Write Service layer (for FacilityDataValue and FacilityDataQuestion)
Refactor the rendering logic to use the JSP and write EL function(s) to check types using instanceof.
Allow a simple the mocked form from Week 1 to save the question answers.

Tasks that are are in progress, soon to be finished with a target milestone of removing the code used to mock up everything from the first few weeks; ability to use the saved schemas for rendering the report form:

Design SQL Schema for the rest of the domain classes
Write mappings for the rest of the domain classes
Support loading the previously saved values for a form/startdate/enddate/location into a page for viewing or editing
Write methods to save the rest of the domain classes in the data access layer
Write methods to save the rest of the domain in the service layer

Now that I have summarized work completed and in progress, let's explain the overall design:

FacilityDataFormSchema serves as the overall representation of the report form in the system.
FacilityDataFormSection is simply that, sections on the form, e.g., monitoring equipment status, stock status of vaccinations, number of people vaccinated, etc.
FacilityDataFormQuestion holds metadata regarding a question.
FacilityDataQuestion is the question itself; it specifies the datatype; it is subclassed for each question datatype; if not subclassed, then the question is considered to be "freetext" -- in other words: just simply a text-based question.

CodedQuestion is a question that has a coded answer. This too is subclassed for each coded question datatype.

StockQuestion is exactly as the name says, to track stock of items such as vaccinations. The coded answers are: "not_stocked_out","stocked_out","expired","not_applicable"
BooleanCodedQuestion is a simple "yes","no","not applicable" type of thing; e.g., "Was there mobile clinic today?"

NumericQuestion is a question which has a numeric answer, e.g., "Number of Adults Vaccinated."

FacilityDataValue is what holds the values entered in the report forms for each question.
FacilityDataReportFormData is a non-persisted class used for retrieving the answers for a specific report.

Hopefully this makes up for my lack of updates.

The long overdue progress report

2009-06-12T14:39:00.006-04:00

This is gonna be short, sweet and to the point:

Week 1:

I wrote a mock report form with 10 questions (screenshots in a later post)
I then wrote up some code to render it approriately for each question type.

Week 2 (still ongoing):

Designed the SQL schema, and wrote the service/database layer classes for 2 of the classes.
Wrote in the functionality to save the report data to the database.

Will explain the design at a later date.

Ciao!

Open Everything NYC Recap

2009-04-21T00:11:00.010-04:00

I attended Open Everything NYC on Saturday. For those who do not know, Open Everything is an "un-conference" which is a conference where the participants run the show. There are several open sessions, and a few keynotes.

Some of the open session topics were on education, Open Source Software licensing, and even relationships! The Open Relationships talk was really interesting. I find it amusing how many people wind up creating alter egos to prevent employers from finding out things about them.

(Some of) the keynote speakers were amazing:

Schuyler Erle, a guy who wrote some code for UNICEF, utilized text messaging as a means to track distribution of Bed Nets to prevent malaria via a web application, among other things. If you want to research this it's all on the wiki.

Robert Steele, a former spy (yes a spy!) whose talk in my opinion was pretty much utterly useless! I saw diagrams which were well.. horrid. His talk had ZERO flow planning, it seemed to be a bunch of conspiracies, one after the other. Let alone the fact the guy is abrasive. After his talk, I went up to him to let him know that his site (which he linked in his talk), was down; his response was condescending and RUDE. I turned to some people behind me as I was leaving, and said that there was no way I could have summarized anything that guy said (I was writing notes for the wiki); they agreed. The consensus on Robert Steele was pretty universal: Conspiracy nutjob.

The final speaker, Leslie Hawthorne, a woman I have a lot of respect for gave a talk that was short, sweet, and to the point. She disussed how open source software development can be used in a common sense way to solve complex problems we face. OpenMRS, solving the problem of the HIV/AIDS crisis in the developing world; Sahana for the disaster relief management in areas devastated by floods and such. Amazing talk! Best part, she did not use any slides!

John Britton, the conference organizer gave the closing talk, and he took notes as to what should change next time. Longer open sessions etc came up. Additionally, we found out: it's possible to do this ongoing, I'd REALLY enjoy that. I met some freaking awesome people.

We were to screen RIP: "A REMIX MANIFESTO" at McFaddens Bar and Pub by the UN, but the owner didn't allow us to do it; which was stupid. We wound up sitting around half price drinks/appetizers and had some good conversations and fun.

Overall, I had fun and would do it again. I went into this not knowing what to expect.

Accepted into Google Summer of Code 2009

2009-04-20T17:05:00.012-04:00

For the second year in a row, I was accepted into Google Summer of Code!!! I will be working with OpenMRS on the Facility Data Module.

My project will focus on developing tools for collecting and ultimately generating reports for aggregate data from external sources.

Groovy Forms Module is NOT dead

2009-02-08T17:09:00.004-05:00

Hey folks!

I'm still alive and not dead. The Groovy Forms Module is not a dead project, and WILL be finished. I plan on getting work started back up on it soonish. School is back in session for me. I'm sorry for the long delay.

That is all.

GSoC wrap-up

2008-09-10T10:02:00.004-04:00

The program officially ended on August 18^th. I'm awaiting the arrival of my t-shirt!!

Now, I didn't quite have time to finish my project prior to that date since my uncle suddenly passed away on August 10^th.

The project itself is about 80 percent completed. All that is left is to get the rendering working and finish up the management page to edit the form metadata as it appears in the system.

My time is now limited since school started up again for me, so as much time as I can I'm going to devote to finishing up this project.

I'd like to thank the following:

Burke Mamlin for helping me and answering all the questions I had and guiding me when I was lost.

Ben Wolfe for putting up with me and helping me when Burke was MIA.

OpenMRS and its wonderful worldwide network of developers for making this project into what it has become.

Paul Biondich for encouraging me (along with Burke) to apply for summer of code.

Last, but certainly not least, Leslie Hawthorn for managing this program and every problem that popped up. She must have super human powers or something.

The list can only be so long, I feel like I'm accepting an academy award here. It was a great experience, and I will definately continue to maintain my project in whatever free time I can find.

GSoC 2008: We're in the home stretch

2008-08-10T21:20:00.003-04:00

Well folks, I can't believe it's almost over. What a journey. I never imagined I'd be able to do this. I have an (almost) working project. I have a few more things that need to be done.

Let's highlight what IS done:

GroovyForm and its related metadata is stored
Model class is interrogated for its properties and those are stored in a container class.
From the data collected in the container class, I generate markup checking for a predefined set of data types.
The view and its related controller is generated -- sneaking in some groovy magic of course!
GroovyForms are successfully saved into the system, along with their respective, model, view and controller.
Forms are persisted when the module is shutdown and reloaded when it is restarted

What's left:

Editing metadata related to the forms currently in the system
Writing the servlet which handles submissions
Create some sample forms
Documentation

I did plan to add a lot of other stuff such as the ability to create custom form widgets, however there were a few problems which caused me to redirect my focus. These will come in after I finish with Summer of Code.

Randy Pausch dies

2008-07-26T15:49:00.003-04:00

I learned via the Official Google Research Blog that Randy Pausch died yesterday. Randy Pausch is famous for delivering a lecture entitled informally "The Last Lecture: Really Achieving your Childhood dreams". Pausch was also a Computer Science professor at Carnegie Mellon University (CMU).

He will be missed greatly.

RIP Randy Pausch

GSOC 2008: Week 5

2008-07-02T02:47:00.015-04:00

So, it's time for an update. This week got off to a sketchy start, but it's gained momentum. Let me enumerate what I have done thus far with the project. First, I've added AJAX using jquery. I figured I would use jquery mainly because it provided painless AJAX goodness. Prior to even thinking of using jquery, I wrote my own AJAX code using a tutorial that I found while googling. I had to tweak it a bit, but for the most part, it seemed very standard. However, after I wrote the AJAX equivalent code, it didn't feel too elegant. So, first I'm going to show the AJAX code I wrote; then I'll show you the jquery version; finally, I'm going to show you the servlet which handles the AJAX on the server-side.

First, the AJAX I wrote:


 function AjaxValidation(url,callback) {
        var req = init()
        req.onreadystatechange = processRequest

        function init() {
            if(window.XMLHttpRequest) {
                return new XMLHttpRequest()
            } else if(window.ActiveXObject) {
                return new ActiveXObject("Mircosoft.XMLHTTP")
            }
        }

        function processRequest() {
            if(req.readyState == 4) {
                if(req.status == 200) {
                    if(callback) {
                        chkSyntaxCallBack(req.responseXML)
                    }
                }
            }
        }
        this.doGet = function() {
            req.open("GET",url,true)
            req.send(null)
        }
    }
    function chkSyntaxCallBack(responseXML) {
        var res = responseXML.getElementsByTagName("result")[0].firstChild.nodeValue
        document.getElementById("out").innerHTML = res
    }

    function checkSyntax() {
        var target = document.getElementById("groovyModel")
        var url = "${pageContext.request.contextPath}/moduleServlet/groovyforms/createGroovyForm?groovyModel="+escape(target.value)
        var ajax = new AjaxValidation(url, chkSyntaxCallBack)
        ajax.doGet()
    }

I warned you that it wasn't too elegant. Understanding this isn't too hard. Here is the call sequence: init() -> doGet() -> processRequest() -> chkSyntaxCallBack(). Not that bad. Now let's see the jquery version.


$(window).ready(function() {
        $("#groovyModel").bind("blur",function() {
            $.ajax({
                type:'POST',
                data: { groovyModel:$("#groovyModel").val() },
                url:  "${pageContext.request.contextPath}/moduleServlet/groovyforms/createGroovyForm",
                cache: false,
                success: function(data) {
                   var res = $(data).find("result").text()
                   $("#out").html(res)

                }
            })
      });
 })

Okay, that's much better. A few things are still happening here. When the window is finished loading, I bind my textarea element which has the CSS id of "groovyModel" to the blur event (lost focus). Then you see the AJAX. Now this is very straight forward. We're using the POST method, we're sending whatever value is inside of the textarea at the time the event is fired, we're posting to a servlet, not going to cache, and when we're done, it's printed to the screen. Very straight forward.

Now, like I said, this is all backed on the server-side by a servlet, which is written in Groovy. So here we go:


/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.0 (the "License") you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.openmrs.module.groovyforms.web

import javax.servlet.ServletException
import javax.servlet.http.HttpServlet
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
import org.apache.commons.logging.LogFactory
import org.codehaus.groovy.control.CompilationFailedException

class CreateGroovyFormServlet extends HttpServlet {
    def classLoader
    static final def log = LogFactory.getLog(CreateGroovyFormServlet.class)
    private static final long serialVersionUID = 066373513262051L

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        def generateTemplate = request.getParameter("template")
        def generateController = request.getParameter("controller")
        def finalMarkup = request.getParameter("markup")
        def clazz = URLDecoder.decode(request.getParameter("groovyModel"))
        def name = request.getParameter("formName")
        def version = request.getParameter("version")
        def res = this.checkSyntax(clazz)
        if (clazz) {
            if (checkSyntax(clazz)) {
                response.contentType = "text/xml"
                response.setHeader "Cache-Conrol", "no-cache"
                response.writer.write "\n\t$res\n"              
            } else {
                response.contentType = "text/xml"
                response.setHeader "Cache-Control", "no-cache"
                response.writer.write "true"
            }
        } else {
            response.contentType = "text/xml"
            response.setHeader "Cache-Control", "no-cache"
            response.writer.write "\n\tPlease fill in the Form Model\n"
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response)
    }

    @Override
    void init() throws ServletException {
        if (log.infoEnabled)
            log.info("Initializing...")
        classLoader = getClassLoader()
    }

    def getClassLoader() {        
        def gcl = new GroovyClassLoader(this.getClass().getClassLoader())
        gcl
    }

    /**
     * This method is used to relay errors to the user
     * @param clazz  the class
     * @return the exception message or null if it was successful
     */
    def checkSyntax(clazz) {
        def sb = new StringBuilder()
        sb << "import org.openmrs.*\n\n\n"
        sb << clazz
        def res = null
        try {
            getClassLoader().parseClass(sb.toString())

        } catch (CompilationFailedException e) {
            res = "Exception: ${e.message}"
        }
        res

    }

    /**
     * Check if it is result groovy code.
     * @param clazz the class
     * @return whether or not it is result groovy code
     */
    def isValidGroovy(clazz) {
        def sb = new StringBuilder()
        sb << "import org.openmrs.*\n\n\n"
        sb << clazz
        try {
            getClassLoader().parseClass(sb.toString())
        } catch (CompilationFailedException e) {
            return false
        }
        return true
    }
}

This servlet contains a lot of utility methods. One compiles, one initializes/returns the GroovyClassLoader, and of course doGet(), doPost() and init(). doGet() and doPost() both do the same thing, with doPost() simply delegating to doGet(). The code should be reasonably easy to understand. checkSyntax() returns null if it was parsed cleanly, otherwise it returns the exception message, the stack track wouldn't be useful in my case. It returns an XML tag <result> with "true" if it was successful, the exception message if it was not, and a message stating that the field must be filled in if it's empty or just not passed in. I implicitly import org.openmrs.* to allow for easier access to the OpenMRS domain model classes. The parent classloader for the GroovyClassLoader is set the servlet container's classloader. This gives me access to the classpath when loading Groovy classes.

I still have a bit to do, templating needs to be written in, for the most part it's done. Just have a few problems I'm facing, but I'll get through it. Too many people are relying on me succeeding. I feel that this project could help a lot of people, so i feel pressure to succeed. I still need to write in the "Edit" functionality of the "Manage Groovy Forms" page.

I'm definately making progress. More updates to come, that's for sure.

GSoC 2008: Groovy Forms getting some AJAX!

2008-06-21T18:48:00.010-04:00

No, not the cleaning product! The "Web 2.0" kind of AJAX! Now where will this goodness be placed? The pages for creating the forms and managing the forms.

First off, I used Direct Web Remoting (DWR) to provide a link between my backend java codebase and the front-end javascript! It's quite amazing. You can choose to publish/unpublish the forms with the tick of a checkbox and DWR will magically set the published attribute on the form to the proper state. I then decided to go one step furthur, and provide a mechanism to backup the forms via xstream to XML. Now, with the XML files, two files are maintained, one individual XML file for each form, and one global one, which makes up the model for the entire system. The rationale for having the XML file for each form is that you can just zip up the form folder, and unzip it into another OpenMRS install and you're good to go. Adding the ability to re-generate the XML files via the management interface is especially handle so that if you make a quick change on one system, then want to install it onto another you can.

Now, DWR will be used for creating the forms as well. This will be done mostly to easily relay errors, such as syntax errors in the Controller and the Model of the groovy form. Don't fear, I'm going to go overboard with AJAX! It'll only be used up until the point of where templates are generated. After that point, a Servlet will take over the bulk of the work (I am undecided on the Servlet bit.).

Now what's next? Several things need to happen.

First, creating the form:

We need to validate that form fields are not empty; also the input must be checked for validity.
The model's syntax needs to be compiled and syntax errors need to be relayed to the user.
We need to get the fields of the class and store them.
We need to generate templates like: <%= textArea(...); %> -- They will not be run it through the template engine immediately until the user has confirmed what they want,
After the view has been tweaked -- it is run through the template engine; at this point we will also run the controller through and generate that and present it at the same time the final view is presented.
The user will be presented with the HTML of the view and Groovy controller and given a final opportunity to tweak it before it is saved to the system.
The form is added to the system -- by default the form is not published.
Finally, to publish the form so that it can be used to enter data, they go to the management screen and tick the checkbox.
The form is now ready to be used for data entry.

Pictures are worth a thousand words so here we go: One and Two.

First one contains one form which is published, the rest are not. The second, no forms are published.

The user interface is intuitive and easy to use. It's a great design, of course I'm biased since It was was me who designed it.

GSoC 2008: Updates and such

2008-06-14T23:55:00.007-04:00

Okay, let's see what was accomplished in the past few weeks:

I tweaked the domain class interrogation code a bit. Basically, now there is a 1:1 relationship between a field and the domain model metadata storage container class instance.
I've started the templating work -- most of it right now is just methods which will be called like: <%= textField(...) %> -- that will generate a text field html form widget.

I know I haven't accomplished much, but there's a reason, I swear!

June 11th I went to Rockville, MD to the Hypoparathyroidism Association's 3rd Annual Hypoparathyroidism Conference. I just got home tonight.

Let me stray off a bit to explain what hypoparathyroidism is. Basically, the parathyroid is a gland in your neck, underneath the thyroid. Most people get it via surgical error, where the surgeon cuts out, or damages the parathyroid. When this occurs, the PTH (Parathyroid Hormone) is no longer produced. Now, this is responsible for regulating among other things, Calcium. Without this present, the calcium levels in the blood drop, and patients start to experience Tetnay, where their muscles involuntarily contract. It's not fun. If the levels drop low enough, you can go into convulsions, and ultimately seizures. Death is also a possibility, which is why it's important for patients with hypoparathyroidism to take their meds (Calcium Supplements, sometimes Magnesium, Vitamin D (usually D2 or D3), and a medication which is the active form of Vitamin D called Calcitriol.) Some patients also take other meds as well. These must be continued for the rest of their lives. I got Hypoparathyroidism idiopathically -- which means the origin nor the cause is known.

Back to the point: I was at this conference, and it's such a rare disease that I don't know many people. So I wound up talking with the people there. As a result, not much work was done. Monday, I plan to get the templating working, then probably do some Front end UI work.

Well, that's so NOT groovy

2008-06-11T00:04:00.005-04:00

So, I was working on my summer of code project, and I have groovy code along side my java code. I needed to add the groovyc ant task. While i assumed that groovy-all-1.5.6.jar, (note the all) contained everything that was needed, guess what folks, it doesn't! I spent the greater part of the evening tracking down this problem, and then i added the ant-1.7.0.jar and ant-launcher.jar jars, after that suddenly everything worked. That begs the question though, why isn't everything included in the groovy jar?

The problem: NoClassDefFoundError on MatchingTask class.

I figured I would put this out there for others in case they too experience what I did.

GSoC 2008: Week 1

2008-05-31T00:48:00.007-04:00

Okay, week 1 is nearing an end.I accomplished alot of things.

First, I completed the meta-data storage code. I wrote some tests, which revealed some bugs that needed fixing, and they were. I am happy to say, that the metadata storage works!

Writing the test was difficult due to the fact I store the forms in the system using a static List in my container class. I wound up updating to JUnit 4 to get at the @BeforeClass annotation so that the only one set of forms gets loaded into the container class. This helped me greatly. Additionally, the @AfterClass annotation was handy for cleaning up from the tests.

Secondly, Writing the code for interrogating the model was a piece of cake, thanks to groovy. All code for interrogating the model has 50 lines! That includes a model class I wrote to hold the field types and field names. I'll show you, but before I do, I should note that return statements are optional, and the final statement will be returned.


package org.openmrs.module.groovyforms.util

import java.lang.reflect.Field
import org.openmrs.module.groovyforms.metadata.model.GroovyFormsDomainModel

/*
 * Utility class containing methods for class interrogation.
 */
class GroovyFormsClassUtil {
    /**
     * Interrogates the class for all declared fields and
     * stores the type and name in a container class
     * @param the {@link Class#getCanonicalName() canonical name of the class}
     * @see Class#getCanonicalName()
     * @return a reference to a container class containing the type
     */
    static def getModel(fields) {
        def domainModel = new GroovyFormsDomainModel()
        def names = domainModel.fieldNames.&add
        def types = domainModel.fieldTypes.&add
        def f = fields.each {Field field ->
            names field.name
            types field.type.canonicalName
        }
        domainModel
    }

With groovy, it's so easy and concise (as you can see). Let's explain what's going on. First, I pass in the Field array I get from Field.getDeclaredFields(). Now, groovy adds methods onto the standard JDK classes, one of those methods is a method named each() which takes a closure. Now, back to the point, I pass a Field into the closure. That closure is executed for each element (in this case, a Field). Then I add the name, and the type to a List stored in a container class, now that container class is also written in groovy!


package org.openmrs.module.groovyforms.metadata.model

/*
 * Ths class holds information about the properties of the model. 
 */
class GroovyFormsDomainModel {

    /**
     * The field names
     */
    def fieldNames = []

    /**
     * The field types
     */
    def fieldTypes = []

}

Now, the fields are Lists, not arrays. Anyways, I've gotten off on a tangent here, so let me get back on track.

What I accomplished:

Week 1:

Code to generate the directory structure, serialization of metadata back/forth between XML and POJOs (Plain Old Java Objects), Wrote tests to ensure everything works in that regard. Additionally, I wrote the code to interrogate the domain model which I will generate the forms from.

Next Week

Write up the templates for the view/controller and write code to do the generation of the view/controller. Write some tests to ensure everything generates correctly.

Unrelated to that, my stored-value card from google came today. It feels nice to be $500 richer! This is going to be the best summer, I'm already having fun doing this. It's amazing seeing the whole project evolve into something amazing.

GSoC 2008: Progress report

2008-05-29T00:58:00.008-04:00

I have made a lot of progress on my Google Summer of Code Project.

First, I've completed the code for the generation of the directory structure for the forms. This is done using the form id, which is the name with all illegal characters removed. The only valid characters left are alpha-numeric and periods. Let me tell you, the regular expression to replace all of those characters was hell to write. But, thanks to the help of Jason Davis, I was able to make it much more readable and easier digest. You've gotta see it to get an idea of how bad it was, so here goes:


   /**
     * Removes all illegal characters, then removes all spaces and makes it all lower-case.
     *
     * @param str the form name
     * @return a viable form id.
     */
    public static String formNameToFormId(String str) {
        return str.replaceAll("[\\$\\(\\)%`~!@#&;:\\^=\\+\\?<>\"\\*\\\\////\\\\{\\}'\\]\\[\\|\\s+]", "").toLowerCase();
   
    }

That is pretty much hell on earth to read, and it was hell on earth to type. Here's the *MUCH* simpler version:


   /**
     * Removes all illegal characters, then removes all spaces and makes it all lower-case.
     *
     * @param str the form name
     * @return a viable form id.
     */
    public static String formNameToFormId(String str) {
        return str.replaceAll("[^a-zA-Z0-9.]", "").toLowerCase();

    }

Note, you can clearly see that i'm negating that entire sequence. It does the SAME thing, but is MUCH more readable. That reads: "replace everything that isn't a letter from A to Z *OR* a to z(lower case letters) *OR* from 0 through 9 *OR* a period. Whereas the above just excluded the invalid characters explicitly but was a MONSTER of a regular expression.

Secondly, metadata persistence is written in, I'm using xstream. It's a great tool for XML serialization.

That's it. Oh, by the way, these are the things I earmarked TWO WEEKS FOR! Now, I push domain class model processing up, will work on that tomorrow.

Ready...Set...Code: Google Summer of Code has started!

2008-05-27T00:43:00.012-04:00

Today was the official start of Google Summer of Code 2008 Hopefully everybody is finding it a pleasant experience. I have yet to start coding as today was a US Holiday (Memorial Day).

The project plan for the summer has been finalized. I decided to set two-week blocks, rather than do a weekly thing. I chose this, as it's extremely flexible and can scale items either back or forward.

The project plan can be found here. A Google Doc which my mentor and I used to plan the project can be found here. Finally, See my general plan written as a previous blog post.

Best of luck to all the summer of code students!

Thank you so much Google!!

2008-05-20T12:22:00.004-04:00

Today I got the coveted "Google Book" that all Google Summer of Code students have been talking about constantly! I've flipped through it, it's an amazing book! Want to know the name? Everybody knows it already, it's "Beautiful Code" by O'Reilly.

Thank you so much!!!!!

Google Summer of Code Status Report

2008-05-19T01:23:00.012-04:00

I haven't really blogged since I last announced that I was accepted into Google Summer of Code. I have a phone meeting with my mentor to bang out a project plan, I more or less have a general idea of how I want things to go, and he does too. Overall, it should be a very successful summer.

I've been enjoying the Community Bonding period. I have made a lot of friends. My fellow summer of coders are amazing. I planned a potential meet-up for google soc'ers from NY, NJ and CT (to be announced formally when it is more concrete).

Now, onto the fun part, telling you all about my project and how I plan on doing it. I'm gonna break this down. There's a lot of things that need to happen. A lot of data needs to be passed between the front and back ends.

Firstly, Direct Web Remoting (DWR) will be used to grab all the information the users enter into the form and forwards it to the backend whose job it is to generate the form, and then relay it back to the user showing them the result, then saving it to the system. DWR will also be used to provide some AJAX magic.

Then, after I have the data, I need to use reflection on the Form Model and based on the data type, using a templating engine, such as Velocity generate HTML form components.

String, etc: text field or text area; Using some Groovy ExpandoMetaClass magic will aid in deciding if we use a text field or text area.

List: drop-select select box

Boolean: radio or checkbox with some Groovy ExpandoMetaClass magic, i'll add a property which will help aid in deciding which one to use.

After the form is generated, a controller will be generated with default checks that the fields are not empty. This will also be done using Velocity for templating.

Once I have everything generated, it will be saved on the file system someplace with an associated XML file containing all metadata(title,version, description,etc) which will be read in by the system when showing which forms are in the system.

Bus Factor in Open Source Software Development

2008-05-14T16:17:00.004-04:00

Leslie Hawthorne posted an interested thread to the Google Summer of Code Student's List regarding the Bus Factor and the related Single point of failure.It presents a large problem in FOSS development.

She posed the following questions:

1) Do you see the bus factor as a problem in Open Source in general?
How about for your project?

2) Do you think that the bottlenecks result from having too few people
involved in a project? How do those bottlenecks get resolved if it is
hard to bring on newcomers due to bottlenecks?

3) What parallels can you draw between the concept of the bus factor,
socially speaking, and reliability engineering?

The best example of how it is a problem in open source can be explained by the saga of Hans Reiser, whom everybody knows killed his wife. He is the lead developer on ReiserFS. Now with him in prison, there is a good chance that ReiserFS will now slowly die due to his incarceration.

Imagine for a moment if you will, that Linus Torvalds got hit by a bus or something related to that. What would happen to the Linux Kernel? Well, it would probably not die, but it would be a HUGE hit since he is the one who leads the development. Would it die? Probably not. The Bus Factor for linux is pretty low.

As for my Summer of Code project, the Bus Factor would be high. Since I am the primary developer.

Applying this socially, every organization is ultimately led by the vision of one person, and usually there are safeties in place to prevent the Bus Factor from even becoming an issue. So this really can't be applied socially in my opinion. BUT if Google were eliminated, Summer of Code would cease to exist. So I suppose it could be applied.

The success and potential failure is usually dependent on one person (or a select few in some cases). Again, referencing Hans Reiser, his project will now most likely fail, may not; but the probability is high. This is the same across all industries.

Now, does anybody else have answers regarding this topic?

Posting code made easier (for everybody else reading your blog!)

2008-05-06T15:17:00.015-04:00

I've noticed something while reading my daily blogs, a lot of code is just unreadable because most blog systems (blogger looking at you), screw up indentation, unless you wrap it in a pre tag (opening and closing are both required. This makes it readable for your readers! I've left comments on the blogs that didn't know this, and now they do.

This message is primarily for the Google Summer of Code students, but is useful to the programming community as a whole. When you post code, wrap it in a pre tag and be sure to close them when your code example is complete.

Groovy 1.6-beta-1 released!

2008-05-03T00:45:00.003-04:00

So, i read that groovy released 1.6-beta-1. They kept the mixins syntax that was added. I love the new syntax, it's easy to use, and concise as well.

Congrats to the Groovy team! Great Job!

Accepted to google summer of code!

2008-04-21T16:09:00.004-04:00

I was accepted to participate in Google Summer of Code. I will be blogging regularly about my progress. The project I will be working is a Groovy Forms Module, which will enable administrators of OpenMRS to quickly create forms along with HTML and controllers. I think it will be a fun experience.

The new groovy mixins syntax

2008-04-09T01:29:00.007-04:00

Today, I read this post to the groovy dev list and felt the strong urge to play with it. Now to use this, you'll need to compile the groovy code from the trunk in their subversion repository. Read the tutorial about how to build from source. To avoid the dreaded OutOfMemoryException, be sure to increase the amount of heap available to the JVM by doing: ANT_OPTS=-Xmx512m. Now the code.

 
class DeceptiveIntegerExt {
    static def minus(int self, int other) {
        self + other; 
    }
}

Integer.mixin DeceptiveIntegerExt 

assert 5 - 5 == 10

Let's explain this code: First, I create my mixin class which I named DeceptiveIntegerExt for the sheer reason that the only purpose was to overload the subtraction operator and make it add the numbers. Then I add the mixin class to the Integer class; finally I assert that my mixin works as it should, and indeed it does. Albeit that this is a VERY simple example, but I wanted to play with it.

That's all for now.

a CICE Bot

2008-04-06T23:02:00.007-04:00

After writing a bot using both BGGA and First-Class Methods (FCM), I wanted to do Concise Instance Creation Expressions (CICE) as well. To compile you will need the cice prototype compiler and the jerklib jar. Now here we go:


import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.listeners.IRCEventListener;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;

/**
 * Created: Apr 6, 2008 10:55:08 PM
 *
 * @author Robert O'Connor
 */
public class CICEBot {
    ConnectionManager manager = new ConnectionManager(new ProfileImpl("cicebot", "cicebot", "cicebot2", "cicebot3"));
    Session s = manager.requestConnection("irc.freenode.org");

    public CICEBot() {
        s.addIRCEventListener(IRCEventListener(IRCEvent e) {
              if(e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                e.getSession().join("#jerklib");
              } else if(e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                JoinCompleteEvent jce = (JoinCompleteEvent)e;
                jce.getChannel().say("Hello from CICE!!!");
            }
        });
    }

    public static void main(String[] args) {
        new CICEBot(); 
    }
}

The regular java version looks like this:


import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;
import jerklib.events.listeners.IRCEventListener;

/**
 * Created: Apr 6, 2008 10:05:09 PM
 *
 * @author Robert O'Connor
 */
public class JavaBot {
        ConnectionManager manager = new ConnectionManager(new ProfileImpl("javabot", "javabot", "javabot2", "javabot3"));
        Session s = manager.requestConnection("irc.freenode.org");

        public JavaBot() {
            s.addIRCEventListener(new IRCEventListener() {
                public void receiveEvent(IRCEvent e) {
                    if (e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                        e.getSession().join("#jerklib");
                    } else if (e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                        JoinCompleteEvent jce = (JoinCompleteEvent) e;
                        jce.getSession().sayChannel(jce.getChannel(), "Hi from Java!!!");
                    }

                }


            });
        }

        public static void main(String[] args) {
            new JavaBot();
        }

}

a first class bot (w/ FCM)

2008-04-06T22:45:00.005-04:00

After writing a bot using BGGA, I decided to write one using First-Class Methods. Now to compile this, again you will need the FCM prototype compiler and the jerklib jar.


import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;

/**
 * Created: Apr 6, 2008 10:23:06 PM
 *
 * @author Robert O'Connor
 */
public class FCMBot {
    ConnectionManager manager = new ConnectionManager(new ProfileImpl("fcmbot","fcmbot","fcmbot2","fcmbot3"));
    Session s = manager.requestConnection("irc.freenode.org");

    public FCMBot() {
        s.addIRCEventListener(#(IRCEvent e) {
            if(e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                e.getSession().join("#jerklib");
            } else if(e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                JoinCompleteEvent jce = (JoinCompleteEvent)e;
                jce.getChannel().say("Hello from FCM!!!");
            }
        });
    }

    public static void main(String[] args) {
        new FCMBot();
    }
}

It is much like the BGGA bot; in fact i changed nothing and followed the same design:


import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;
import jerklib.events.listeners.IRCEventListener;

/**
 * Created: Apr 6, 2008 10:05:09 PM
 *
 * @author Robert O'Connor
 */
public class JavaBot {
        ConnectionManager manager = new ConnectionManager(new ProfileImpl("javabot", "javabot", "javabot2", "javabot3"));
        Session s = manager.requestConnection("irc.freenode.org");

        public JavaBot() {
            s.addIRCEventListener(new IRCEventListener() {
                public void receiveEvent(IRCEvent e) {
                    if (e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                        e.getSession().join("#jerklib");
                    } else if (e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                        JoinCompleteEvent jce = (JoinCompleteEvent) e;
                        jce.getSession().sayChannel(jce.getChannel(), "Hi from Java!!!");
                    }

                }


            });
        }

        public static void main(String[] args) {
            new JavaBot();
        }

}