Jeff Terrell: Alright let's get started today.
Jeff Terrell: hope everybody had a good weekend.
Jeff Terrell: All right, i'm getting started y'all.
Jeff Terrell: Thank you all right um.
Jeff Terrell: So I hope everybody's had a good weekend and ready to dive in today I just sent a first email, I sent over to the mentors preparing them for their meeting with all this week and.
Jeff Terrell: i'm excited for you to get to meet your mentors I think that'll be a good relationship and that hopefully really helpful to you, but also rewarding to them, so I think that's a really cool part of this course.
Jeff Terrell: One of the little note, but a few just announcements upcoming deadlines and things like that, first of all i'm going to change some of the stuff that I talked about in the first day of class when we went over the syllabus and the grading policy so.
Jeff Terrell: Let me Let me describe what i'm changing here.
Jeff Terrell: So I had said that assignments are do we meet with your mentor and that was the hard deadline, the soft deadline was like Sunday night i'm changing that now to to have this same deadline for everybody of Monday at 8am.
Jeff Terrell: And instead of them mentor telling me kind of what the what the deliverable looked like to look acceptable or not i'm going to actually i've asked Raj to do that or ta.
Jeff Terrell: And so we'll have a little bit more consistency, I think that also is really going to help your mentor meetings, be more focused on mentoring and coaching and helping and have more above.
Jeff Terrell: I don't know just a friendly collaborative atmosphere, no tinge of management and just pure mentoring, so I hope that will improve things.
Jeff Terrell: Also, the grading is going to be based on a two point grading scale.
Jeff Terrell: So basically if you didn't do it at all, you get zero if you did some of it, but not all of it, you get one.
Jeff Terrell: If it's acceptable, then that means you met all the requirements in the assignment and, in some cases for unusually high quality.
Jeff Terrell: assignments and deliverables then you'll actually get three points out of two so that's 150% This is intended to be effectively kind of like a pass fail, with just a couple more options here.
Jeff Terrell: So Raj we working on grading everything every Monday morning and he'll get through it as fast as you can and assign grades based on that.
Jeff Terrell: Everything will need to be accessible by Dr Raj from your project website, which is one of the very first things that you have to i'll talk about that in just a second.
Jeff Terrell: And then, if you if you don't get all all of the points on the assignment maybe you didn't get to all of the requirements or you just missed a few things you have the opportunity to earn half those points back if you submit by the following week.
Jeff Terrell: Each week we'll have an equal weight in determining the assignment grade so if there are several things doing a week all of those are averaged together to determine that week's assignment grade.
Jeff Terrell: And then, of course, some things don't really make sense to be graded this way.
Jeff Terrell: assignments zero and 15 are turned into me directly.
Jeff Terrell: And will not contribute to the team's assignment grade and assignment 10 is graded independently that's actually worth I forget 10 or 15% of your total course grades, so that won't be part of the assignment great.
Jeff Terrell: Questions so far about that grading change for assignments.
Okay.
Jeff Terrell: next thing is I realized that.
Jeff Terrell: there's a bit of a fuzzy boundary I haven't done a good job of kind of highlighting this this change in the middle of the Semester, but the walking skeleton is a really big assignment that's going to be a major milestone for your project.
Jeff Terrell: This is effectively when you have everything integrated, if you remember this from the lecture a few times ago we're talking about the project narrative Arc.
Jeff Terrell: And at that point, your features are expected to integrate with your walking skeleton and be deployed in as much as possible, or, in some cases it might not make as much sense to deploy.
Jeff Terrell: But for the most part, things should be deployed and available accessible to your clients actually experienced those features in the live APP.
Jeff Terrell: So what we're going to do it after assignment eight is do is every week you'll have DEMO videos that you record and post to your website showing what some feature that you have finished looks like and how the client can actually access that from their.
Jeff Terrell: From their workstation so this doesn't have to be super complicated it hopefully will be pretty easy, in fact, in some cases, you could probably get away with just even like an animated gif of the feature just click click click this is how you know, this is what it is.
Jeff Terrell: But you know, putting something on YouTube or whatever is totally fine too, especially if you want to kind of narrow what you're doing.
Jeff Terrell: But this isn't intended to be anything heavy, this is just a communication device, and so this will be graded on the same point scale as the assignments Raj will look through all those and.
Jeff Terrell: Presumably, most of these videos will get a full two points, so I I really hope this isn't something that's going to be a burden for anybody, but.
Jeff Terrell: I think you guys are really effective communication devices is actually something i've used in projects in the past.
Jeff Terrell: projects that i've done kind of in professional environments we've often done kind of DEMO videos I wouldn't necessarily say often, but when we have it's actually been really neat to have those.
Jeff Terrell: archived and available for anybody to see if this is what the future looks like now that it's done it's really handy to have this festival.
Jeff Terrell: Any questions about DEMO videos or assignments assignment grading.
Jeff Terrell: Okay.
Jeff Terrell: don't see any questions on zoom either.
Jeff Terrell: Okay.
Jeff Terrell: So assignment one and assignment to our do in one week, it will be due next Monday at 8am.
Jeff Terrell: assignment one is the website.
Jeff Terrell: i'm going to assume that you will read this i'm not going to read this in detail in this lecture because that might be boring but basically.
Jeff Terrell: You know, read this it's doing a week notice that it's not just creating a website, there are also some decisions that you need to make with your team, including you know if you have particular roles that you want to assign like webmaster or project manager or.
Jeff Terrell: tech lead or design lead or any of these kinds of things that would be now would be a chance to make those those assignments.
Jeff Terrell: Also team rules, so are there any particular rules around team behavior you know if you're going to miss a meeting is there a certain timeframe, you need to notify your teammates by.
Jeff Terrell: Is there any particular coding style or collaboration style that you want to adopt as a team, these are conversations that you can have.
Jeff Terrell: This week, as you meet with your team to think about just how to set things up for collaborating that everybody's on the on the same page about how you're doing work.
Jeff Terrell: And notice that all deliverables and, of course, will be a part for the ones that you actually email me personally, all of the team deliverables will be posted on your project website.
Jeff Terrell: So there will be a section for that, and that will be the delivery mechanism you won't be emailing anything to anybody as far as assignments go they'll just be posting them on your website by Monday 8am and brush will be able to see them from there.
Jeff Terrell: When you're done with the website, be sure to send it to me so that I can link it up into the course website and brush and find it.
Jeff Terrell: You will need to deploy your site.
Jeff Terrell: Their titles live is a fine place to go if you want to use like a wordpress site that's free it's fairly straightforward.
Jeff Terrell: There are other options, such as static site generators.
Jeff Terrell: And hosting a different output of static sites.
Jeff Terrell: Questions about website.
Jeff Terrell: Like you know you need to do.
Jeff Terrell: Okay.
Jeff Terrell: Next, the other thing is going to be do in a week is the project management approach now I used to do a project manager on board was assignment it wasn't always assignment to but.
Jeff Terrell: This was one of the early assignments that i've done in the past iterations of this course.
Jeff Terrell: And I got a little bit of pushback from students at the end of the Semester, who said I you know I really didn't want to use cello you made me start low, and so I thought, no that's fair I I use trial I it's not the best tool ever but it's free it's it's fairly easy to use pretty straightforward.
Jeff Terrell: we'll talk a little bit more about that today, in fact quite a bit more and show an example of a trailer board.
Jeff Terrell: That I use there's different ways to set it up, but anyway, the point of assignment to is now not necessarily to create a trailer board.
Jeff Terrell: But to think about how you want to manage your project and maybe you will want to use trailer and maybe you want to set it up the way that i'm going to show you in class today.
Jeff Terrell: But maybe you won't maybe you want to just use a Google spreadsheet and share that maybe you want to use github projects, maybe you want to do something creative.
Jeff Terrell: So we'll talk about kind of what needs to happen with project management today that's The point of this lecture but.
Jeff Terrell: You now have the choice as to what kind of project management tools and processes that you're going to use, and so the main requirement of this is.
Jeff Terrell: The document describing your team's approach to project management and then the secondary deliverable is an implementation of that approach, you know if you if you say you're going to use a trailer board go ahead and create it and share that on the website as well.
Jeff Terrell: Both of those things do in one week questions about this.
Jeff Terrell: You have to know you need to do.
yeah okay.
Jeff Terrell: Okay.
Jeff Terrell: By the way, your mentors would be good people to ask, as well, like you know how do you manage your projects, what are some tips that you might have for managing projects i'm going to be sharing.
Jeff Terrell: All that I noticed share, at least within the confines of a lecture today, so I hope that you'll be equipped for making decisions about project management after today.
Jeff Terrell: But you know, my opinion is is just my opinion and different people who do software engineering on a day to day basis might have different opinions and.
Jeff Terrell: You might be enriched by hearing places where mentors disagree with me or maybe they agree with me, or maybe they would just supplement when I have to say with something else, so you know those are good conversations to have.
Jeff Terrell: I hope that you're setting up meetings with your men your clients as well, because in two weeks, your user stories will be do.
Jeff Terrell: So be aware of that you'll need to meet with your client and get a pretty.
Jeff Terrell: pretty good download from them about their vision for the project so that you can finish the user stories assignment and that will include.
Jeff Terrell: Well, the actual user stories remember the sort of template for those we'll talk a little bit about that today.
Jeff Terrell: But also note that some you will categorize your user stories into two groups either sort of need to have or a nice to have see where did I say that I said something like that somewhere.
Jeff Terrell: But anyway, yeah need to have versus nice to have features so that'll be a conversation point with your client, as well as you're hearing about all the things that they want.
Jeff Terrell: They might tell you automatically, but if they don't you can ask them as well you know how how important Is this how important is that How important is that.
Jeff Terrell: and start to get a feel for what are the real like need to hash for this project and wish, things would be nice to have if we can finish those.
Jeff Terrell: And that's due in two weeks.
Jeff Terrell: question about this.
Jeff Terrell: Nothing okay.
Jeff Terrell: Well yeah these things are intended by the way, I think I may be said this before, but they're intended to keep you on track for your project and just get things moving so that it's not just one huge deliverable at the end of the Semester that you stress yourself out but about.
Jeff Terrell: Okay, and yeah mentor meetings are expected and required this week, you will be graded on your attendance in your mentor meeting so.
Jeff Terrell: I hope you are scheduling that if you really can't make this week work and things are not working, of course, just email me we'll figure something out but.
Jeff Terrell: But if I don't hear from you and you don't show up for your mentor meeting or schedule one, you will get a zero for this week, so if you expect you to me.
Jeff Terrell: Okay, so today i'm going to talk about basically, the main thing is just project management i'll spend a little bit of time on user stories.
Jeff Terrell: But mostly i'll be talking about project management, what is it, how to do it effectively what are some ideas that can help you think about project management and frame the questions.
Jeff Terrell: what's the yeah and that'll that'll equity for assignment to.
Jeff Terrell: So the goal of project management is to keep the project moving.
Jeff Terrell: Why, why do we need project management.
Jeff Terrell: I mean, think about just starting on this project that you have from your client and just figuring out it out as you go just winging it not having any sort of specified approach for project management.
Jeff Terrell: It might turn into kind of a chaotic disaster right, you might realize all the kinds of mistakes that you're making and.
Jeff Terrell: You didn't really have a plan, and so you might get overwhelmed pretty quickly so project managers it management is intended to give you enough structure to just keep your project moving.
Jeff Terrell: that's that was kind of the reason for the music today float on by modest mouse just keep the project floating on.
Jeff Terrell: Now that sounds kind of obvious so what's hard about that.
Jeff Terrell: A lot of the difficulty of this comes from collaboration.
Jeff Terrell: If you were working alone on this project let's say that you didn't even have a client you just had an idea for an APP that you wanted to create you were the only one working on it.
Jeff Terrell: The only thing that you would have to do is figure out dependency order us right i've got to do this before I do that, so let me do this first when I can do that.
Jeff Terrell: And you break your project down into these tasks and just order it based on dependencies do a nice, you know topological sort on that and it's a graph.
Jeff Terrell: And off you go and not that that's always easy to do but that's a much less complicated problem than doing the same thing collaboratively.
Jeff Terrell: When you do it collaboratively things get a lot more complicated both working as a team of developers.
Jeff Terrell: But also working with a client who has the vision for the project, rather than you having a vision for the project, these are both degrees of collaboration kinds of collaboration, you have to do to complicate project management.
Jeff Terrell: So for for multiple people working on a project, you have to coordinate just in terms of the development team who works on one right.
Jeff Terrell: And you can think about this, the analogy in computer science there's actually a lot of analogies in computer science, the project manager analogy here would be a single threaded program or a multi threaded Program.
Jeff Terrell: Just curious how many of y'all have done multi threaded programming before.
Jeff Terrell: just a handful of people okay Okay, not a whole lot.
Jeff Terrell: If you if you haven't done it before you can take my word for it, but that gets a lot more complicated when you start to introduce multiple threads.
Jeff Terrell: Things are things are easy, as long as you're talking about a single thread relatively easy.
Jeff Terrell: So the same analogy applies to projects of development change multiple people working on it or not.
Jeff Terrell: Okay, let me talk about communication overhead, this is one of the.
Jeff Terrell: invisible things that you might not notice if I weren't telling you about it, but once somebody said it, you would say oh that's really obvious in hindsight, but maybe you just didn't think about it in advance.
Jeff Terrell: So there's this famous book the mythical man month by Fred brooks, we all know, Fred brooks or at least know who he is.
Jeff Terrell: This was the only textbook that I was assigned for my software engineering class and undergrad which I took probably oh three ish.
Jeff Terrell: and
Jeff Terrell: hang on hang on no I think that's not sure I think we didn't actually read I didn't read that and undergrad, but I do remember hearing about this book in undergrad and that was the only book, I remember hearing about from that class.
Jeff Terrell: um I read it later I read it after I came here I got my PhD and was doing software projects with a team of people for a startup for their startup that I started actually.
Jeff Terrell: And I was really kind of shocked by how many insights there were in this book, this is kind of a classic software engineering book, I may have mentioned it on the first day of class as well if you ever want to dig deeper in software engineering, this would be a really good read.
Jeff Terrell: But yeah I read it, and I was like this is so insightful and so relevant to what i'm doing managing software projects, I really wish i'd read it sooner.
Jeff Terrell: The idea of a man month which we could call person month.
Jeff Terrell: To be a little bit more modern here.
Jeff Terrell: So person month is just one person working for a month.
Jeff Terrell: And so it makes sense to reach projects by person months to kind of figure out how much effort is going to be required for this.
Jeff Terrell: And that makes sense from a business like a management perspective that way, the business can figure out okay about how much is this project going to cost what's the approximate timeframe, going to be.
Jeff Terrell: It makes sense, so you could say like this is a 12 person month project.
Jeff Terrell: But if you say, this is a 12 person month project, the reason why the title of this book is the mythical man month is that you can't just allocate the person months, however, you like.
Jeff Terrell: So is a one person by 12 month project equivalent to a 12 person by one month project.
Jeff Terrell: The answer is absolutely not an analogy would be telling nine women, they have one month to make a date.
Jeff Terrell: It doesn't work that way.
Jeff Terrell: So the key insight that the book has is that rating project effort by person assumes no communication overhead.
Jeff Terrell: If there were zero communication overhead you really could break a project at this way, and you could do one month by 12 people or 12 months by one person.
Jeff Terrell: But there is communication overhead and that's a very real factor in software projects.
Jeff Terrell: Or at least collaborative software projects, I suppose that's one of the things that makes a non collaborative software project a lot easier, is that there is no communication overhead.
Jeff Terrell: You got all the communication happening within within your cranium so there's no real communication between between people.
Jeff Terrell: So let's let's think about this, so how would we quantify the communication overhead.
Jeff Terrell: We can use a proxy measure for this and just think about how many handshakes are possible with a certain number of people in the room.
Jeff Terrell: So if there are three people how many possible handshakes are there.
Jeff Terrell: one, two and three right three possible handshakes.
Jeff Terrell: What about four people.
Jeff Terrell: require a little bit of thought.
Jeff Terrell: Six yeah.
Jeff Terrell: So, adding one person double the number of handshakes.
Jeff Terrell: And, in general, how many communications must take place to coordinate in developers well how many vacations, what do you define that as but just as a proxy measure how many handshakes you have for and people, the answer is n times N minus one over to, and this is an order in squared.
Jeff Terrell: Right.
Jeff Terrell: yeah the N squared term in there, so this overhead scales exponentially in the number of people on a project.
Jeff Terrell: that's a pretty big deal that can that can really add up you start talking about maybe not exactly doubling but scaling exponentially every time you add.
Jeff Terrell: Another person to the project, so you get up into like 12 people on a project you got a lot communication overhead.
Jeff Terrell: there's a so called law comes from the mythical man month and says it's it's from it's called brooks's law, adding developers to a late project only makes it later.
Jeff Terrell: and actually i'm not quite sure that's from that book, it might be from an essay he wrote called no silver bullet I forget anyway.
Jeff Terrell: And the reason why is that you're adding communication overhead every time you add people, and if you add a developer to a project it's already late.
Jeff Terrell: you're saying okay developers, who are already on the project, you have to stop what you're doing and communicate all that this person needs to know to this new developer.
Jeff Terrell: you're adding communication overhead you got to stop during the actual development work to make that happen so that's why the project is getting even later when you add more people to a lake project.
Jeff Terrell: it's all about communication overhead.
Jeff Terrell: So we said that the goal of project management is to keep the project moving, but a secondary goal that would constrain that goal would be to add as little overhead as possible.
Jeff Terrell: and industry has caught on with this idea of communication overhead, this is no longer as revolutionary an idea, as it was when Dr brooks first made the argument.
Jeff Terrell: it's now understood that there's communication overhead and that this has a cost in terms of time and developer time to the project so.
Jeff Terrell: Nowadays, most companies are moving to some teams of three to six developers, probably at most six most teams that you find in industry will not be bigger than that, and the reason for that is exponential scale of.
Jeff Terrell: Communication overhead if you have a broadcast paradigm.
Jeff Terrell: that's this all to all there so.
Jeff Terrell: In fact, I think I remember a mentor applying this time around the mentor in this class and they said something like.
Jeff Terrell: I really don't want to work with a team that's bigger than I forget the number it's like six or eight.
Jeff Terrell: So, and they didn't know that they were going to get a team of three to four but but yeah i'm on the same page like I don't want to have eight people that's too much too much communication overhead gets in the way of actually getting work done.
Jeff Terrell: So how do we scale up.
Jeff Terrell: In terms of like you know we know of companies that have thousands and maybe 10s of thousands of developers, how do they manage that.
Jeff Terrell: Well, the trick is that they don't broadcast messages to every single developer and we'd be back in order and square territory, and that would be disastrous.
Jeff Terrell: What they do is they break it up into smaller teams and the teams, generally speaking, don't talk to each other, the Inter team communication is managed pretty carefully to try to keep it minimal.
Jeff Terrell: And by the way, here's another computer science analogy, how do we scale up with data we have a whole bunch of different pieces of data that we need to store somewhere and we need to be able to manipulate that data efficiently.
Jeff Terrell: There are ways to do it, the solution would be trees, which, generally speaking, have longer than operations.
Jeff Terrell: And trees are a hierarchical data structure, and this, by the way, is why hierarchy tends to be useful in companies in larger organizations that have a lot of people.
Jeff Terrell: Now there are definite problems with hierarchy, as we all know, but there's a reason why this is kind of a default mode for a lot of larger organizations and companies and corporations hierarchy limits the communication.
Jeff Terrell: So that it doesn't drown the actual work of the of the company.
Jeff Terrell: Okay, so that was talking about communication overhead, this is one of these invisible factors of projects that until you kind of see it you just don't see it, but it can affect your project greatly.
Jeff Terrell: And so having a little bit of ability to see that in your project and think about it can help you be more efficient in terms of your project management and in terms of just getting your work done so Questions about communication overhead.
Jeff Terrell: Everything makes sense, or else i'm putting you to sleep either way.
Jeff Terrell: Okay i'm going to transition into some tips and tools for project management this comes from all of my experience doing projects.
Jeff Terrell: Some of these things are more obvious than others, one that I think is fairly obvious is to exploit natural seems in the work.
Jeff Terrell: So when you think about the work that needs to happen in your project, especially when you're new with your client and you start to develop some user stories and get a feel for what all needs to happen.
Jeff Terrell: There will be some natural seems in that work to say well you know here's the front end here's the backend or this is this page and that's a different page.
Jeff Terrell: or This deals with this kind of data and this deals with this kind of data so there's these natural ways that you can divide the workout so just be on the lookout for those kinds of things.
Jeff Terrell: So, for example, if if there are three pages to create for the website assignment coming up during a week, then what you could do is assign each person that page.
Jeff Terrell: I forget exactly how many pages, there are there are five maybe you do kind of a round Robin allocation or whatever, so that would be a natural seem in that work.
Jeff Terrell: To find and exploit as you start to define your tasks.
Jeff Terrell: But notice that there is often pre work.
Jeff Terrell: which has to happen before the parallelizable work can happen.
Jeff Terrell: Once you have the work divided up then that work can hopefully happen in parallel.
Jeff Terrell: and multiple people can be working at the same time, which is another important thing about keeping your project moving you know, in other words, the goal of project management.
Jeff Terrell: You don't want to have one developer just blocked unable to do any work you want a developer who's available to be able to work on something to move the project forward.
Jeff Terrell: But sometimes you have some pre work to do before you get to the parallelizable work so, for example in the website assignment need to read the requirements to determine that three pages are needed.
Jeff Terrell: that's work that has to happen before you get to the parallelizable work.
Jeff Terrell: And on the other end there might be work that you need to do after the parallelized or, for example, to synthesize everything into a coherent whole.
Jeff Terrell: So maybe you need to or maybe communication, you need to share the site with people, this is something that you need to do after the work is finished.
Jeff Terrell: After the parallelizable work is finished.
Jeff Terrell: If you're talking about defining tasks that's a kind of pre work but typically that is considered to be project management overhead and there's usually not explicitly tracked as a task it just falls into the so called overhead bucket.
Jeff Terrell: we're not going to track, maybe, maybe if you're diligent, you would track how much time you spent on it just to have a sense of what the communication overhead for the project was.
Jeff Terrell: But it's usually not going to be like a task that you may be assigned an identifier to and assign a person to it's just work that has to be done.
Jeff Terrell: But there are other kinds of pre work that you might assign an explicit tasks to, and there are kinds of post work that you would assign them explicit tasks to.
Jeff Terrell: But the point is pay attention to the natural seems in the work and also noticed that sometimes even when you find some scenes that can make for some parallel tasks there might be setup work and finishing work to be done, that is not parallelizable.
Jeff Terrell: Anybody ever heard of the mapreduce paradigm for distributed algorithms.
Jeff Terrell: little bit.
Jeff Terrell: Okay couple people, maybe yeah, this is an example, I mean maybe it doesn't connect to my stability haven't heard of it but.
Jeff Terrell: The idea is that we got a break the work that if you got 1000 computers at your disposal to do this really large task.
Jeff Terrell: To do a little bit of work to break the problem up into little chunks and then you assign all those chunks to the individual cores and then at the end, you have a reduced set that starts to fold all the results together until you get your final your final answer.
Jeff Terrell: And this is very similar to what i'm talking about here, we work post work and parallelizable work.
Jeff Terrell: also remember the lesson from quality to the Max.
Jeff Terrell: you're not going to know everything about your project up front you're going to be finding that, as you go it's a progressive understanding of what your client wants and what the priorities are.
Jeff Terrell: So the seams might not be evident until you've gone some distance down the path and that's Okay, you might want to do a bit of like.
Jeff Terrell: lazy project manager lazy task definition, in other words you do tasks definition and you, you wait on it until you actually have to do it, and then you do it, and if you wait that long That gives you more clarity about what needs to happen, because you now understand it better.
Jeff Terrell: Any questions about this.
Okay.
Jeff Terrell: Another thing that might be obvious is you need to write things down.
Jeff Terrell: don't rely on just your memory, to remind you of everything that you need to know when you need to know it write it down our human memory is fallible.
Jeff Terrell: And if we don't remember all the details, we might kind of remember them in our favor and if you're remembering them in your favor and appliances remembering the details in their favor that can be a problem.
Jeff Terrell: But just having things written down and keeps us honest.
Jeff Terrell: With you boyd's needless conflict, you can always refer back and say, this is the record I haven't this decision it's just timestamp at this at this date, you know, and this is what was written as the decision, so we can always go back and look at that later.
Jeff Terrell: In trouble if you're if you use cello comment threads are a good place to ask questions and they can generate email notifications, and so, usually what i'll do when i'm working with a client is I will actually invite them to my board.
Jeff Terrell: And I will tag them and comments, if I have a question have some task that's defined in a card.
Jeff Terrell: And if I realized later that I have some question about that for the client i'll just tag them in the comment right there.
Jeff Terrell: they'll get an email notification the common answer that and that way I have my written documentation right there, this was the question, this is the response from a client it's all right there.
Jeff Terrell: Okay, this one might be obvious in hindsight might not be obvious I don't know so define a source of truth.
Jeff Terrell: One of the things that you need to be able to do as a developer is figure out what is the next thing i'm going to work on, I just finished, a task.
Jeff Terrell: what's The next thing I need to work on, with a good project management solution, you can figure that out pretty easily but let's say, for example, that you it's Friday at three o'clock.
Jeff Terrell: you're looking for the next thing to work on, you have quite a bit of time this weekend to work on your projects, you know you don't have a lot of you know, big new terms coming up next week.
Jeff Terrell: Not a lot of plans with your friends and so you're going to you're planning on spending, you know five or 10 hours, this weekend to work on.
Jeff Terrell: Your project, so you ask your project management teammate somebody has the project manager role on your product on your team let's say and you ask them to send them an email hey what's The next thing to work on, but you don't hear from them until Monday.
Jeff Terrell: kind of a problem right.
Jeff Terrell: You had five or 10 hours that you could spend on the project and you were just waiting to figure out what to work on so.
Jeff Terrell: If your source of truth is something is maybe a person who isn't always available and maybe I should have said to find it and always available source of truth, then it's asynchronous communication, you might end up waiting on that communication to respond.
Jeff Terrell: So my recommendation is to push project information to a shared source of truth, so that anybody can query it on demand.
Jeff Terrell: And this is the whole idea behind a project management board like fellow or like Google or sorry github projects or something like that.
Jeff Terrell: Is that this is the shared source of truth that anybody can query on demand or query just it's not like an sql query it just means like go look at the source of truth and figure out what you need to figure out.
Jeff Terrell: So you might use a trailer board, you might use a spreadsheet.
Jeff Terrell: But just something that is shared and it isn't a place that's accessible at all times, so you don't have to wait on somebody now for this to work notice that it requires discipline from all teammates to keep the source of truth updated.
Jeff Terrell: So if you have a trailer board or spreadsheet or something like that, and it says that the next task somebody should work on its number 78.
Jeff Terrell: But somebody already started number 78 they just forgot to update that, then you start number 78 and it turns out you're doing duplicate work.
Jeff Terrell: that's a waste, and so you have to be disciplined, this is one of the things that you will learn over the course of the Semester, if you don't know what already is that.
Jeff Terrell: To be an effective collaborator you have to maintain some discipline about keeping this source of truth updated.
Jeff Terrell: anytime you make a change that's relevant for your teammates to know about you need to make sure that the trip, the project board or whatever source of truth, you use is up to date.
Jeff Terrell: Questions so far.
Okay.
Jeff Terrell: um.
Jeff Terrell: Another recommendation is to hold your communication to the beginning of the cast as much as possible.
Jeff Terrell: And to give you a story that kind of goes the other way, I mean let's say that we we each have a page to do for the website i've got mine you've got yours are other teammate has another one.
Jeff Terrell: And you find a font face and a size that you like, for the website, I really like to houma 18.4 the H3 headers or something like that, and you come up with a set of fonts that that you like, to the website.
Jeff Terrell: And for consistency of course it'd be nice if all the pages on the site share the same style, it would be kind of weird if my page looked a certain way, but other pages with different way, so.
Jeff Terrell: But we didn't specify that in advance, we didn't think about that detail this is again a.
Jeff Terrell: Progressive understanding kind of thing once we got into the task, then we started to realize Oh, there are more details than what I have figured out before, when I was to find a task now I realized there's this detail, we haven't decided on what function, we use well.
Jeff Terrell: Probably the thing that you would do is you'd mentioned your teammates and mentioned whatever innovation, you came up with you know to home at 18 point or whatever, and request that they copy it.
Jeff Terrell: The natural thing to do.
Jeff Terrell: The analogy to computer science here is interpreting communication.
Jeff Terrell: programs that are multi threaded there are a lot easier if they have to do as little of this as possible.
Jeff Terrell: And so efficient ways of doing distributed algorithms and things like that, like the mapreduce paradigm, they do all the communication up front, or as much of it as possible and there's really not a lot of coordination that has to happen in the middle of tasks.
Jeff Terrell: Sometimes that is necessary, you do have to do enterprise communication sometimes but as much as possible it's best to avoid inter probably like.
Jeff Terrell: In progress communication by thinking about your issues in advance, during a task definition face.
Jeff Terrell: Another thing that happens, a lot is you again progressive understanding, you get into the middle of a task you realize there's something you need to ask the client.
Jeff Terrell: Oh, I started doing this, but I realized I don't know, did you want green or purple.
Jeff Terrell: So you you basically park the thread of the implementation of that work to go and ask the client and that's a fine thing to do.
Jeff Terrell: I there, there is a need for it sometimes but it's not ideal, in terms of being efficient, because what happens is, if you have multiple tasks in progress.
Jeff Terrell: Then you're doing context switching between those two things like you you're working you realize you're blocked on this, because you need to ask client something, and so you switch to this other thing.
Jeff Terrell: and start this new task, and you get that all in your head and then you realize the client gets back to you and you get your.
Jeff Terrell: This thread on blocks and then you switch it and you're having to do all this context switching between task one task to and you can't do that but that's work that, ideally, you would be able to avoid and the way to avoid, that is, by getting everything nailed down in advance.
Jeff Terrell: So the idea here is to do all your communication during the past definition face as much as possible now we're we're only human we can't predict everything in advance.
Jeff Terrell: We fail even even experienced developers when they're defining a task will fail to mention this detail or that detail.
Jeff Terrell: either because they just didn't even think of it as a question, or they just Whatever the reason, is so you know, this is, this is something to shoot for as an ideal, this is not something to beat yourself up with if you fail to do it.
Jeff Terrell: Does that make sense, why we do this.
Jeff Terrell: What context switching whatever multiple things in progress yeah okay.
Jeff Terrell: here's a little rule of thumb that I like to use.
Jeff Terrell: To help us figure out how big a tasks should be another question that I get how big should my tasks be when i'm defining my tasks and my answer is aim for about two to four hours of work per task, at least in the context of COMP by 23.
Jeff Terrell: There is no right answer, but there are some trade offs so here's kind of the different things that you can hit if you if you get too big or too small too small means you spend a lot of time just managing cards.
Jeff Terrell: And this is overhead time this is time that you know you're just taking away from actual development time, so you want to minimize that as much as possible.
Jeff Terrell: But on the other hand, if it's too big, if your cards are too big, that means you don't actually see progress, very often, which can be frustrating.
Jeff Terrell: You spend a whole week and you weren't able to move any cards on your board or check anything off as done.
Jeff Terrell: And so you don't want to make it too big either so there's a balance to be struck between don't want to spend too much time writing all these tasks definitions, but I also wanted, be able to see see things moving from day to day or from week to week.
Jeff Terrell: So, if your partner too big, you might say, well.
Jeff Terrell: If you made, I don't I don't see that you did anything last week, did you actually do anything and.
Jeff Terrell: You know, hopefully there's a lot of trust within your team and they say yes, I did and here's what I was working on and you believe them that they weren't slacking but.
Jeff Terrell: Being able to see you know cards broken up into two to four hours ish and being able to see those move across the board really helps everybody feel good about the project and the progress you're making.
Jeff Terrell: Now, if I was in a full time development dig my typical recommendation is more like four to eight our size tasks as a sweet spot but that's when i'm working eight hours a day on project, and you know there's two or three other people working on that project, at the same time.
Jeff Terrell: Here y'all are working i'm my kind of target would be about 10 hours per week per person on this project, and for that I think it makes less sense to have a 48 hour size task.
Jeff Terrell: Now, in case you didn't know estimating how long things is going, things are going to take is a hard thing to do.
Jeff Terrell: And I don't expect that you'll get that right, every time I say in for two to four hours per task, but especially as you're starting out with APP development, you might.
Jeff Terrell: Think something's going to be two hours and it turns into 20 right, so these things happen these things happen, even to experienced developers.
Jeff Terrell: I tried to improve my estimation game all the time, but, but I still completely miss it sometimes and that's okay that's expected, but this is again it's just kind of a an ideal to shoot for.
Jeff Terrell: And the goal is that we have steady visible progress on the project like tires on the road getting traction on that road and living.
Jeff Terrell: that's what we want to see helps everybody's morale helps the client know that you're getting worked on and it just feels good to always have always be able to see things moving.
will spend more time on your work.
Jeff Terrell: Okay oregon's i'll spend more time on your work and expected, even if you know that law.
Jeff Terrell: that's exactly right.
Jeff Terrell: yeah great okay so let's move to a quick poll.
Jeff Terrell: i'm interested to hear.
Jeff Terrell: If you've used trial before polivy.com slash Jeff terrell.
Jeff Terrell: Okay, so about a quarter of y'all have used it quite a bit.
Jeff Terrell: Interesting all right.
Jeff Terrell: it's definitely a popular tool, a lot of people use trolling these days like I said it's certainly not perfect, I keep being frustrated by different limitations fellow has the search is pretty awful.
Jeff Terrell: But it's still it's free and it is a pretty good job tool to get the job done.
Jeff Terrell: somewhere between quite a bit and a little about half of you have used her fair okay.
Jeff Terrell: Great, thank you for your responses and.
Jeff Terrell: Anybody still filling that out yet we're waiting.
Jeff Terrell: For that, just a second.
Jeff Terrell: Actually yeah i'm going to move to something else, anyway, before I go to the next well um so I wanted to give y'all, especially those of you who have not used travel very much before.
Jeff Terrell: A demonstration of how I use tableau, and this has worked pretty well for me in the past on collaborative software projects.
Jeff Terrell: So let me show you all this trailer board, this is for the closure error mediator, this is a project that we have going on in the APP lab.
Jeff Terrell: OK, so the basic idea of travel, if you haven't seen it before, is that we have cards.
Jeff Terrell: And these cards can kind of be dragged up and down within a list or between lists.
Jeff Terrell: But that's a card each card has a collapse to view and it's list, but then you can also.
Jeff Terrell: Look at the details of the car the description, there are labels that you can add you can assign people to a card, you can add checklists cards and due dates and things like that and see like this one has one out of one checklist items completed.
Jeff Terrell: This one has a somebody assigned to the card, so this is an example of.
Jeff Terrell: Of cello it's up to you to define whatever lists makes sense for your project and, of course, whatever cards makes sense for your project.
Jeff Terrell: But I wanted to give you a sense of how I use traveling because there's a lot of ways to do it, and at least seeing an example, I think, will help.
Jeff Terrell: things seem more concrete and giving you something concrete to start with, so what we basically do on a lot of software projects that i'm involved in this, we might have a reference column with things have just need to always be there, this might be, for example, the.
Jeff Terrell: links to the clickable prototype or to the user stories or something like that.
Jeff Terrell: there's a backlog, and this is things that aren't are not ready to be worked on yet.
Jeff Terrell: Maybe you need more specification for some of these tasks, you need to have a meeting with the client and figure out what they want.
Jeff Terrell: Or maybe these are waiting on other things, to finish, or maybe you just haven't thought much about it, yet you realize, you know I need this thing and need some sort of new infrastructure, but I haven't really finished thinking about it, yet, so let me just add a card to the backlog to.
Jeff Terrell: remind myself, that this is work that I want to do at some point in the future.
Jeff Terrell: The ready column here is like this is stuff that's actually ready to be worked on.
Jeff Terrell: There are no dependencies are not completed.
Jeff Terrell: it's fully specified.
Jeff Terrell: In progress and stuff that somebody is working on, and these are typically have at least one person assigned to it.
Jeff Terrell: And, at least for this project what we've done is we actually have a code review step and so when somebody's done working on something we say.
Jeff Terrell: That code needs to be reviewed before it's considered finished, so when the code is when the person is working on the code and is ready for somebody else to review it they move the cards code review.
Jeff Terrell: When the reviewer has signed off on it and said this code looks good and the outstanding issues have been addressed, then they can move too hard to to merge.
Jeff Terrell: And then the person who wrote the did the future to To begin with, can merge that card merge that that Code into your the master branch, at which point I believe in this project is automatically deploy a continuous deployment solution, and then we move it to deployed slash done.
Jeff Terrell: If we wanted another step of like the client needs to review it we don't actually have a client on this product per se, we might have another column here that says.
Jeff Terrell: To approve or clients to review or something like that, but these are all the stages of development and its general approach, by the way, if you've heard the term combine.
Jeff Terrell: that's the basic idea behind con bond is that your cards are flowing from left to right and each place that they hit is a stage of work.
Jeff Terrell: So it's a pretty natural thing it works well spatially in the 2d space to like have cards that are flowing from left to right.
Jeff Terrell: To the different stages of work and that's what people mean to large extent by con bond, there are some further details, if you get into con bond that are not necessarily captured here.
Jeff Terrell: Such as limiting the size of how many things can be in a particular work state at a time, but that's the basic idea.
Jeff Terrell: One of the thing that i'll mention here is that we have we do a few extra things on our trailer boards we actually number all of our cards.
Jeff Terrell: This is not something that trailer gives you automatically we just insert the card number right there in the title of the fire and I can see the card number from the URL.
Jeff Terrell: But I will I will do that because it's useful to be able to.
Jeff Terrell: sort of make informal connections between the cards, for example, here we have a card, this is card number 99 and it has a parent card card number 92, so this is one of potentially several child cards a card number 92 that's what that P 92 needs here.
let's see here.
Jeff Terrell: Number 92.
Jeff Terrell: There we go and then number 92 is authentication and so what we do here for lot of our projects is sometimes a group of cards makes sense to kind of get groups together.
Jeff Terrell: And we'll add a container label, you can you can name containers whatever you want.
Jeff Terrell: use whatever colors you want, and then the container cards don't have any work themselves, they just represent.
Jeff Terrell: A grouping of child parts, so all of these have a P 92 to indicate that 92 is the parent.
Jeff Terrell: And the child cards are fine double from this checklist within the parent just something we do you don't have to do it that way different project management tools will have more sophisticated ways of tracking parent child relationships and hierarchical relationships between tasks.
Jeff Terrell: that's how we do it questions about our use of trial.
Jeff Terrell: Okay, hopefully, if you haven't seen before they'll give you a sense of what it is and how you can set it up.
Jeff Terrell: Something that.
Jeff Terrell: I should mention the block label.
Jeff Terrell: If we have some.
Jeff Terrell: If we have some card that's in progress, and then we realize Oh, you know what I can't keep working on this until I hear back from my clients about that one thing you cannot have Blocker label.
Jeff Terrell: I usually do that and read this indicates like I can't make progress on this right now.
Jeff Terrell: So I need to work on something else.
Jeff Terrell: Okay, so after having talked about project management i'm interested to hear what are you inclined to use for project management, so let me go to another poll here.
Jeff Terrell: looks like most of you are planning to use tron.
Jeff Terrell: People with github projects.
Jeff Terrell: Share documents and other things.
Jeff Terrell: cool.
Jeff Terrell: As best to say i'm glad to see nobody's using jira but then somebody did.
Jeff Terrell: Like i've got my opinions about project management everybody does and that's why experienced software engineers like your mentor.
Jeff Terrell: might have their own opinions and it might be interesting to hear where their opinions differ from mine.
Jeff Terrell: Okay, still waiting on a few people to fill that out.
Jeff Terrell: Okay, it looks like most of you are planning to use trailer so that's fine you're you're not winning any bonus points by choosing fellow it doesn't really matter to me, but that is probably the path of least resistance.
Jeff Terrell: Okay, let me spend this is just kind of a.
Jeff Terrell: A free tip from my experience is kind of related to the idea of project management, but something that.
Jeff Terrell: I have.
Jeff Terrell: i've stumbled upon this way of working and I found it to be really effective for me.
Jeff Terrell: You may find it to be really effective for you, you may not, you may not even care to try it, but I wanted to share it with you, because it really has made a big difference in my ability to be productive, both in terms of building software and in terms of all kinds of other things so.
Jeff Terrell: The thing that I like to do is I like to break down my tasks, even the relatively small tasks into really small steps.
Jeff Terrell: And I have some tools that are lightweight enough that they don't get in my way doing this, they don't have a lot of overhead as I break these things down i'm pretty fluent in them, I can very quickly break something down and.
Jeff Terrell: It really feels good to have small steps on a checklist that you're checking off as you go.
Jeff Terrell: And so what I do, for example, here's what I do for for Class preparation is your all my This is my standard checklist of things that I need to do so i'll go through i've got my checklist.
Jeff Terrell: I did record I didn't I didn't actually set a record reminder, but I didn't record, and so I can go through, and I can mark these things is finished or not, you can see that.
Jeff Terrell: summary at the top here is changing, as Mr things out so.
Jeff Terrell: So if i'm working on a software task I might say okay read the card.
Jeff Terrell: fill in some tasks read the card i'll fill in some tasks and my tasks would be like.
Jeff Terrell: change this controller to be to do this other thing at a model for this out of database, migration, you know change this new to do that.
Jeff Terrell: Ad this ad that you know commits.
Jeff Terrell: update cello deploy whatever all my steps are and i'll have a list of you know 10 or 20 different tasks that I need to do, and as i'm working.
Jeff Terrell: i'm my mind is free to focus entirely on this very small thing that i'm doing, and so I stay just hyper focused on what's in front of me, and of course i'm not getting notifications ideally from from slack or email or whatever, but.
Jeff Terrell: But having a broken down into small steps really helps me focus.
Jeff Terrell: It helps me not feel overwhelmed by like oh there's lots of you, what do I need to start on, and then I get this I sort of distract myself from what's in front of me by thinking about all there is to do.
Jeff Terrell: I just capture all those free thoughts into a checklist and then I know I have it saved and I don't need to remember it, so I can I can get all those thoughts out of my head and just focus entirely on what's in front of me so.
Jeff Terrell: I recommend that way of working like I said it's been effective, for me, maybe it will, for you, maybe not it feels good.
Jeff Terrell: To see progress being made, especially if it's you're checking something off every five minutes it's like this feels good i'm getting worked on i'm feeling accomplished feeling productive.
Jeff Terrell: And it reinforces that sort of Melissa day stay doing this.
Jeff Terrell: Right, none of my attention is given to remembering what needs to be done because it's already captured in that checklist.
Jeff Terrell: And it can help me get into that creative flow state if y'all y'all have ever experienced that that's a lot of fun.
Jeff Terrell: When you're fluent in some programming language or some sort of act of creation and you can just kind of exert you're willing to the system.
Jeff Terrell: And you just feel like there's this fluid way to just tell the computer what you need to do, and it does it and you're creating something and it's like it's a really fun sort of State at the end.
Jeff Terrell: And if you're interested, I have a video demonstrating my setup this is using org mode in emacs so feel free to look that up if you're curious.
Jeff Terrell: Okay questions about focusing in on tasks or project management anything covered so far.
Okay.
Jeff Terrell: alright.
Jeff Terrell: So I wanted to mention just a couple more things about user stories we did talk about this during the project narrative architecture.
Jeff Terrell: recall that there's a template for this as a something in order to something I can something.
Jeff Terrell: So, for example, as an authenticated user in order to keep up with my friends, I can see a list of recent posts from my friends most recent first is a really concise way of capturing.
Jeff Terrell: capturing what you need to do, and if you capture it in a way that focuses on the person who benefits from the feature.
Jeff Terrell: you're not capturing implementation details or you know this we're going to need this Controller and that model and whatever you just capture it in terms of value delivered to a user.
Jeff Terrell: Now the obvious thing to see here is that of course you're going to need to talk to your file to figure out new user stories remember this is assignment three doing two weeks.
Jeff Terrell: But the thing to remember, which I covered in that lecture last week as well, or maybe a couple weeks ago at this point.
Jeff Terrell: The thing to remember is that the client may have a particular thing in mind that they don't actually meet.
Jeff Terrell: that's just the way to the solution that they know so they might say, well, I want a an ios APP and an android APP but what they really mean is.
Jeff Terrell: I don't really need a nap I just want something that looks good on a phone right.
Jeff Terrell: And so, if all you have is I need an ios APP and an android APP to go a certain direction, but if you take the time.
Jeff Terrell: To understand where your clients coming from and what needs are driving that statement, in other words to kind of a nice behind the needs, then you realize oh it's not actually about.
Jeff Terrell: You know, getting in the Google play store in the in the ios APP store it's really just about getting an experience that looks good on a phone.
Jeff Terrell: So.
Jeff Terrell: to uncover what your client really wants try to enter their world and see things from their perspective.
Jeff Terrell: So the better your ability to adopt other perspectives and relate to people and understand where they're coming from.
Jeff Terrell: More effective, you can be at gathering user stories and understanding, where you can be creative to meet a need in a creative way that maybe isn't what the client had in mind, but would meet the need, perhaps even better than what they had in mind.
Jeff Terrell: So, in other words, try to understand the client's context where are they coming from so here are some questions I got these courtesy of some professors at the Arizona State University.
Jeff Terrell: Through the.
Jeff Terrell: Well, through through King part.
Jeff Terrell: Anyway, some questions to help you get into your clients context and understand their perspective.
Jeff Terrell: ask them what is the primary motivation for X.
Jeff Terrell: What is the key problem that X addresses these are things to help you get to the need behind the knee.
Jeff Terrell: Why is X important to your company to your research group to your whenever to your startup.
Jeff Terrell: And what do you hope to accomplish with X.
Jeff Terrell: So hopefully that'll help you get a better set of user stories and get a better sense of what is really needed it doesn't Tirana.
Jeff Terrell: than you might otherwise, but the key is really not just to engage at the surface level of what they're saying, but to try to understand one layer deeper, what are the needs behind the things that they're saying.
Jeff Terrell: that's a pretty difficult thing to convey in a sort of lecture context, but hopefully as you experienced that.
Jeff Terrell: And maybe keep that in mind you'll start to see ways that you can connect that.
Jeff Terrell: I think some of you will be better at this than others and.
Jeff Terrell: Questions about this.
Okay.
Jeff Terrell: So that's all I have today for today on Wednesday we're going to start on the design side of things, and this is going to drive believe it's assignment for you in three weeks, I want to say the clickable prototype so we're going to spend at least one lecture and probably to on.
Jeff Terrell: How to design things that look good and how to use tools to do designs for clickable prototypes like Sigma.
Jeff Terrell: So that's all I got for today thanks everybody.