A Real Final Exam: Computer Science

Well, since entering K-12 education in the 2004/2005 school year, I have now written and administered my first “real” semester exams!

While I have always given exams at the conclusion of the semesters, I have never really given a genuine exam “experience”. There would be a test. That test usually consisted of 50 questions. 25 of the questions were True/False and 25 were Multiple Choice. The students were given a single sentence review guide of “Always Be True to Yourself”.

Now, with that as the review guide, I think you could safely guess that the answers were “B” and “True”. Your guess would be correct. Sadly, I did have students fail that test.

The test was not a “give-me grade” since there was usually a major end-of-year project that the majority of their semester grade was based upon. This final was created so we could simply check a box that said we gave a paper final.

This year, I opted to write and administer a genuine rigorous exam as I was not using any major end-of-year projects.

Computer Science (EOY) Final Exam – Test

Computer Science (EOY) Final Exam – Answer Key

As you can see, this is a bit more rigorous of a test. In fact, all of the questions require a calculated answer.

Once the tests are completed, I will analyze student performance in another post.

A Real Final Exam: Robotics & Automation

Well, since entering K-12 education in the 2004/2005 school year, I have now written and administered my first “real” semester exams!

While I have always given exams at the conclusion of the semesters, I have never really given a genuine exam “experience”. There would be a test. That test usually consisted of 50 questions. 25 of the questions were True/False and 25 were Multiple Choice. The students were given a single sentence review guide of “Always Be True to Yourself”.

Now, with that as the review guide, I think you could safely guess that the answers were “B” and “True”. Your guess would be correct. Sadly, I did have students fail that test.

The test was not a “give-me grade” since there was usually a major end-of-year project that the majority of their semester grade was based upon. This final was created so we could simply check a box that said we gave a paper final.

This year, I opted to write and administer a genuine rigorous exam as I was not using any major end-of-year projects.

Robotics and Automation (EOY) Final Exam – Test

Robotics and Automation (EOY) Final Exam – Answer Key

Robotic Classification Systems Notes

As you can see, this is a bit more rigorous of a test. In fact, all of the questions require a calculated answer.

Once the tests are completed, I will analyze student performance in another post.

At a Loss

I am actually at a loss for words, which is rare for me.

We are wrapping-up final exams and to-date, I have 3 students who have willfully chosen to not take their semester exam! These students did not qualify for an exemption and therefore receive the grade of a zero on their exam! The students are fully aware of this are do not care.

Why They Don’t Care

Currently, we run a 9-week quarter system. Quarters 1 and 2 comprise the fall semester and quarters 3 and 4 comprise the spring semester.

At the conclusion of each semester, we have a semester exam. Each of the two quarters is 45% of the semester average (combined for 90% of total grade) with the remaining 10% coming from the semester exam.

The two semester grades are equally averaged together to calculate a year-end grade. This grade is what is used to determine if a student receives credit for the course.

These 3 students have said that as long as they get credit for the year, they are fine to fail the semester.

What The Numbers Look Like

Let’s say that we have a student with the following grades:

Q1) 85 (B)
Q2) 75 (C)
SE1) 90 (A-)
S1) 81 (B-)
 
Q3) 70 (C-)
Q4) 61 (F)
SE2) 0 (F)
S2) 58.85 (F)
 
YR) 69.925 (F)

As you can see, this students finished the first semester with a low-B (81). They opted to not take the final exam and finished the second semester with an F (58.85). This resulted in them finishing the year with a 69.925. While this is technically passing, this is barely a pass and clearly does not demonstrate what the student is capable of.

Now, let’s look and see what happens if the student were to have taken the exam:

Q1) 85 (B)
Q2) 75 (C)
SE1) 90 (A-)
S1) 81 (B-)
 
Q3) 70 (C-)
Q4) 61 (F)
SE2) 88 (B+)
S2) 67.75 (F)
 
YR) 74.375 (C)

As you can see now, if the student were to simply take the exam and score an 88, which they scored higher than that on the first semester exam, they would finish the second semester with a 67.75, which is 8.9 points higher than if they took a zero on the exam.

For the year, they would finish with a 74.375. For GPA purposes, this is still a C, but it is a mid-C versus a low-C that was rounded-up from a high-F.

A Suggestion – Make It Count More!

I would suggest that we look at increasing the weight of the semester exam. At 10%, it has an impact on their grade, but not too much of one.

As opposed to a 45% / 45% / 10% split, maybe we should consider a 40% / 40% / 20% split. Here is how that would look with those grades from earlier:

Q1) 85 (B)
Q2) 75 (C)
SE1) 90 (A-)
S1) 82 (B-)
 
Q3) 70 (C-)
Q4) 61 (F)
SE2) 88 (B+)
S2) 70 (C-)
 
YR) 76 (C)

Using the 40% / 40% / 20% split, you can see that the semester average and therefore the year average is impacted greater.

Let’s see what happens when a students elects to take a zero on the exam:

Q1) 85 (B)
Q2) 75 (C)
SE1) 90 (A-)
S1) 82 (B-)
 
Q3) 70 (C-)
Q4) 61 (F)
SE2) 0 (F)
S2) 52.4 (F)
 
YR) 67.2 (F)

As you can see now, if a student were to decide to take a zero on the exam under the 40% / 40% / 20% split, they would fail the semester with a 67.2.

By all accounts, the student is academically able to perform they work, they are just unwilling to do it and know that they can still get their course credit.

What are your ideas to address the situation?

A Real Final Exam: Principles of Technology

Well, since entering K-12 education in the 2004/2005 school year, I have now written and administered my first “real” semester exams!

While I have always given exams at the conclusion of the semesters, I have never really given a genuine exam “experience”. There would be a test. That test usually consisted of 50 questions. 25 of the questions were True/False and 25 were Multiple Choice. The students were given a single sentence review guide of “Always Be True to Yourself”.

Now, with that as the review guide, I think you could safely guess that the answers were “B” and “True”. Your guess would be correct. Sadly, I did have students fail that test.

The test was not a “give-me grade” since there was usually a major end-of-year project that the majority of their semester grade was based upon. This final was created so we could simply check a box that said we gave a paper final.

This year, I opted to write and administer a genuine rigorous exam as I was not using any major end-of-year projects.

Principles of Technology (EOY) Final Exam – Test

Principles of Technology (EOY) Final Exam – Answer Key

Maximum Height & Range Calculator

As you can see, this is a bit more rigorous of a test. In fact, all of the questions require a calculated answer.

As I have several students who have had no exposure to trigonometry, I have had to provide them with an Excel spreadsheet that has the formulas for solving maximum height and range problems. That spreadsheet is provided above.

Once the tests are completed, I will analyze student performance in another post.

Relic Recovery Brainstorming

FIRST-FTC-RelicRecovery17-18-Color-840x700We got our first glimpse of the 2017-2018 FIRST Tech Challenge game last night with a 30-second teaser video posted onto YouTube.

As soon as that video was posted, the speculation began on what the game would be. As an FTC coach, I have no access as to what the game will be ahead of time. The only information I have, beyond the teaser was released in e-mail communications to coaches and mentors.

On May 16th, we received an e-mail from FIRST with the following excerpt:

2017-2018 Season Game Update:
 
In preparation for the 2017-2018 season, we would like to advise our teams that the 2017-2018 game will not be using the beacon that has been used the past two seasons.

On May 18th, we received an e-mail from AndyMark with the following excerpt:

FIRST Tech Challenge Field Pre-Orders Available

Whether you're a veteran FIRST Tech Challenge team or dipping your toe in the water next year, one thing is certain: you're going to need field elements! We've been proud to supply official game fields for FTC for several years now, and we'll be doing it again with the 2017-2018 game, FIRST Relic Recovery!

Like last year, we're taking preorders for delivery in September; your field elements will arrive early in the week after the FIRST Tech Challenge Kickoff on September 9th.  This year, the game allows us to offer a quarter-field option in addition to the usual half-field and full-field options.  This means that you can have official field elements for practice starting at $150!

We've also got you covered with official soft tiles and field perimeters to create a full, official playing field. And you know we can't talk about FIRST Tech Challenge without mentioning the competition-proven NeveRest gearmotors and TileRunner drive system that makes it easy to get up and running with a top-notch drive system.

What is of most interest in the AndyMark e-mail is the 2nd sentence of the 2nd paragraph:

This year, the game allows us to offer a quarter-field option in addition to the usual half-field and full-field options.

This indicates, at least to me, that major scoring components are limited to each of the corners of the game field this year.

Guessing the Game

Here is the video that was posted on May 18th:

So, I have no real clue as to what to expect in the autonomous period. I am going to guess that there will be some set of tasks to complete in the mid-field area.

For the main portion of the game, I envision that each corner will have a pedestal for holding a single “relic” or multiples “relics” from a specific historic period. The relics will be “broken” into 2 to 4 parts and scattered on the center of the game floor. They are possibly placed or dropped there as part of an autonomous task.

The goal will be that teams must retrieve parts of a relic, assemble it, and place it onto the correct historical pedestal.

I am going to guess that more complex relics are worth more points or there may be lower, middle, and higher positions on each pedestal to place a single relic at a specified level.

For the end game, teams will likely have to “climb out” of the archaeological site by grabbing onto a cross bar placed somewhere on the field, possibly at mid-field.

Countdown Timer: https://www.timeanddate.com/countdown/generic?iso=20170909T11&p0=70&msg=2017-2018+FTC+Kick-Off+Event&font=sanserif

What do you think the game will be?

Spring Exam Exemptions

It is that time of the year again. It’s time for spring semester exams and ’tis exemption season! This is the season when students start seeking if they qualify to be exempt from having to take the semester exam in a given class.

Each school I have had the opportunity to work at does this process differently and each school has used different criteria to determine eligibility for exemptions.

Exemptions (Spring 2017 Finals)
Exemptions (Spring 2017 Finals)

Here, you can see that I have a total of 146 students. There are 88 students enrolled in Business Information Management (BIM) across 4 sections. There are 15 students in my single section of Computer Science I. There are 25 students in my single section of Principles of Technology. There are 18 students in my single section of Robotics & Automation.

As you can see in the chart, 51 of the 88 BIM students are eligible to be exempt from their spring semester exam. This means that 57.9% of my BIM students are eligible to be exempt from their exam!

In Computer Science, that percentage rises to 66.7% are exempt and in Robotics and Automation is continued to climb us to 72.2%!

Unfortunately, in my Principles of Technology, the percentage plummets to 48%. This has been due to poor grade performance because many teams elected to not submit required documentation with their projects throughout the semester.

As Computer Science, Robotics & Automation, and Principles of Technology are stand-alone single-section courses, let’s take a quick look at how each of the BIM sections performed individually.

BIM Exemptions (Spring 2017 Finals)
BIM Exemptions (Spring 2017 Finals)

Here is the break-out of the 4 sections of BIM that I teach.

While the average for all 4 sections of BIM was 57.9%, 1 section performed well above that average, 1 section section performed well below that average, and the other 2 held pretty close to that average.

  • 2(B) has 10 of 23 students qualifying for exemptions, which is 43.4%.
  • 3(B) has 14 of 23 students qualifying for exemptions, which is 60.8%.
  • 4(B) has 14 of 19 students qualifying for exemptions, which is 73.6%.
  • 4(A) has 13 of 23 students qualifying for exemptions, which is 56.5%.

Compared to past years, this is close to what I have experienced as far as exam exemption qualification is concerned.

Python Recursion and Factorial

As the final Computer Science lesson of the 2016/2017 academic year, I reviewed the somewhat concept of recursion in the Python programming language. In this review, I used the mathematical concept of factorial to discuss recursion.

#Program Name: Recursion Sample
#Programmer Name: Eric Evans, M.Ed.
#Program Description: Provide a functional example of a recursion problem in Computer Science using the mathematical concept of factorial.
#
#Define function named factorial which will have an input value of n.
def factorial(n):
    print("Factorial has been called with n = " + str(n))
    if n == 1:
        return 1
    else:
        result = n * factorial(n-1)
        print(n,"! = ",result)
        return result
#Output the function factorial with an input value of 4.
print(factorial(4))

Let’s pull this concept apart line-by-line.

Lines 1 through 5 and line 14 are comment lines and have no real bearing on the program. They simply exist for documentation purposes.

At line 6, we declare a new function named “factorial” that will receive an input of “n”. This is done using the def or define call in Python. The “factorial” function occupies lines 6 through 13.

On line 7, we output the text “Factorial has been called with n = ” concatenated with the value of “n” cast as a string.

On lines 8 and 9, we enter the first part of a conditional statement. At line 8, we use a Boolean equals to see if “n” is equal to 1. If “n” is equal to 1, then line 8 executes and returns the value “1”.

Line 10 begins the process of addressing what to do if “n” does not equal 1.

On line 11, we declare a variable named “result”, which is defined as the value of “n” multiplied by the value of the “factorial” function with an input value that is one less than the current value of “n”.

Line 12 is simply allowing us to see the factorial value of the current “n” value each time through the loop.

Line 13 returns the value of the variable named “result”.

Line 15 calls the “factorial” function and provides it the necessary input to process. In this case, it is a 4.

Now, let’s see what happens when we run this code:

Factorial has been called with n = 4
Factorial has been called with n = 3
Factorial has been called with n = 2
Factorial has been called with n = 1
2 ! =  2
3 ! =  6
4 ! =  24
24

So, let’s see what’s going on with this output.

Lines 1 through 4 of the output are generated by line 7 of the code. That code displays the static words with the dynamic output of the value of “n”. Notice that each time through the loop, it decremented by 1.

Looking at lines 5 through 7 of the output, we see that the calculations actually start with the lowest factorial number of 2 and increment by 1.

Now, if you notice, the way the calculation was coded on line 11, we are performing the following:

  • (Step 1)  4! = 4 X 3!
    • This is the original problem. Solve for 4!, but it is defined needing to know the value of 3!, which is defined in step 2.
  • (Step 2)  3! = 3 X 2!
    • To solve step 1, we need to know the value of 3!. However, it is defined needing to know the value of 2!, which is defined in step 3.
  • (Step 3)  2! = 2 X 1!
    • To solve step 2, we need to know the value of 2!. However, it is defined needing to know the value of 1!, which is defined in step 4.
  • (Step 4)  1! = 1
    • To solve 3, we need to know the value of 1!. It has a given value of 1.
  • (Step 5)  2! = 2 X 1 = 2
    • Now, that we know the value of 1!, we can calculate the value of 2!.
  • (Step 6)  3! = 3 X 2 = 6
    • Now that we know the value of 2!, we can calculate the value of 3!.
  • (Step 7)  4! = 4 X 6 = 24
    • Now that we know the value of 3!, we can calculate the value of 4!, which was the original problem.

As you can see, the final solution is dependent upon the solution of a previous step, which was dependent upon the solution of a previous step, which was dependent upon the solution of a previous step, which – well you get the idea. This is the basic concept of recursion.

Robotics to FIS Career Fair

FIRST Tech Challenge

Today, I had the honor of taking several of my FTC 11242 team members to Ferris Intermediate School for its inaugural Career Fair! We were offered to chance to come over and present about careers in robotics and automation.

Part of our discussion centered around working on a team and interpersonal skills. I presented it to the 4th graders that we were working with in the context of playing soccer on the playground at recess. I also had a few team members speak to the challenges that were faced, but held it at an age-appropriate level.

Afterward, our discussion moved to careers in robotics and automation. We first looked at Amazon and the use of the Kiva Robotics systems in order fulfillment. We discussed how the old system was setup and how that compared to the new system and the jobs that is created.

nasa-curiosity-patchOur last discussion was centered around the NASA Curiosity Mars Exploration Rover. We discussed the problem presented in the NatGeo clip. In the presentation, I setup what was going on, but then had the participants sit in groups with the team members and work through brainstorming ideas for how the rover could traverse the rocks that were damaging the rover. The groups were given only 4 minutes to brainstorm.

When their time was up, we came back together and quickly presented the ideas. I then discussed with them that what they had just done was a brainstorming session – the same type of thing that NASA did when they discovered the problem.

In both of our presentations, we had 2 groups whose faces lit-up when they saw that the solution NASA ultimately used was the one they had come up with in the brainstorming session!

Basic Variables in Python

Today, we have been playing with basic variables in Python. The plan is to output something similar to the following:

Hello World
1 + 1 = 2
2 + 2 = 4
4 + 4 = 8

This output is to be generated entirely from calling variables.

#Programmer Name: Eric Evans, M.Ed.
#Program Name: 02 - Hello Variable
#Program Description: Outputs assigned information using only variables.
#
#DECLARATION OF VARIABLES
firstWord = "Hello"
secondWord = "World"
space = ' '
#OUTPUT
print(firstWord + space + secondWord)

Now, as you can see, the first line of the output is somewhat easy to code. We declared the variables firstWord, secondWord, and space and then called them to print concatenated together.

#Programmer Name: Eric Evans, M.Ed.
#Program Name: 02 - Hello Variable
#Program Description: Outputs assigned information using only variables.
#
#DECLARATION OF VARIABLES
firstWord = "Hello"
secondWord = "World"
space = ' '
firstAddend = 1
firstProblemSum = firstAddend + firstAddend
secondAddend = firstProblemSum
secondProblemSum = secondAddend + secondAddend
thirdAddend = secondProblemSum
thirdProblemSum = thirdAddend + thirdAddend
#OUTPUT
print(firstWord + space + secondWord)
print(firstAddend + " + " + firstAddend + " = " + firstProblemSum)
print(secondAddend + " + " + secondAddend + " = " + secondProblemSum)
print(thirdAddend + " + " + thirdAddend + " = " + thirdProblemSum)

Things start to act problematically when we try to produce the last 3 lines of output. When we run the application, we receive an error because we are attempting to mix string and integer variables on a combined output line.

To resolve this issue, we must typecast the integers as strings.

#Programmer Name: Eric Evans, M.Ed.
#Program Name: 02 - Hello Variable
#Program Description: Outputs assigned information using only variables.
#
#DECLARATION OF VARIABLES
firstWord = "Hello"
secondWord = "World"
space = ' '
firstAddend = 1
firstProblemSum = firstAddend + firstAddend
secondAddend = firstProblemSum
secondProblemSum = secondAddend + secondAddend
thirdAddend = secondProblemSum
thirdProblemSum = thirdAddend + thirdAddend
#CASTING OF VARIABLES
firstProblemSum = str(firstProblemSum)
firstAddend = str(firstAddend)
secondProblemSum = str(secondProblemSum)
secondAddend = str(secondAddend)
thirdProblemSum = str(thirdProblemSum)
thirdAddend = str(thirdAddend)
#OUTPUT
print(firstWord + space + secondWord)
print(firstAddend + " + " + firstAddend + " = " + firstProblemSum)
print(secondAddend + " + " + secondAddend + " = " + secondProblemSum)
print(thirdAddend + " + " + thirdAddend + " = " + thirdProblemSum)

As you can see, on lines 15 – 21 we cast each of the integer variables as a string variable. At this point, lines 24 – 26 will execute as expected.

The compilable code can be viewed at https://repl.it/HesM/3

Boolean Truth Tables

In my Computer Science class, we are revisiting Boolean operators and are looking more in-depth at Boolean Truth Tables.

In this post, I will look at the Boolean operators of AND, OR, NAND, NOR, and XOR.

For clarification, the following are considered equal and will be used in the post:

a AND b > c is equal to a . b > c

a NAND b > c is equal to a . b > c

a OR b > c is equal to a + b > c

a NOR b > c is equal to a + b > c

a XOR b > c is equal to a ⊕ b > c

For additional clarification, here are the logic gate representations of each of the objects that are presented:

Boolean AND & NAND Logic Gates
Boolean AND & NAND Logic Gates
Boolean OR & NOR Logic Gates
Boolean OR & NOR Logic Gates
Boolean XOR & NOT Logic Gates
Boolean XOR & NOT Logic Gates

So, let’s build our truth tables for each of the above named scenarios:

a . b > c
A B Result
TRUE TRUE TRUE
TRUE FALSE FALSE
FALSE TRUE FALSE
FALSE FALSE FALSE

In this scenario, let’s say that a = 10, b = 5, and c = 7. In this case, the statement A > C is TRUE. However, the statement B > C is FALSE. If we look at the truth table above, the result is that the entire statement is now FALSE.

For an AND statement to be TRUE, all parts of the statement must be TRUE.

a + b > c
A B Result
TRUE TRUE TRUE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE

In this scenario, let’s say that a = 10, b = 5, and c = 7. In this case, the statement A > C is TRUE. However, the statement B > C is FALSE. If we look at the truth table above, the result is that the entire statement is now TRUE.

For an OR statement to be TRUE, at least one part up to all parts of the statement must be TRUE.

a . b > c
A B Result
TRUE TRUE FALSE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE TRUE

In this scenario, let’s say that a = 10, b = 5, and c = 7. In this case, the statement A > C is TRUE. However, the statement B > C is FALSE. If we look at the truth table above, the result is that the entire statement is now TRUE.

For a NAND statement to be TRUE, at least one part up to all parts of the statement must be FALSE.

a + b > c
A B Result
TRUE TRUE FALSE
TRUE FALSE FALSE
FALSE TRUE FALSE
FALSE FALSE TRUE

In this scenario, let’s say that a = 10, b = 5, and c = 7. In this case, the statement A > C is TRUE. However, the statement B > C is FALSE. If we look at the truth table above, the result is that the entire statement is now FALSE.

For a NOR statement to be TRUE, all parts of the statement must be FALSE.

a ⊕ b > c
A B Result
TRUE TRUE FALSE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE

In this scenario, let’s say that a = 10, b = 5, and c = 7. In this case, the statement A > C is TRUE. However, the statement B > C is FALSE. If we look at the truth table above, the result is that the entire statement is now TRUE.

For a XOR statement to be TRUE, at least one condition in the statement must be TRUE. However, if all conditions in the statement are TRUE, then the result is FALSE.