Postgraduate university projects
Dissertation as part of postgraduate MSc in Advanced Computer Science.
Language used: C# and ASP.net with the Microsoft Ajax Toolkit, CSS, Javascript and XHTML Application:
Web based Ajax RSS reader similar to the Google Readerapplication but with added functionality. With added Podcast streaming and saving and Blogger editing integration and creation of RSS feeds from any web page.
More info about project: My Masters dissertation which spanned over 3 months involved again a software development project. This time concentrating on a web based application. The application developed was called a Really Simple Syndication (RSS) Reader, and its main purpose was to track dynamic changes made to the content of a website, via subscription to XML encoded web-feeds. In essence the reader allowed one to get the latest headlines and video in one place, as soon as it’s published, without having to visit the websites you have taken the feed from.
The programming language primarily used was C# and the latest version of .NET 3.5. Development and unit testing was carried out in Visual Studio IDE. The design and planning process included architectural UML diagrams such as class and sequence diagrams. As a backend to the application a MySQL database was used to assist in storing important data, which was later moved to Microsoft SQL server. Due to this being a web application development project ASP.net was used as the web application framework to help in the design and implementation process.
Alongside ASP.net the Microsoft Ajax toolkit was used, which provided a seamless integration of Ajax technologies to be added to the application. Ajax technologies allowed the injection of desktop like responsiveness to the web application. Website design was coded in XHTML and overall site design was completed using CSS. I also took advantage of the freely available web service API’s provided by Google and managed to fuse Google technologies into the final version of the application. Most notably the web application made use of the Google Blogger API which enabled the application to have a built in Blogger editor.
Screenshots:
Name of application (Logo):
Web interface making use of CSS and XHTML
Full Blogger editor WYSIWYG integration built into application
Generating a RSS feed out of a standard web page
Ajax collapsible panel in action
ASP:Repeater in action
Server side code logic:
Utility classes
The RSS reader application is built on several utility classes which assisted in encapsulating data related to the content of a feed (title, link and so on).
Each time a feed is added by a user into the application, the contents of the feed are cached in a secondary storage medium namely a MySQL database. In order for this to occur several custom utility classes were designed to help in this process. RSS and Atom objects which were basically instances of the utility classes FeedData and FeedItemData were thus created allowing each of these objects to be added into data structures such as lists. The purpose of these list containers was to hold data in memory until it was processed later on.
Class name: FeedData
Purpose: Assists in encapsulating a feeds channel data
Class name: FeedItemData Purpose: Assists in encapsulating feeds item data
Class name: FeedSubscription Purpose: Assists in encapsulating feed subscriptions
Class name: UserData Purpose: Assists in encapsulating a new users account data
Class name: BloggerItems Purpose: Assists in encapsulating data related to blogging items
Class name: Podcast Purpose: Assists in encapsulating podcast data related to podcast streaming.
Each of the utility classes designed for this application had their own set of basic modifier and accessor functions defined via set() and get() functions to set/get feed data respectively, plus some additional helper methods.
Below is a snippet of C# code, which creates a new FeedData object associated with storing the channel data taken from a feed using a utility class named FeedData. As can be seen in this example a variable newChannelData of type FeedData is created, and its corresponding setfeedGenerator(string) is being called.
FeedData newChannelData = new FeedData(); newChannelData.setfeedGenerator(feed generator name goes here);
Class diagram logic:
Class diagram mappings explanation:
Motivation behind mapping the User class with FeedSubscription:
1 user may be subscribed to: 0 or many feeds.
Motivation behind mapping the FeedSubscription class with FeedData class:
1 feed subscription has: 1 feed channel data.
Motivation behind mapping the FeedData class with FeedItemData class:
1 feed channel data can have: many feed items.
Motivation behind mapping FeedItemData class with Podcast class:
1 feed item may have 1 audio file (podcast) enclosed.
Testing approach
To recap the following features were provided by the RSS reader application: Display web-feeds Share subscribed web-feeds Generate web-feeds in RSS format out of standard web-pages Stream podcasts Discover new web-feeds Posting to a Blogger blog
Each of the individual features which exist in the RSS reader application were tested upon using a testing approach called functional testing. This approach entailed testing units of source code to verify that they were working correctly. The author incorporated a development pattern which involved creating small test applications (separate from the main application) for each of the features listed above, once the code logic was in place they were tested upon. Thus, testing was taking place during the development stage and not left until the very end.
By applying this testing approach it meant that the code logic of a feature was tested upon numerous times before they were eventually added to the main project. In this way the main code of the application remained relatively bug free. The added benefit using this approach was that testing the smaller units of code was easier to complete, since debugging was a manageable process on the small units. In contrast, if the testing approach adopted involved writing a section of code, inserting it straight into the main application and then testing it, any errors encountered would have been harder to pinpoint. The following is a walk-through of the test pattern utilised on the Display web-feeds feature:
- Feature selected: Display web-feeds
- Function split up into manageable units to ease in development
- Units are tested upon
- If errors are found – debug
- If no errors and function satisfies the feature re-test again
- Function is moved into the code of the main project/application
- Function is tested again in the main project, to ensure that the function still maintains its objective and works
Summarizing the outlined development/testing approach :
Skills learned overall:
On reflection on completing this software development project many skills have been gained in terms of both technical and theoretical. A majority of the skills learn relate to technical skills since this was a software development project.
Technical skills involve:
• Using the ASP.net web application framework • Using JavaScript code • Using the Argotic Syndication framework • Using the Google Blogger API • Using the Microsoft Ajax Toolkit • XHTML and CSS code – Web application design • Learning a new programming language C# • Unit testing
Theoretical skills entail:
• Logic related to HTTP requests and responses • Really Simple Syndication, Atom, GoogleData (GData) formats • Ajax design