Robotics – Semester Grade Closing

The semester exam in Robotics & Automation was given today and the final grades for this course are ready for posting.

1st Semester - Robotics & Automation (Pre-Exam)
1st Semester – Robotics & Automation (Pre-Exam)
1st Semester - Robotics & Automation (Post-Exam)
1st Semester – Robotics & Automation (Post-Exam)

As you can see, the semester exam had no impact on the grades for this course.

F’s = 0 < – > 0
C’s = 1 < – > 1
B’s = 4 < – > 4
A’s = 13 < – > 13

This class had a semester failure rate of 0.00%.

BIM 2(B) – Semester Grade Closing

The semester exam in Business Information Management – 2(B) was given today and the final grades for this course are ready for posting.

1st Semester - Business Information Management - 2B (Pre-Exam)
1st Semester – Business Information Management – 2B (Pre-Exam)
1st Semester - Business Information Management - 2B (Post-Exam)
1st Semester – Business Information Management – 2B (Post-Exam)

As you can see, the grades in this class did shift to the right, but not by much.

F’s = 3 < – > 3
C’s = 3 < – > 3
B’s = 3 < – > 2
A’s = 12 < – > 13

In the end, two of the failures climbed a bit, but not enough to pass and the 3rd actually slid lower. The number of C’s held and one B climbed to an A.

This class had a semester failure rate of 14.28%.

Computer Science I – Semester Grade Closing

The semester exam in Computer Science I was given today and the final grades for this course are ready for posting.

1st Semester - Computer Science I (Pre-Exam)
1st Semester – Computer Science I (Pre-Exam)
1st Semester - Computer Science I (Post-Exam)
1st Semester – Computer Science I (Post-Exam)

As you can see, the grades in this class did shift to the right.

F’s = 3 < – > 2
C’s = 1 < – > 1
B’s = 6 < – > 3
A’s = 4 < – > 8

The total number of A’s doubled and the number of B’s and F’s decreased and C’s held.

For the semester, this class had a failure rate of 14.28%.

 

Principles of Technology – Semester Grade Closing

The semester exam in Principles of Technology was given today and the final grades for this course are ready for posting.

1st Semester - Principles of Technology (Pre-Exam)
1st Semester – Principles of Technology (Pre-Exam)
1st Semester - Principles of Technology (Post-Exam)
1st Semester – Principles of Technology (Post-Exam)

As you can see, the grades in this class did shift to the right.

F’s = 1 < – > 0
C’s = 5 < – > 4
B’s = 8 < – > 10
A’s = 11 < – > 11

While the total number of A’s remained unchanged, the number of B’s increased and the number of C’s and F’s decreased.

This class had a semester failure rate of 0%!

Pre-Exam Grades

It seems we were just talking about grades and here we are at the conclusion of the first semester! Hard to believe that we are now at the midway point of the 2016/2017 school year.

As we come into semester exams week, I have run my current S1 reports which factor Q1 and Q2 but don’t have a semester exam calculated in.

Computer Science I

1st Semester - Computer Science I (Pre-Exam)
1st Semester – Computer Science I (Pre-Exam)

As you can see, the grades in Computer Science for S1 led to a double-hump camel and not a nice bell curve. While we have a nice spike in the 80’s (42.85%), we have another smaller spike in the 50’s (14.28%).

Currently, this class has failure rate of 21.43%. Hopefully, the semester exam will be enough to pull some of those failures up to passes.

Principles of Technology

1st Semester - Principles of Technology (Pre-Exam)
1st Semester – Principles of Technology (Pre-Exam)

As you can see here, the grades don’t give us a nice bell, but there is no double-hump. At present, 44% of the students in the class are holding an “A” for the semester.

Currently, the class has a failure rate of 4%.

Robotics & Automation

1st Semester - Robotics & Automation (Pre-Exam)
1st Semester – Robotics & Automation (Pre-Exam)

As you can see here, the grades give us a nice bell, but it spikes in the 90’s. At present, 72% of the students in the class are holding an “A” for the semester with 38% of those holding a 100%.

Currently, this class has a 0% failure rate!

Business Information Management I

1st Semester - Business Information Management - 2B (Pre-Exam)
1st Semester – Business Information Management – 2B (Pre-Exam)

 

1st Semester - Business Information Management - 3B (Pre-Exam)
1st Semester – Business Information Management – 3B (Pre-Exam)
1st Semester - Business Information Management - 4B (Pre-Exam)
1st Semester – Business Information Management – 4B (Pre-Exam)
1st Semester - Business Information Management - 4A (Pre-Exam)
1st Semester – Business Information Management – 4A (Pre-Exam)
1st Semester - Business Information Management - All Sections (Pre-Exam)
1st Semester – Business Information Management – All Sections (Pre-Exam)

As you can see, all of these classes have a heavy shift to the A’s with 71% of all students enrolled. Just under 22% of students are evenly split between B’s and C’s.

Currently, all BIM classes together have just over a 7% failure rate for the semester.

 

Progress Report 4 Grades

It’s once again that time. It’s time for progress reports. I’ve lost count of how many times I’ve been asked by my students if they can lose their eligibility or can only re-gain it at this progress check. As a UIL coach, I have to say that’s not filling me with a lot of confidence as we come into the proverbial home-stretch of the semester.

For the record, students can only lose eligibility at a report card (each 9-weeks) and at the state-mandated 6-week grade check that is obviously 6-weeks into the start of the school year.

This progress check, I also began to adjust grades to be in alignment with the campus policies for grade distribution. In the graphs below, the blue represents the original (uncurved) grades for the grading period and the red represents the modified (curved) grades for the grading period.

The first cluster is percentage of A’s, the second cluster is percentage of B’s, the third cluster is percentage of C’s, and the final cluster is percentage of F’s.

Progress Report 4 - Computer Science I
Progress Report 4 – Computer Science I
Progress Report 4 - Principles of Technology
Progress Report 4 – Principles of Technology
Progress Report 4 - Robotics
Progress Report 4 – Robotics
Progress Report 4 - BIM (All Sections)
Progress Report 4 – BIM (All Sections)

While it appears that some classes tremendously benefited from the modifications (e.g. Computer Science I) and other received little benefit (e.g. BIM – All Sections), remember that you are looking at percentages and not actual numbers.

At the time of this writing, my current enrollment numbers are as follows:

  • Computer Science I – 14 Students (1 Section)
  • Principles of Technology – 25 Students (1 Section)
  • Robotics & Automation – 18 Students (1 Section)
  • Business Information Management I – 83 Students (4 Sections)

As you can see, in some of the classes, an adjustment to the grades of 2 students can reflect as a major grade shift in some classes (e.g. 14% in Computer Science I) and a minor grade shift in other classes (e.g. 2% in BIM – All Sections).

Quick Hands-On Primer to OOP in JAVA

JAVA Programming Language LogoAs a quick hands-on primer to object oriented programming in JAVA, I am going to work with my students to create a basic program that asks the user for their first name and then to select a language they want to be greeted in. The program will then produce the appropriate greeting in the language selected.

In this primer, we will be working with two files (primary.java and secondary.java). The primary.java file will contain our main class of the application while the secondary.java file will be handling all of our active “processing”.

//Program Name: OOP Primer (File 1 of 2)
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class primary{
    public static void main (String[] args){
        System.out.println("** Greetings Generator **");
        Scanner firstName = new Scanner(System.in);
        System.out.print("What Is Your First Name?_ ");
        String userFirstName = firstName.next();
        System.out.println("Thank you, " + userFirstName);
        Scanner language = new Scanner(System.in);
        System.out.println("Select the Language for Your Greeting");
        System.out.println("1 - English");
        System.out.println("2 - Spanish");
        System.out.println("3 - German");
        System.out.println("4 - Pig Latin");
        System.out.print("Language Selection: _ ");
        int greetingLanguage = language.nextInt();
        System.out.println("");
        secondary myGreeting = new secondary (userFirstName, greetingLanguage);
        System.out.println(myGreeting.greeting);
    }
}

In lines 13 – 16, we are working with receiving the first name of the user.

In lines 17 – 25, we are working with receiving the language the user would like to be greeted in.

Line 26 is the one line that confuses my students to most. This is the heart of Object Oriented Programming. This line is creating a new object named “myGreeting” which is based upon the variables userFirstName and greetingLanguage that is processed in the secondary.java file.

Line 27 is the output of a method we created in the secondary.java file named “greeting”. You can see what that method is by reading the secondary.java file.

//Program Name: OOP Primer (File 2 of 2)
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

public class secondary{
    public String greeting;
    public secondary (String userFirstName, int greetingLanguage)
    {
        switch (greetingLanguage) {
            case 1:
                greeting = "Hello " + userFirstName;
                break;
            case 2:
                greeting = "Hola " + userFirstName;
                break;
            case 3:
                greeting = "Hallo " + userFirstName;
                break;
            case 4:
                greeting = "Ellohay " + userFirstName;
                break;
            default:
                greeting = "Invalid Selection";
                break;
        }
    }
}

In line 7, we created a public string variable named “greeting”. A public variable is one that can be passed between files within the application. Think of it as a “global” variable.

In line 8, we are establishing which variables we should be receiving from any files. In this case, that is the string variable “userFirstName” and the integer variable “greetingLanguage”.

Lines 11 – 26 utilize a switch for a conditional statement based on the integer value of “greetingLanguage” variable. In those lines, you can see that we declare the value of the variable “greeting” for each case. This is the method that is called-up in line 27 of the primary.java file.

For the record, I require my students to encase all of the applications within a loop to ask the user if they wish to run the application again or to exit. As this requirement would only impact the primary.java file, here is the completed code for that file:

//Program Name: OOP Primer (File 1 of 2)
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class primary{
    public static void main (String[] args){
        int runAgain = 1;
        while (runAgain == 1){
            System.out.println("** Greetings Generator **");
            Scanner firstName = new Scanner(System.in);
            System.out.print("What Is Your First Name?_ ");
            String userFirstName = firstName.next();
            System.out.println("Thank you, " + userFirstName);
            Scanner language = new Scanner(System.in);
            System.out.println("Select the Language for Your Greeting");
            System.out.println("1 - English");
            System.out.println("2 - Spanish");
            System.out.println("3 - German");
            System.out.println("4 - Pig Latin");
            System.out.print("Language Selection: _ ");
            int greetingLanguage = language.nextInt();
            System.out.println("");
            secondary myGreeting = new secondary (userFirstName, greetingLanguage);
            System.out.println(myGreeting.greeting);
            System.out.println("");
            Scanner runItAgain = new Scanner(System.in);
            System.out.println("Would You Like to Run Again");
            System.out.print("1 - Yes  /  0 - No : _ ");
            runAgain = runItAgain.nextInt();
        }
        System.out.println("");
        System.out.println("Program Complete - Exiting");
    }
}

As you can see, the code to run the application again, adds lines 12 to 13 & lines 30 to 37.

Following is brief video of what the output should look like with the program compiled and executed.

QR Robotics Classification

Upon returning from Thanksgiving break, we’ll be looking at standard classification systems for robotic and automation systems. To start with, we’ll be doing a QR knowledge hunt.

Robot Classification Knowledge Hunt Cards

Classification Knowledge Hunt Card #1
Classification Knowledge Hunt Card #1

The 17 cards are placed on the walls around random parts of the main hallway. Unlike in my larger classes, everyone will be able to start at a set question and will not have to work in groups. Each student must move through all 17 cards in any order they would like as long as there is no unnecessary “congregating” around any single card.

This particular knowledge hunt requires the students to utilize a QR scanner to “read” the question.

They must scan the QR code and then either use their existing knowledge or research skills to answer the question. The answers are then recorded on a provided answer document, which is submitted for a grade.

Semester Grade Calculator – Take 2

Blue Pelican Java BookFollowing our review from the Thanksgiving break return, we’ll be covering an introduction to object oriented programming.

The first lesson will be a simple lesson almost verbatim from Blue Pelican Java. however, the second lesson will be to take the semester exam grade calculator created earlier in the week and adapt principles of OOP to it.

The code they are starting with is similar to the following:

//Program Name: Unit 1 & 2 Review
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class gradecalculator{
    public static void main (String[] args){
        int runAgain = 1;
        while (runAgain == 1){
            System.out.println("**Minimum Grade Calculator**");
            Scanner q1 = new Scanner(System.in);
            System.out.print("Enter Your Q1 Report Card Grade_ ");
            double myQ1Grade = q1.nextDouble();
            Scanner pr4 = new Scanner(System.in);
            System.out.print("Enter Your PR4 Report Card Grade_ ");
            double myPR4Grade = pr4.nextDouble();
            double c = ((69.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            double b = ((79.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            double a = ((89.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            System.out.println("With a Q1 grade of " + myQ1Grade + " and PR4 grade of " + myPR4Grade + ":");
            System.out.println("");
            System.out.println("To score a C, you will need a minimum of a " + c + " on the semester exam.");
            System.out.println("To score a B, you will need a minimum of a " + b + " on the semester exam.");
            System.out.println("To score an A, you will need a minimum of a " + a + " on the semester exam.");
            System.out.println("");
            System.out.println("** NOTE: Negative grades indicate the exam could be skipped");
            System.out.println("** NOTE: Grades over 100 indicate this average cannot be achieved");
            System.out.println("");
            Scanner runItAgain = new Scanner(System.in);
            System.out.println("Would You Like to Perform Another Calculation?");
            System.out.print("1 - Yes  /  0 - No : _ ");
            runAgain = runItAgain.nextInt();
        }
        System.out.println("");
        System.out.println("Program Complete - Exiting");
    }
}

They will be breaking the program into two separate parts. The main method will be handling keyboard inputs, screen outputs, and the while loop. The calculation method will be handling the calculations.

Here is a possible solution to the problem:

//Program Name: OOP Concepts (File 1 of 2)
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class gradecalculator{
    public static void main (String[] args){
        int runAgain = 1;
        while (runAgain == 1){
            System.out.println("**Minimum Grade Calculator**");
            Scanner q1 = new Scanner(System.in);
            System.out.print("Enter Your Q1 Report Card Grade_ ");
            double myQ1Grade = q1.nextDouble();
            Scanner pr4 = new Scanner(System.in);
            System.out.print("Enter Your PR4 Report Card Grade_ ");
            double myPR4Grade = pr4.nextDouble();
            System.out.println("With a Q1 grade of " + myQ1Grade + " and PR4 grade of " + myPR4Grade + ":");
            System.out.println("");
            calculation myGrade = new calculation (myQ1Grade, myPR4Grade);
            System.out.println("To score a C, you will need a minimum of a " + myGrade.c + " on the semester exam.");
            System.out.println("To score a B, you will need a minimum of a " + myGrade.b + " on the semester exam.");
            System.out.println("To score an A, you will need a minimum of a " + myGrade.a + " on the semester exam.");
            System.out.println("");
            System.out.println("** NOTE: Negative grades indicate the exam could be skipped");
            System.out.println("** NOTE: Grades over 100 indicate this average cannot be achieved");
            System.out.println("");
            Scanner runItAgain = new Scanner(System.in);
            System.out.println("Would You Like to Perform Another Calculation?");
            System.out.print("1 - Yes  /  0 - No : _ ");
            runAgain = runItAgain.nextInt();
        }
        System.out.println("");
        System.out.println("Program Complete - Exiting");
    }
}
//Program Name: OOP Concepts (File 2 of 2)
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

public class calculation{
    public double a;
    public double b;
    public double c;
    public calculation (double myQ1Grade, double myPR4Grade)
    {
        a = ((89.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
        b = ((79.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
        c = ((69.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
    }
}

As you can see, the calculation.java file is responsible for the calculations and the gradecalculator.java file is handling all of the other functions of the application.

In reality, we would not necessarily break-up a program like this, but this allows the students the opportunity to see how OOP concepts work on an existing application they have developed.

Semester Grade Calculator

JAVA Programming Language LogoAs we are coming out of Thanksgiving break, I have given my students a “review” project that covers many of the topics that we have covered up to this point in the year.

The goal of the project is to allow for students to enter their Q1 report card grade and their current Q2 in-progress grade and calculate the minimum semester exam grade needed to achieve a final grade of a “C”, a “B”, and an “A”.

The students were given the following “starter” code to work from:

//Program Name: Unit 1 & 2 Review
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class gradecalculator{
    public static void main (String[] args){
        int runAgain = 1;
        while (runAgain == 1){
            System.out.println("** Minimum Grade Calculator **");
            Scanner q1 = new Scanner(System.in);
            System.out.print("Enter Your Q1 Report Card Grade_ ");
            double myQ1Grade = q1.nextDouble();
            //Copy line 15 and modify for PR4 grade
            //Copy line 16 and modify for PR4 grade
            //Copy line 17 and modify for PR4 grade
            double c = ((69.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            //Copy line 21 and modify for a grade of a b
            //Copy line 22 and modify for a grade of an a
            System.out.println("With a Q1 grade of " + myQ1Grade + " and PR4 grade of " + myPR4Grade + ":");
            System.out.println("");
            System.out.println("To score a C, you will need a minimum of a " + c + " on the semester exam.");
            //Copy line 26 and modify for a grade of a b
            //Copy line 27 and modify for a grade of an a
            System.out.pringln("");
            System.out.println("** NOTE: Negative grades indicate the exam could be skipped");
            System.out.println("** NOTE: Grades over 100 indicate this average cannot be achieved");
            System.out.println("");
            Scanner runItAgain = new Scanner(System.in);
            System.out.println("Would You Like to Perform Another Calculation?");
            System.out.print("1 - Yes  /  0 - No : _ ");
            runAgain = runItAgain.nextInt();
        }
        System.out.println("");
        System.out.println("Program Complete - Exiting");
    }
}

This particular project requires students to utilize their knowledge of working with integer and double variables, scanner keyboard inputs, Boolean logic operators, and iteration loops.

Following this review, students will receive their first exposure to object oriented programming with a multi-class application and methods.

Following is a possible completed solution for the application:

//Program Name: Unit 1 & 2 Review
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Fall 2016

import java.util.*;
import java.lang.*;
import java.io.*;

public class gradecalculator{
    public static void main (String[] args){
        int runAgain = 1;
        while (runAgain == 1){
            System.out.println("**Minimum Grade Calculator**");
            Scanner q1 = new Scanner(System.in);
            System.out.print("Enter Your Q1 Report Card Grade_ ");
            double myQ1Grade = q1.nextDouble();
            Scanner pr4 = new Scanner(System.in);
            System.out.print("Enter Your PR4 Report Card Grade_ ");
            double myPR4Grade = pr4.nextDouble();
            double c = ((69.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            double b = ((79.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            double a = ((89.5 - ((myQ1Grade * 0.45) + (myPR4Grade * 0.45)))/0.10);
            System.out.println("With a Q1 grade of " + myQ1Grade + " and PR4 grade of " + myPR4Grade + ":");
            System.out.println("");
            System.out.println("To score a C, you will need a minimum of a " + c + " on the semester exam.");
            System.out.println("To score a B, you will need a minimum of a " + b + " on the semester exam.");
            System.out.println("To score an A, you will need a minimum of a " + a + " on the semester exam.");
            System.out.println("");
            System.out.println("** NOTE: Negative grades indicate the exam could be skipped");
            System.out.println("** NOTE: Grades over 100 indicate this average cannot be achieved");
            System.out.println("");
            Scanner runItAgain = new Scanner(System.in);
            System.out.println("Would You Like to Perform Another Calculation?");
            System.out.print("1 - Yes  /  0 - No : _ ");
            runAgain = runItAgain.nextInt();
        }
        System.out.println("");
        System.out.println("Program Complete - Exiting");
    }
}