0.2.2 Retrospective

Well, this does it for the project… at least, the programming part. I should celebrate, but I have to get a paper draft in as soon as possible, so I’m going to jump into the rest of that.

This release was very difficult in the beginning. As I feared, ASP does not provide the greatest support for CSS. There is something there, that once I got used to, was usable enough. But I was very frustrated with the way ASP got in the way

My main peeve is that ASP tries to build an HTML presentation model on top of HTML through its custom tags. The reason this is so irritating, is that it is an abstraction on top of HTML and CSS, which is more complicated than the underlying technology. There are hundreds of asp custom tags, and while their attributes may be similar in many cases, there are enough exceptions that require someone using it for the first time to look up what tag supports what each time.

I shouldn’t have to look it up in the first place. Ideally, I want to specify a CSS class or id on any given tag. This works reasonably well for individual tags, but I also want to specify rules for embedded tags as well, and this is where ASP breaks down. Because the ASP implementation of its custom tag is an abstraction, I don’t know what type of HTML tag it is ultimately using to implement the style. Of course, I could find out, but what’s to say that the implementation will change in the next version of ASP? It’s dangerous to depend on such implementation details for maintenance purposes.

I will concede that the ASP designers really did not have much choice. Once the decision was made to create the whole WebForms abstraction and to encourage non-use of standard HTML tags, the CSS model breaks down, because it is strongly coupled to HTML. Without knowing too much about the ramifications, I’d like to put out the idea that perhaps it would’ve been better to try and extend the attributes of standard, existing HTML tags for as much of the base functionality of ASP as possible. But alas, from what I hear, one of the primary motivators of the ASP form design was to mimic WinForms terminology and behavior. While this might have increased the chance of ASP adoption by developers who were already versed in Windows development (which naturally is the #1 priority), it’s made the HTML-CSS-Javascript model (something that is not that easy to learn in its entirety and with all its quirks across versions and browsers) hellishly more complex and non-intuitive.

One last rant… the overarching complaint I have about ASP throughout the process of this project, is that there is very little carryover value to learning ASP. Let me clarify that. If you were to learn the implementation details of ASP and how it works under the hood, it would translate into a lot of knowledge about the underlying implementation of HTML, CSS, JavaScript, and general web-related concepts. But if you were to learn how to use ASP (such as what you would find in a beginner’s and intermediate book about ASP), you would get very little knowledge other than how to use ASP. I haven’t used JSP since it’s earliest incarnations (and before CSS became standardized and ubiquitous), so I can’t speak with any authority on it, but I do some dabbling in PHP, and the experience is profoundly different.

Anyhow, this is getting longer than I wanted it to be. I’m not profoundly unhappy with ASP… just a little disillusioned maybe.

Moving on. I’m done with the UI rework. I didn’t go for something too elaborate — just something that was simple and organized as possible. If I had more time I would make it a little more graphic (icons and such) so that it wasn’t just a series of tables from page to page. But I think I got it in enough reasonable shape.

Here’s a sampling of some of the pages:

Student View Class Info

Admin View Class Info

My Account

My Classes

Edit Lesson

Drilling Module

Now that the UI rework is done, the final step is to deploy to a live site. I was hoping to find a free, temporary ASP web hosting site, but I might have to do something low cost if I want to avoid hosting that requires something like embedded their ads.

 

0.2.2 Release Planning

This release is slated to be a UI-only release. The last release completed the features slated for the scope of this project, and at this point, I wanted to do a major design touch-up. I don’t think there is much point in breaking this down to stories, as I find that my UI design time can be fairly unpredictable. Sometimes a design can go well on the first try, but more often than not, there are little details that just feel missing or out of place, which can take a considerable amount of time to fix.

That being said, I do have a time limit on this project, and am itching to finish the rest of my paper so that I can get a draft to my advisor and 2nd reader by April 1, or sooner if possible.

The major goal for this release is that the website not be just so plainly ugly. I made virtually no effort on design-related work throughout the project, in faith that it would theoretically not be too difficult to apply design changes separate from implementation, through CSS. Of course, that’s the theory, but I’m a little wary of how well that will carry over into what ASP allows.

We’ll see how it goes.

 

0.2.0 Planning

Spring semester hasn’t officially started, but I’m on the hook to get this system running and ready by May 1.  That means it’s in my best interest to start now.

I’m going to take a different approach now that I have limited time. Although I’ll still be presenting my iteration planning, the focus is not so much on meeting a particular iteration deadline, so I’m not going to worry about estimating in even chunks, and I won’t be reporting on each story as I complete them, as this adds a lot of overhead. Instead, I’ll just be writing up my planning and retrospectives, and the iterations will be anywhere from 1 to 4 weeks. Bottom line is that I need to meet my monthly goals to stay on track.

For this month, I need to complete the framework for the drilling module, with an arithmetic-based curriculum for easy testing, and then start on a riverboat curriculum.  I’ll divide the month’s goal into two iterations, leaving a lot of the administrative aspect of assigning lessons for the 2nd iteration.

In the 1st iteration, I want to:

• Create a ProblemGenerator and ProblemSet interface framework, that is modular enough to be used with both arithmetic and riverboat problems.
• Implement the two interfaces with 3 arithmetic units — addition, subtraction, multiplication (division adds a wrinkle with decimal/remainders that makes it more difficult, and the point is just to make something easy for testing)
• Create a drilling UI that calls the appropriate generator, hardcoded for now in the lesson DB.
• Implement the two interfaces with 1 riverboat unit — TBD which kind of problem will be done.

 

0.1.9 Retrospective

I think this was probably the first release that I came pretty close on my estimate — I’d say within 5%. I didn’t keep track down to the minute, but for the first time I felt pretty comfortable with what I needed to do. I think this means I’ve been relatively successful now in refining my estimates.

That being said, as more and more gets added to this website, I’m realizing that things are actually quite complex… not only from a programming perspective, but more importantly from the user interface perspective. I’m realizing how important it is to really nail down exactly how the interface is supposed to flow from one page to another, especially for web applications.

Unfortunately, it’s out of scope to do an entire revamp of the UI workflow. I’m going to try to make minute adjustments in future iterations to at least make things a bit palatable… and it’ll also help to reduce the scope of some of the planned features. It’s better to have things simpler but intuitive, than “full-featured” but confusing.

This is the last iteration before the end of this semester, and I’m hoping to finally finish this project in the spring. There’s quite a bit more left to do, so hopefully we can start picking up the pace in January!

 

View Study Group Lesson Status

This story involved quite a bit of legwork, but after it was all said and done, there was a significant amount of reusable code that I will be able to make use of in the next few stories, so it was a good investment of time.

There’s not much to say in regards to this story except that right now, it’s a little messy with studyGroup, course, user, and lesson IDs floating around. I think if I were to start all over again, I would aim for a simpler DB structure, but then again, I’m not sure that a real-life implementation would be able to make do with a simplification.

Anyhow, I was able to implement a link from the view class page, which is the display of the percentage of study group members who have achieved mastery; this links to a new page showing the individual mastery status of each study group member.

 

Show Self Mastery Status

This story involves displaying all the lessons for a student for a particular class, and showing that student’s mastery status. This is basically just a percentage which represents the level of the student according to the drilling/testing he or she has been performing.

Actually I probably should have designed the DB and data structures for the student records, as I don’t have any existing information in the DB on how well a student is doing. For now, though, I’ll stick with my original plan, and I just am using a temporary dummy value for the student mastery level. However, this is something that would be determined differently, once the student records structures are finished.

Here is the display of the new lessons table in the student view, along with a placeholder for the study group mastery status.

 

Delete Lesson

This story went much faster than expected, so I let a little feature creep occur and expanded the implementation. The original story had me creating a new field in the Lessons DB table, which marked a lesson as deleted. I don’t want to actually delete the lesson record, just mark it as delete, so after adding the new field, all I had to do was retrieve only the non-deleted lessons and update that field when a lesson was deleted.

This would have been fine, except I wondered whether it would be useful, then, to support undeleting a lesson, which is presumably what marking a record as deleted is for in many cases. So, I set out to make a new page called Deleted Lessons, which shows all the deleted lessons for a particular class. From here, the user can click on the Undelete button to restore the previously deleted lesson.

This story demonstrated the dangers of feature creep, however, as the story took about 3 times as long as what it took to just implement the original story… but oh well.

 

Create Lesson

This story was similar to previous stories on creating study groups and courses, only this time the scope was much larger because there were many more fields that belonged to a lesson. So although things went a lot faster than figuring things out for the first time, there was a lot of busy work to get things up and running.

I made some design compromises, knowing that I am only trying to build the admin section to have the minimal functionality. For example, it would have been nice to have a Javascript Date calendar selector to choose the dates, but a simple text box does just fine. I could spend extra time to do all the validation to ensure properly formatted values, but life is short and that’s beyond the scope of this project.

Here’s the create lesson form. Many values are populated by default to avoid guesswork by the user:

 

View Lessons

This ended up being a fairly substantial story, mainly because there wasn’t any lesson-related code set up in the project yet, and because it required a new service class to implement from scratch. It wasn’t too bad as it is the same kind of thing required for the course and study group services, but it did add time to what I thought it would take.

One new thing here was dealing with DateTime objects and SQL datetime types. I wanted to know how to convert between the types, and did a quick Google search, using the 1st result as a way to do the code. This was a bad idea, and I learned to be a little more thorough in my code research…luckily it didn’t even compile, because I couldn’t introduced a more subtle error. Instead, all that was required was a cast, which makes sense as if Microsoft owns both SQL Server and ASP, they shouldn’t require some jumble of bloated code to communicate with each other. At least one would think.

Anyhow, I got it working, and below is the admin view of the lessons for a particular class. The edit button doesn’t do anything, as that is just a placeholder for a later story.

 

Delete Study Group

This story was relatively straightforward — just a little rusty after not programming ASP for awhile. I tell you, it’s just not very intuitive, and I always have to go back and think, is that really how it’s supposed to work? Fortunately, I’ve built up a lot of code at this point that I can go back to for reference. I didn’t do anything patently new in this story, so I was able to figure it out eventually.

As shown below, I’ve create a temporary study group called “sg to delete”, and assigned 2 students to it.

After deleting the group, the entry disappears, and the students are automatically moved to the Unassigned group.