07.09.08
Posted in About Me, Customer Service, KSU, SAnToS, Technology at 3:00 pm by Todd
Update (10:15a 11 July 2008): The DNS information should be propagated by now and most of the bugs worked out. We had some issues with CVS and host name that needed to be fixed. Hopefully those are the last bugs we find for a while.
Update (5:00p 09 July 2008): Looks like the DNS information is harder to change than expected. So the post of this entry was a little premature. Oops!
For the last 2+ years I have been working to upgrade our project management server to use new hardware and new software. And it is finally complete! Today, we finalized the migration from the old project management server to the new one. The new one is running GForge AS 5.4 purchased from the GForge Group. We had several issues getting this done but it looks like the job is complete (some of them mentioned in this post).
I would like to take the time to thank Tim and Marcelo (from the GForge Group) for helping get the migration completed. They certainly worked hard this last week to make sure this happened.
I would like to thank Travis, Cole, and Seth (past and present members of the CIS system admin staff) for working to get this migration completed. They worked on it for quite some time to make this happen. They also suffered my constant pressure to get it done and get it done correctly.
I am particularly excited about a couple of features in the new software: 1) CruiseControl, 2) the Eclipse plugin, and 3) Subversion. I have used CruiseControl for some toy projects in the past and I am really interested in getting it to work for some of my real projects (SpAda and Cadena). And since I use Eclipse as my main work environment, it will be nice to have the ability to interact with GForge from inside of Eclipse. That integration will make it easier to track and fix bugs as well as keep on task. And with the ability to use Subversion, I will finally get a chance to try it out. I have been using CVS for so long that I do checkouts from my fridge to get my midnight snack.
But the best feature is that the CIS department system admin staff will be taking over the admin duties for the box. This means no more late nights or early mornings fighting with the machine. And it means no more customizations to deter script kiddies. And it means no more little changes to the GForge code to make sure it works correctly. Best of all, no more KSUAFRS (a custom download manager that Jesse and I wrote for GForge) – John and Robby decided that feature was no longer necessary.
I am really glad that this task is complete, that it got done without any major issues, and that the admin duties now fall on the department (instead of me).
Permalink
07.07.08
Posted in KSU, SAnToS, Technology at 10:05 am by Todd
Today is the day that the project management server is getting migrated. It will soon be running on new hardware (dual Opteron 248, 12G RAM, 80G hard drive) using new software (GForge AS 5.4). I am hoping that in a few hours I will post a completion announcement here.
Wish us luck and say a prayer that Murphy doesn’t visit Nichols Hall today.
Permalink
06.13.08
Posted in About Me, Family, KSU at 1:00 pm by Todd
The Spring of 2008 has been a very busy time for me. It ranged from fantastic (graduation and vacation) to sad (funeral). Here are some highlights:
- Kari successfully defended her thesis to get one step closer to completing her Master of Science in Animal Science degree (4/21/08).
- My grandmother, Arlene Mullin, passed away unexpectedly (4/16/08). We celebrated her life and our family in Ames, IA (4/23/08). I will really miss her and I know the rest of the family will as well.
- Submitted a paper to Sensys 2008 about our work with Cadena and sensor networks (4/28/08). I did almost no writing (at least none that made it into the paper) but drove many of the ideas that were explained in the paper. I was also charged with doing a lot of the experimentation and investigation (so I learned a lot about nesC, TinyOS, feature modeling, and the Feature Modeling Plugin). It would certainly be an accomplishment to have a second publication but I have a hard time taking credit since I did very little writing.
- Hosted my cousins (Cherie and Ashley Swanson) for a visit to the Little Apple (5/1 through 5/4/08). We set it up on a weekend where Ashley could attend the Taste of Home Cooking show, visit K-State to investigate possible majors, and shadow Noah at della Voce. I think this gave Ash a great view of Manhattan, K-State, and a career in the restaurant business. And I am so glad she got to chat with Jackie McClaskey – she sold the College of Agriculture better than anyone else I have met.
- Kari completed her Master of Science degree in Animal Science and walked in the Graduate Schools graduation ceremony at Bramlage Coliseum (5/16/08).
- I surprised Kari with a vacation that was meant to celebrate her graduation and our anniversary as well as give us a time to unwind and get some much needed perspective on life (5/23 through 5/27/08). We spent 5 days (4 nights) in the Turks and Caicos Islands. And I surprised her even more by having our good friends (and neighbors) the Wallaces meet us there and vacation with us. What a fun surprise and what a fantastic vacation.
And it looks like the summer will also be full of fun and adventures. Births, vacations, wedding, job search, and much more are on the agenda for the summer. So it should be interesting – wish me luck.
Permalink
06.12.08
Posted in About Me, KSU, Manhattan at 9:13 am by Todd
Just wanted to let everyone know that the Wallentines survived the Tornado last night. Kari, Anna, and I were safely stored in the basement as the sirens went off and the newscasters tried to keep us informed. Virg waited out the storm up at work (his house doesn’t have a basement) and then spent the evening with us. He had a tough time getting home since the damage was on his side of Manhattan. Luckily, his house had no damage.
I know not everyone in Manhattan was spared but I am glad to hear there were no fatalities here in town. I am praying quite a bit today for people in Chapman (KS) – it sounds like their twister was a lot stronger than ours.
What I am hearing right now:
- K-State has some damage. Kari and I will head up to campus to check out her office.
- K-State is quasi-closed today. Some people are working today to clean-up but classes were cancelled. I imagine most people will be at home today.
- Damage from the store was mostly on the west side of town (in my old neighborhood – University Heights and around Lee school).
- All of my friends are ok and still have houses. But I am betting that the office of one of my friends is ruined (if not tornado damage then definitely flooded).
Well, that is it for now. Wallentines ok – Manhattan has some damage – K-State closed. More to come as things change and as I find out more information.
Update (11:50a 12 June 2008): We took a trip up to see Kari’s office. Weber Hall is still standing but has quite a bit of glass damage and a large amount of roof damage. I hope to upload pictures this afternoon that I took on campus. The good news, Kari’s office was undamaged and Nichols Hall is fine (my office). And for the most part, the damage on campus isn’t that severe. There is a lot of tree damage, a lot of broken glass, and some roof damage.
Permalink
03.25.08
Posted in KSU, Programming, SAnToS, Technology at 1:00 pm by Todd
Last week I posted my first bug reports to Eclipse.org’s Bugzilla database. Tom Grosman (leader of the Hibachi project) suggested that I submit my patches as bug reports in their official bug database.
My first bug report was about the NullPointerException I found. I mentioned this in a separate post earlier.
My second bug report (or enhancement) was about making parameters available as children of subprograms (procedures and functions). I mentioned this in a separate post earlier.
My third bug report (or enhancement) was about making an extension point available in Hibachi so others can create their own outline views. I mentioned this in a separate post earlier.
This is quite an achievement for me since I have never contributed to an open source project like this. I have reported bugs but never gone this far in diagnosing and fixing issues. And I hope these won’t be my last.
Permalink
03.24.08
Posted in KSU, Programming, SAnToS, Technology at 1:00 pm by Todd
As I worked through my outline view extension of the Hibachi UI, I realized that it would be great to re-use the icons that are already available in the Hibachi UI and currently used in their outline view. It would be even better if the icons were accessible in a standard way (similar to the Eclipse Workbench UI, JDT UI, and Team UI conventions currently used).
The standard pattern that I have found is as follows:
- Provide a Java interface that has String constants that map to each icon available. The name should be
ISharedImages and the interface should declare 2 methods: 1) getImage(String) : Image and 2) getImageDescriptor(String) : ImageDescriptor.
- Provide a static method (which is public) on the main plugin class that will get an instance of
ISharedImages. It is typically named getSharedImages() : ISharedImages
- Provide a class that implements
ISharedImages. This class can be hidden from use by others in an internal package and not exported by the plugin.
This pattern can be seen in the
Java Development Tooling (JDT) UI, the
Eclipse Team UI, and the
Eclipse Workbench UI.
[Note: Direct links to the main plugin and ISharedImages classes are provided in the Related Links section at the end of this post]
The Hibachi UI isn’t currently implemented in this way but it is quite close. The Hibachi UI plugin does provide some String constants and a method in the main plugin class. The follow snippet gives an idea of what is currently implemented in the UIPlugin class.
public static final String ICON_PROCEDURE = “procedure.gif”;
public static final String ICON_FUNCTION = “function.gif”;
…
public static ImageDescriptor getImageDescriptorForIcon(String name) {…}
This allows the UIPlugin to cache ImageDescriptors but still forces the user to create and dispose of the Image (which is the important one to cache). So I took it upon myself to patch their UI plugin to provide this in the same way that other Eclipse plugins share their images (as described above). This will likely reduce the amount of memory because Images will be cached as well as ImageDescriptors. It will also make it easier for developers that extend Hibachi and make use of the icons because they will no longer have to create and destroy the Image.
My first task was to create the ISharedImages Java interface to hold all the constants that map to all of the images (icons) available in the Hibachi UI plugin. I chose to put that interface in the org.eclipse.hibachi.ui package so that it would be available to other plugins (that package is already set as “exported”). This also seems to be the standard location for the interface.
The second task was to create a class that implemented ISharedImages. I chose to create the class in the org.eclipse.hibachi.ui.internal package and name it SharedImages. This class implements the 2 required methods with some simple (straight-forward, pass-through) logic. In other words, it makes use of existing logic that was used to load and cache images but was not available outside the plugin (see the SWTResourceUtil and AdaPluginImages classes).
The third task was to create a method in the main plugin (UIPlugin) to get an instance of ISharedImages. This method uses the lazy initialization pattern (single instance that is a private field that is created the first time the method is called). This was easy to declare and simply creates an instance of SharedImages (which implements ISharedImages).
To make sure I did it correctly I wrote some code in our outline view plugin that grabs images. Testing that code brought a smile to my face since it worked the first time (which hardly ever happens for me).
Here is a patch for that chunk of work.
At this point I have working code that matches the standard pattern but there is a lot of duplication of effort in the plugin. I would like to find a way to reduce that. For now, I will simply submit this patch and hope someone else can help make it better. Hopefully this patch is useful and will be merged into the mainline for the Hibachi project.
Related Links:
Permalink
03.11.08
Posted in KSU, Programming, SAnToS, Technology at 1:27 am by Todd
With two minor changes to the Hibachi codebase under my belt, I needed to start working on tasks that advance the goals of the SAnToS lab (my employer). The first task on that list is to extend the outline view so that we can display SPARK annotation information. The SPARK annotation information will eventually come from a custom parser being developed by Jon Hoag.
Here is a quick example of what
SPARK annotations look like.
procedure Add(X : in Integer);
--# global in out Total;
--# post Total = Total~ + X;
The first line is the Ada declaration for a procedure named
Add that takes 1 parameter (of type
Integer with a mode of
in and named
X). The second line, which is an Ada comment and a
SPARK annotation, states that a global variable named
Total is changed in the body of the procedure. The third line provides a post-condition describing the value of
Total after the procedure is executed. This information will eventually be shown in the outline view to make it easier for
SPARK developers to navigate and understand the code.
This first task required a lot of investigation into the Hibachi codebase. I first had to understand the current extension points for the Hibachi UI plugin. I was hoping to find an extension point already created that would allow external outline views to be used. Finding that there wasn’t one, I had to devise a plan of attack. I would first create a list of possible solutions and then dig into each one until I had a favorite. I ended up with 3 possible solutions (2 of which were feasible).
The first option was to simply make changes to the current outline view to support the SPARK annotations and hope it would get merged into the mainline. This seemed like a bad idea for several reasons (our goals are not directly inline with the goals of the Hibachi project, SPARK annotations won’t always be available so the code would get messy, etc.). This option was abandoned very quickly.
The second option was to refactor the current Hibachi UI plugin to provide extension points for the content and label providers that are used in the outline view. I considered this but decided this might lead to a more fragile extension point so I opted to not pursue this option at this time. But there is no reason not to revisit this option in the future since it might make more sense in the long-run.
The third option was to refactor the current Hibachi UI plugin to provide an extension point that would allow others to provide their own outline views. This would require the Hibachi developers accept our changes into the mainline but would mean that we could keep our SPARK specific implementation out of their way (in other words, in our own plugin). This is the option that I pursued.
With that decision made, I started hacking away at the code trying to find the best way to design and implement the extension point. I tried to follow the example provided in the PrettyPrinter extension point but had to make some small changes. I chose to create a single extension point, refactor the existing outline view to use that new extension point, and then create a Manager pattern to keep track of the extensions and instantiate outline views. I also had to design a user interface that allowed the user to select the outline page implementation they wanted to use for each project (in the long-term this mechanism will likely change to allow a global setting of this).
The extension point that I created for the outline view is as simple as I could make it. It simply takes 3 values: 1) an
ID, 2) a name, and 3) a class name (this follows the pattern used in the PrettyPrinter extension point). Below is an example of how to use it (taken from our
SPARK plugin):
<extension
point=”org.eclipse.hibachi.ui.adaContentOutlinePage”>
<outlinePage
class=”org.sireum.spada.ui.outline.SparkContentOutlinePage”
id=”org.sireum.spada.ui.outline.SparkOutlinePage”
name=”SPARK Outline Page”>
</outlinePage>
</extension>
Note: Using the Eclipse Plugin/Manifest Editor makes declaring this extension much easier.
It should also be noted that the name provided will be used in the listing of outline pages available in the Property Page for the selection of Outline Page (as described below).
After my refactoring, I was able to test that the existing outline page still functions as expected. This wasn’t as easy as it sounds. It took me several days to get it right because of serious over-sight in how I implemented part of it – oops!
I then created the property page UI to allow the user to select their desired outline view. A screenshot of this is shown here.
Once that was all in place I created the start of our SPARK outline view. And with just a little elbow grease, I was able to get a very simple (no images) view done in a matter of hours. Most of that time was spent understanding the Ada model that Hibachi uses (which is very good based upon my limited experience with it).
The next step is to finish the basics for the SPARK outline view (handling all parts of the model, handling the navigation, and making it pretty with custom icons). This will likely take some real time to get right.
Anyway, here is the patch. I have spent some time testing but I am sure there are things that I missed. And their might be more refactoring necessary to bring it inline with Hibachi standards and style. I hope that the Hibachi developers will merge the patch, test it, and commit to using it in the mainline.
Permalink
03.10.08
Posted in KSU, Programming, SAnToS, Technology at 1:00 pm by Todd
I have been working with Hibachi for a couple of weeks now and so far I am impressed with it. Well written code, especially for an open source project, and well documented (at least in comparison to what I have been reading for the last couple of years).
One issue that I came across while using it was that the outline view doesn’t show the parameters as sub-children in the tree. Let me see if I can convince you that making them sub-children isn’t just preference.
I assume the reason the Hibachi developers chose to do it this way is because it mirrors what the Eclipse JDT (Java Development Tools) does. Specifically, for each method in a class, there are no sub-trees. It simply lists the parameter types after the name. For example, given the following Java code:
public void myMethod(String s, Integer i) {
....
}
the outline view would look like the following screenshot:
So it seems reasonable that Hibachi (aka, ADT - Ada Development Tools) would do the same. But I think the Ada language is different enough from Java that it makes sense to re-evaluate this decision. I think that since Ada parameters have a mode (in, out, or in out) that it would be an improvement for users if each parameter were its own sub-tree node in the outline view. Then the icon used in the tree can denote the differences in mode.
So my suggestion is that we modify the model to return the parameters as children. With this change, the outline view shows each parameter as a sub-tree node. This makes it possible to change the LabelProvider (specifically the AdaOutlineLabelProvider) to add decorators for the mode.
Anyway, here is the patch that I created. I hope it is merged into the mainline.
Permalink
02.13.08
Posted in Customer Service, KSU, Linux, SAnToS, Technology at 3:47 pm by Todd
One of my duties in my current position (Research Associate at
K-State working for the
SAnToS lab) is system administrator. I help to manage laptops, workstations, and servers. The only server I still manage is our project management server that runs
GForge (named
projects.cis.ksu.edu). That server will soon be transitioned over to the responsibility of the
CIS departments
system administrators. Unfortunately, the transition has been a little painful. Let me explain.
Over the last couple of years we have had increasing downtime on the old hardware (a 7 year old dual processor workstation) and old software (the open-source version that we custom patched). Because of this, we wanted to upgrade both the software and the hardware. And with the shortage of man-power in the lab, we decided to share the server with the rest of the department and then transfer responsibility of it to the department as a whole.
We selected some existing hardware that was in our
Beocat cluster, upgraded the amount of storage space, and did a fresh install of Linux. We then purchased a commercial license from the
GForge group for their
GForge AS. We then started the process of upgrading and transitioning. This is when the real pain started.
Some of the pain is self-inflicted. We wrote our own plugin for GForge which modified how the file release system worked. In doing so, we deviated from the standard file locations. This made it a non-trivial upgrade.
Some of the pain was organizational. Because the
CIS system admin staff would be taking over this responsibility, we wanted to let them do the migration. Which meant them learning about it as well as experimenting. Trouble was, they have turn-over (students graduating or leaving for better jobs). So this task fell between the cracks quite often and meant a lot of re-learning by a new person. This made the transition drag on for quite a while.
Some of the pain was caused by the GForge Group. I am sure they try very hard but their customer service leaves a lot to be desired. It almost feels like dealing with Microsoft — our issues are too minor for them to take seriously. So bugs we found were brushed under the rug despite them being true “show-stopper” bugs (we are not going to do the final switch-over until they are fixed).
- The first issue is that mailing list archives that are marked as private are not protected. Meaning that any visitor to the site can see the “private” messages on our lists. Not a good thing.
- The second issue is that some of the data was lost during the transition. Specifically, the document manager in the old version provided a title and description to go along with each document. In the new version, there is no title. And during the transition, the consultant did not migrate the description over so we lost both the title and the description. Not a big deal but it would cause several man-hours of work for us to fix.
- The third issue is that files and releases that are marked as hidden are not actually hidden. We like to (or tend to) keep all of our releases on the server but hide the old ones so that our users (downloaders) are not confused. But when we do this, they are not actually hidden from the user in the new system (they were on the old system). Again, not a big deal but certainly more burden on us to manage our releases.
- The fourth issue is that the mailing list messages in the archives are not attributed to the correct author. This is more of an annoyance than anything else but still an issue that we would like to have fixed.
I suppose this post is part venting (getting this frustration off my chest) and part warning. When dealing with the GForge group, be aware of what you are getting into. It might be best to simply use the open-source version or purchase from a different vendor.
Update (01 July 2008): I just had a very productive phone call with Tim Perdue, the founder/CEO of the GForge Group. He was worried that this post might give people the wrong impression about his company. Because of that, I wanted to set the record straight.
First, I wanted to thank Tim for calling me to chat about this blog post. I was quite surprised since I didn’t think anybody read it. But with the magic of search engines, I suppose things get read at odd times.
Second, I think that the GForge Group has a very good product. GForge AS has a lot of really cool features that I am excited to use (integration with Eclipse, CruiseControl, and an integrated tracker and task manager).
Third, a lot of the issues that I was venting about have nothing to do with the GForge Group or GForge AS. I am guilty of screwing up this process as much as anyone when I implemented the custom download manager. And some of the issues had to do with our internal staff. All that to say there is plenty of issues in this “project” and enough blame to go around.
Last, I want to clarify this statement: “When dealing with the GForge group, be aware of what you are getting into”. I am just saying that any single bug might not be important to them. This is very normal for any small software company so it shouldn’t be taken as a dig on just them. I guess I just expect more out of customer support (which might be my problem and not theirs).
I should also update this post with the status of the migration. It looks like all but one of the issues has been resolved (we still haven’t fixed the document description issue). We are just performing some final testing to make sure there are not any more bugs before we do the final move. We hope that this will happen on Monday (July 7, 2008) (no promises though – unexpected issues always seem to arise).
Permalink
02.07.08
Posted in KSU, People at 9:35 am by Todd
I just wanted to congratulate Larry Hollis on his
promotion to full professor at K-State. He certainly deserves it.
Larry works in the
Animal Sciences and Industry department here at K-State. He has been team-teaching a class with
my wife for a couple of years. He has also taken over as her mentor in the department and done an outstanding job.
Powered by ScribeFire.
Permalink
« Previous entries Next Page » Next Page »
