Data Design: Modeling and ERDs

This week we were lucky to have a relatively simple set of WODs which focused on data design and generating Entity Relationship Diagrams. Although simple, this topic is extremely important and necessary for next weeks lesson, Data Design Implementation. Since I’ve studied this material in the past, this was a great (and very much needed) review.

WOD 1: Library Data Model
In our first WOD, we were tasked with designing a data model for the typical library system. In this system, the library holds multiple copies of books. Patrons, who are either students or faculty members, can borrow and reserve up to 5 books. This system must be designed to meet the following requirements:

• Check whether a recently returned book has been reserved
• Check which borrower has a specific book on loan
• Check which books are currently with a specific borrower
• Check the status of a particular book (borrowed/not borrowed)
• Check which reservation should receive a recently returned book
• Retrieve the loan and reservation history for a book

Since I’ve studied data design in previous classes and I’ve worked with Lucid Charts before, I found this WOD fairly easy to accomplish. I finished my first and only attempt in Av time of 15 minutes and 38 seconds. Here is the Entity-Relationship Diagram I drafted for this problem which, I believe, meets the required specifications:

WOD 2: Car Rental Data Model
The Second WOD was similar to the first but a bit more challenging. We were instructed to create an ERD for a car rental company. The company has a number of offices in various cities and locations. Each location has a set of vehicles, each vehicle can be categorized into one of five vehicle types (i.e. Economy, Standard, Van, Box Truck, Cargo Van). Customers can reserve a vehicle at a specific location for a set date and time. When the vehicle is returned, the car rental clerk records the date, time, odometer reading and gas level.

Like the previous WOD, I was able to finish my first and only attempt in AV time of 14 minutes and 35 seconds. While my solution varies slightly from that presented by the professor, I believe that it provides a satisfactory design for this data model. Here is my ERD:

Conclusion
The exercises this week were fairly simple to accomplish but we can easily see how models can quickly get complicated as the data and relationships become more complex. In the application that I am building for the final project, I already know that I am going to have at least 4 different entities: Users; News subscriptions; Commute subscriptions; and Blog subscriptions, however, this number may change. Representing my data model as an ERD will undoubtedly be helpful and provide direction when I eventually take on the task of implementing the backend database.

Notify Hawai’i – Milestone 1

Development of the Notify Hawai’i web application is progressing at a steady rate. Here I will describe the current state of the system, what I am working on for the next milestone release, and discuss my experience with project management.

Current State
There is an in-memory database to store user information (i.e. first name, last name, email address, telephone number, and cell phone provider). This information will be gathered and validated when users register for an account with the application, however, this function is not yet implemented. User information is edited from the ‘My Account’ page.

There is a second in memory repository to store News Service subscriptions for each user. These subscriptions are added and updated from the News Services webpage. Currently, user and subscription information is added to the database during the initialization of the application on start up.

The application is able to retrieve news articles from a specific set of online newspaper sites. These sites include the Honolulu Star Advertiser, the Maui News, and Civil Beat. The articles that can be retrieved are grouped into the following categories:

Honolulu Star Advertiser: Breaking News, Popular News, and Sports.

Maui News: Breaking News, Business News, Hawaii News, and Local News.

Civil Beat: Most Popular Stories, Honolulu News, Honolulu News, Education, Politics, Energy and Environment, and Development.

Articles are retrieved using the Jaunt Web Scraping API. Once articles have been harvested from the applicable websites, they are sent to users via email or text message. We use the Apache Commons Email API which includes the JavaMail API as well.

The future of Notify Hawai’i
There is still much work to be done on this application. While implementing the News Services module, I realized that sending a list of articles via SMS text message may not be a worthy endeavor. Depending on the number of subscriptions held by the user and the number of articles published by the site, these lists can be quite lengthy. Since HTML cannot be displayed in SMS text messages, there is no efficient way to present article titles and links. Therefore, I will most likely remove the text message option and only issue News notifications by e-mail.

For the next milestone release, I plan on implementing the Commute Services module. This service will allow users to request notifications when commute related events occur. By using the Google Maps API and Honolulu’s ‘TheBus’ Web Services API, I hope to be able to inform users on estimated commute times and bus services. I also plan on putting the finishing touches on the News Services and Account pages and bring them to a completed, fully functional state.

Project Management
I’ve had both good and bad experiences working alone on this project. It is nice to have complete control over the implementation but I often think another developers opinion would be a valuable and welcomed resource. Also, building the entire project by myself has required a huge amount of effort. It would have been nice to partner with someone to share that load. However, since the majority of the documentation has been written (i.e. the user and developer guides), maintaining them by incrementally adding updated information pertinent to the newly implemented functionality should be easy.

Going forward, I would like to be better about creating and closing Github issues. The issue management system is a great tool to guide software development and I should be utilizing it more. I am also going to start working off of branches from the master repo instead of doing all of the work in the master repo itself.

Overall, I feel that this project is progressing along at a reasonable rate and is actually useful in its current state. I’m excited and looking forward to building out the next few modules!

View the project on Github here.
View the deployed application on Heroku here.

Application Design: Tests and Templates

This week we endured one of the longest sequence of WODs to date. The majority of the exercises focused on the important task of implementing tests to challenge the application and ensure quality. We also studied the use and creation of template code to increase efficiency. Although these exercises were not particularly difficult, there were several little “gotchas” that resulted in my failing of a few of the exercises.

E47: Digits Test
The goal of the first WOD was to implement two simple tests to ensure basic functions of the application worked correctly. The first test checked that the index page could be successfully retrieved. The second test checked that a new contact could be added to the database and correctly displayed in the table of contacts.

Although I watched the introductory screencasts and studied the example applications, I struggled during my initial attempt at this WOD. Within 30 minutes, I had written the two test cases and created the applicable Page classes (following the page object pattern) but was unable to compile the code. In my application, the two test methods were passed the TestBrowser object which was then used to navigate through the application. This approach, however, is not valid in the Play framework as test methods cannot be passed parameters. After approximately 20 minutes, I managed to debug my way out of this predicament and successfully run the tests. In all, I spent over 50 minutes attempting to complete this WOD resulting in a DNF. After watching Dr. Johnson’s solution, I immediately repeated the exercise and completed my second attempt in Rx time of 17 minutes and 30 seconds.

E48: Digits Text Template
The second WOD was much easier than the first. The goal of this exercise was to use Scala templates to recreate the Bootstrap text fields in the New Contact form. By utilizing templates, not only do we ensure controls have a uniform appearance but we also reduce redundancy making the code cleaner and easier to read. Since the templates were given to us and are simple and easy to use, I was able to complete my first attempt at this WOD in Av time of 10 minutes and 39 seconds. After watching the solution, I repeated the WOD and managed to shave off over 5 minutes from my time finishing in just 5 minutes and 15 seconds.

E49: Digits Selection
The third WOD continued with the use of templates but this time we added a selection control to the New Contact form which is a much more complicated task than adding the textbox control. Utilizing selection boxes requires the creation of a backing class that maintains a list of valid options which must be passed to each View that uses that selection box control. The actual implementation is not very difficult but but ensuring that all the pieces fit together can be challenging. This slowed me down a bit during my first attempt at this WOD. I also experienced an import conflict since both the form helper and Bootstrap templates have a “select” method. In the end, I was able to finish this WOD in Av time of just under 38 minutes. Like the previous WODs, I made a second attempt at this exercise after watching the solution and was able to achieve Rx time of 21 minutes and 42 seconds.

E50: Digits Custom Template
In WODs 2 and 3, we used preexisting controls in the Bootstrap template. In the fourth WOD, we created our own control template that consisted of a textbox and selection box. Creating custom templates can be useful if the same form or set of controls is displayed in multiple places throughout your application. However, as a classmate pointed out, there is a drawback – error messages are displayed for all controls in the group if any control contains a validation error. This WOD was not too difficult and I was able to complete my first attempt in Sd time of just under 16 minutes and my second in Rx time of 6 minutes and 17 seconds.

E51: Digits Init
In the fifth and final WOD, we learned how to override the onStartup method of the Global class that allows us to initialize the application to a specified initial state. This was not a difficult WOD, however, I DNF on my initial attempt due to the fact that I imported the wrong application package. This error did not throw an exception – the code compiled but the onStartup method was not invoked. After over 16 minutes, I gave up and watched the solution screencast. I immediately repeated the WOD and finished my second attempt in Rx time of 7 minutes and 26 seconds.

Knowing the State of the Repo
Before beginning each WOD, we were instructed to create a new branch off of the master repo and do the exercise in that branch. At the end of a successful WOD, the branch was to be merged into the master repo. After several WODs, and several series of branching and merging, it can be difficult to know the state of the master repository. Fortunately, Github provides a network diagram tool that visually represents the branching and merging activity of the repository.

Git Network Diagram

This is an extremely useful tool that allows one to quickly get a sense of the current state of the master repo.

Conclusion
Although this weeks WODs were significantly more involved and required more time and effort than any previous WOD, the skills we acquired are necessary for producing a quality application.

Final Project Mockup: Notify Hawai’i

When I registered for this class at the beginning of the semester, I expected two things: 1) that this course would require a lot of hard work and 2) that we would most likely be building a fully functional web application by the end of the semester. At the time, I had no idea what I was going to build for the final project but I did know that whatever it was, I wanted it to be useful.

For the last several months, this project was placed on the “back-burner” in my mind and every-so-often I would think of potential web applications to pursue. I eventually landed on an idea that I thought was not only cool but useful and doable too.

Notify Hawai’i

Notify Hawaii Homepage

I’ve decided to implement a notification system for services based in Hawaii. Here is a brief description of how I envision the application will work:

Users will be required to create accounts and provide their email and/or phone number. They will then be able to set up specific triggers that will send them notifications by email or text message. These are a few sample triggers that will be built into the application:

• At a specified time, send me an email with the title and links to the current Honolulu Star Advertiser breaking news articles
• At another specified time, text me if my commute home is going to take more than 30 minutes
• Send me a text messages if my bus is running early/late
• Send me an email if a new Craigslist post matches some parameters (e.g. Apartment for rent, in Manoa, dog friendly, less than $x, etc)
• Email me if a new blog post is added to a specified WordPress site

For some of these tasks, I’ll rely on 3rd party APIs (Google Maps to estimate commute time, TheBus Web Services API to assess bus schedules) and utilize the Jaunt Web Scraper and Automation tool for the others.

Available Services

I am working on this application alone. While I am disappointed that I will not have the opportunity to work with and learn from another student, I do look forward to having full control over the implementation of the application. However, there is a lot of work to be done and I am concerned that I may not be able to accomplish everything that I wish to achieve.

Looking back at my experience building the mockup application (which can be found here), I’ve come to realize that I had no clear direction while working on the app. In my mind, I had an idea of what I wanted the user interface to look like but nothing was concrete until the code had been written. Going forward, I think I would greatly benefit by having a clear and defined set of goals to guide my progress through each milestone. Fortunately, Github already has an Issue tracking tool for this purpose.

This is just the tip of the iceberg and there is still a lot of work to be done on this project. But I believe that this application, if implemented correctly, can be amazingly cool and useful for all users.

Application Design: MVC and Play

Model view controller (or MVC) is a popular and useful software design pattern aimed to help developers separate the internal representation of data from its presentation. In a typical application there are three fundamental components:

1. the Model which is the internal representation of the data
2. the View which is the interface in which users interact with the data and
3. the Controller which are the actions that can be performed on the data model

This week, we focused our attention on applying this design pattern to application created using the Play Framework.

E41: Digits Mockup Results
The goal of the first WOD was simple, create a non-functional mockup of the contacts database web application we call Digits. Since there was no functionality to implement, this WOD exercised our skills using Twitter Bootstrap more than any other technology we’ve used this semester. There are only two pages to the Digits application; a home page that displays a table of current contacts and a ‘New Contact’ page that displays a form used to add new contacts to the database. Since I don’t have the Bootstrap table and form tags memorized, I had to refer to the documentation. In a previous exercise, I bookmarked all of the main sections of the bootstrap reference material which allowed me to quickly find and access the tags I needed to complete this WOD. I attempted this WOD twice with the following results:

• 1st attempt: 24:51 Av
• 2nd attempt: 16:52 Rx

E42: Digits Form Results
In the second WOD we enhanced our Digits app by adding partial functionality to the new contacts form. Now when the Add button is clicked, the contents of the form are printed to the console. Prior to attempting this WOD, we were instructed to watch a screencast previewing the process of adding functional forms to a Play application. While watching the screencast, I took detailed notes on the structure and syntax of the additions so that I could refer to it while working on the WOD. This preparation allowed me to complete both of my attempts at this WOD in Rx time:

• 1st attempt: 16:15 Rx
• 2nd attempt: 11:21 Rx

E43: Digits Form Validation Results
In the third WOD, we extended the functionality of our web app even further by adding data validation capabilities to the new contact form. With data validation, we are able to ensure that the user doesn’t leave required fields blank or that submitted responses follow a specified format. Play makes the process of validating user input surprisingly easy – simply implement the validate method to identify validation errors and annotate the form controls with the appropriate html/bootstrap tags when errors exist. During my first attempt at this WOD, I mistakenly imported the wrong ValidationError package and spent a few minutes troubleshooting the errors this caused. However, I was still able to complete all attempts at this WOD in Rx time:

• 1st attempt: 15:52 Rx
• 2nd attempt: 8:34 Rx

E44: Digits Model Results
The goal of the fourth WOD was to implement an in-memory repository for storing contacts entered by the user and allow the application to dynamically display all the contacts in the database. Implementing the in-memory repo was fairly straightforward as was revising the scala.html files to dynamically generate content, however, I still DNF’d on my first attempt at this WOD. Although I was able to add and retrieve contacts from the repository, I was unable to get the Application test to pass successfully. Only after spending a significant amount of time scouring my code for the bug (and being unsuccessful at finding it) did I think to do a clean compile of the code and re-execute the test. To my surprise (and disappointment that I didn’t think to try this earlier), the test passed. I repeated the WOD twice after this initial attempt and achieved Rx time on both attempts.

• 1st attempt: 32:31 DNF
• 2nd attempt: 12:28 Rx
• 3rd attempt: 12:57 Rx

E45: Digits CRUD Results
The fifth and final WOD took the digits app one step further and provided the user with update capabilities. There are a lot of steps associated with implementing this function, fortunately Dr. Johnson outlined these steps in a screencast we were instructed to watch before tackling the WOD. Although I took notes and referred to these notes while performing the exercise, I still DNF’d on my first attempt due to an error in the way I assigned ids to contacts in the repository. After realizing my mistake, I repeated the WOD twice and achieved Av and Rx time.

• 1st attempt: 42:58 DNF
• 2nd attempt: 22:23 Av
• 3rd attempt: 11:29 Rx

Conclusion
There are many benefits to using and abiding by the MVC design patterns including simplified application development and robust code. However, like many of the technologies we’ve used this semester, the learning curve is steep. But if I learned anything from this series of WODs it’s that by practicing and incrementally adding complexity to practice exercises, even tasks that initially seem complex can become simple.

Web Application Frameworks

This week we began working with the Play web application framework. Frameworks aim to alleviate overhead associated with web application development by providing libraries for common tasks such as database access and user authorization and authentication. Since the developer no longer has to build these functions from scratch, he can focus on implementing the things that really make the app stand out.

But we must learn to walk before we can run and our WODs reflected this.

The first WOD was a simple exercise that had us create a new Play project from scratch, import it into IntelliJ and ensure that it passed all QA tests (i.e. checkstyle, application and integration tests). We were given very clear instructions on how to accomplish these tasks and because of this, I was able to complete my first and only attempt at this WOD in Rx time of 9 minutes and 54 seconds.

The second WOD was a little more interesting than the first. Using this Play Framework template provided by Dr. Johnson, we were instructed to recreate our ‘A history of browsers’ webpage from a previous WOD. Since the HTML and CSS code was already written, we could focus on the simple, yet crucial, details of the framework (like removing views, routes and controllers) and getting a general sense of how to structure apps in this environment. Since I’ve used the Play framework in the past, this WOD was a review of material I already knew therefore, I was able to finish my first attempt in less than 14 minutes qualifying as Rx time. I repeated the WOD twice after watching Dr. Johnson’s solution and completed my second attempt in 7:50 and my third in 9:02.

The third WOD was like the second in that we recreated a project from a prior WOD, however, this exercise was more difficult since it consisted of multiple pages. For a beginner, adding pages to a Play application is a non-trivial task.  Each new page requires its own view file in the Views directory, action method in the Application.java controller file and a defined mapping in the routes file. Initially, it can be difficult to remember how all of these parts fit together in the entire framework but with practice, it becomes routine. Again, since I’ve worked with Play in the past, these exercises were more of a review and I was able to complete my first attempt in 13:03 and my second in 13:55, both qualifying as Rx time.

Like the two WODs before it, the fourth and final WOD was a revisit of a previous project in which we were to recreate the Kamanu Composites website in the Play framework environment. This was a fairly easy WOD to complete since the HTML and CSS code could be copied out of the previous project and because it didn’t require adding new views or modifying routes. I finished my first attempt in Rx time of 11 minutes and 40 seconds and my second attempt in 10 minutes, 31 seconds.

Although the learning curve is steep, using web application frameworks can provide huge benefits. By promoting code reuse, frameworks boost developer efficiency and productivity. By enforcing structure, projects become clearer and more organized. These are just a few of the many reasons learning to use a web application framework is well worth the time and the effort.

A08: Open UH Schedule Helper – Milestone 3

http://www.UhScheduler.com

Over the course of the semester, my team and I have been building the Open UH Schedule Helper web application. The goal of this app is to provide UH student with support for course planning and scheduling. We’ve made a lot of progress since Milestone 2 and I’ll briefly describe the functionality here. More information can be found in the Users Guide or by watching the introductory screencast on YouTube.

For those of you more interested in the technical aspects of the application, we’ve put together a Developers Guide and screencast as well as made the code publicly available on Github.

Application Functions Overview:

1. Searching and Filters

We’ve implemented an easy to use search and filter function. Searches are performed on combinations of the following three fields: department, instructor, and course title. To help speed up the search, if the user selects a department, the contents of the instructor select box is updated to include only those instructors associated with the selected department.

Select boxes auto-update to include only relevant selections.

Queries can be made more specific by applying filters. Clicking the “Show Filters” button exposes the available options which include filtering by Focus, meeting days and meeting times.

2. Interacting with search results

After a search is performed, results are displayed in the table immediately below the search form. As users mouse over each entry in the table of results, a corresponding event is dynamically added to the calendar object below this table. Courses that can be added to the users schedule without conflicting with another course are displayed in green; courses that do conflict are display in red.

Preview the schedule in real time. Events in green can be added without issue. Red events indicate a conflict.

There are three functions associated with each result. Each function is invoked by clicking one of the three icons described here:

• The green “+”: Clicking this icon adds the associated course to the users’ schedule. Users must confirm this action before the course is added.
• The blue “i”: Clicking this icon displays the late breaking information associated with the course. Users are able to add their own late breaking news item from the resulting modal if they choose to do so.
• The eyeball: Clicking this icon adds the associated course to the watch list. Users must confirm this action before the course is added.

3. Editing the Schedule and Watch List

Removing a course from the schedule and watch list is done from the users account page. All courses in the users schedule are listed on the Course List tab; courses in the users watch list are listed on the Watch List tab. The process for removing a course is the same for both lists: Activate the appropriate tab and click on the “Remove” button associated with the course to remove.

Edit and Delete options are all conveniently located in one place.

Users must confirm this action before the course is deleted.

4. Editing Late Breaking News

Late breaking news items contributed by a user can be edited from the users account page. Comments left by the user are displayed on the Late Breaking News Tab. Each comment can be either edited or deleted by clicking the appropriate button.

Late Breaking News items for courses in the users schedule and watch list are aggregated and listed on this tab as well.

5. Notification Preferences

The application is capable of issuing email and text messages to users who choose to receive notification that new late breaking news has been added to a course in their schedule or watch list. Users are opted out of this service by default. To opt-in, users simply navigate to the account page, select “Opt-in” under the “Notification Preferences” section, enter contact information and save their changes. A confirmation email and/or text message is sent to confirm the user’s selection.

Contact information is checked to ensure a valid entry.

Technologies:

Like last semester, the technologies we used to implement this application are Twitter Bootstrap, MySQL, and the Play Framework. There were, however, new technologies used that I will describe below:

1. Jaunt: Java Web Scraping & Automation API

The primary function of this application is the searching of courses based on specified criteria. In order for this function to work, we needed a database of course information. Although the university must have this information somewhere (since it is posted on the course availability website), it is not accessible via a public API. Therefore, we decided to use Jaunt, a web scraping technology, to obtain this data. Given a url, Jaunt will retrieve the page and return its contents in a way that makes it easy to the data you need.

2. FullCalendar jQuery plugin

Another major function of the application is constructing a schedule of courses. Initially, we represented the schedule as an html table with each column a day of the week and each row a half hour time interval. Courses were illustrated by coloring the background of the cell corresponding to the day and time of that course on the schedule. This approach became complicated when we realized that not all classes start and end on the half hour and if we wanted an accurate representation of courses on the schedule, we would have to color fractions a cell. With this revelation, we abandoned this approach and adopted the FullCalendar plugin as our solution which makes adding and removing events at any time of day simple.

3. JavaMail API

One of the features of this application is its ability to notify users when late breaking news items are added to a course in their schedule or watch list. Notifications are sent via email and text message. Although there is a Play framework plug-in that enables this functionality, we built it using the JavaMail API. Like Jaunt, there is excellent documentation and many examples available on-line.

4. Java TimerTask

Instead of bombarding the user with emails and text messages whenever someone comments on a course, the team decided to send a single notification summarizing new comments at 5pm each day. To implement this auto-executing, scheduled event we used the Java TimerTask Class. And like Jaunt and JavaMail, TimerTask was easy to use because of the ample documentation.

Lessons Learned

I think one of the greatest things about computer science is being able to use code and tools written by someone else to make my projects that much better. However, searching for the tools, reading the documentation and learning how to use it can be an intimidating and daunting process. In most of our classes, we write all of the code we use so rarely do we get to experience this process. I think one of the most valuable things I did this semester was repeat this process with the 4 technologies listed above.

I also think working in a group with the same people for the entire semester was a valuable experience. Up until now, I had complete control over the code in my projects and every implementation decision was mine to make. But when working with teammates, no one should have this kind of control and initially, it was a difficult thing for me to get used to. But here we are now at the end of the semester and I think I am a better team player because of this experience.

OpenUhClassScheduleHelper: Milestone 2

An overview of the application

Over the course of the last few months, my team and I have been working on building the Open UH Class Schedule Helper web application. The primary goal of this application is to help students be better prepared when registering for the coming semester. We attempt to accomplish this by providing several useful tools including a course search function, the ability for students and teachers to leave Late Breaking News, automatic update notifications as well as several other useful tools.

1. The Search Function
After logging in to the web application, the user is redirected to the search form. From here, the user can search for courses by a number of different criteria including department, course instructor, course title, focus attributes, meeting date and time. Results are presented in a easy to understand format.

2. Late Breaking News
We’ve implemented a system that allows both teachers and students to leave comments that they feel would be beneficial to students perusing the course offerings. Instructors may sometimes want to provide additional enrollments restrictions or elaborate on the course descriptions. Students could comment on what others could do to be better prepared for the course. This is feature allows this to happen.

3. Automatic update notifications
With the course information database updated regularly and the addition of teacher and student comments, the content of the web application is dynamic and always changing. To keep our users always in the know, we will be implementing a notification system. This system will send users either an email or a text message when new or revised information for a course they have added to their schedule or watch list becomes available.

4. Jquery FullCalendar Implementation
The jquery tool ‘FullCalendar’ is being used to display the users current schedule on both the Results Page and the My Account page. On the results page, events representing the day and time of a course are dynamically added to the schedule as the user mouses over an entry in the results table. If there are no conflicting events already on the calendar, the event is colored green; if conflicts exists, the event is colored red. Events already added to the schedule are colored blue.

Full Calendar displaying current schedule and temporary events.

View the installation instructions here.
And the deployed application here.

Works in Progress

While we have been ambitions with our plans for this application, implementation has been moving at a glacial pace and unfortunately, not all of the functionality mentioned above has made it into Milestone 2. In this section, I will discuss the functions of each page that are not yet complete.

The Search and Results Page
Currently, users are not able to add courses to their schedule or wait list from this page, nor are they able to add Late Breaking News.

Since the search form, results table and current schedule are all displayed on this page, pixel management has been, and continues to be, an issue. In an attempt to manage the available space, we’ve decided to limit the height of the results table by restricting the number results displayed at any time to 5; all other results will be paginated. This function has not yet been implemented since it relies on a mySql backend.

Pixel management continues to be an issue.

The My Account Page
From this page, a user will be able to set their notification preferences, view their schedule and watch list, view and edit their comment history and see what they’ve schedule in previous semesters.

Currently, we do not save the users notification preferences to the database, nor do we have a mechanism in place to issues notifications when necessary.

The jquery ‘FullCalendar’ tool is also used on this page to display the users current schedule as like previously reported, the events are not properly placed when using the deployed application.

Under the ‘Comments’ tab, every comment the user has made is listed in a table. From here, the user has the option to edit and delete their comments. In its current state, users are only able to delete a specific comment; the edit function is not yet complete.

The Map Page
Eventually, we would like to be able to display the location of each of the courses in the users schedule on a map. This page and function has not been implemented.

The Instructor Page
Since we are using CAS to validate login credentials, we are unable to access the instructor page by this method. Therefore, a link is displayed on the On boarding page that takes us to the instructor page. This page will identify the instructor, search the database for all course being offered by that instructor and display the results in a table. From here the instructor will be able to add, edit, and delete comments associated with each of their courses. These functions have not yet been implemented.

The Development Process

Developing this application has been difficult. I feel that we spent too much time working on the mock up and not enough time on implementing the functionality. If I recall correctly, our team was able to meet only once after being given the green light to begin building the app and although we met regularly over Google hangouts, those conversations are not as informational or productive as meeting and discussing the project in person.

I also feel that we could have been better prepared before moving into this phase of development. While working on the ui mockup, each page could be assigned to a specific team member and that person was free to build it however they wanted because the work they were doing rarely affected the work someone else was doing (because it’s just ui). This is not the case when implementing functionality; a component one team member is building may need to be used by the other team members. I realized late in this process that working with the group to develop an interface for each java object would have been extremely useful. This would have allowed all members to work on their component without having to wait and see what methods were being implemented by other team members.

Going forward, I think our group needs to communicate better and more frequently. I also think we could do a better job of allocating and distributing even amounts of work among all team members. Although we attempted to do this, it is difficult to assess how much work each issue requires. The list of Github issues can be found here.

A06: Open UH Schedule Helper – Milestone 1

Registration can be a very stressful experience for students. Deciding what to take, when to take it and with whom to take it from are just a few of the many questions students must consider when designing a schedule for the coming semesters. Fortunately, the University of Hawaii offers a huge variety of classes in the areas the of dance, finance, and Persian (to name a few) so filling a schedule with fun and interesting classes is rarely a problem. However, the sheer volume of offerings can make finding these classes difficult. The current course availability website presents courses divided up by departments. Within each department, courses are listed in ascending order by course number. This format makes finding classes simple if you know exactly what you’re looking for and a nightmare if you don’t.

The Application
The title of our project is OpenUHClassScheduleHelper and our goal is to make the building of schedules for the coming semester as simple as possible. We intend on doing this by providing a simple and efficient way for students to search through all courses offered at the university and isolate only those courses matching specified criteria. Students will be able to search by course number, title, instructor, day and time, focus, and level (i.e. 100, 200, 300, etc). As they find classes they’d like to register for, they’ll add it to their schedule. We’ll offer a variety of utilities that include printing their schedule for easy reference and locating their classes on a map. We are also building the application to be mobile friendly so users visiting the site from their smartphone or tablet can do everything they could do as if they were using their laptop or desktop computer.

Designed to be mobile friendly.

While we expect that university students will compose the majority of our users, we also a hope that instructors will find the application useful as well. While performing interviews with potential users, we learned that being able to add descriptions to courses would be valuable to some instructors. The application currently does not implement this functionality, however, we plan to include it in a future build.

For a more thorough description of our identified stakeholders and their requirements, view the wiki page here.

To ensure that our stakeholder requirements are being met by the application, we built a mockup site and asked our stakeholders to use it and provide feedback. That mockup site can be viewed here. I found that this mockup evaluation was very helpful and resulted in some very valuable insight. See the Mockup Evaluation Wiki for more details.

We also created several use cases designed to challenge the application in every possible way. A few include viewing the site without logging in, logging in and adding classes to the schedule and registering for an account. View the Use Case Wiki for a complete description of each use case.

The Team
The team consists of myself and two others, Evan Komiyama and Jon Ortal. Since we were all in ICS314 last semester, we are all familiar with the same technologies, i.e. Twitter Bootstrap, Play Framework, MySQL and Github. This has helped in the development of the application since we were all able to hit the ground running, so to speak. We have been meeting regularly, at least 3 times per week; usually twice in person and once via Google Hangouts. Occasionally we will email the team with updates or issues. During our meetings we discuss our progress on the project and any obstacles we may have encountered.

I feel that every team member has been committed to the successful completion of this project and has been willing to help others when help was needed. There are, however, areas where we could improve. I think that because milestone due dates are usually weeks out, staying motivated and not falling behind on development has been difficult. Then as the deadline approaches, the work is rushed and the quality of the product declines. I think a way we can be better about staying on schedule is by creating better Github issues and assigning a due date to each one. By doing so, our tasks are defined as well as a time timeline.

Overall, I think this group works very well together and I am confident that we will be able to successfully implement the OpenUHClassScheduleHelper project.

View the GitHub repo here.

Software Engineering…Part 2

Here we are again, at the beginning of a new semester and I’ve enrolled in the second part of Dr. Johnson’s Software Engineering class, not because I’m a glutton for punishment, but because last semester was one of the most productive and educational semesters of my entire college career.

We’ve already been informed that the structure of this class will differ from the last. Gone are the regularly scheduled lectures, the difficult homework WODS and the high pressure in-class WODs. This semester will be project based. The class was divided into teams and over the course of the semester, each team will build a functional web application. Dr. Johnson’s description of the course can be found here.

I was assigned to the OpenUHClassScheduleHelper project and I’m glad, and excited, that I was. Here is the description of the project from the ICS414 Project Ideas webpage:

A web application that provides UH students with support for course planning and scheduling. This can include: finding WI/O/E classes, searching for classes based upon specific requirements (final time, prereqs, etc.), building a grid-based time table, and a map showing distances between classes.

My partners in this project are Jonathan Ortal and Evan Komiyama, both of whom I’ve worked with before. Since we were all in ICS314 last semester, we are all familiar with the same technology (i.e. Twitter Bootstrap, Play framework, MySQL) which will definitely help when implementing this application.

There are, however, a few technological risk factors that could potentially prevent us from successfully implementing all the features of this application. A few are as follows:

1. Obtaining course data
   It is currently unknown if the university offers a programmatic way of accessing course data (i.e. CRN, course title, instructor, WI/O/E, pre-reqs, etc). Our initial approach may have to be to employ a method known as web scraping. This approach is not ideal since even a minor change to the format of the target web page could cause our application to break.
2. Dynamically generating reports
   A proposed function of this application is to build a grid-based time table of the students schedule. Since this report is dependent on the courses the student has indicated they will take, the content will need to be created on the fly, specifically for each student. A possible way to achieve this would be to create the report using HTML and CSS and displaying that in the browser for the user to print or utilizing the Play PDF module to output the report as a pdf.
3. Mapping routes
   Another proposed function of this application is to display distances between classes on a map. Although we didn’t study integrating maps into our applications in ICS314, I know that it can be done because a couple of students did it as part of their final project. I imagine that since the location of buildings on campus are static and don’t change very often, their coordinates can be stored in a table in the database. Then, when mapping a route between classes, the coordinates of the two buildings can be passed to the mapping module to display the route.

Overall, it seems like this will be a fun project to implement. I’m confident that if we implement this web application correctly, it can become an awesomely useful tool for UH students.