More work on the paper

After re-reading the report template from Prof. Pollice, we realized that what we had typed for our background would fit better in the methodology section. Today, we reworked the section into the methodology, adding code snippets and talking more about our development process. The document is still very much in draft form and not completed yet, but can be found in the report section of our SourceForge.

https://sourceforge.wpi.edu/sf/docman/do/listDocuments/projects.veniceb08/docman.root.mqp_report

Work From Home Day

Physical limitations are preventing us from making it to the university today. Luckily, we can write most of our tutorials individually without a fast speed to the internet.

Public Art Clustering

One problem with the map application is that there are tons of public art in any given area, and sometimes there are more than one public art in the exact same place. One way to solve this is to cluster the public art to not only speed up transactions but to create more readability.



Figure 1 -
This image depicts points within a certain radius being connected. From here we calculate how many other points each one touches.



Figure 2 -
The points are sorted by how many connections they have, and then for every point that one connects to, we disable so that another point may not connect to it, and so that it cannot connect to other points. Using this method we can group the most amount of points into each cluster, minimizing the number of clusters. The above image is 'unweighted' such that the circle or cluster point is not at the center of mass.



Figure 3 -
This image depicts the clusters at center of mass.

Venice Web Client Ported to Maven2

Formerly known as VeniceClient is now the new VeniceWebClient project. It has successfully been ported to the maven2 project. It uses the VeniceWebService to access the database through the framework. It can be accessed here as it has been deployed already here

Venice Web Service Project Ported to Maven2

Formerly known as VeniceFrameworkWebService is now the new VeniceWebService project. It has just been committed to the repository. We had been thinking about porting the Netbeans project to maven for a while now, seeing that there were two major problems with the status quo.

1. Integrating the framework and the webservice would be difficult if the projects were using different build tools (one Ant w/convoluted Netbeans artifacts, one with maven2).
2. The framework needed to be built seperately, copied over to the webservice folder. There was an anomaly which resulted in ~20mb war file even though the framework was only about 9mb

Since both projects are now maven2 projects, one can be the parent and the other a module. This way they can share dependencies as well as share each other's source files cross-project--which was exactly what we needed. This is also means that using one single maven command, the developer can build both the framework and the webservice and subsequently deploy them.

The VeniceClient is still a Ant/Netbeans project, we are hoping to port this over soon so that all three projects are under the same build tool.

The ultimate benefit is that all projects will be IDE independent as well as cross-platform.

Write once, run anyway anywhere!

Embeddable Public Art

An embeddable version of the Public Art application has been created, and it can be seen below!

One New Web Client

For this week's meeting with Professor Carrera, we made a couple of front ends to demonstrate the extensibility of our framework. The applications show different ways that Municipal Data Objects (Public Art in this case) could be displayed to varying end users.

One of the web clients that we made is a proof of concept of our web service. It is laid out in an archival format, and allows users to search through Public Art objects either by entering an ID or by hitting previous and next buttons. Upon clicking one of the buttons/links, an AJAX request is sent from the .jsp to a servlet (the server-side of the client...yes we know that is kind of confusing). The servlet parses the request and sends a SOAP request to the web service, which in this case is located on the same server as the Client but does not need to be as it is a wholly separate entity. The Web Service is an (proof of concept) application built using the Venice Framework, and thus calls methods in the framework to fulfill the SOAP request. The Web Service then takes the Java objects that it is returned, converts them to XML, and sends them off in a SOAP response to the server-side servlet of the web client. The servlet then parses the XML response and sends out a JSON-encoded AJAX response to the .jsp which displays the results.

This application can be accessed here. Please disregard the absurd loading .gif...it is in the wrong div.