Journal Entries, Week #1

----- ALIO --------------------------------------------------------------------------------------------

Journal entry for Assignment 1

Status:

The assignment is complete. The label changes based on what radio button is chosen.

Obstacles encountered:

Installing Visual Studio took more memory than expected and had to clear some memory.

Proposed solutions for your problems? Is the clearing of memory a long term solution of just a stop-gap measure?

Solutions proposed:

Analysis of development process

Conversation of what to expect and discuss with the customer is a good starting for the project.

Vague. Be specific and complete.

What seems to be working –

Article between XP and Interaction Programming was informative and a good introduction to the principles.

Vague

What seems to not be working –

Everything is ok so far.

Be specific. What does “ok” really mean?

Proposals for change

It would have been beneficial if we were able to meet with Dr. Nguyen during class where everyone could be involved.

This is an observation of the past not a proposal for the future—what are you really trying to say, especially given the fact that Dr. Nguyen has Comp212 class during our Comp410 class period?

----- BEOWULF -------------------------------------------------------------------------------------

Status of Milestones

Finished first homework, it looks nice. Visual Studio and c# sure are amazing, and sure make it easy to whip up some little app like that.

Gains Made

Got familiar with c# and vs.net, like with using properties instead of methods for everything. And vs.net has lots of nice features, especially that intellisense and how you can expand/collapse pieces of code. Brilliant stuff.

Obstacles

I’m not real impressed with the documentation for c# (or framework class library docs or whatever they call it), mainly in its navigation. The java API documentation was so fast and easy to find anything. But there is no simple quick way to lookup, say, the radiobutton class for c#. I had to wade through lots of help docs and stuff.

Solutions

Writing about it in my journal. Maybe someone else has some suggestions on this. If others feel the same way, I wouldn’t mind putting together a webpage that mimicked the JDK style of documentation for c#. I would just need to get the documentation data in some raw form like XML, which might be hard.

Extreme Programming

Interesting approach, I have to say I agree somewhat more with Kent Beck than Alan Cooper, extreme programming sounds like an innovative and promising idea. Some of the ideas of XP that looked most impressive to me were stand-up meetings (in my work experience, so much time is wasted in meetings with people loving to hear themselves talk), the pair programming, and releasing early and often (also commonly done in the open source community, incidentally) to get customer feedback.

Missing what’s working/not working/proposals sections of development process analysis—or at least it is too buried in the prose to find them.

Use proper capitalization—look professional, other people are reading this.

----- JAMESMCD -----------------------------------------------------------------------------------

There were two major things that happened this week. We started discussing the process of XP programming and introduced our semester project.

After much reading about XP, from people both for and against it, I am turning into a fan of the idea. I don’t know if I’ll actually like it in practice, but the only way to know is to try. The central aspect of XP is the interaction with the costumer, a part of programming I have never thought about. I was shocked when I started reading about how a costumer will commission a software application, but have very little idea of what it should do. I see that as similar to going to a construction company and asking for them to build you a bridge, but not saying where or how large.

I understand the challenges associated with non-technical people not understanding the extent to which their software should work. They do not necessarily understand the challenges associated to adding certain functionality or the ease of adding others. As software engineers it is our job to make these notions clear to them. If we can help them form their ideas before code is even written then the resulting product will easier to design and make the costumer more happy.

I really enjoyed the conversation between Beck and Cooper, however I feel it focused too much on the design of the interface for a piece of software. There is so much more to coding than making the interface and I believe that XP is much better applied to these parts then the actual interface design. Extracting the desired functionality out of the costumer is extremely important. The process changes a little bit more when designing the interface. The costumer most likely has very strong opinions on this. I agree with Cooper when he says “During the design phase, the interaction designer works closely with the customers. During the detailed design phase, the interaction designer works closely with the programmers.”

After our first meeting with our costumer, Dr. Nguyen, I am very excited about our project. It will incorporate different and challenging features and will draw on knowledge from many areas of computer science. My immediate concern is with the organization of the development process. Everyone has ideas as to implementation and design. The class is set up to encourage group discussion and decision making, however it would not be difficult to imagine a situation where arguments over details would consume too much time. Some sort of organization will have to be set up that prevents arguments from dominating the time.

Nice discussion but where are the bulleted items that need to be discussed in each journal?

----- JSEGARS -----------------------------------------------------------------------------------

Before Class

Thus far, my knowledge and experience in the project is basically limited to creating a test project in Visual Studio .NET. I had quite a bit of experience working with Visual Studio last semester so most things are pretty familiar to me. I hadn't worked with the GUI tools before, however, but I found them to be very intuitive and had no problems creating a simple dialog box.

In terms of our actual project, I really don't know what to expect right now. I wasn't able to be at the meeting with our customer, Dr. Nguyen, so I'm kind of in the dark as to what he's expecting us to provide him. I guess its basically equivalent to the situation where I'm relying on a boss to inform me about customer requirements rather than meeting with the customer on my own.

At this point, the only change that I would like to see is in the organization of time. Since several people have a 2:00 class, keeping as much of the class inside the 1:00 to 1:50 time period as possible would beneficial to us. I know this isn't possible all the time, though, because of outside constraints.

After Class

After class today, I felt a lot better about some of the concerns mentioned previously. Those who were able to attend the meeting with Dr. Nguyen did a good job of briefing those of us who weren't able to stay and I felt like I've got a lot better grasp of what's going on now.

Required items were not discussed or difficult to isolate in the text.

----- LIPINSKI -----------------------------------------------------------------------------------

Milestone: Simple Windows Application in C#

Assignment number 1 is complete with documentation. I have also manually tested it to ensure it is working properly.

Gains Made: I have developed an understanding of the GUI building elements of the C# development tool of Microsoft Visual Studio .NET. I also experimented with the various properties of several of the interface components to better understand how to fully utilize them.

Obstacles Encountered:

· How to Design the GUI to make it look good

· How to implement the overall program. Figuring out what buttons should do what, and the best layout overall for future extensibility.

Solutions Proposed:

· GUI Design – I messed around with the placement of the various components until I achieved a pattern that looked uncluttered and had symmetry to it. My solution was to put the label on the top, the button on the bottom, and have the radio buttons and text boxes in the middle lined up to emphasize a radio button going with each text box. I also enlarged the label, to make it easier to view, and centered its text to further the symmetry.

· Program Implementation – I opted to use a private String field to keep track of the currently selected text. I then had the radio buttons update the field with the text from the text box they were associated with whenever they were selected. This allowed the button to be independent of the radio buttons, and only refer to the field to update the label. This allows future versions to have other options aside from radio buttons for selecting which text, all they need to do is have whatever they pick update that same field.

Are there any outstanding problems or did your proposed solutions fix all your issues?

Development Process

After the first session with Dr. Nguyen I feel that the project is off to a good start. We got enough information to get going, and know the immediate needs of Dr. Nguyen. The readings on XP were very informative. I think the approach is a good one, but I worry about the feasibility of it. Especially having everyone aware of everything that is going on. Especially since unlike employees we won’t be together as a class for long periods of time.

What’s Working: The session with Dr. Nguyen was very productive. We managed to ascertain what exactly he wanted, and even came up with possible extensions to his idea. I think the communication with him is off to a good start, as well as the initial steps of planning the project in steps.

What’s not Working: I think everything seems to be working fine. The only thing I haven’t liked is having the first meeting with Dr. Nguyen without the entire team present. Now if anyone else thinks of something, instead of having that first opportunity to formulate something with his input they will have to go through the “lines of communication” and this will delay an idea that may be crucial to early development.

Given that assembling 15 people at once is all but impossible, this issue begs for an alternative solution.

To Change: I think that we should separate into groups for a short while, and each group brainstorm about each of the different parts of the project overall, and then present to the class the ideas behind them. How to make it extensible, what to implement first, overall plans to implement it, etc.

This is a very nice journal entry—clear, complete, concise, and professional.

----- LOCALGUY -----------------------------------------------------------------------------------

XP vs. Interaction Debate

These two different views on programming organization do not seem to differ that much to me. Alan Cooper even seems to accept both of them into his programming philosophy. Basically I see the main differences as a planning issue. XP says that you should jump into programming and decide on test cases before hand while Interaction calls for extensive planning with a new individual to coordinate between the customer and programmer. I think that the answer lies somewhere in the middle with a combination of both ideas. XP may be jumping into things too early without a great idea of what the customer wants while Interaction could be taking planning to a very painstaking detail that may cost a lot of money.

Programming Assignment

I was slightly confused as to the assignment specification so I took it to mean that we should create a form consisting of a label and a button with several radio buttons having adjacent text boxes. When the button is pushed the text from the text box will be transferred to the label.

This sounds like an obstacle encountered—what’s your proposed solution?

I played around with C#’s GUI builder for a while and then decided upon my implementation. I noticed in the .NET Framework SDK that there is a RadioButtonList class but I could not figure out how to add RadioButton Objects to it. Supposedly there were examples on how to use RadioButtonList in the documentation but I could not seem to find them. So, I used the ArrayList class to create lists of the radio buttons and text boxes. When the button is pushed I simply iterated over the radio button list and found which radio button had been selected and then I used that index to get the text from the text box list so that I could transfer it to the label.

That was not good OOP. The button knows who it is and what it is supposed to do.

With this approach it is easy to add more radio buttons and text boxes without adding much more code since I used a changeable list to contain the from objects.

Group Project

I am very excited about the group project! I think that this is a great opportunity to get some real world experience and learn some new technology. I also think that the Mall Simulation project sounds very interesting. I am really wondering how we are going to split it up and where we are going to start working first.

A lot of the required information is here, but buried in the prose, making it hard to find. For instance, was a proposed change for the development project actually proposed above?

----- OTHELLO -------------------------------------------------------------------------------------

· Milestone Status:

o Gains: Although the “milestones” at this point are very clear, I have accomplished some of the assigned tasks (turning in the course survey, reading the article, etc.). Believe it or not, but I was required to read the article (the Beck versus Cooper debate) for a previous study with Dr. Nguyen.

Somehow I didn’t realize earlier about the “sample C# VS app” that we were suppose to complete, but I do have some prototype available. I’ll probably update it, but it’s at http://www.owlnet.rice.edu/~othello/comp410/.

I don’t think there’s really much more to address at this point, so I’ll get onto the “Milestone Obstacles”.

o Obstacles: Probably the most obvious thing at this point is my lack of preparedness for Visual Studio. I mean, I’ve come in with practically zero experience with that environment – hence I’m still not sure what the difference between a “Solution” and a “Project” is. I’m also not completely satisfied with my Assignment1 app. Navigating the course website hasn’t been intuitive for me either, since the links on the left for me, connote some soft of sectional division (like on other websites). However, I’m not used to seeing them dynamically change like they do (or at least on other sites, they will make it more obvious by changing color also, or something of that sort).

o Proposed solution: Most of the “obstacles” will be resolved over the course of time. I’ll definitely frequent the course website more, and hence get acclimated to its layout, as will I learn the ropes for Visual Studio. I’m planning on improving the way I implemented Assignment1, but for me the most intuitive approach is to directly do as asked – one label (for “a label”) which changes in value based on a radio button selected, and another label that changes in value based on the value of the currently selected textfield.

· Development Process:

o What’s working: I like the directness of the class discussions, and the casual/relaxed nature of the class / development process so far.

o What’s not working: At this point, it still seems very much unstructured, and I’m not sure if I’m convinced if it’ll be the ideal way to harness productivity for the class. I’m also a little frustrated at not being able to attend the portions of the discussion after class.

o Proposals for change: I’m not sure, but I have a feeling that some hierarchy may help facilitate “tasks” and a sense of “knowing what to do”. At least that was the structure used in Comp312 (the other “Software Engineering” course I’ve taken thus far). I hope that we can focus on using the time allotted, and reduce the amount of staying after class.

Nice journal, though late.

----- RYANAIP -------------------------------------------------------------------------------------

Development Status

I completed the first assignment, which helped to get me more comfortable with C# and the Visual Studio environment. I like the interface designer and the component system in general – It makes it very easy to layout components and to work with user controls. For example, I created a UserControl that containing a radio button and a text box that simplified the task of grouping controls together.

In general, I like the .NET user interface system better than Java’s system. I couldn’t, however, find a .NET equivalent to Java’s various layouts (flow, grid, etc.). I don’t think there’s a need for anything very extensive, but I would like some simple, non-coordinate based layouts. In the assignment, I wanted to dynamically add a radio button/text box pair to a panel and was forced to calculate the coordinates for each component. Perhaps that’s an argument for web forms, which do allow flow layouts.

The most straightforward development path (making a component in the designer, double-clicking on it, and filling in the event function code) creates code where the model and the view are tied very closely together. When we start working on larger projects, we’ll have to be careful to avoid unnecessarily tying our interface to our functionality.

What proposed solutions do you have for the above obstacles?

Process Analysis

After reading about XP, I’m curious to try it out on our project and see how it works. In particular, I think the continuous release concept will be good for our class. We don’t have the option of working past the end of the semester, and it guarantees that we’ll be left with some sort of working project. Good point.

One of the points of XP is that everyone is working in close enough quarters that they can communicate continually. This will be difficult for us since we’ll have to be working outside of class.

To some extent, the problem already showed up Wednesday when part of the class couldn’t attend the customer meeting. I’d like to find a time that works for more people to meet if we need extra time instead of running past the end of class. Maybe the lab time on Fridays can serve that purpose.

In general, I’m happy with how things have been going. I like the way ideas are beginning to flow in class – hopefully the trend will continue.

What proposals do you have to help alleviate the above problems?

----- THEWANG -----------------------------------------------------------------------------------

1) Visual Studio .Net installed fine on my laptop.

2) I was able to get to www.exciton.cs.rice.edu through the Remote Desktop Terminal Services Client and run a few programs.

3) The sample works. It took a little while to come up with the code because I hadn’t used GUIs much and had to figure that out as well as figuring out how the design view interacted with the code view. I simply had a global variable that recorded the state of the radio button (actually, the text in the text box that corresponded to the selected radio button). I also ran through a few other simple examples and tutorials.

The program is in /thewang/comp410/proj0.

4) I read the discussion between Beck and Cooper, the interview with Cooper, and parts about xp written by the previous class.

After reading the information about XP, there are still parts of it that simply don’t make any sense to me. I think that the creation of tests is an excellent idea, especially to ensure that the consumer gets what he wants from the “black box” program. However, maybe it’s just what I’ve always done, but I feel that it’s good to have a relatively firm grasp of what it is that needs to be accomplished in relation to the infrastructure. Maybe I’m not fully confident enough to “let the tests write the code”.

For the interaction design, I agree wholeheartedly that the lack of understanding between consumers, programmers, and HCI or other middlemen can cause a tremendous amount of headache in the software design process. However, I object to the idea that programmers have absolutely no concept of what the users want, and that the two use completely different brainwaves. I think that even programmers, who have so much invested in the logical thinking of programs have a responsibility to understand real life and relate that to how programs work. Teachers have to relate theory to students and IT has to relate technical details to marketing, so why shouldn’t programmers and consumers have to communicate?

What programming and other development problems were encountered and what do you propose to do about them?

----- TJICE -----------------------------------------------------------------------------------------

There isn’t much to talk about this week (it’s only the first week.) I have completed the assignment for this week. It wasn’t difficult, just a simple form. As far as what I have gained, I became acquainted with C# and Visual Studio .NET. There weren’t any true obstacles except trying to figure out C#. Define “true obstacle”.

In class this week, an open lecture approach was chosen, one in which Dr. Wong led the conversation and we filled it. It was pretty dry this week. I assume that was just because we were getting back into the swing of things this week. As far as a proposal for change, the class could be more talkative. This will make it easier for everyone to work together later on. Maybe this will improve in the subsequent weeks. A very important point—everyone take note!

I also read the discussion between Beck and Cooper on the XP vs. Interaction Design. Basically Cooper thinks that the client is totally ignorant about how software works, and he thinks solutions can’t be efficiently made if there isn’t a mediator between the client and the developers, one who comes up with a full design after discussing issues with both sides. Essentially the all of the work is done before any of the work begins on the developers’ side. Beck thinks that open communication between the client and developer frequently produces fast solutions and makes a better product in the end. I’ll leave my personal views for the discussion tomorrow.

Record your personal views here! That’s the intention of the journal.

Do you have any proposals for changes?

----- WRPRICE -----------------------------------------------------------------------------------

As this is the first Friday of class, there is no milestone status to report; however, we did have one assignment – to make a simple program. At this time, the program is working properly with no observable bugs at the moment. Thus, there are no known non-working parts. Similarly, I do not propose any changes to the program at this time since it was a simple orientation exercise and does not relate directly to the course’s long-term project.

Regarding the program, there were many ways to implement it. I chose to do much of the design layout in the .NET Designer and then simply added a little loading and event-handling code. The most interesting part of the assignment was to decide on a way to implement the desired behavior – that is, when a single button is clicked, various objects’ text properties were changed based on the selection of one of a number of radio buttons. For my implementation, I chose to make a structure holding a radio button and an associated textbox. I then placed each radio/textbox pair into an instance of this structure, and created an array of the structures. Then when the button is clicked, it iterates through the array looking for the radio button with its Checked property set to ‘true’ and then performs the desired actions on those objects. I chose this method because it seems easily extensible and the behavior of the button is contained entirely in its own Click event.

Any obstacles encountered? Be specific as to answering the required journal items.

What is your analysis of the development process so far? What proposals for change to the development process do you have?

----- JKDOT -----------------------------------------------------------------------------------------

Notes:

So far, I’ve just learned about the general aspects of the project (from the discussion in class on Friday). I’ve been tasked to work on the user interface (the GUI, primarily) and will work with Jeff Segars to gather information from the customer (Dr. Nguyen). On the task list, I’m responsible for “user stories”, which essentially means that I’ve got to come up with situations and scenarios detailing how the product will be used. This is a very important step in the design process because the application won’t be useful for our customer if it doesn’t do what he wants (or react how he anticipates). The user stories should not only portray general usage situations – they should also investigate outlier cases (such as, a tricky task, difficulties with using the interface, navigation, etc.). I don’t know what is plausible for this project, but from an HCI standpoint, it would be great to be able to do heuristic evaluations, task analyses, and user tests to fine-tune the interface. This is a unique opportunity to design and build an interface from scratch.

Milestone:

Jeff and I discussed what we would do for our milestone:

Meet with the customer to find out the specific needs, goals, and get a better idea of what he wants to see.
Develop user stories and perhaps some task sequences (steps that a user may take to accomplish a goal).
Craft a prototype in Visual Studio.

We wrote out a list of questions to begin with in our conversation with Dr. Nguyen. We’ve emailed him in order to set up a time for the interview.

What obstacles were encountered?

Missing analysis of the development process. No proposals for change.

----- SWONG -----------------------------------------------------------------------------------

Overall, a reasonable first cut for all. The biggest problem was one of completeness—people tended to leave required items out of their discussions.

The use of bullets to organize one’s discussion directly correlated to the completeness of the discussion. An outline layout is highly recommended for the future.

When you state a problem, always discuss some ideas for a solution for that problem. Problems don’t go away just by saying we don’t like them—it takes contributed ideas from all to come up with a solution.

Travis’s observation on class participation is crucially important. Passivity on the part of any member of this team will spell disaster for the whole project.