Project by: Henry Toll (11th Grade)
Project Advisor: Jacob Farkas
Student(s)’s Advisor(s): Shauna Finn

Description of the Project:

I’m still mainly focusing on my upcoming AP CS Principles A test, so my description has barely changed since trimester 2. This project is mostly about preparing for the SAT Computer Science subject test. I am proposing a project to further my understanding of Java which would include some coding projects. I don’t only want to practice for the test but to also work on small projects that can be shown. I think I can represent the school’s values of critical thinking and creativity through coding because most of coding is logic problems. You have to use the tools given to you by the language to manipulate data to reach a certain answer. I think the best example of a way to show my completion of this project would be the outcome of my results on the AP coding test.

Final Product:

Public boolean evaluateLight(int row, int col){
int numChecker;
if(lights[row][col] == true){
for(int c = 0; lights[row].length() > c; c++){
if(lights[row][c] == true){
numChecker += 1;
}
}
if(numChecker % 2 == 0){
return false;
} else {
return true;
}
} else {
for(int c = 0; lights[row].length() > c; c++){
if(lights[row][c] == true){
numChecker += 1;
}
if(numChecker % 3 == 0){
return true;
} else {
return false;
}
}

Final Reflection on Learning:

I learned a lot this year about Coding, and general ideas around coding. How to code in OOP, and coding using the features of OOP. For example, using classes and subclasses and creating files for all of them, and limiting how much code is in the main class. How to code efficiently by using the write sorting algorithms, and or just using preexisting methods and classes from imported libraries. Or just how to look at preexisting code, and or make my code that is able to be easily useable – that’s super important because if you work in a big team then people should be able to understand how your code works, but more importantly be able to use your methods without needing to understand what you did to get from the input to the output. All this learning helped me a lot of the AP test, but it also gives me the self confidence to make a project, and even more importantly give me the self confidence to learn some new idea while coding, or really any computer based software.

Update on Progress from Weeks 1-3 (include any photos or video if relevant):

Hence the upcoming AP exam (Computer Science A on May 18th), I’m primarily focusing on getting ready for it. To prepare I mostly practiced questions that will come up on the exam, and finished off the things I need to know for the exam. The final things I needed for the exam were some basic understanding of sorting/ searching methods, data trees – binary trees, non binaries, and some of the basic methods of some of the data classes- Strings, Ints, Integers, ArrayList, etc. The sorting methods are an insertion sort, and a selection sort. They both used to convert an array into a sorted array from least to greatest. The insertion sort basically works by keeping a smallest value running int(or some number data type), and comparing it to the whole array when it finds the smallest value it runs again except it moves that value to the front, and runs through it again from the end of the sorted array. The selection sort is basically switching the current value with the next value in the array if the next one is larger, and do that until it’s sorted – both sorting methods are N^2 because they run through the array by the array size/length. The searching methods are the selection search, and the binary search. The sequential search is pretty simple; it just runs through the whole array to find the smallest value – it’s n number is n. The binary search is a little more interesting: it goes to the middle of the array, and finds out if the value is higher or lower than the current value, and then whatever direction it is in the array it makes a sub array of that array, and follows until there are two values left in the array – it’s N number is log n. The data tree stuff can be pretty complicated(I just started learning about it, and don’t fully understand it). It’s basically an abstract idea of how to store data in a system to access each node easily. I mainly focused on binary search trees which is where you have everything to the right of the current node being larger than the previous node, and everything to the left being smaller. But when you expand that it becomes more difficult because that rule has to stay true for the branches of the next level of nodes. But the cool thing about this is that similar to the binary search you can use the numeral value of what you’re looking for, and some if statements to easily find that value in this data structure. The methods I learned are kind of boring. Methods are basically functions built inside a class so that the iterations of that class can call that method on the data that we inscribe to it, in the iteration of it. So for example, let’s say we want to create a new ArrayList of dogs, so ArrayList<String> dogs = new ArrayList<String>();  than we can use the .add method of the ArrayList to add a String data type for dogs. So dogs.add(public String smallDog= “Small Dog”); It’s little tools like this that are essential but aren’t especially interesting. 

Update on Progress from Weeks 4-6 (include any photos or video if relevant):

I took the AP CS A test during this period. I won’t get my score until the summer, but I felt pretty confident on the test. In the time leading up to the test, I spent more time studying the methods I would need to know, and practicing the multi choice questions on the test. The actual studying was pretty boring, but It was necessary for the test. The test itself has two sections: the multiple choice, and the written response part(or typed response). Each section lasts for an hour and a half with a short break between each section. The test is long, but I actually enjoyed it, especially the written response part, because it’s creative, not just boring work. You actually need to create an idea of how to do something. I’m hoping to practice some Python, and practice some more coding now that I’m done with the test.

 

Update on Progress from Weeks 7-9 (include any photos or video if relevant):

This week I learned some Python ideas, and thought of two interesting projects I could do this summer. I’m doing an internship this summer that will require me to code in Python, and possibly R, so I decided to brush up on the schools. Python is basically entirely object oriented code – similar to Java. Object oriented programming is where the data in that code is saved into objects. This means that the basic ideas behind Python are basically the same to Java, but some of the syntax is different. For example, no semicolons after lines of code – the habit of putting a semicolon after each sentence has been a little hard to break. My summer ideas are to either build a drone and then integrate it with GPS and write path finding code for it. Or to build VR flashcards for Dyslexic kids to help them with suffix learning. I did an AR flashcards project two years ago in Unity and I believe I can integrate it into VR.

TRIMESTER 2 UPDATES:

Description of the Project: 

This project is mostly about preparing for the SAT Computer Science subject test. I am proposing a project to further my understanding of Java which would include some coding projects. I don’t only want to practice for the test but to also work on small projects that can be shown. I think I can represent the school’s values of critical thinking and creativity through coding because most of coding is logic problems. You have to use the tools given to you by the language to manipulate data to reach a certain answer. I think the best example of a way to show my completion of this project would be the outcome of my results on the AP coding test, but a better one for the school would be my coding projects. I will work on something that could be shared to show my skill and something kind of interesting. This might be a unity project or some type of advanced algorithm or even some form of AI.

Final Reflection on Learning:

This trimester has been an interesting time in my coding knowledge because I’m starting to be able to understand some of the more complicated and interesting concepts that power our modern world or even will power our world. For example, the NEAT AI arthrograms of the work with methods made for billions of data inputs. In truth, I don’t understand the ideas but I get the logical idea behind them, the Mathematical ideas, and some of the syntax ideas. This doesn’t mean I could make a new version of these ideas but I could use prebuilt classes to accomplish the goals of these advanced topics. I’m pretty proud of my progress towards the subject test. I think I’ve gotten significantly better at working on all the questions on the test that has to do with the subjects I’ve studied. Furthermore, I think I have almost finished all the topics I need to relearn or learn for the test so in trimester 3 of this project I’ll be able to focus on the test questions themselves.

Final Product:

Recursion:

Recursion is when you create a function that calls itself inside the function to create a loop.

For example to make a recursive numStars function, you need to take a input of numbers and turn it into stars – for example like this

 // 2 – > **

 /// k – > ***

 public static String numStars(int k){

   if(k > 0){

//this is the base value or when to stop looping the function

     return “*” + numStars(k – 1);

//here we call the function inside the function

   } else {

     return ” “;

   }

 }

//here is a demonstration of 2 stars and 9 stars in this function

Sub-classes and Iteration:

//Here is a class called philosopher and a subclass inside it called Nominalist

private static class Philosopher {

       private String name;

       private String favoriteSubject;    

       public Philosopher(String n, String f) {

               name = n;

               favoriteSubject = f;

       }      

private static class Nominalist extends Philosopher {

//here we add the sub class called nominalist to the philosopher class

       boolean franciscan;    

       public Nominalist(String n,boolean frank) {

               super(n,“logic”);

               franciscan = frank;

       }     

}

//this is a example of a class that could be used to store information in a more efficient way but it isn’t a method or function that can be shown by outputting something in the console.

Arraylist:

//Here is a example of a Arraylist

int[] myArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };

 static String myString;

int[] myOtherArray = new int[20];

// Or you can initialize it in the constructor.

for(int i = 0; i < myOtherArray.length; i++){

    System.out.println(myOtherArray[i])

}

//again this is a example of something isn’t a function or method and can’t be input into the console with some values to show what it can do. It’s just a way to make a array that is able to do something that makes array based work a lot easier and more efficient.

Update on Progress from Weeks 1-3:

In the first three weeks of the project I worked on experimenting with NEAT in Python. I had still been studying for ACT for most of this time so I didn’t want to take away from my practice by diving deep into coding. NEAT stands for NeuroEvolution of Augmenting Topologies which is basically a fancy way of saying an arbitrary evolving neural network which is a type of “AI ” that tries to make itself better at something depending on what you want it to get better at. When I was messing around with this library I wasn’t trying to actually work on implementing it into some form of a game – which is something I might do in the future. I just wanted to kind of understand the barebones of it. This doesn’t mean any of the hard syntax behind it but the logic of what they are trying to do. To my understanding Neural Networks are a fundamental part – or logic – behind a lot of self learning and deep learning algorithms. A neural network is a coding simulation of the human brain’s use of neurons and how they move throughout their mind. It’s basically the idea of creating a input layer and an output layer and then having a tone of yes or no functions in between them. The data will go through these layers and will be separated through these functions and will thus be sorted into something that the human and code for. The really interesting part is the evolutionary aspect for it because it is a very fundamental way the computer can choose which functions are best for getting an outcome closer to perfection depending on what the user’s view of perfection is. I found my research on these questions and ideas really interesting.

Update on Progress from Weeks 4-6:

Between weeks 3 and 6 I started working on getting ready for the subject test by working on 2D Arrays, Subclasses, and Recursion. 2D Arrays are very similar to Matrix unlike regular Arrays but instead of just having the columns it also has the rows. When you are initializing an 2D array you just have to write two [][] instead of one. You can also think of it as an array inside arrays. The logic behind 2D arrays is pretty similar to 1D arrays except you need to almost repeat each loop step. Subclasses are basically the idea of building a smaller class inside another class. For example if you are making a game and you have a enemies class you can have a boss subclass. This makes sense because a subclass will have all the methods and fields of the parent class but the subclass and have special fields and methods to that specific thing. Recursion is something I’ve done before but I’ve never mastered. It’s a very weird type of looping where you call the function inside a function which makes it run onto another return function. I find it hard because you have to think of the function almost as a loop but the information for the iteration of the loop and its info is from the previous loop of the function or last running of the function. 

Update on Progress from Weeks 7-9 (include any photos or video if relevant):

In the last week of my project this Trimester, I focused on three main concepts: Arraylist, Public, Private, and Static variables, and sorting ideas. I worked on ArrayList for weeks 7 and 8. ArrayList is a way to get around the issue of Java’s typical arrays. A normal array in java can only have a certain number of saved values. This is to save memory – which makes sense, but can be annoying sometimes – when you are initializing a variable in java you are creating a section in memory to store some type of data – numbers, letters, single characters. This means that when you initialize an array you can only pre allow so much memory in a certain spot, you can add to what’s in that spot but you can’t extend it. An ArrayList gets around this by basically using iterations of class to be the data points in the memory spot. In Java classes can make an infinite number of iterations of the class so you can make as many points in the array you want. Also, the ArrayList class has some really useful methods built into them so it’s nice and easy to use. I worked on public, private, and static variables and sorting ideas in the final week. The public, private, and static variables are a way to determine what kind of memory of variables or fields are stored in. For example, the public is the default variable and will cause the variable to be able to be changed anywhere. A private variable can only be accessed from the class or place where it was originally initialized. Finally, Static variables are a thing that can be used in classes where all the iterations have the same memory spot. This means that if you have for example an enemy class and you make three different zombie iterations then all three could share the same health where when one is changed they all change. I also worked on some sorting ideas which was more the theoretical idea of taking time vs efficiency, and big data functions/methods. I didn’t have enough time to finish this subject but I’m currently working on understanding the various merge sorts, and how mathematical they shorten the total time and efficiency.