Presented within will be various questions evaluating your knowledge and experience gained this semester. In places where you are able, the more you write and explain topics the better the chance you will have of receiving full credit (and alternatively, the more credit you will receive should something defer correctness).

Unless otherwise specified, the questions on this experience are open resource with the exception of other individuals. In that respect, it is CLOSED PERSON. This means you are not to communicate with other people (either in the class or otherwise), in real life or electronically. Use your own knowledge, use your own skills, and use your own ability to access the allowed resources to aid you in coming up with your well thought out responses to each question.

You are allowed, and expected, to seek clarification on any question by asking any of the tutors or me. But the aim here is to evaluate what you have learned, so do not expect tutoring. Any help should be prompted by a well-asked question. Any reply (if possible) from a tutor, should also be in the form of a question.

You are to do all items. Submission is to be as follows:

• an organized and easy to read presentation of information on your EoCE wiki page.
• if applicable, a supplemental archive submitted using the submit tool (likely via Makefile)

The EoCE is worth 26 points of your overall grade (projects + participation + journal + eoce = 104), representing a distinct fourth category within the grading policy of the course (Projects, Journal, Participation, and EoCE).

While some classes are allocated a specific meeting time during finals week, I make all such times available should you be free and have questions. As such, finals week in CHM123 will look something like this:

• Monday, December 9th, 2019: from 02:30pm - 05:30pm
• Tuesday, December 10th, 2019: from 08:00am - 02:15pm
• Wednesday, December 11th, 2019: from 02:30pm - 05:30pm

DEADLINE FOR SUBMISSION: You have until 05:29:59pm (that's 17:29:59 in 24-hour time) Wednesday, December 11th, 2019 to complete your EoCE(s). This is the ultimate deadline for any and all coursework. There is no “late”, only “too late”. Don't be that person, not with this.

Good luck!

NOTE: The code created for 0x1, 0x2, and 0x3 will be done in the eoce project. The code created for 0x4 will be done in the oop0 project.

Provide your well-thought out, reasoned, and substantiated response to the following question:

• If you were creating your own implementation of the universe, what data structure(s) would you use to store its structure? Why?

Feel free to be philosophical. But certainly be verbose.

Both data and discrete tended to wage war against those who possessed 'brute forcing' problem solving habits. To my dismay, some may still cling to some of these habits, and they usually manifest in their persistent struggling, project after project (consistently having issues with the same sort of things).

Some, however, while initially caught by surprise, took matters into their own hands and developed improved problem solving skills, which clearly benefit them on their projects.

Yet others did nothing short of soar to new heights, experimenting and writing out algorithms to test an idea, or even to make their lives easier.

Here, at the end, I would like to give you a choice (you need only do 1, but I may consider, depending on a host of other factors) additional contributions as extra credit.

Pick one from the following list to perform:

• write a program that allows for the playing of Tic-Tac-Toe. You must make use of Data Structures to accomplish this feat in some central way.
• using Data Structures, write a program that implements a playable version of the Egyptian Ratscrew card game
• graphs: create your own graph data structure implementation, where you can add to and remove items from the graph, handling cycles and other graph-y things
• hash tables: create your own hash table data structure implementation, where you can add to and remove items from the hash table, dealing with collisions and other hash table-y things
• pick a programming project you scored 32-64% on, re-implement from the ground up, immaculately comment, beautifully indent, and provide that for evaluation on this problem.

Note that I'm not looking for name drops or other surface level attempts to gain credit. I want to see well thought out, and central utilizations of data structures in the solution of your choice.

Your task for this section is to explore the implementation of a text-based solitaire game utilizing linked lists/stacks; be it in writing a functional program, or planning out and documenting various aspects of the game logic via documentation or pseudocode.

• How will you handle card placement eligibility?
• How will you determine if a card can be placed on a foundation?
• How will you detect a win situation?
• How could you use stacks to facilitate various aspects of this process?

Show me you can recognize uses for some of the Data Structures we've been playing with this semester.

Throughout the semester, your class-related activities have been numerically captured and made available to you via the status tool.

Now that we are nearing the end, and your programming skillset is significantly expanded, I would like you to write a program to take this data and calculate your grade (reflective of currently recorded data).

The status tool has an option that will take all your status data and 'flatten' it… converting all the necessary data into one stream of values. To obtain this data, simply run the status tool, providing your course desig, as well as the flatten argument and the file DESIG.status.flat will be created in your current working directory.

For example:

lab46:~/src/data/eoce/0x3$ status data flatten
lab46:~/src/data/eoce/0x3$ ls
data.status.flat
lab46:~/src/data/eoce/0x3$ cat data.status.flat
-1 7 8 7 8 6 8 2 8 0 8 0 8 8 8 1 0 -2 4 4 8 8 11 12 13 16 19 20 24 24 100 0 0 26 24 28 -3 32 39 42 52 32 52 51 52 46 52 52 52 73 78 24 0 -4
lab46:~/src/data/eoce/0x3$ 

Your program needs to do the following:

• check for and open the data.status.flat file
  • if error occurs, display message and exit
• reading one integer at a time, load the values into a linked list according to its category
• there will be three categories (linked lists), each one identified by a header/sentinel value encountered in the flattened data stream:
  • -1 indicates the start of journal data (13% of grade)
  • -2 indicates end of journal data / start of participation data (13% of grade)
  • -3 indicates end of participation data / start of project data (52% of grade)
  • -4 indicates end of project data (and end of data stream)
• once loaded into their linked lists, calculate their totals, and totals out of grade component
• tally up all three, and print out the results
• calculate the current overall score, with a precision of 3 decimal places
• display the letter grade

Letter grades are on the following scale:

• A (100.00+)
• A- (94.00-99.99)
• B+ (88.00-93.99)
• B (82.00-87.99)
• B- (76.00-81.99)
• C+ (70.00-75.99)
• C (64.00-69.99)
• D (58.00-63.99)
• F ( 0.00-57.99)

Final program output should resemble the following (note the formatting/spacing):

lab46:~/src/data/eoce/0x3$ ./0x3
Participation:   6    / 12 =>  6 / 13
      Journal:  38+1  / 56 =>  9 / 13
     Projects: 328+24 /377 => 48 / 52
-------------------------------------
Total:                        63 / 78
=====================================
Score:                         80.769
Grade:                             B-
lab46:~/src/data/eoce/0x3$ 

As promised, another code rewrite opportunity! We've been focusing our implementation of Data Structures so far as being implemented in C, which has been a good choice for keeping a lot of unnecessary cruft out of our way.

But now, we've gotten to a point where we should be able to better distinguish the capabitilies of the Data Structures and the functionality of a language, so we are going to re-implement our code in C++ using classes/objects (encapsulation), inheritance, and polymorphism (among other C++ features, like function overloading and access control).

The logic and concepts should be largely the same, but due to access control you may not have access to core Data Structure elements (like the value variable in Node)- instead, you have indirect access via accessor functions.

To obtain the code, do a grabit: grabit data oop0

Note that we're not copying over existing code to this project- as the Object-Oriented nature of C++ has dictated, enough changes have taken place where it will actually be easier to rewrite from scratch (and as rewriting is also one of the goals in this endeavor- all the better!)

Your task is to implement the same linked list functionality to C++, adhering to the class declarations (APIs) specified in the provided header files (do not change these, your code should work with them as written).

For more project specifics, please reference this page:

• http://lab46.corning-cc.edu/haas/fall2019/data/projects/oop0

Documentation is important. Notes are important. Partial credit is a possibility, but you need to demonstrate you know conceptually what is going on.

To submit, follow the regular submit procedure for the project (ie by issuing a make submit).

During some standard time between now and 05:29:59pm (that's 17:29:59 in 24-hour time) Wednesday, December 11th, 2019, you are to approach me to perform an in-person knowledge assessment. This is to help ensure consistency and validity of the other work you are performing on the EoCE (which of course you are following the rules and doing it all yourself with no outside help).

Valid times include any remaining class or office/lab hours with no structured/scheduled activities, or any of the finals week availabilities.

Note that you only have a single opportunity to take this (no make sure you allocate yourself an adequate amount of time).

Pro tip: Don't wander in 30 minutes (or similarly time deficient) before a deadline and expect an extension/more time to work on it.

When ready, please proceed: DATA IPKA

Of all the concepts explored and work you've done this semester in this course, identify something that was meaningful to you.

• What is it?
• Why does it stick out in your mind? Explain.
• How did you feel about the course? (Preferably in terms of your computing education)
• Was it useful/interesting to you?
• What was your least favorite aspect, and why?
• Any comments, suggestions?

After an exciting and intellectually challenging run, we're arriving at the end of this semester's journey. Some will be moving on, others sticking around for more. I make it a practice to listen to your thoughts and suggestions. The course, as we all experienced it, unfolds in a manner pertaining, in part, to how you respond to concepts and topics (do we need more time, can I crank it up a couple notches, etc.) so each semester and each class is entirely different from any other- because of each of you, and all of us, working together and learning together.

So, searching deep down within your soul- balancing reason with emotion, and considering attendance and timeliness; what grade do you feel you deserve for this course, and why? Justify your answer based on your own perceived performance to course ideals and content, not on need or desire.

All responses to questions, unless specifically indicated otherwise, should be addressed on this document (or the intended wiki document).

Please edit the appropriate section and provide the necessary information.

For any other specific deliverables, if using a project directory tree you can obtain a copy of, when ready, submit it using the Makefile, as follows:

lab46:~/src/DESIG/eoce$ make submit
...

If no formal project, you can submit requested files (preferably in an archive of their own), using the submit tool. A project called eoce has been likely set up for this purpose.