Journal Entries, Week #2

 

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

Journal entry 2

Status:

·        Currently working on the first proposed Milestone for people to people communication:

·        The current Milestone is to create a UML and some stub code for the communication between two or more “people”.

·        The process so far is in its information gathering stage where I am going to meet with Ryan, Bryan, Jim, and Will to define what people and spaces are, since the connections between people are dependent on the definition structure of a person. Hopefully we will have something resembling a structured UML from this meeting

 

Obstacles encountered: 

·        At first I met with one person and we soon realized that we were basing our design plan off assumptions we were making about the thinking of other people.

·        At first the idea for communication was going to be based off the attributes, this soon became apparent that this thinking would not lead to the necessary decoupling so the idea of behavioral classes that controlled communication (better described as interaction) between people is currently being considered as a viable replacement.

 

Solutions proposed:

 

Analysis of development process

·        There seems to be a good interaction between the different teams where people are recognizing where there is need for interaction with other teams.

·        The stressing of communication is necessary; and all the alternative means of communicating with the rest of the class is something that will come in handy.

What seems to be working –

·        Communication with the groups and the milestones are a good way to quantify and plan our project.

What seems to not be working –

·        The groups seem to be misallocated.  The communication with the people to spaces, space to space, and people to people are so closely linked with the definition of people and spaces.  Right now with one person in charge of one part it seems that there are too many people working on one overall section.  This makes the other sections seem over burdened by comparison.

Proposals for change

·        Once people finish their milestones there should be a class period, maybe on that Friday where people describe what they did, this way people not working explicitly on one section can still have a grasp of what is happening and be able to give help if it is needed.

 

 

Nice solid journal entry.   Good suggestion—that’s essentially the plan for Friday classes.

 

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

 

 

Clearly, only number 3 is when we need to meet in Symonds.  Having all those workstations can actually be a distraction if we’re trying to do something else, because people are playing with the computers and not listening.  Whenever we need to do number 3, I suggest we do it on Monday, Wednesday, or the one Friday of the month when we do have the Friday lab in Symonds.  This means on the other days we don’t need to be in Symonds for the lab, and we can have it at a more convenient time, like Thursday 3-4 in our regular room….or something.  Anyway, it seems like a reasonable compromise to me.  Let me know what you think.

 

Nice journal entry.   Interesting proposal for the lab time issue.

 

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

 

Milestone Status:

 

My specific task was to define what a Spaces is, however I have been working with Bryan Lipinski, as well as Ryan Aippersbach and Ali Ongun, to design a system that defines Spaces and People and their interactions.  This initial step if very difficult because an design needs to be found that will allow for the implementation of a behavior system as well as a decision making system that is completely undefined.  It has to be flexible enough to allow for constantly changing algorithms and processes.

 

Despite these challenges we are well on our way to a very extensible, flexible, and VERY OO system.  We hope to have stub code for all this by the milestone deadline next Friday, as well as possibly having test in place that run the Person-Space interactions of people moving around and making decisions, perhaps in a completely random way.

 

Development Process:

 

I feel the initial tasking assignments were done well and covered a good range of subjects were included.  I particularly like the idea of having people investigate future technology so that we are not hung up waiting to figure that out when we reach that point in our project.  I am concerned about workload distribution, however I also feel that a perfectly “fair” distribution is not possible.  There will always be certain aspects of the project that require more attention than others.

 

Also, I am interested in why it is necessary to juggle people from task to task.  It seems to me that it would be better to leave people on their task, once they become more well defined, and then just swap partners more.  Therefore people retain their expertise in one area while still being aware of the project as a whole.

 

The partner-switching is an XP practice designed to promote overall project awareness as well as group code “ownership”.     Let’s discuss this issue more as it is one of the ways that XP differs from traditional tasking techniques.

 

Lastly, and I know this is beyond our control to some level, but card access to Symmonds and having VS.NET on at least half that room is really becoming necessary.  I run a very old laptop in my room with only an 800x600 display and 8Gigs of memory.  VS.NET does not run well on my computer.  Also, the remote desktop approach, using exciton, has it’s flaws too, mostly being speed, the other being that I can’t get to a computer where I can view it well.  I know comp460 got card access and we have at least as many people in our class as they do, so we should at least get VS.NET on half that lab.

 

At the moment, card access to Symonds won’t fix the speed issue because .NET isn’t installed on those computers.    I’m working on the card access issue though.

 

Nice journal.

 

 

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

 

Note:

 I’m kind of playing catch up since I missed most of the first week.  I complete the first assignment, and found that while I was grossly intimidated by the VS interface (SO many buttons, menus, etc.) and had to call someone for a hint, by the time I compiled and ran the code, I was pretty excited about VS.  Since I’m really fresh and novice in terms of using VS or C# or the .Net framework, I’d like to caution others that stupid questions may be forthcoming.  Once in a while I may interject a few usability issues that I see in various things.  For example, in Visual Studio, so far I’ve noticed a couple things.  I opened it and started working with practically every window cluttering my workspace.  Thus, it was hard for me to see what was changing dynamically in other windows.  It took me a few minutes to find the tool tray that had all the elements (radio buttons, etc.) because it wasn’t intuitively marked (had to use the help menu).  I was also surprised to see that every time I dragged and dropped a new element, all the attributes would appear WHERE I COULD EASILY CHANGE THEM in a window on the side.  I didn’t realize the implications of this window until I switched to viewing the code.  It was then I saw that I could modify things in that previous window and the changes would reflect in the code.  Another thing I liked about the interface was that some of the icons on the topmost toolbar are familiar to those of us who have been using Microsoft Office.  This was comforting to me and made me feel a tiny bit more confident in my skills in figuring out the application.

 One thing I didn’t like was that I didn’t know what windows to close.  I wasn’t sure what pertinent information would be hidden if I closed something, so I just left them all open (and had a claustrophobic desktop).  Also, when it came time to compile and run my code, I couldn’t easily figure out how to do it.  After consulting the help menu for several minutes, I finally guessed and chose “Build …” from the Build menu.  This compiled the code, pointed out the errors, and allowed me to run it afterwards.  I just don’t think “Build” as a command was intuitive to me since I was looking for “Compile”.  In general, I find the help menu to be pretty well organized (I use the Index search capabilities) and mostly helpful to me.  I’ll be spending a lot of time wandering through the help menu! (Until I get a book, that is)

The moral of this story is that I’ve got a long way to go in learning this new application, but it shouldn’t be too bad if I keep playing and working in it.

 

I like the description of “life in the trenches”.   Real people have real problems.   The more we share those problems, the more we can help each other and the better off we’ll all be.

 

Milestone Status:

My milestone will be to compose and compile several different “user stories” or scenarios that will aid us in creating a good interface for the application.  Perhaps the “stories” will help the other teams as well.  I will be investigating normal use, navigation, tasks, and outlier cases (strange cases that may cause problems).  I will also be helping Jeff with the first GUI prototype.  As of yet, I’m not sure what the best method would be as far as presenting the use cases.  What would be most helpful to the rest of the team?

I could present in class or lab, post it on the web page, or write a report/document and give copies to each member of the team.  I’ll ask around and find out.

Obstacles so far are few as I’m just getting started.  The only real obstacle would be if I couldn’t get in contact with the customer if I needed to.  So far, gains made have been the initial meeting with Dr. Nguyen.  I’ve posted the results of that meeting to the newsgroup.  Jeff and I have ideas on how to get started, but we have a feeling that once we present the prototype to the customer, he’ll have more suggestions/edits for us.  This is fine since it’s very difficult to tell someone else what you visualize in hopes that they’ll design it exactly right the first time.

 

Hence the need for an “agile” development process.

 

Analysis of development process:

So far, just contacting the individuals I need information from and meeting with them seems to be working fine.  I realize that we’ll have to communicate better with the rest of the development team so that we don’t crash and burn.  I had a feeling in class today that if people had known about the way Dr. Nguyen envisioned the graphics, for example, ahead of time, they could have changed their objectives.  We discussed the communication factor and all I have left to suggest is that we are consistent with posting our progress, questions, fears, etc.  I’d also like to know what could be done in class after milestones (Presentations? Talks?).  Giving a short talk on issues that we may be having will put them into the open and allow the rest of the team to offer solutions and suggestions.  Perhaps we can have some way to be able to do this anytime one particular team feels it has an issue (not just after a milestone).

 

Consider the issue that we have one hour class sessions.   It would be impossible to get through 13 people in an hour.   But what about over two class periods?    That’s still less than 10 minutes per person.    4 people per hour is about the maximum one could reasonably expect to get through.   Can we prioritize the issues?    How would we do this?

 

Nice journal, though the prose style, which engrossing to read, does make it more difficult to quickly pick out the issues, which is something to consider considering the amount of material in the combined journals.

 

 

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

Milestone: Dummy UI

 

Gains Made

For the milestone due next week I plan to have a mockup in Visual Studio of the main GUI that the mall manager will interact with.  I'll also have feature lists for the other portions of the GUI, such the store creation module.

 

Kijana and I met with Dr. Nguyen on Wednesday to get a better idea of what he expected in the interface.  She's using the information to develop stories and scenarios from which we can better develop a user interface.  Any work I could do on the GUI was dependent on Dr. Nguyen's requirements outlined in this meeting so most my work this week was simply learning what the customer was looking for in the UI.

 

Obstacles

The other main issue I've been dealing with (along with Travis) is how the we're going to visualize the mall in the UI.  Its turning out to be challenging to come up with a way that will allow for easy creation of a mall layout but will also look realistic.  Travis came up with an idea of drawing everything based on a grid layout and this seems like the most natural way to allow the customer to draw his own mall layouts.

 

Development Process

 

What's Working

Our project divisions seem to be working out pretty well and there seem to be good natural pairings for people to work together.  Having another person to help come up with UI ideas is very helpful.

 

What's Not Working / Change

That said, the project divisions are also causing some communication problems as we talked about in class today.  Another problem area of communication is with the customer.  In our meeting with Dr. Nguyen, he mentioned that every time we meet with him, we should email him back with a summary of what was covered in the meeting.  We should probably assign this task to someone or rotate among all of us, but we definitely need to improve our communication with the customer.

 

Customer relations are key here.    The issue of needed a point person is coming up more frequently, I see.    

 

Currently we have a flat management hierarchy going.   Is this the best way to do things, or do we have to move to a situation where “some programmers are more equal than others”?

 

Nice journal.

 

 

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

Milestone: Create UML Diagram to represent a “Person”, as well as create stub code for a person.

 

The milestone is coming along slowly.  I am in communication with the Space designer, as well as the person to person interactions designer and space to person interactions designer.  Knowing that the majority of the project is set upon the framework for rooms and people, I want to make sure that I’ve examined lots of options to find the most suitable one for the project.

 

Gains Made: I met with Jim for over 4 hours to discuss how rooms and people should be modeled.  Both the room and people have to be closely related, due to interactions so we explored various possibilities.  Jim and I also met with Dr. Wong and asked his opinion.  Needless to say it was different, but along the same lines.  After our discussions, we believe that a behavioral interface is needed for the objects to properly communicate, where a behavior is carried with the object, and invoked by other objects when it encounters to them.  We think that this will allow for extensibility in the future.  This also limits what the space objects and people know about each other giving even more room for extensibility of these objects in general in the future.

 

Obstacles Encountered:

·        How to design the people/spaces in regards to how they interact.

·        How to make a person independent to the world, but still able to communicate with it, and interact with it.

 

Don’t be afraid to stop and say “Whoa!  This hole’s a lot deeper than I thought it was.   Let’s readjust our milestones to be more realistic!”   Being honest with yourself and with your customer is much better than missing deadlines.

 

Solutions Proposed:

·        A behavioral interface for a person.  A person contains behaviors that can be requested by objects.  These objects can then invoke the behaviors.  Likewise a person can request behaviors of other people/rooms/items and invoke an appropriate method.  All traits of a person can then be encapsulated within the behaviors.  Exact implementation has yet to be decided yet though.

 

Development Process

 

The project is going well. 

 

Let’s avoid the term “well”, shall we?  It’s so vague that it really doesn’t tell us anything.

 

What’s Working: Having another person to bounce ideas off of.  It also helps to have other people outside of your group working with you.

 

What’s not Working: Finding a UML program for C#.  Talk to jamesmcd about this.  There are some possibilities to try out.   I struck out in getting free copies of Visual UML though.

 

To Change: Maybe allow groups of greater then 2.  Although Jim and I are a group, the actual group should also contain everyone involved with the model, since this is a major issue to get right, and we need to get it right from the get-go.   Having everyone know what everyone else is doing for the model, and other ideas/perspectives would be a much better environment for creating the model.  Another idea might be to spend the first 5 minutes of class each week or so to have one or two groups present on what’s currently going on with their milestone, and possibly get suggestions from the group.

 

Are you implying a project hierarchy?   

 

UML Diagram of a person to come soon…

 

Nice job on the journal.   Lots of good issues raised.

 

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

 

Milestone (Web Services):

§         I could not get a web service to deploy through VS.  I can create one and compile it but when I try to access it my browser does not recognize it as a web service and I cannot debug it in VS.  I reinstalled VS and looked up possible solutions online, but none of them seemed to help.  I would like to get some help from the class on this issue since it seems that it is a problem with my machine and not my programming. 

 

The lack of VS debugging may be that your login is not part of the VS Debuggers group that was automatically set up when VS installed.

 

What is the best way for us to communicate the exact particulars of a problem for others to see and possibly help out?

 

§         I am questioning how we plan on using Web Services or Remoting since in general they seem to execute code from a server.  Any data needs to be stored in a data base.  This does not seem to be the two way line of communication that we want.  Perhaps there is a more complex way of using these services but I need more time to experiment with them.  Does anyone have ideas about alternate ways of communication?

Does all data need to be on a database, or just the particulars that define a given simulation run?

 

 

Who’s your partner?   Maybe we should adjust the partners to get a little more directed expertise teamed up you?   Also, I can help if needed—my scheduling is a little tougher than most though. 

 

Development Process:

I like how we were able to split up this project into so many areas so quickly and easily.  I also thought that the talk with the consultants from Microsoft was very informative although I was disappointed I had to leave early.

Now that we have been split up I would like to see everyone come together and get a good idea of where we want to take this project and get some real specification.  I do not think we all have the same idea for where we want it to go. 

Perhaps we need an organization session to write up some very general UML for where we want to take the project.  I think it may also be better for us if we work in pairs instead of alone, so that we get a better idea of how everyone envisions the project and get more input.

Aren’t we already supposed to be working in pairs?

 

Keeping everyone aligned is a tough problem.   The usual tack of constant meetings is not without its drawbacks, such as boredom and diversion.    How can we create a cohesive force in the project development structure?   How is this related to the issue of leadership?

 

Good job on the journal.

 

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

·        Milestone Status:

 

o       Gains: I’ve discovered some documentation regarding .NET Remoting, as my chosen field of specialization for the next couple of weeks.  Among the documentation was a simple server/client demonstration. The example shows an object that is instantiated at the server, but passed to the client.  However, any method calls on the object are still executed on the server.

 

.NET calls this type of object a MarshalByRefObject (in the System namespace), so any class that extends System.MarshalByRefObject can inherit this ability.  In addition, ISerializable objects (or any class decorated by the Serializable attribute) can be used in Remoting and they’re “marshaled by value”.  This corresponds pretty similarly to the call-by-value/call-by-reference ideas in the study of programming languages.

 

Remoting also has the added benefit that it doesn’t have to be configured with IIS server (unlike WebServices, which mandate that step).  However, it can also act as a WebService if the Remoting object is configured in IIS.  In addition, the network transport protocols can use undecorated TCP/IP, or HTTP, and the object encoding can be done in raw-binary, or XML/SOAP.

 

Thus, it seems that Remoting can offer a great deal of flexibility, as well as a lesser configuration cost.

 

The methods in which MarshalByRefObjects are implemented are a basic example of the proxy pattern (p. 210, under “remote proxy”).  The class that is being marshaled is converted to a runtime type similar to an interface, with a TransparentProxy subtype on the client side, and the RealProxy subtype on the server side.  The TransparentProxy implements all the supertype calls by translating the arguments into appropriate data (whether the entire value, or just a reference is encoded is determined by how the argument is marshaled), and then transports them through the network stream encoded in either binary or XML/SOAP, depending on the settings of the channel.  On the server side, the request is intercepted, executed, and the results sent back.

 

This is a sufficient way to implement the intellectual property arguments presented at the MS .NET presentation on Wednesday (1/22/03), provided that one has sufficient server resources.

 

Some interesting technical information mixed into the discussion here (perhaps out of necessity in places).   However, is this the best place for this sort of technical documentation, or is there a better place for us to archive this newly gained knowledge?

 

o       Obstacles: There is definitely not as much of a preponderance of information about Remoting as there is about WebServices.  Part of this, I figure, is attributed to my lack of experience fishing around MSDN/VS documentation.  In addition, I have not yet found any documentation explaining how a server can send back a MarshalByRefObject without the request for the object being initiated by the client.  I was hoping that once the client initiated the session (and thus connected the proper streams and initiated whatever necessary for the transport/encoding methods), that the client could also send martial-by-reference objects back to the server.

 

o       Proposed solution: In the interim, I’ll continue to search for more documentation on Remoting and read more examples, to try to solve the MarshalByRefObject issue addressed in the above “Obstacles” section.  In addition, I aspire that my continued usage of Visual Studio and the MSDN website / documentation will allow me to increase my productivity.

 

Check out http://www.pocketsoap.com/ to see if you can find anything useful there.   There are other places on the web that talk about small web servers for the PocketPC too.

 

·        Development Process:

 

o       What’s working: My Assignment1 program is finally working.  I refined it after figuring out exactly what Visual Studio does for me “automatically” whereas what is required by the C# language.  I had hesitated before to perform some tasks like delete auto-generated code or change the listener method dispatcher in fear that it would introduce further program errors.  I had learned this while watching other students in class use Visual Studio, or explain their development process.

 

o       What’s not working: During the beginning of the course, I had felt left out of the process due to legitimate scheduling conflicts directly after this class.  It left me quite frustrated to not understand completely what was going on in class, even though I had tried to contribute as much time and resources to this course as I had felt necessary.

 

o       Proposals for change: I propose that the class only meet afterwards when at agreed times for all of the contributors (students).  I think it will help bring unity in understanding what the project is going to entail, and alleviate some frustration of those who can’t stay immediately after (I know for a fact that I’m not the only student who has a class immediately after this one, nor am I the only one who has felt some frustration about it).  However, I think this proposal is already in the near implementation, in that most of the discussion will occur in class once the ramp-up process if complete.

 


My Assignment1 Screenshots

 


(as started)                                (after some text has been entered and “Apply” clicked)

 

The user-code uses ZERO if, while, or for statements, or any other comparison/conditionals.  You can find the code at http://www.owlnet.rice.edu/~othello/comp410/

 

Nice journal.  I hope you’re right about things settling down soon.

 

----- RJMORGAN --------------------------------------------------------------------------------

o        Status of the student's milestones -- be specific and complete!

o        Gains made

I have written some sample code in C# utilizing the various elements of the language.  So far I studied the use of properties, events and delegates, as well as inner classes.

o        Obstacles encountered

In writing code for inner classes, I ran into problems accessing fields in the enclosing class.  The problem was not related to visibility, rather it stemmed from the fact that the inner class does not have an intrinsic reference to its parent.

Be specific in describing what the problem was.   Did you get an error message of some sort?   Or was it that you simply couldn’t find the reference to those fields?

o        Solutions proposed

The obvious solution to this problem would be to pass in the necessary reference in the constructor.  I still need to investigate the various uses of attributes and their code-modifying abilities, which might provide an elegant solution to the inner class problem.

o        Analysis of development process

o        What seems to be working  -- why?

I’m fairly happy with our division of labor, putting some people into conceptual thinking and some people into researching advanced technology.  It looks like we’re getting the foundation we need to make the right decisions for our product.  We are deriving benefit from the variety of people working in the specific areas they feel most comfortable and knowledgeable.

o        What seems to not be working -- why?

I’m a little uncomfortable with the lack of communication about each group’s progress.  It seems like we are all just working to that milestone in two weeks, and there is little communication/feedback from other members of the group.

What do you mean by “that milestone”?  

How did the lack of communication/feedback affect you?

o        Proposals for change

On Wednesdays, we should each discuss some of the ideas we are tossing around or researching so that the larger group can provide some feedback.  We would need to keep the discussions short, but I saw a little of this on Friday, and I think it did wonders to keep everyone in the group on target for the project

 

What did you feel about the discussions we had this Wednesday (1/29/03)?   Was that along the lines of what you were thinking?

 

A little vague in a couple of places, but a nice, complete journal entry overall.

 

 

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

Development Status

Milestone Progress

I’ve been thinking about people-spaces connections, which I’ve been assigned for my first milestone.  Since this topic obviously ties in closely with the definitions of people and of spaces, I spent time discussing things with James, Ali and Bryan.  (I haven’t talked to Brian about spaces-spaces connections yet, as I think that will be more of a networking issue.) 

 

Is spaces-to-spaces communications really any more of a networking issue than any other type of communications?   Are the networking issues anything more than back end implementations hidden behind adapters to the main communications interfaces?

 

We’re still in the process of figuring things out, but we’ve been discussing abstracting out the behaviors of objects so that a person or a room is in a fairly simple object that has a set of behaviors (E.g., a buying behavior, a talking behavior, a shop-lifting behavior, etc.).  When two objects interact, they can invoke each other’s behaviors.  We’ve also discussed giving object various traits (E.g., age, ethnicity, favorite color) so that two objects – like a person and a store – can compare themselves with each other to see how closely they match.  The issue we’re dealing with now is whether or not behaviors and properties can be merged into one mechanism instead of remaining separate.

Composites anyone?

 

By the milestone deadline, we’ll hopefully be able to complete a UML diagram of the people/room structures.  Anyone who has questions or suggestions should feel free to come ask.  It will be easier to explain the details in person.

 

How can you communicate your on-going progress?   Can you post it somewhere?   Be sure that your mechanism can handle images, as diagrams will communicate your ideas more quickly than words.

 

I’ve written some simple code demonstrating how property matching could work (basically using double dispatching).  I’ve placed it in “My Documents\ryanaip\PropertyTest” on the server.  Even if we don’t use the property idea, the code may be useful.

 

Any documentation included as to how your demo works and what it exactly is supposed to demonstrate?

Comp410.Utilities and FlowPanel

Last week I mentioned that I couldn’t find any components that laid objects out in a non-coordinate system (like Java’s layout managers).  I put together a simple FlowPanel class that mimics vertical boxes in Java – objects are placed in the panel from top to bottom in the order they’re added.

 

The class is in the Comp410.Utilities namespace.  Anyone who wants to use it can reference the “My Documents\ryanaip\Comp410Utilities.dll” on the server.  I’ve also placed the project in my directory, so if anyone builds any other useful classes, they’re welcome to add them to the project and update the .dll.

 

We have no code repository!   What should we do?    We also have no version control.    Exciton is running VisualSourceSafe, which VS integrates tightly with, so there are possibilities here. 

 

Process Analysis

Several people seem to have noticed the problem that this project will require a lot of communication and that we won’t have enough time in class to deal with everything.  I think that we can solve this problem by splitting up into teams when we assign milestones – Instead addition to assigning everyone a task, we could create two or three groups that are in charge of related tasks.  Those groups could meet and make any high level decisions necessary before people pair of to work on their individual milestones.

 

This process is basically what Ali, Bryan, James and I have been following, and I think we’ve come up with much better ideas than if we’d started off right away as two separate pairs.

 

There’s that project hierarchy thing rolling around again.   There’s a manpower issue that hasn’t been addressed yet.   Who has the time to do all this organizing?

 

I think everyone got something out of the .NET talk on Wednesday.  Hopefully we can get the sample projects posted somewhere for those of us that had to leave early.

 

 

Nice journal.   Lots of important issues raised.

 

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

Project #1 Milestone

 

Artificial Intellignence: Configurable Behaviors

 

            In trying to come up with a second milestone, it seemed like there were lots of points where my milestone would cross that of others.  Because until now there hasn’t been an effective method of communication, I simply seemed stuck at times trying not to implement all of the desired components differently than others.  I guess communication is the key here.

A point that cannot be emphasized enough.  

 

Drive your development by determining what it is that you need from other parts of the system, not by what they provide you.    If they do not provide you with what you need—note that this is terms of net content and possible behavior, not in terms of the specific methods or values—then it won’t matter what their interface is.   However, if the net content  and behavior is there, then an adapter can always be built to interface the two sub-systems.

 

You must be clear in communicating what you need from your “external” systems.   

 

To wait for the specifics of an API from another team is to bog yourself down in too much implementation details.  

 

Note that your notions of compositable behaviors is actually the answer that the other groups are seeking, not the other way around.

 

            As for the upcoming milestone, I am working on developing the AI (I switched with TJ) of the people.  To me, it seems like the way to implement the decision making is to have utility functions for various behaviors.  Some behaviors may be implemented at random times (such as mugging, deciding to go to a particular store across the mall, or leaving the mall), while others may be triggered by some event (such whether to enter a store I see or to take the left fork through the mall).  All of these utility functions will take into account the various factors that may affect that specific behavior.  Mugging, for instance, is not influenced by the desire for an expensive blouse, while shoplifting might. 

 

Is there any way that the “intelligence” of the customers can be implemented in a staged manner, that is, can we start with simple, dumb people and then work up to smarter ones?

 

 

            There are a few details that may become more evident along the way.  The first is to determine if walking would be considered a separate behavior.  It would be nice to extract that out into the set of behaviors, but it will greatly slow down the system if every ten feet would result in the person questioning whether she wants to walk another ten feet or not. 

 

How about we start simple with enter a space vs. leave a space?

 

Another is the existence of demographic data vs. personal preferences of various people.  Ethnicity and wealth simply are not sufficient factors in shopping preference.  Along those lines, many factors will constantly be changing throughout a person’s shopping experience.  Muggings, lack of Tickle Me Elmos, and a handful of purchases will decrease a person’s willingness to buy.  There will need to be several feedback mechanisms that factor into the utility functions.

 

Don’t confuse what influences are present with the existence of an influence.  At this stage of the game, which is the more important issue?

 

Obviously, the complexity increases proportionally in the number of behaviors and the number of factors that it involves.  If real mall numbers are used, there may be thousands of people in the mall at any time.  Unless the AI can be optimized to not increase proportionally, or at least at a low rate, where the people are run from – on the mall system, on its own system, or from client systems –  will greatly affect the number of people in the simulation.  Having an accurate measurement of how the mall system deals with a horde of people is also necessary for determining various crowd control abilities of a mall (such as fire or act of God).

 

With a mall full of individuals, I don’t think you can ever get away from it being an O(N) problem.

 

For next Friday, I will hopefully have a method for choosing behaviors based on real and/or fake demographic data outlined in a UML diagram.  Hooks for behaviors and demographic data will be included where necessary.  Choosing a particular behavior inolves the existince of some sort of utility function that will include personal preferences and internal and external feedback. 

 

The required points about what worked or not and the analysis of the development process was lost in the prose.   Outlines help us keep on track.

 

A lot of important development issues were raised however.

 

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

This week I tried to make a generic opengl program that will take in a .txt file that gives the characteristics of a mall and draws the floor plan in 2D and the actual mall view in 3D.  I successfully made code that accomplishes this.  I encountered weird pointer errors.  I think there is a memory leak somewhere, but it’s not apparent.  So I will try and find it.  As of right now I have just have a generic mall layout, I haven’t added any stores or people yet.  I plan on working on these last two aspects in a later milestone.  But the first priority is to get rid of the memory leak, and I might add an embedded editor to this program to all for dynamic change to the layout.  I also need to place this in program inside of an C# Win32 Application.

***Be specific as to what you are going to attempt to do to find this memory leak.

Missing the analysis of the development process.

 

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

 

Current milestone:
            Single-machine equivalence of a multi-machine connection


Current milestone description:

            The goal is to make running different parts of the application (stores vs. people vs. ???)
            on the same machine as transparent as running them on physically different machines.

 

Ideas:

 

Problems so-far:

 

 

Solutions (kind-of):

 

Note that the existence of a mall administration station to run the overall simulation may give you a de facto “manager” that you need.

 

Is going with any sort of custom networking at this state a wise thing to do?   Perhaps by going with existing technologies for the moment will enable us to learn more about the problem before we dive into the very deep and dangerous waters of custom networking protocols.

 

Future milestone goal:

            Try to come up with a sample implementation of each method and demonstrate capabilities.

 

Nice.   I liked the pros vs. cons arguments.

 

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

 

The journals were much better this week.   The nice level of completeness that was submitted really helps us get a good feel for what is going on in the project as a whole.  I really feel much better “tuned in” to the issues facing each developer after reading the journals this week.  I was able to concentrate on the real project issues this week instead of just trying to figure out what was going on.

 

One thing that needs work:  Try to look beyond the specifics of the problem at hand to understand what the problem is really saying to you on a larger scale.  It is easy to get lost in a myriad of details, especially on a system like ours that displays exponentially growing complexity.    Rather than compiling a laundry list of details, ask what is the same about all those things, or perhaps what is different about all those issues.    At this stage, the existence of a type of entity is more important that its concrete manifestations.  

 

 

Remember that right now, what everyone else needs from you is some sort of working stub code, not full functionality.

 

We need to nail down APIs, which means that they have to be put through their paces, which means that systems need to be cobbled together as quickly as possible.   The sooner we see how the pieces really interact, the sooner we can adjust the APIs to fix it.    To change the APIs later in the project will be very expensive indeed.