New version of the PowerPoint

There is a new version of the PowerPoint presentation up on SourceForge. It is in both .ppt and .pptx format, although the .ppt is not fully editable due to limitations in the old software. Changes in this version comprise changes Fabio suggested in yesterday's meeting, including a 'flow of information' slide.

Venice Framework up and running on VPC server

So we've got almost everything moved over to the VPC server. The embeded app can be found at: http://cityknowledge.org:8088/VeniceWebClient/embed.html

Also running: MySQL server, GlassFish, Web Service, Client application and servlet, ImageMagick script

Powerpoint presentation is up on SourceForge

Our first draft of the Powerpoint presentation is up on SourceForge. It is complete, content-wise, but still needs to be fleshed out.

First Drafts of all section are up on SourceForge

First drafts of most of the sections are up. Still lots of work to do on everything though:

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

Whoops, I was logged into Justin's account for that
-Eric

Initial JavaDocs for VeniceFramework are up on SourceForge

The initial generated JavaDocs are up in a .zip file on Sourceforge. These documents pertain only to the Framework, and not to any pieces of the proof of concept. A good amount of the code is correctly commented, but some more work still needs to be done.

Application Creation Document Updated

Revisions have been made to the "Developing Applications on the Venice Framework" document. The document now includes information on how to create web services using the Framework, and how to test those web services. It links to some tutorials that we found to be very well written and informative.

The background document has also been reworked a bit.

Developing Applications on the Venice Framework Tutorial, Version Uno

The first version of the "Developing Applications on the Venice Framework" document is up on SourceForge. It details how to build the framework to produce a JAR, and how to include that JAR as a library in an external project.

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.

VeniceClient updates

Today we made some progress with the VeniceClient web client. The front-end .jsp now communicates effectively with the VeniceTestServlet (kind of a stupid name in retrospect) using AJAX aided by the technologies JSON and Prototype. The client does not currently display anything, but we will have one or two front ends to demponstrate by the meeting with Professor Carrera tomorrow.

Solution to Blocked MySQL in University

We've had this problem for a while now. When we work in the IUAV, we have excellent internet connection but the MySql connections are blocked off. This makes it hard for us to do testing beyond using HSQLDB + DBUnit + JUnit. The first part of the solution is to tunnel the connection through SSH. In order to do this...

1. Ping the server (your.server.net), get the actual IP and copy it somewhere (this will be explained later)
   
2. Start putty
3. Put the actual IP into the hostname field
4. Under the tree menu, goto Connection-->SSH-->Tunnels
5. For Source Port, put the "MySQL port" (default: 3306)
   
6. For Destination, put "localhost:MySQL port" (default: 3306)
7. Now connect to the server and login
8. Your computer's port MySQL port should now be the server's tunneled MySQL port. You can now connect to it using MySQL admin tools

This was all well and good that we could connect to localhost:3306 to access the MySQL database remotely, however, we this still meant we had to change all of our project configurations to adapt to the change of the hostname from your.server.net to localhost. This was feasible, but not practical. So instead, this is what we came up with.

1. For Windows OS', navigate to C:\windows\system32\drivers\etc and find the hosts file
2. Open the hosts file with notepad
3. Append "127.0.0.1 your.server.net" to the end of the file
4. Change all Non-tunneled connections to the actual IP address of your.server.net so as not to connect to yourself at 127.0.0.1 (e.g. pinging your.server.net would not work with the host file changed)

Since the change is made only in one place, it makes it much easier to do the testing and it means less errors switching around configurations all the time.

Photos up on the server

The photos have all be uploaded and made available on our server (slocketrocket).

http://slocketrocket.res.wpi.net:8080/photos/

We are working right now on getting photo information retrieved properly in our framework (hibernate issues) and we should have everything integrated soon.

Relating Photos and MDOs

We had to make a decision regarding MDO objects and how they would be related to pictures. We decided that pictures will be hosted on the server separately from the database. Each photo has have a unique filename. The Photo table in the database has a unique id, a description, and the unique filename. This table is related to MDO in a relational table that has both ids.

The issue we had was with the initial population of the relational table. Previously, PublicArt objects had a value called 'c2kid' which was also used for the names of the images. They still have this 'c2kid', but the id is no longer used directly to access the images. Instead, we inserted new Photo rows into the Photo table for each PublicArt row, using the 'c2kid' as the name. We then inserted a relation into the relation table for each matching pair of 'c2kids' (PublicArt and Photo).

Using this method, we were able to populate the database while keeping a general format for the relation between the two classes instead of using an arbitrary string ID that is unique to PublicArt.

Praha uno

A bit off-topic, but here are some pictures from our recent trip to Prague:

End to End Web Service Working

We were able to get the Framework all .jar'd up and put into the web service. We then did a bunch of compliance testing and got them communicating with each other. The web service can now retrieve data from the database. The client now allows a user to enter an ID, and it will retrieve from the database the PublicArt object of that ID. This marks a giant leap forward because it demonstrates how our framework will be implemented into applications, such as the PublicArt web service or the Admin Console.

The link for this functionality is here. Note that this overrides the previous web service, so you can no longer multiply numbers by two.