Jeff Terrell: Okay. Hey Peter, great. You're here.
Jeff Terrell: Yeah, so everybody this is Peter Lau. He is a commercialization manager with the UNC Office of Technology Commercialization and he has some things to tell you, I guess, Peter, do you want me to describe more about why you're here or do you want to talk about that as well.
Peter Liao: You got a short version. You'd like to use. That's fine. Otherwise, I'm happy to dive in whatever works for you.
Jeff Terrell: Go for it. I'll
Peter Liao: Fill in any details that maybe you missed or anything like that.
Jeff Terrell: Do you need to our screen or anything like that.
Peter Liao: No, I was just going to say a few words if that's
Peter Liao: All right.
Peter Liao: Yeah, so the Office of Technology Commercialization is a central office that works campus wide with
Peter Liao: Faculty, staff, and students to manage issues around intellectual property. And so we see those and a lot of different ways, primarily. My job is to help
Peter Liao: Find commercial applications for things that come out of UNC research so primarily working with faculty and
Peter Liao: And grad students to take inventions or software that come out of primarily research and
Peter Liao: And find, you know, broader impact for that. So beyond just publishing papers. So can we actually make some products or services out of that. And so I work with
Peter Liao: A big range of technologies and teams from across campus and physical sciences, more or less, primarily software and copyright
Peter Liao: On the normal time I do sit in citizen home just short walk down the hall from Jeff's office and provide support for all of computer science. And so I think in kind of
Peter Liao: Setting up this class last year, we had some discussion around intellectual property and how to help
Peter Liao: The class and students and you know project sponsors manage issues related to intellectual property. Because clearly, I think the desire is to have real world projects for you all, and to have an opportunity to
Peter Liao: You know, create something that has some potential lasting value. And so, in particular for you know companies sponsors.
Peter Liao: They may have, you know, thoughts, more desires around securing you know rights to that so that they have that as an asset.
Peter Liao: For their company that they have the ability to use that freely or if they want to.
Peter Liao: You know, have some exclusivity around that and make something proprietary that they have the ability to do that too. And so we worked collectively
Peter Liao: ROTC working with Jeff working with our Office of University counsel to deal with issues around students to hopefully craft a plan that works.
Peter Liao: For everyone and addresses all of their needs. So I believe that's been posted on the website for the class and certain teams have been indicated that they have IP.
Peter Liao: matters that are related. And so you'll need to review carefully the guidelines for that and what the expectations are. So I think
Peter Liao: You know, the, the goal for me to kind of come and say a couple words to you at the beginning of class.
Peter Liao: This semester was just kind of one introduce myself. So certainly, if you have questions about any of this, your role as students, what role the university might take in the future, feel free to reach out to me.
Peter Liao: either directly or through Jeff. My email is there on the slide. And I'm happy to try and address any questions.
Peter Liao: For those of you already are prospectively on track to participate on one of these companies sponsored teams or teams that may have some, you know, intellectual property issues and those include
Peter Liao: Those that might be sourced from across campus with faculty that have a project that may move forward in some sort of commercial Avenue. We want to make sure that we have the ability to do that.
Peter Liao: You know, you'll be hearing from Me to round up any, you know, signed confidentiality agreements or other paperwork associated with that your acknowledgement of
Peter Liao: This we collect similar documents from the sponsors as well. And those cases so that everybody's on the same page vibe expectations so
Peter Liao: I would say generally you know the expectations for students are, you know, one
Peter Liao: To, you know, abide by the confidentiality procedures. So if you know companies are you making a special opportunity available to you to work on these real world projects.
Peter Liao: And they are asking for, for you to treat that confidentially, take that seriously and you know don't post it places you're not supposed to don't share it broadly without
Peter Liao: You know, asking questions. And I think that's probably one takeaway from all this is if you're not sure, please ask. Ask me ask the sponsor, as Dr. Darrell about
Peter Liao: You know, is this okay, is this appropriate because more communication is better than less. And then to we want you to have a good rewarding experience. I think this is a great opportunity to
Peter Liao: Get a glimpse into kind of what real world development looks like certainly folks that have this as a full time job out there doing software development often get hired work for hire and have to assign their rights.
Peter Liao: Over to their employee or employer or, you know, their clients. And so I think this probably mimics a lot of what you might see if this ends up being your chosen profession, so
Peter Liao: Yeah, I think Jeff. That's kind of what I wanted to cover. I'm happy to be resource or address questions as they come up either now or later. And we're excited to be a part of the class again.
Jeff Terrell: Great. Thanks, Peter. Yeah, and to fill in one thing you're not at all required to pick a project that does have these IP considerations and
Jeff Terrell: You're not going to be penalized if you don't or anything like that. This is purely optional, but it is a way to potentially access
Jeff Terrell: Some of these companies that that might have more requirements around how they work with students.
Jeff Terrell: It's a way to be able to get them involved in contract 23 so it's really an opportunity if you don't feel comfortable with that and signing, you know, legal agreements and things like that, by all means you can totally opt out.
Jeff Terrell: And I'll show you. I'll talk about how to do that in particular, towards the end of this stage lecture.
Jeff Terrell: And yeah, as Peter said, I mean I signed these kind of work for hire agreements and stuff fairly often as a as like a freelancer when I'm working on the side for somebody. So it really isn't that uncommon.
Jeff Terrell: But yeah, and I guess Peter before you go just. Does anybody have any questions for Peter
Jeff Terrell: And while we're waiting there just for a second for any questions on this projects page here on the website is where you can find which projects. We actually have that are sensitive to IP considerations and confidentiality and that kind of thing.
Jeff Terrell: I'll talk more about this in just a second. No questions for Peter, I see no raised hands. I see nothing in the chat. So, all right. Well, Peter. Thanks very much for your time.
Peter Liao: Absolutely. Good luck. Have fun.
Great.
Jeff Terrell: Okay. Um, so yeah, as Peter said, if you think of questions later just email him or feel free to email me as well and
Jeff Terrell: I can connect us or whatever.
Jeff Terrell: Okay, so some announcements before we get into the topic for today.
Jeff Terrell: The lecture recording has been posted to the website. I got that up. I think by 530 on Monday. So I had a pretty good turnaround time that time in general, it's probably going to be even the day of lecture, you know, maybe by 530 or it might be the next morning.
Jeff Terrell: But I think within 24 hours, I should be able to get everything uploaded to YouTube and everything and
Jeff Terrell: As I mentioned last time slides are already
Jeff Terrell: Posted for today. And they were posted last time. But let me mention one thing about that.
Jeff Terrell: Well, okay. Before I do, yeah, I'm not going to announce in general that I have reporting supposed to this will just be a standard thing that I do every time. So know that that's available.
Jeff Terrell: Well, okay, so maybe I forgot. Oh, yeah. No, I said that later. Anyway, get ahead of myself a little bit here. But, um, the
Jeff Terrell: The PDF version of the slides. I've noticed is a little bit different. It could be a little bit funky sometimes and maybe some stuff gets cut off that isn't in the HTML version.
Jeff Terrell: I'm not going to go over all of that with a fine tooth comb. So if you open the PDF version. And you notice the things look a little bit weird. Maybe just try the HTML version instead
Jeff Terrell: And that would be from a page like this.
Jeff Terrell: Okay. The other announcement. I kind of already talked about a little bit. The, the client applications for projects are now posted to the website. I have a little snippet here about IPA. So that's something that Peter just talked about.
Jeff Terrell: The project details are here. This is actually the the raw submission that I got from each one of these clients.
Jeff Terrell: I haven't really had time to go through these in detail and capture any follow up conversation that I had with clients.
Jeff Terrell: But there was at least one client that I actually they submitted their application because we pivoted enough from what they had originally submitted as we talked about it, that it was worth just kind of starting with a clean slate.
Jeff Terrell: Clean slate. If you are curious what questions they are answering, you're welcome to check out that linked form.
Jeff Terrell: You know what problem are you having that you think software could solve. There's a variety of questions here, including the one about
Jeff Terrell: Let's see, for something in here about IP and I'm just reading too fast to see it.
Jeff Terrell: Maybe that was an unsung page to
Jeff Terrell: Yes, I have concerns about students owning the work they do a lot. OK. So anyway, all that's available if you're curious about it.
Jeff Terrell: And we will be having clients come and pitch these ideas live and in person, for the most part.
Jeff Terrell: And
Jeff Terrell: That'll happen over the next two class periods. This is just the application materials and any additional attachments that the clients provided
Jeff Terrell: But you yeah this is kind of supplemental to the pitches that you'll hear next couple of class periods.
Jeff Terrell: Okay, any questions about that.
Bryce Koester: What does it mean when it says IP next to the application.
Jeff Terrell: Sorry, I couldn't quite hear you say it again.
Bryce Koester: What does it mean when it says IP next to it right
Jeff Terrell: These are the clients that are actually sensitive to intellectual property issues or confidentiality issues.
Jeff Terrell: So these are, these are the ones that you would be talking with Peter about the signs and forms to participate in. And I think that's seven out of 24 of these projects are that way.
Jeff Terrell: There are examples of what you'd be signing here so
Jeff Terrell: I don't really feel like opening that up to a Word document, but some pretty simple participation agreement. This was really intended to
Jeff Terrell: Be something that works out well for you as a student, because
Jeff Terrell: The University really didn't want to require students to be responsible for their own you know legal forms and stuff like that.
Jeff Terrell: Assuming the students could figure out access to a liar and pay for that and all that kind of stuff. So, so they actually have this framework in place to guide how clients can engage with you if they have these kinds of concerns.
Jeff Terrell: I believe over at NC State as where I got some of these ideas from I think they actually require all students take a capstone course and require all students to sign forms like these here. It's more of an optional thing if you opt into projects like that.
Jeff Terrell: Okay, any other questions.
Jeff Terrell: Great.
Jeff Terrell: Okay, so today.
Jeff Terrell: The things I hope to have time to cover today. It's a little bit of a full slate. We'll see how far I get want to talk about the narrative arc of a project.
Jeff Terrell: Just kind of the overall flow of what is a project look like
Jeff Terrell: Also some tips on how to work with clients effectively.
Jeff Terrell: How to Pick a project. There's actually a lot of different ways to pick a project.
Jeff Terrell: And then talk a little bit about assignment zero which
Jeff Terrell: Is doing a week, basically.
Jeff Terrell: So let's start with the narrative arc of a project.
Jeff Terrell: And I'm going to talk about this at a high level, and then drill down on each of these
Jeff Terrell: steps. First you got to understand what's needed. You got to meet with your client, figure out what is it that they want built and just get that understanding
Jeff Terrell: Then storyboard, or maybe a better word would be design, design, what you're going to build talk about what that looks like.
Jeff Terrell: Then you prototype, the actual application and build a working prototype of the app.
Jeff Terrell: And iterate on that app.
Jeff Terrell: Adding features.
Jeff Terrell: You might have a launch phase. This often does not happen in contract 23 projects, but I've including it here kind of for completeness.
Jeff Terrell: And finally, you will have to hand off your project so that the client can sort of effectively be the owner of the project.
Jeff Terrell: Alright, so let's drill down on this.
Jeff Terrell: Let's understand it. Let's talk about understanding what's needed
Jeff Terrell: I'm going to start with a
Jeff Terrell: What I like to call the $5 word $5 word of the day is desert Radha, which is I think it's Latin it means like that which is desired. And so this is a fancy way of talking about you got to understand what the client actually is wanting
Jeff Terrell: To get to get your head around that, of course, you got to talk to the client to be able to do this.
Jeff Terrell: And note that understanding is progressive. So start with a high level view and then drill down on the details as you go.
Jeff Terrell: But try to get a overall picture of everything at a high level, first before you start drilling down into details.
Jeff Terrell: Much like we just did right we talked about the narrative arc of a project at a high level, and now we're drilling down into details and so we're doing some kind of a progressive way, starting with the high level and working our way down to the details.
Jeff Terrell: All right. One of the big ideas of this class is that successful projects need ongoing communication between the developers and the client to deepen that understanding of what's needed as things unfold.
Jeff Terrell: And therefore, a critical element of successful projects is to have good feedback loops to reflect your understanding, back to the client.
Jeff Terrell: And iterate on understanding improving at a Teddy each step. Well, we will talk a lot about feedback loops both today and as a general theme of this course.
Jeff Terrell: But we do need a feedback loop for our understanding of what's needed and there will be a variety of different ways that we have that as we work on our projects.
Jeff Terrell: But the idea is that we're trying to build something that satisfies the clients and so we need the client to weigh in on on what we've built and give feedback and say, this works or this doesn't work right wanted to change in this way.
Jeff Terrell: And as a feedback loop that'll help us iterate and get closer and closer to something that the client is really happy with.
Jeff Terrell: As an example of something not to do, don't just try to understand everything have a meeting with the client understand everything you you can go off and build it and come back three months later to show your client what you've built that would have
Jeff Terrell: Really no feedback loops or just feedback at the end, but there's not an opportunity to take that feedback and iterate on it. If you're showing them what you've built at the very end. What you want to do is be in communication constantly as the
Jeff Terrell: As the project unfolds.
Jeff Terrell: The output of this face is going to be user stories.
Jeff Terrell: There's a different. There's a variety of different ways that you can capture this understanding and documenting
Jeff Terrell: Documenting it is important. Maybe I should have had a bullet point about this, but having something written down is actually really kind of critical for success over a more substantive project because there's enough details in there that you're going to forget.
Jeff Terrell: And you might also, it might not even be you that forgets. It might be a client that forgets what he or she said they wanted having that written down, it's going to be really helpful later to say well we understood you to be saying this. And in fact, we wrote this down and
Jeff Terrell: Maybe even you approved that that was what you wanted. And so that's what we built, you know, I'm sorry. That's not what you want. Now, and that's fine. That's, that's part of the feedback process is that we iterate.
Jeff Terrell: But, you know, we didn't build the wrong thing. We built what you asked for. So having that document. It can be a really helpful thing.
Jeff Terrell: And user stories are one way to document it. That's the way that will be doing in this class.
Jeff Terrell: That's not the only way to do it, but it's a pretty lightweight way to capture these this setup desert Radha and move forward.
Jeff Terrell: As always, jump in, in the chat or raising your hand with any questions that you have.
Jeff Terrell: Okay, so let's talk about user stories.
Jeff Terrell: One of the tendencies that some of us as engineers have is to get absorbed by fun technical questions. And so we can spend a lot of time talking about
Jeff Terrell: Oh, would it be cool if we did this and we could use a you know dependency injection in our code to do it this way and and you know
Jeff Terrell: We could use this this testing framework and we can kind of get sucked into like these cool technical things that are fun for us but don't actually add value to the client.
Jeff Terrell: And sometimes we kind of lose sight of the forest through the trees by doing that kind of thing. I know I'm guilty of that sometimes and I have to kind of constantly guard.
Jeff Terrell: My attention from string of things that I find interesting but maybe aren't necessarily the most helpful.
Jeff Terrell: So user stories are one way to kind of help with that.
Jeff Terrell: Here's a template of a user story I'll come back to why that's helpful helpful in that way.
Jeff Terrell: There's a template as a insert role here in order to insert goal here I can insert description of feature here.
Jeff Terrell: So it's a little bit abstract, let me give you an example as an authenticated user
Jeff Terrell: In order to keep up with my friends.
Jeff Terrell: I can see a list of recent posts from my friends most recent first
Jeff Terrell: So you see the role as authenticated user. The goal is to keep up with my friends and the feature is seeing a list of recent posts from my friends most recent first
Jeff Terrell: This is a really concise way of talking about a requirement which is one thing I really like about it.
Jeff Terrell: It captures a lot of information about what needs to be built in a way that is concise and pretty easy to read.
Jeff Terrell: Notice that this has a first person perspective, it says, I can see, not a user can see
Jeff Terrell: And this is one of the ways that user stories help you focus on value delivered rather than implementation details and fun technical stuff.
Jeff Terrell: So you're actually trying to get your head in the space of somebody who is this role, who who participates in this role.
Jeff Terrell: How do you see the world as a user in that role. What need do you have, and that's the goal that you're describing, and then what does the future actually look like in light of those two things.
Jeff Terrell: So you're trying to get into perspective of these different users and that really helps maintain your focus on delivering value.
Jeff Terrell: So that's the benefit of user stories.
Jeff Terrell: After creating user stories we come back to our favorite word of the day feedback invite feedback from your client.
Jeff Terrell: The idea of feedback is that it's better to understand better does to discover misunderstandings early
Jeff Terrell: If you realize after writing a user story that that's not what the user what the client wants from you the client realizes like I did, kind of, I could see why you would say that, but now that now that I see that written down, I realized what I really want is
Jeff Terrell: Most recent last or you know whatever it is I'm
Jeff Terrell: Having that feedback from the client at this stage for any sort of course corrections that you might need is way better than waiting until after you've already implemented various features and then the client says things like that. So, you know, early feedback is good.
Jeff Terrell: And know that this is assignment three for you this semester.
Jeff Terrell: Got a couple of assignments before then. But, um, but it's a pretty early assignment.
Jeff Terrell: Alright, any questions about user stories.
Jeff Terrell: Okay.
Jeff Terrell: Step to have a project and the narrative arc of a project is to storyboard or design your project developing software is a creative act.
Jeff Terrell: And like other creative acts that are substantial. It's not just kind of a trivial thing you do in an afternoon or you spend half an hour. You're just making a paper airplane or something like that.
Jeff Terrell: It is helpful to actually have some some thought put into the design of the thing that you're going to build before you build it kind of have those as two different phases of work.
Jeff Terrell: So let's think about, you know, more broadly speaking of suck about creative acts.
Jeff Terrell: Other designed things have a design artifacts to guide the implementation.
Jeff Terrell: So one example would be if you're creating a building.
Jeff Terrell: You might have a blueprint of that building.
Jeff Terrell: And that really helps the the builders, the people who were actually implementing this design to know what they're building. It also gives you a chance to think about in detail that design before you commit to actually laying a foundation and starting the construction
Jeff Terrell: So at this point, we could say, well, gosh, that master bedroom with the king size bed looks pretty small. Do we want to expand the footprint, or the footprint of the building, or do we want to have like a queen size bed in there. Maybe or
Jeff Terrell: Do we want to do anything about that we want to move some walls around. So these are things that we can identify at this stage of design by looking at and iterating on the art. The design artifact itself.
Jeff Terrell: It's, it's a really valuable thing to have.
Jeff Terrell: Another example of a design artifact for a different kind of creative endeavor would be a storyboard.
Jeff Terrell: So this is a maybe a quick. I don't know whether this is like some sort of a short or or what, but it's just an example of what
Jeff Terrell: Like a storyboard might be for a quick video. So it's looking it's talking about like how many seconds does each screen or each maybe seeing take what does each scene look like it gives you an idea of the perspective of that scene and the various elements in it.
Jeff Terrell: Maybe there's information about how the transitions work. So you can see after that first scene, there's a
Jeff Terrell: Fade in from black. Maybe that's the leading in animation.
Jeff Terrell: So this is a way to just like get a sketch of what you're going to actually
Jeff Terrell: Create before you create it and having that as a separate phase of work is really helpful because now you can show this to the director of whatever this video is and get some feedback on that right see is this, is this really going to
Jeff Terrell: Do what you want to do. Do we need to refine this in some way, we need to add a scene, take out a scene, etc.
Jeff Terrell: OK, so the goal for the design phase of work here for a software app is similar. We want to create a design artifact with the app that will guide the implementation and also allow for iteration on the design itself.
Jeff Terrell: Inviting feedback from the client or even just letting you iterate, as you look at it and see whether it makes sense or not.
Jeff Terrell: And one challenges that we've got a lot more views than a blueprint does a blueprint for a simple house might just be a single thing.
Jeff Terrell: Often there when you really get down to construction. There's actually a lot of different layers to these kinds of things that you might have an electrical layer and plumbing layer and heating and air conditioning layer different things like that.
Jeff Terrell: But
Jeff Terrell: Even so, you might have more views in an app design than you would for a fairly simple construction project.
Jeff Terrell: Also, we don't have a linear sort of medium here. We're not dealing with film or or even a story of some sort. We're dealing with something that's navigable by the user. So it's more of a
Jeff Terrell: virtual space of different places that the user could go and so it's not linear, like storyboard is for video
Jeff Terrell: The solution to these challenges and this goal is to create what's called a clickable prototype.
Jeff Terrell: This is the design artifact that I recommend and let me show you an example of this.
Jeff Terrell: I should have navigated away.
Jeff Terrell: This is a clickable prototype that I worked on over the summer with a designer who knows a lot more about design than I do. So if it looks good. You can credit
Jeff Terrell: My colleague and not me, but what this is is a this is a graphical screen. I mean, these are these are graphical elements.
Jeff Terrell: You know, the designer went in and created a rectangle, set the background color purple change the border radius in different ways, added different reptile rectangles different text.
Jeff Terrell: And and just laid everything out dragged elements around until it looked. The way he wanted it to. So this is just one screen.
Jeff Terrell: And the reason it's a clickable prototype is because I can click. If I click over here, you can see that Connect button turns blue
Jeff Terrell: And the idea of that is this is indicating to me as a user of this clickable prototype where I can click to make the prototype go places. So if I click Connect.
Jeff Terrell: Then it takes me to the homepage and then I there's various other places. I can click to navigate around this simple app that we designed
Jeff Terrell: Now this is just the design artifact, these, these are not real projects, you can kind of tell by looking that this is just as project name. Number one, which isn't very realistic and this is not a real site. I can't even select this text. This is a graphic.
Jeff Terrell: This is an HTML. This is more of like an image, but it's an image that I can click into various places so I can click around. I can see you know different
Jeff Terrell: Screens here and all of these screens are things that we've designed to look a certain way, and this is the design artifact of this app that we're building this is guiding implementation that is currently ongoing actually we have people working on this implementation as we speak. So
Jeff Terrell: But the fact was this. This is the design artifact that we we created early on to guide and implementation and to iterate on what the design is
Jeff Terrell: We invited feedback from the stakeholders and clients of his project, which is kind of a bigger project.
Jeff Terrell: And, you know, Incorporated their feedback into the design. So, so this is a really valuable to have. I mean, seeing it here. You can probably understand how nice it would be if you're building an app to have screens like this, telling you exactly what it should look like when you're done.
Jeff Terrell: That said, it's not always something that developers are eager to jump into because you feel like you don't know what you're doing, you know, you've learned how to code, you don't necessarily know how to design things we'll talk about that later in the semester but
Jeff Terrell: Will we will address that concern.
Jeff Terrell: Alright, so as you could see, we were not dealing with a live app. It was a canned experience. It was pre scripted with different elements that were kind of predefined there's no dynamic anything here except what page what screen you're on.
Jeff Terrell: But it really does look and feel like the real thing.
Jeff Terrell: Doesn't it. I mean, that's it kind of feels like an app.
Jeff Terrell: Including navigation two different screens. So, you know, you really get a good sense of what this app is going to look like when it's done.
Jeff Terrell: And this is a really, really useful thing to get feedback from a client, a lot of times a client, looking at user stories, it's going to say
Jeff Terrell: I mean it sounds reasonable. It's hard for me to really see what its gonna look like. And so the feedback that they provide is
Jeff Terrell: less valuable maybe then it could be. And, you know, if they could only imagine in some detail when it looked like they could provide some really useful feedback at an early stage.
Jeff Terrell: Once exactly what a clickable prototype kind of mock the client can really get a very specific vision of what their app could look like and provide really substantive feedback at an early stage.
Jeff Terrell: That's really valuable. Again, a lot better to discover you know of course corrections and things like that early before you've actually implemented a bunch of stuff in code.
Jeff Terrell: There is a kind of a knob that you can turn in terms of what the quality of your design looks like it could be low phi kind of a wireframe kind of sketches and black and white and
Jeff Terrell: Nothing too fancy. Or it could be like a pixel perfect hi fi prototype and that's more like what you saw just now.
Jeff Terrell: Right, we talked about why this is so valuable getting a really concrete understanding to the client early and also just to the dev team can know exactly what you're building
Jeff Terrell: And of course after the output of this phase of work, invite feedback from your client.
Jeff Terrell: I talked about this already. This is a sign of for
Jeff Terrell: If you're nervous about this, we will talk about design principles as well as tools you can use, namely sigma. We'll talk about those in future lectures, before I sign up for us do
Jeff Terrell: Okay, third phase of the project narrative arc is to prototype.
Jeff Terrell: All right, I have a story to tell here when I was in high school I took a AP Computer Science course.
Jeff Terrell: And one of the things we had to do. There was some kind of a project. I don't even remember what it was about. But I know it was a collaborative project. So I was working with two or three other students. And we were trying to write this, try this program.
Jeff Terrell: And I kind of cast a vision to my teammates of like we could do like
Jeff Terrell: A UI, like a almost a graphical user interface on the command line.
Jeff Terrell: I know there are ASCII characters that you can do to like drop boxes with corners and edges and stuff. We could do that and have like
Jeff Terrell: Have it looked almost like a graphical user interface, but just on the command line. And, you know, everybody was getting really excited about this. And we started working on it.
Jeff Terrell: And it was just a dismal failure.
Jeff Terrell: It was a disaster. What happened was we were working hard and everything. And I was, I was working on the gooey side of things and trying to get all this box drawing code figured out
Jeff Terrell: And I thought, you know, things were not shaping up the way that I thought they should. But we can just stay up all night the night before and get it done and
Jeff Terrell: Everything you know will be will be the champions of this. Not that anybody was really competing but will be the will have the best the best solution to this problem.
Jeff Terrell: Of all the teams. Well, I think. Finally, about two or three in the morning. I finally threw in the towel.
Jeff Terrell: It was just not coming together and this is before energy drinks were really a thing. So there's only so much Mountain Dew and Dr. Pepper. You can drink it a night.
Jeff Terrell: For you just crashed in the sugar but um but yeah we failed, and I think that one of the main reasons we failed actually was because
Jeff Terrell: We were each working on our own thing. And first of all, we butt off too much. Alright so that was there's definitely that but
Jeff Terrell: The failure. I want to talk about right now is that we were going to just connect everything together at the end. So I was working hard on just getting the basic box drawing stuff working
Jeff Terrell: And we thought, Okay, once I have stuff working, then it'll be easy just to connect it up with the code that everybody else has written to guide the logic of what we're doing.
Jeff Terrell: And that was a big
Jeff Terrell: That was, that was part of the reason we failed. I think I didn't even get my stuff done in time, let alone get to a point where we could integrate
Jeff Terrell: So,
Jeff Terrell: So this is kind of a thing that can happen though and software products. This is not just me that has made this mistake.
Jeff Terrell: A lot of people are tempted to just go off and try to implement all the different pieces and in a certain way, it makes sense to wait until everything is working individually before you connect it together in the end.
Jeff Terrell: But this often is a really bad idea for a couple of reasons.
Jeff Terrell: One problem is that the client can't see the app as it's being built. And so, can't give any feedback. The feedback loop is destroyed when you go this route.
Jeff Terrell: Because there's nothing for the client to see, they can't really look at one component in isolation or look at, you know, one module of your code and the tests that passes that doesn't really give them any sense of the overall app and what it's going to look like.
Jeff Terrell: Or what the progress is looking like relative to the goal and other problem is that this is stressful.
Jeff Terrell: You know that you have this integration thing thats hanging over your head and you're hoping it's going to go well, but it might not.
Jeff Terrell: And you might realize. Once you get to the end that you were assuming one thing as you wrote module. A your teammate was assuming something different.
Jeff Terrell: When he or she wrote module be and the module and module, we don't talk to each other. And it's just miscommunication. It's not necessarily anybody's fault but
Jeff Terrell: Then you got to somebody you're both. Both sides have to kind of shift their end until they can figure out how to talk to each other. So that's stressful.
Jeff Terrell: And in the end, you might fail to deliver anything useful. What can often happen is you think integration is going to be easy and you don't allocate that very much time to it.
Jeff Terrell: There are often this you know integration is where the bugs appear
Jeff Terrell: To are a lot of bugs appear. So a lot of times, it would be easy. If there were no issues and no mismatches between abstractions and different things like that. But you find all those things when you integrate and so it ends up taking a lot longer than you anticipated.
Jeff Terrell: So my general advice to anybody working on software is to integrate first to create what what I call a walking skeleton. I got this from the company I worked at last I don't know how widespread that term is but
Jeff Terrell: Create a walking skeleton. The idea of this is that you integrate the front end the back end the database infrastructure and everything before you start adding all of the features.
Jeff Terrell: So you get the front end talking to the back end, you get the back end, talking to the database, you get everything deployed, but the front end and the back end deployed somewhere so that the client can actually see it.
Jeff Terrell: If you, if you've integrated with infrastructure. That means the client should be able to get to your app and see it.
Jeff Terrell: And this is done before you add features. So there might be 20 features that you need to add after you've finished the walking skeleton walking skeleton is just
Jeff Terrell: The end to end functionality, just as bare bones as you can possibly make it just to show that everything is talking with everything else correctly.
Jeff Terrell: Now that is challenging, but doing that early means you're not, you don't have a big body of code that you got to wrestle with to get talking, you have a relatively small set of code that you just try are trying to get integrated
Jeff Terrell: And once that's done, you can develop with confidence because you know you have something deployed that is functional. And if you broke something along the way. And now the front end doesn't talk to the back end correctly.
Jeff Terrell: You know that it was your code that you just have been working on that. Did it broke it, because it was working before it makes things a lot easier because if there is a bug. You have a lot more constraints sense of where it is.
Jeff Terrell: I'm also having a deployed means that you can invite feedback along the way from your client.
Jeff Terrell: Did you know, does this look good so far. We finished feature x. We haven't even started y&z but now you can see feature x and the the live deployed app. What do you think
Jeff Terrell: So this is, this is great.
Jeff Terrell: This is hard.
Jeff Terrell: It is hard, but it's worth it if you tackle this sooner. You will avoid your future self cursing you
Jeff Terrell: You'll be glad you did. But it is hard and I i've said, my advice is to integrate first to create a walking skeleton. But I require that of you and this semester.
Jeff Terrell: It just makes everything goes so much better than everybody scrambling at the end. Everybody's stressed out and things are not working, etc. So just trust me.
Jeff Terrell: I'm doing this for your good but it is it really does work out better
Jeff Terrell: Questions about that.
Jeff Terrell: Okay, as a concession you, you may omit the authentication piece from the walking skeleton. Sometimes that can be a little bit complicated. If you can fit that into the walking skeleton awesome but
Jeff Terrell: If you need to leave that out for the purposes of assignment eight, you can. How does the actual logging in and user registration and stuff like that work.
Jeff Terrell: Alright, so now that we've understood what's needed. We've storyboard we prototype.
Jeff Terrell: Now we just iterate on features. And this is actually
Jeff Terrell: Kind of easy with a clickable prototype done you know what you're building what it should look like, what the walking skeleton on the foundation is laid a deployment is a known quantity
Jeff Terrell: You've already, you already have a deployment story that works. And so it's relatively easy just to crank out features and it's hopefully fairly parallelizable so that multiple people on the team can be working on features at the same time kind of stepping on each other's toes.
Jeff Terrell: Note that you probably should not consider a feature to be done until it is deployed for the client to see so deployment is part of the implementation of a feature.
Jeff Terrell: And really a feature is not done until the client is actually approved that it meets with their satisfaction, at least for now.
Jeff Terrell: The client ideally should be providing timely feedback, either. That looks good on features that you've deployed and submitted for their approval or else they have some sort of request for something to change.
Jeff Terrell: Also, don't forget to add tasks as you implement features.
Jeff Terrell: And that's what assignment 11 is intended to address.
Jeff Terrell: Now, many people many projects in contract 23 will not get to a launch phase. That's okay. But if you do
Jeff Terrell: The idea of the lunch faces that this is when you're releasing it to
Jeff Terrell: To the users of the app, whatever that is.
Jeff Terrell: You've already deployed on your code that step four is your iterating and even. Step three. As you were kind of walking skeleton you figured out how to deploy your code and you catch deploying it as you created it.
Jeff Terrell: So that launch is not about deploying code somewhere. It's actually about releasing it to where users can use it.
Jeff Terrell: And that might just be like, alpha and beta users at this point.
Jeff Terrell: But the fact that you can get it in their hands means that you can get more feedback on the app that you built
Jeff Terrell: This can uncover bugs and issues just getting that diverse set of perspectives from all the different users of the app. So that's pretty valuable.
Jeff Terrell: Like I said not often something that happens in conflict 23 but if you can get there for your client. That would be awesome.
Jeff Terrell: And this often requires more of the client than the developer maybe coordinating alpha testers getting feedback from Alpha testers understanding does the app meet the needs of those users. That's really something that your client should do more than you.
Jeff Terrell: But the client might need your help to get this done. So, for example,
Jeff Terrell: building the app and publishing it in the app store might be something that you need to do for your client, although your client will need to then
Jeff Terrell: Fill out the screenshots and the description and various other things for you know the overall App Store entry and that kind of stuff. So just for mobile apps, it's also for web apps.
Jeff Terrell: There's some steps that you might need to do. There's other steps to the client will need to do. But anyway, that can be a conversation between you and your client.
Jeff Terrell: Questions about iterating or launch. I think both of those were fairly straightforward, but
Jeff Terrell: No questions so far all the quiet today.
Jeff Terrell: Finally, hand off your project to your client at some point at the end of the semester, you're going to need to say
Jeff Terrell: Good luck. I'm out. You know, I'm I've completed the semester I have completed this course.
Jeff Terrell: Maybe you'll be interested to keep working with your client, you're certainly welcome to do so. Some clients might even be interested to hire you on afterwards and actually pay you to work on the project. That'd be a nice bonus if you're if you wanted
Jeff Terrell: But I expect that most of you will say, Okay, this is a good learning experience. But I've got other things to focus on now. So
Jeff Terrell: And even if you don't even if you know you're going to keep working on it. You need to make sure that your client and everybody else who might work on the app in the future is is able to work on it without a lot of headaches, so
Jeff Terrell: For one thing you'll want to write a README file with everything that a computer science friend of yours would need to know to start working on this project.
Jeff Terrell: So that's kind of a developer oriented read me. This might talk about the technologies that you use the way that you've laid out the code. The way you know any sort of
Jeff Terrell: coding style conventions that you might use
Jeff Terrell: The state of the tests and, you know, technical debt, stuff like that. That's assignment 12
Jeff Terrell: And then write another document, preferably stored in the repository that describes the project to your client paying attention to where the code lives.
Jeff Terrell: And where the various application components and services live and that's assignment 13 so where stuff deployed, who has access to that infrastructure, who's paying for that infrastructure. Hopefully it's your client.
Jeff Terrell: And just everything that the client might need to know about how to actually sort of give this to another developer and how do I manage this happened. Ongoing basis.
Jeff Terrell: And share the overview with your client and ensure that they have access to the code.
Jeff Terrell: If the client doesn't already own the infrastructure, then you'll need to make sure that it is transitioned to be owned by them so that you know the app stays running as long as they're paying for it.
Jeff Terrell: By the way, my intention for this class is that you should not have to pay anything to anybody to participate in this class. Sometimes you might need some sort of infrastructure that is not free. That is paid.
Jeff Terrell: That should be something that your client pays for you and I have
Jeff Terrell: I think there might be one or two clients who expressed some hesitation on that front. But I think almost every single client has said, Yeah, we can cover modest costs up to like maybe 20 or 30 or maybe as much as 50 bucks a month so
Jeff Terrell: So keep that in mind as you're working on projects that you should not have to pay for any sort of infrastructure.
Jeff Terrell: So in summary of the project narrative arc. First step is to understand what's needed create those user stories and invite feedback.
Jeff Terrell: Then you create a clickable prototype to capture what the design of the app should be and invite feedback.
Jeff Terrell: Then you create a walking skeleton to enable feedback.
Jeff Terrell: So integrate and deploy the front end and back end database first and the client should be able to see and use the fledgling app.
Jeff Terrell: And then iterate on features and advise feedback.
Jeff Terrell: Optionally launch and invite feedback.
Jeff Terrell: And finally, hand off the project and invite feedback. Hopefully, you see the theme here feedback.
Jeff Terrell: Okay, so that's always going to talk about what the narrative arc of a project. If you have any questions.
Jeff Terrell: post it in the chat or interrupt me
Jeff Terrell: But otherwise, let's keep going. I want to talk about working with clients.
Jeff Terrell: I had a sense that my slides were a little bit on the long side, I am going to try to my skip a few things here to try to keep this in time. So I'll try to move a little bit fast.
Jeff Terrell: Clients are connected with some need that software might could meet, they might not even know whether software can do what they want or not, because, generally speaking, most of them are not experts in software.
Jeff Terrell: You, however, are the software expert, you have some software development skills.
Jeff Terrell: So this can be a fruitful collaboration. If a bridge can be built between these two worlds.
Jeff Terrell: And I want to talk about how to build that bridge, what you can do and what some dysfunctions of that kind of relationship could be and how to avoid them.
Jeff Terrell: All right.
Jeff Terrell: First of all, we're going to talk about the bridge from kind of two angles. I'm going to focus on your responsibility here and a little bit lesson for now on the clients responsibility.
Jeff Terrell: Because you're in control of you.
Jeff Terrell: But let's talk about sort of from the client's perspective what the client brings to the relationship. Your responsibility is to understand the need that the client brings
Jeff Terrell: Some of the questions that you might need to get a good handle on are just. First of all, what is the need
Jeff Terrell: What does the client want here, what would they like to have. What is the pain that the client feels or maybe the client is representing some other kind of user that feel feel some sort of pain.
Jeff Terrell: Why is this idea or this project important
Jeff Terrell: Is there some sort of, you know, social or cultural significance, maybe that the software might have
Jeff Terrell: Who would actually benefit from the software.
Jeff Terrell: Who are the users and the different kinds of users.
Jeff Terrell: Who are the different people that need to use the app in some different capacity. Maybe you need a separate administrative type user rather than just a regular user.
Jeff Terrell: And also, just as you understand the need better you'll get a better sense of what range of things would meet the need
Jeff Terrell: So it might be as you understand what they really need. You say, like, Well, you know, I think a spreadsheet would actually serve you well here.
Jeff Terrell: Or maybe a trailer board would would serve you well. And maybe the combination of those two things would be everything that you need. Maybe, maybe it wouldn't be as nice. In some ways, as some really good custom software but sure would be a lot simpler and
Jeff Terrell: cost less to build
Jeff Terrell: So, those can be conversations you have now I've, I've kind of done a lot of that vetting already so I know that what the clients are wanting that are actually pitching their ideas.
Jeff Terrell: Are reasonable for this class, but I'm just pointing out here as you understand this need better. You might come up with some creative solutions to some of these different kinds of needs. So one example of a creative solution. I have a brief story to tell you about
Jeff Terrell: I was I've been working on an app that summer.
Jeff Terrell: I like to kind of stay sharp and it's nice to be able to do some freelance work on the side like some extra money, but some this app that I'm working on. There is, there's an issue that we've been encountering recently where
Jeff Terrell: One element of the page is kind of outside of my control. It's like this iframe embedded sort of thing and the code that's outside of my control focuses the one of the form fields inside that iframe.
Jeff Terrell: And it pulls the, the whole web page down to that component which is at the very bottom of the screen. Have a lot of different features a lot of different you know UI on that page.
Jeff Terrell: And it's really disruptive and distracting and I can't turn that off. It's outside of my control. So I kind of raised this to my clients attention and said, yeah, there's this issue here actually
Jeff Terrell: I should have raised their attention they they sort of brought up the issue I failed to bring that up but
Jeff Terrell: Um,
Jeff Terrell: Any case. I said, yeah, here's the deal. I've tried to fix this. It's out of my control. I think you need to talk to your other developer who managed that side of things.
Jeff Terrell: So they talked to them and the other developer had a good idea. Why not just put that particular iframe that embedded thing over on a different page.
Jeff Terrell: And separate it out from all of the other components that came before it in the page so that it doesn't disrupt those things. I haven't thought about that.
Jeff Terrell: But a lot of times, as you understand what the actual need is you might say, oh, I, you know, maybe there's a creative solution here that can meet the need, even though it's not what the client initially pitched
Jeff Terrell: This would be just yeah understanding is there a need under the need, is there some underlying need that you could solve with some creative way.
Jeff Terrell: So another example of this that I thought, This isn't a something that I've actually encountered. But imagine that you are building an app for clients that they were really concerned about who would have access to this app and they wanted to really lock that down and control it tightly
Jeff Terrell: They might imagine that what they want is an admin panel or certain administrative users could control a whitelist of who's actually allowed to use the app. So if a user tries to sign up and they're not in the approved whitelist than they are not allowed to use the app.
Jeff Terrell: Okay, yeah, that would work that would meet the need, but the underlying need there is actually
Jeff Terrell: I just want to restrict use of this app to a certain set of users, the underlying need it you know the the fundamental need is not an admin panel, the fundamental need is to restrict the users.
Jeff Terrell: So maybe it'd be a lot easier in terms of implementation to just have a
Jeff Terrell: Completely take out self registration users cannot sign themselves up for the app rather
Jeff Terrell: One user or or maybe any user can invite other users to use the app.
Jeff Terrell: And in which case the invited users get an email with an unmissable token and can then sort of complete the registration or whatever.
Jeff Terrell: And that would mean you wouldn't have to do the administrative panel, you wouldn't need to manage a whitelist you would need to even support registration like self registration of users. So sometimes finding those those
Jeff Terrell: You know, identifying what those underlying needs are Can really unlock some some time savings some complexity savings.
Jeff Terrell: Alright also me to build a bridge to the client. From your perspective, so you need to educate the client about software.
Jeff Terrell: Sometimes clients really just don't have a sense of what software can and can't do,
Jeff Terrell: And also there's they're probably not going to know what kinds of things are within the reach of your skills.
Jeff Terrell: Probably your mentor has experienced the most if not all of these, or at least has an idea what to do in these different situations.
Jeff Terrell: So this is, this is exactly what you should be talking about with your mentor. If you encounter anything like this or if you're concerned about anything like this based on things that you've seen
Jeff Terrell: Okay, keeping an eye on the clock here don't see any questions so far.
Jeff Terrell: I'm either really boring and everybody's asleep or else I'm covering all your questions already, but I will choose to believe the ladder.
Jeff Terrell: Right constraints and trade offs.
Jeff Terrell: Okay.
Jeff Terrell: A trade offs are really fundamental and this is a critical thing, both for you and your client to understand
Jeff Terrell: There's, there are a lot of trade offs that come to the surface. Whenever you're talking about any substantial creative project, including software projects.
Jeff Terrell: So as as one example.
Jeff Terrell: Maybe your client wants one interface element to be higher up above the fold, you know, more, more visible.
Jeff Terrell: And so they want to push it up to the top of the screen or near the top of the screen. Well that pushes other elements down right so maybe something that was about the fall can no longer be above the fold.
Jeff Terrell: There's only so so much to go around of screen space.
Jeff Terrell: If you make everything highly noticeable then that can drain users attention. The attention of users is a finite resource you can exhaust it
Jeff Terrell: If you want a really fast server, it's going to cost you. Right. It'll cost more.
Jeff Terrell: If developer spend more time working on feature a there's less time working on features P through z.
Jeff Terrell: In other words, developer time is also a finite resource that can be exhausted.
Jeff Terrell: So these trade offs and plenty more besides are due to constraints constraints on screen space constraints on user attention constraints on money.
Jeff Terrell: And client budget constraints on developer time and so on developer time is one of the big ones that you're going to wrestle with. And that's, that's a very
Jeff Terrell: Important topic of conversation to have with your client on an ongoing basis.
Jeff Terrell: Wrestling with screen space and user attention is something that you wrestle with primarily in the design phase as you're working on your clickable prototype.
Jeff Terrell: But any sort of designed activity is navigating various constraints and that's where these trade offs are really noticeable.
Jeff Terrell: So the key insight here is that these are finite resources that can be exhausted and so there's an economy of these things. If you use it for this. You can't use it for that. And that's where the trade offs come from.
Jeff Terrell: So a good developer that works well with the client is going to be able to illuminate what these trade offs are
Jeff Terrell: And a good client will listen and respect what the trade offs are and and understand that.
Jeff Terrell: You made a choice to spend that resource on a so you can't spend it on be, you know, remember you already spent some of that on a
Jeff Terrell: So I can't do before you unless we go back and revise what as
Jeff Terrell: Okay, so being able to eliminate these trade offs in ways that makes sense to clients, especially non technical clients is a skill that hopefully will develop time
Jeff Terrell: Um,
Jeff Terrell: Speaking of time. I'm debating whether I'm gonna have time to talk about this. I think I'll come back to this. If I have time. I'm not sure that I'm gonna have time to really get into technical debt, but it is something that I
Jeff Terrell: I hope to cover probably doesn't need to be covered right now but
Jeff Terrell: Yeah, let's move on for now. Alright.
Jeff Terrell: Picking a project. So we talked about narrative arc of the project. We talked about ways to work with clients and how to do that effectively, at least at a high level, you'll probably understand that a lot better than more experience you have with it. I hope this course will help you
Jeff Terrell: Work with clients in a more effective way.
Jeff Terrell: Any questions on what we've covered so far.
Jeff Terrell: Okay. Not seeing or hearing anything
Jeff Terrell: So let's talk about picking a project.
Jeff Terrell: There's a lot of ways to rank projects and a lot of different things to value about different kinds of projects and pitches.
Jeff Terrell: One thing that you might value is clarity of the proposal.
Jeff Terrell: Could you really understand what the need was
Jeff Terrell: If not, maybe that's what's interesting to you want somebody who has kind of a well thought out idea and
Jeff Terrell: Nice and sort of well defined with clear boundaries on what is part of the project and what isn't.
Jeff Terrell: Maybe you value maturity of the idea
Jeff Terrell: We have occasionally had clients who already have UI designs for maybe even as much as a clickable prototype for the app that they want to build
Jeff Terrell: This would be a fairly mature product idea. I don't think any of the clients that are coming to pitch over the next two class periods have clickable prototype or UI designs in place already
Jeff Terrell: That is something that I recommend for non technical people who want software written is that they spend some time thinking about what the design should be learn how to use a tool to create a clickable prototype and spend some time navigating so those constraints on the design space.
Jeff Terrell: That's something that you can do even if you don't know how to write code, but I don't think any of the clients that we've invited
Jeff Terrell: This semester have this already, but I mean it's kind of nice right you have somebody who's already done that kind of work for you knows exactly what they want.
Jeff Terrell: That means you have less creative input on the design side of things. So you might not want an idea to be so mature that already has those things. But then again, it might be nice.
Jeff Terrell: You might value just does this client look like somebody I can have a healthy working relationship with and not fall into some of these dysfunctions that I mentioned earlier.
Jeff Terrell: Does a client seem flexible like they can kind of roll with the punches and you know this feature that they are really excited about. Maybe if I tell them this is going to be a fairly expensive to feature in terms of developer time to implement
Jeff Terrell: Are they going to
Jeff Terrell: throw a fit. Are they going to be super disappointed and lose interest in the project or can they kind of roll with it and say, well, okay, that's a bummer. But okay, let's, let's just keep moving and figure out what we do from there.
Jeff Terrell: Are the reasonable if you got less done than you kind of plans to or that who conveyed to your client, the expected to
Jeff Terrell: Which is probably going to happen at various points, by the way.
Jeff Terrell: Does the client seem reasonable about it. Are they trying to
Jeff Terrell: You know, hold your feet to the fire and today. But you said you would get this done. I'm really angry about this or whatever, or are they going to be kind of like okay I get it, you know, things happen. You don't have a crystal ball. You can't predict the future.
Jeff Terrell: You know, are they are the reasonable and friendly.
Jeff Terrell: You might value social impact of the project, there might be an idea that really resonates with you. And there are some of these ideas in the field of pitches. I can think of one off the top of my head that could have some pretty significant social impact.
Jeff Terrell: That might be something that really attracts you to the project and you say, I don't care how reasonable a client is. I don't care what kinds of technologies, I have to learn
Jeff Terrell: I really want to have a part of this. This is meaningful.
Jeff Terrell: You might care and this, this might come across as kind of crass. But I think it's cool, you know i'm i think it's a valid reason to pick a project.
Jeff Terrell: Just what connections or influence does the client half. Could they hire you. After the semester is over, you know, do they represent a company that you might want to work for
Jeff Terrell: Do they maybe, are they interested in hiring you as a freelance developer after you get done. Or maybe they have connections to somebody who would hire you, or something like that. I think that's legit to prefer those kinds of projects that that's what your goal is.
Jeff Terrell: Maybe in a similar vein, you're interested in projects that that look impressive and sound impressive in your portfolio as you're going around and trying to get a job doing software engineering
Jeff Terrell: Maybe there are particular technologies and tools that you either like and prefer or you would really like to learn and at your resume.
Jeff Terrell: Maybe, especially if you're pretty busy or you are on a team that expects to be pretty busy. You might value how available, the client seems to be, are they like the CEO of a startup and they're not going to be super available or
Jeff Terrell: Are they do they look like they're actually going to have a time to answer questions and things like that.
Jeff Terrell: So as I mentioned, the next two classes are pitch days. This is going to be
Jeff Terrell: There five, you're going to pitch your idea ideas six minutes each. Back to back all class period I shouldn't say all day but all class.
Jeff Terrell: So these pitches will be a blur. By the end of the day, and by the end of Monday, especially so I recommend thinking before class on Friday about what's important to you and writing up a quick rating sheet to rate each pitch immediately afterwards, while it's fresh.
Jeff Terrell: This will counter a natural bias that I've experienced and maybe you have to where you either prefer some of the first pitches because you were mentally alert and fresh. At that time, or the last vicious, which are the ones that are kind of most recent in your mind.
Jeff Terrell: So if you have that reading sheet to counter that bias.
Jeff Terrell: Okay, so two more things here. I want a quick poll about whether to have a pizza.
Jeff Terrell: Instance for this class, I suspect, we've all used pizza and any so introduction
Jeff Terrell: Now a few things to note about this before I open the poll every project is different. So you're less likely to get help from other people. All right. It's not like everybody's working on the same assignments.
Jeff Terrell: But maybe it's something that you used to maybe it would be a nice place to be able to ask questions. Remember that the app lab exists for you to be able to answer or ask technical questions and get help.
Jeff Terrell: You will also be meeting with your mentor. So you have some resources already to be able to ask questions. But maybe this would be nice to have as well. I don't know.
Jeff Terrell: I'm also the thing that the reason I wanted to ask this question now is because yes it could be a useful tool to try to find partners. If you're looking for partners, you could say, for example, I really would like to work on a swift or a swift app for iOS, mobile, mobile apps.
Jeff Terrell: It's really my my interest and there are some of those projects which, by the way, require you to have Mac OS hardware. So not everybody will be able to work on those very easily.
Jeff Terrell: But, you know, if you're looking for a project like that and you don't have somebody else in mind, who is also looking for that it might be, it might be useful place to go for that.
Jeff Terrell: So let me open up this poll
Jeff Terrell: And invite your feedback on that.
Jeff Terrell: Feel free to ask any clarifying questions about this if you're, if you have clarifying questions.
Jeff Terrell: Wonder if I can see
Jeff Terrell: Wanted to be able to see like a histogram of his choosing what but
Jeff Terrell: I'm figuring out how to do that.
Jeff Terrell: Okay, so if you're finishing that up. Go ahead and finish it up and I'm going to keep moving here I'm just got one other thing to cover
Jeff Terrell: I'll leave that whole active so you can keep working on it. All right. Last thing I want to cover is assignment zero which is your pitch preferences.
Jeff Terrell: I see a question from Daniel. Let me get to that. Just a second.
Jeff Terrell: Pitch preferences. The right up is on the websites. It is do basically week from now, next Wednesday. But at 8am.
Jeff Terrell: And I'm going to try to get all of your team assignments and client assignments figured out that morning and then tell you. By the time we meet in class, a week from now, what your team assignment and client assignment are
Jeff Terrell: Here's an example of the email that you will send to me, potentially copying team members that you want.
Jeff Terrell: You can either prioritize a team preference or project preference, meaning that some of you are going to, it's going to be more important to to work with certain people than it is to work on certain projects.
Jeff Terrell: And if that's the case, you would say that you prefer to prioritize the team preference. And of course, tell me who your team is
Jeff Terrell: Otherwise, if you care more about working on a project that's interesting to you, then who you work with, then you would say you prefer to prioritize the project preferences and you would give me a list of project preferences.
Jeff Terrell: Projects will be coded by letter A through what, however, however, however, high we get and you'll just say like a, b, c, d, whatever, whatever your preferences are.
Jeff Terrell: will indicate to me whether you're comfortable with IP assignment and confidentiality agreement, as we discussed with Peter this earlier this class session and then
Jeff Terrell: If you have any preferred teammates, you would list those and copy them on the email that you send to me again that's by Wednesday 19th at 8am.
Jeff Terrell: If you have any questions about that.
Jeff Terrell: Oh, sorry. One of the thing. Some of you are interested in a team of four.
Jeff Terrell: You can submit a team of four at your own risk. I may break it up, depending on kind of how the numbers fall out.
Jeff Terrell: But you're welcome to do that. In fact, if that's really what you want. I would encourage you do that if you want to say.
Jeff Terrell: Contingency plans. Like if you need to break us up. We would prefer to be broken up into two groups of two or
Jeff Terrell: One group of three and one person split off elsewhere. You feel free to say those things I will try to take that into account. There are a lot of variables that I'm trying to juggle here with us, but I'll do what I can.
Jeff Terrell: And if you don't say it. Then I can't take it into account. So might as well say it.
Jeff Terrell: One of the thing is, please don't drop the class after you submit this assignment.
Jeff Terrell: It's really gonna, we're gonna have to juggle things around, potentially, to make that work if you drop the class afterwards. So if you're thinking about dropping my class, try to decide before Wednesday at 8am.
Jeff Terrell: So there's that. Alright, so I have some I see some questions in the poll on the chat. I'm just going to go through those
Jeff Terrell: So Daniel asks in a class this semester we are using campus wire and it seems similar to pizza but you can do other things like create group messages direct messages cetera maybe this would be worth looking into. Since this class is large group oriented.
Jeff Terrell: Potentially, I think I got an email about that I haven't had time to look into it. I'm probably not going to look into it, to be honest, it might be something I
Jeff Terrell: Groups are welcome to use whatever they want. So each team, you can use Canvas wire if you want. Or maybe you can't, I don't know, maybe has to be sign up for class wise.
Jeff Terrell: But, sorry I'm not gonna have time to look into that.
Jeff Terrell: But I do appreciate the idea, though.
Jeff Terrell: Some of you weren't able to submit the poll
Jeff Terrell: That we should have been available@polivy.com slash Jeff Terrell
Jeff Terrell: And the course website. I see. Also, another
Jeff Terrell: Somebody sent the poll closed.
Jeff Terrell: And sure enough, it did. I'll reactivate it. I don't know why it would have closed itself, but should be active again polivy.com slash Jeff Terrell
Jeff Terrell: Right. Andrew posted the URL off the website com 523 yes yes at UNC edu.
Jeff Terrell: And
Jeff Terrell: I think that's all the questions. Anybody else have questions.
Jeff Terrell: Okay. Sorry, I just realized I took you a couple minutes over class. Sorry about that.
Jeff Terrell: If you do have questions, I'll hang out just for a minute or two and
Jeff Terrell: Otherwise, I'll see y'all on Friday for client pitch. The number one.
Jeff Terrell: See ya.
Jeff Terrell: Hey, welcome.