haas:spring2016:hpc0:projects
Table of Contents
Corning Community College
CSCS2320 Data Structures
Assignments, Documents, Information, and Projects
Projects
Class Stats
Project FAQs
Week 13
- End of Course Experience released! Check the bottom of your Opus.
- Note that you must be signed in to view/edit it.
- eoce0 project, after 2 released updates, now starts to compile and operate as expected. Still likely a few more updates upcoming, but we may be at a point where you can commence implementation.
- mktree() functionality now provided (should be all you need to commence work on addnode() and traverse_s()).
- Project pages for the tree part of eoce0 and the entirety of eoce1 are now available.
- The eoce1 project is now available.
- Starting next week, the IPKA (In-Person Knowledge Assessment) will be available.
Week 12
- dll1 results are in- surprisingly, less challenging than dll0 (when you look at the numbers). Also, fairly on par with the fall2014 class (they have a slight but consistent edge).
- work on the stack project is underway, I've had some good questions already. Please, keep them coming.
- queues (dlq0) will be the new project for the week… and will be very similar to stacks.
- dlq0 may be the last weekly project before the EoCE.
- Speaking of the EoCE: I plan to deploy it upon our return from break.
- Because you deserve nice things: I extended the dls0 due date until Wednesday, December 2nd, 2015 (same as dlq0). Note that dll2's due date remained unchanged (and I am not planning on adjusting the due date of dlq0). Hopefully this gives people the opportunity to get stacks figured out, as well as queues (both are rather important).
Week 11
- We're nearing the end of our active list explorations. It has been a long journey, fraught with frustrating logic errors, lots of debugging experience, and a whole lot of time. I have been very pleased with the progress I see from so many.. don't just look at things at the moment, look at how far you've come. There have been some truly amazing improvements.
- Another 2 project week:
- dll2: adding qty to your list implementation, upgrade to display()
- dls0: stack implementation (on top of list)
- I evaluated dln0 and dll0. A few surprises:
- more than a few of you seemingly forgot to submit dln0. You had fully working projects, but just didn't officially submit it. I manually handled it. This time.
- dll0 was simultaneously more difficult for some, yet easier for others. Those who have been doing well seemed to get hit, whereas those who have been catching up had some real breakthroughs.
- Some dll1 observations:
- be mindful of the second (prior) pointer. Just because you've done something before in singly doesn't mean the implementation is guaranteed to be easier (especially if you're not mindful of such details). I'm not saying it is harder, merely: it isn't like the singly version. The same concept is there, so if you have an understanding, that part won't be in your way, but if you aren't drawing pictures and stepping through the logic, the extra pointer will get in your way, turning an otherwise simple operation far more complex.
- all sorting does not require swapping. Only some sorts use swaps. For those having trouble getting swap to cooperate with your sort attempts, you can either fix swap (a worthy pursuit, if not rushed), or go about sorting in a different way.
- don't go and look up existing sort algorithms, that's probably how you got to this issue in the first place. Plot out how you would accomplish a sort… work through the logic. Following the algorithm someone else made vs. figuring out one on your own? The latter will produce understanding at a much higher rate.
Week 10
- Can you believe it– week #10!
- We continue our linked list reimplementation, with dll1.
- with doubly linked nodes, your implementations should be simultaneously simpler and more complex (simpler because you don't need as many extra steps to set things up, more complex because there are twice as many pointers to connect!)
- remember: draw pictures, work logic out on paper, get plenty of sleep, and use the debugger!
- I mean it: don't pull last-minute all-nighters with this stuff- the more tired you are, the less sense things will make. Brute forcing it will not help.
- you are quite capable in accomplishing all that is at play, and to grow considerably as a developer (and isn't that the overall point)?
- sll3 and sll4 have been evaluated
- some seemed to have a late start on sll3, not understanding its basic premise
- sll4 saw some interesting trends:
- appeared more difficult for some (maybe they got too used to nodes as a tool and not as a concept?)
- for those who saw the commonality, they seemed to make rather quick work of it
- while sll4 was a more involved project than sll3, many did better on sll4 than they did on sll2 (the next most involved project)
Week 9
- Doubly-linked stuff is unveiled this week, and it kicks off our first rebuild (second implementation of code).
- Please strive to do a fresh implementation, a lot of the singly-linked stuff is riddled with your learning, and you should continue your learning by giving it an honest go (not to mention most of your previous code will not be compatible without heavy changes).
- Course status has been moved into its own status page, and updated. Check it out for some interesting hints at trends.
- As past trends seem to indicated, sll2 was a more challenging project than some previous.
- At the same time, we seemed to fare much better than prior semesters, and many problems were actually expected as part of the learning process (sll2 relies on past code more than previous projects, so it routed out more bugs that were previously uncaught).
- Conversely, this project was the watershed moment for a few people who achieved their enlightenment. Quite interesting results all around.
- So don't despair! Many who had trouble were doing some amazing things– improving debugging skills, fixing sloppy code… those things only serve to improve your skills.
Week 8
- A few people took advantage of the break and got an early start on things. I thank you for that.
- Graphs are still graphing, so be sure to check out the metrics page for sll2 (and then sll3/sll4 as more people start working on them) for neat class visualizations.
- People are still reinventing the wheel unnecessarily. Please remember, you wrote other functions for a reason.
- People are still not drawing pictures. You NEED to draw this out… that blank uncertainty when you're not sure how to proceed? Pictures will help. So will the debugger when you've got code (but pictures should be utilized throughout).
- Rigging up solutions based on counting will naturally make the code more complex. It is familiar and comfortable, but that doesn't mean it is the best way. Try solving these problems without counting (the only time you ever need to bother with counting is displaying the list with position values, and then really only with displaying backwards). Pre-counting the list is a performance hit.
Break Week
- I have evaluated sll1! No real surprises, and I think everyone actively working on the projects are starting to get a feel for what is going on.
- results show we're pretty much on par… class average is still in the 70s, submit rate holding at 80%.
- I will be submitting warning grades today (Sunday, October 11th, 2015). Generally, those who are doing the work AND keeping up with their opus are doing well, but the opus is killing some people. Don't be surprised if you get a warning grade because of a deficient Opus.
- We're already off to a decent start on sll2! I've updated the metrics page some more, to include another graph. Be sure to check it out!
- I evaluated sln0! Now we're entirely up to date… I'm going to go through and do an Opus check, to try and catch any outliers, and then submit warning grades.
- I reserved giving a warning grade of D as a “shot across the bow”… if you happened to have otherwise been passing, but I suspect problems are afoot, that is what I gave. If you are having trouble/not passing, well, you got a step lower. But, seeing as these are warning grades, and don't actually count, hopefully it'll provide us with an opportunity to right various wrongs.
- I am pleased to say that the class as a whole is looking pretty good.
Week 7
- Wow, week 7! We're almost half-way through the semester… just a few weeks ago we passed the 1/3 point. And look at all the progress we've made!
- You are your own worst enemy once again, it seems. A number of people have been struggling with append(), until they see how simple it is. Remember:
- draw pictures
- don't look at code, focus on the process
- sll2 is making an appearance this week, enabling us to complete our singly linked list implementation. Historically, sll2 tends to give tired/closed minds more grief, so be sure to get plenty of rest and keep an open mind about effective solving of the problems it throws at you.
- I got metrics pages up for both sll0 and sll1; and because it is all in one nice streamlined script, sll2 will instantly be included, so if you're a fan of seeing all the generated data being visualized, enjoy!
- I've decided to give you next week (October 12-16) off from your classes (you're welcome). But, so that you don't end up going through withdrawal, I have decided to release the next round of projects after sll2 a week early. And, if you've noticed, sll2 isn't due until the following week. This means:
- you have 2 weeks to work on sll2
- you have 2 weeks to work on sll3 and sll4
- sll3 is a small transition project, adding some new specifications to our linked list to make it compatible for use in sll4. The intent is that sll3 and sll4 are grouped together (do sll3 first, then move on to sll4).
- If you have a working list implementation, sll3 should not take that much time at all.
- If you don't have a working list implementation, look at sll3 as a “second chance” to get it right.
- sll4 takes us to some new heights… beyond linked lists! Actually, it will enable us to interact with multiple lists (just as a linked list lets us interact with multiple nodes), through the creation of “singly linked lists of singly linked nodes” with the addition of a new group struct (to have groups of lists).
- with that said, the list we've been working on in sll0, sll1, and sll2 would more accurately be called a “list of singly linked nodes” (singular on list, plural on nodes). With sll4 we merely pluralize that.
- If you liked dsi0 and the detail-oriented aspects of sln1, sll0, and sll1 (ie you are more of a hands-on/detail-oriented person), you should find familiarity with sll2 and sll3.
- not that sll2 and sll3 are devoid of new concepts… after all, we're finishing the list implementation in sll2.
- If you liked the more conceptual aspects of nodes and lists (sln0, sln1, sll0), figuring out the unique approaches to problem solving it offers (i.e. you are more of a theory/concept-oriented person), you may find that fresh sense of wonder return with sll4.
- at the same time, there are plenty of familiar patterns, and if you see them for what they are, sll4 could be a rather trivial project to implement (aside from the new stuff being conceptually new, the resulting code is conceptually the same as some things you've already done– if you allow yourself to see that).
- I timed the release of sll3 and sll4 until Tuesday, October 13th at 9:05am. Why? To set a certain pace… I didn't want to overwhelm people who haven't yet fully gotten a handle on the insulating effect of time. I also did want huge bonus point gains should people finish it even sooner in advance (don't you want something to look forward to?)
Week 6
- This week, sll1 will be unveiled, which will continue our singly-linked list implementation with the addition of 5 new functions.
- Old habits die hard; I've noticed many tendencies that people have when solving problems… the problem is, such things are actually working against you and resulting in more complicated pieces of code. These functions should flow… look for how conditions relate to one another, and simplify around that.
- I am seeing many people hit the above-mentioned wall. And it is with insert()… many are treating it as some minor thing (“I got all the other functions done”, “I'm almost done, but having trouble with this insignificant insert function”, etc.)… no, insert() very much is sll0. One does not rush it. Some things I'd recommend, and offer up as hints:
- draw pictures. And draw pictures of at least the following scenarios:
- insert a NULL node into a NULL list
- insert a non-NULL node into a NULL list
- insert a NULL node into an EMPTY list
- Then also try the following sequence of actions:
- insert a non-NULL node into an EMPTY list
- insert a non-NULL node to the beginning of the list
- insert a non-NULL node before the 2nd node of the list
- insert a non-NULL node before the end of the list
- insert a NULL node somewhere into the list
- I would try them entirely conceptually, and also against whatever code you have.
- I've seen many of you exerting too much control… your if() statements are too complex (or, you have too many plain if() statements)
- you do want a couple regular if() statements, but you also want more than just regular if() statements (what else can make decisions that isn't just an if()?)
- if you have a loop in insert(), you're likely doing it wrong (especially since the primary reason you'd want to loop would reimplement a function you've likely already written for sll0).
- There are a number of cases to consider for inserting into a list. You need to specifically check for each of them. There is a hierarchy (that's a hint, and a rather big one). Try to figure out what that hierarchy is.
sln1 results
- I evaluated the dsi0 and sln1 projects! You can view your results by running status data or status data detail on lab46.
- Please let me know if any of the data is incorrect (please e-mail me).
- Surprises: a couple people who I thought should be doing far better but were not. I should be seeing a lot more of them than I am; or at least hearing more from them. I've been hearing a lot from the people who are doing well. That should tell everyone something (going it alone rarely breeds success).
- Unless you were a bottom-dwelling outlier, do not be concerned if you didn't get the result you may have otherwise preferred. With a project a week, and with increasing amounts of details in each project, less desirable results early on have a way of not pestering you later on. Focus more on understanding the material. Even with this project, I've noticed a few more people starting to break through and achieve enlightenment moments. And more will be having them in the future. All is proceeding as planned.
- Some are holding themselves back, clinging ever more tightly to their desire to control every detail, and making it more difficult to see the solution. I've had a few people tell me that the solution, once they saw it, was “so easy it was hard”.. also not uncommon. This is one of those areas where prior experience can get in the way. You think you're good, so you try to apply it to something completely unrelated (you may be quite adept at coding, but Data Structures is about the concepts), and that closes the mind to accepting new ideas. Nobody is in any trouble yet, but I like to mention it as something to be on the lookout for.
- Influence: I can start to correlate subjective observations (who is hanging out together/helping when working on projects)… note that I do not want to discourage you from having coding groups, far from it. But I do want to discourage borrowing of code from others. I'll show an example of what I mean.
Week 5
- Week 5 hits a few milestones:
- This week effectively marks the 1/3 waypoint of the semester. Can you believe it?
- Fall begins on September 23, at 4:21 A.M. … so be sure to enjoy what remains of summer!
- We commence on implementing linked lists, with the unveiling of the sll0 project.
- General observations:
- rushing begets confusion and stalled progress. Be it rushing due to procrastination, or rushing due to not putting adequate amounts of time into understanding, it will hurt you if you do not spend the appropriate amount of time to learn the new concepts and to become increasingly fluent with them.
- I cannot stress this enough: you must draw pictures.
- If you have questions on why your code isn't working, don't be surprised if I ask to see step-by-step pictures of what is going on… too often, the problem can be discovered by drawing pictures.
- If you do not understand sln1, you will have trouble with sll0, so be sure to ask questions!
- Common questions/clarifications:
- sln1 deals specifically and entirely with nodes. NOT lists. A list may be a collection of nodes, but sln1 specifically focuses on the individual nodes. As such, you will not need to utilize any loops in your mknode(), cpnode(), and rmnode() implementations. In fact, it is pretty safe to say that if you are trying to use a loop in those functions, you're doing it wrong.
- The importance of NULL. NULL is an important detail that must always be considered:
- checking for it
- can something be NULL? will problems occur if you don't assume this possibility? (yes and yes, if you were curious).
- setting appropriate things to it
- not setting it to inappropriate things (a char or int cannot be set to NULL, but a pointer can).
- checking for it (did I already say this?)
- Due to some behind-the-scenes tweaks, I was able to issue an two updates to sln1, so we'll look at that in class (recognizing there are updates, and applying them).
- Please be sure the updates are applied before upgrading to sll0!
Week 4
- Can you believe it is already week 4?
- With dsi0 behind us, and sln0 underway, I'll be unveiling sln1 this week, which will be our first actual exposure to linked nodes (the thing we've been talking about for a while now). This will commence the real essence of the course, a series of comprehensive projects, each one building on the prior.
Week 3
- dsi0 seems to be helping some people realize their need to review. Strange how a fixed and nearing impending deadline seems to do that.
- There are tutors available. If you feel your C skills need brushing up, I highly recommend you see them. And/or sit in on my C class.
- Brian will be tutoring in the LAIR Mon/Wed at some point between the 12:05pm and 2:40pm timeframe (I should have the schedule soon)
- still waiting on confirmation on second tutor and location/hours.
- The next project, sln0 is released. As I said before, sln0 is about drawing pictures and writing pseudocode (like, on paper, with a writing utensil), as we start to explore the linked node concepts (offering you a chance to translate your understanding from the array used in the dsi0 program).
Week 2
- We continued our explorations of this linked node concept; more and more people started on dsi0.
Week 1
- Welcome! I've wrapped all the initial activities into one project, dsi0, that I'd like you to perform by the given deadline (by 11:59:59pm / 23:59:59).
haas/spring2016/hpc0/projects.txt · Last modified: 2015/12/05 06:06 by 127.0.0.1