TED Talk Self Reflection

Today, I presented my TED Talk about the Java programming language to our gifted class. This was a great experience for me since it improved my presentation skills and provided and opportunity for me to inspire and teach.

I thought the content of the speech was spot on. It covered most of the topics necessary and allowed me to explain the Java language a bit, something I treasured. However, I did notice that I did not explicitly state my purpose for the project. During the Q/A session, I did explain my purpose of using Java on the robotics team; but since this was not mentioned in the talk, I lowered my score a little bit.

In terms of delivery of the talk, I thought I did well. The introduction and conclusion were in full circle format, something I thought would put meaning to the speech. I also thought the hook to my talk was pretty interesting. Another thing I tried to do was land a couple of jokes. After presenting, I did realize that my jokes weren't as funny as they were supposed to be. This made the talk awkward at points. Adding to this was the point at which I had a pause of around 2 seconds to breath and find my place. Due to these factors, I rated my score lower than maximum for delivery.

After analyzing my presentation, I settled on a critical, yet comfortable grade for my TED Talk. I rate myself:

26/30 or 86.7%

Update

Just to let you all know, to see all the blogs I've commented on, visit the "Check out these other cool projects!" post.
Mainly, I've commented on two or three blogs multiple times, but sometimes, I branched out and looked at some new blogs.

Thanks!

Cycle 6

Welcome to Cycle 6!

This week, I have been finalizing my talk and refreshing my mind on some previous Java topics that were a bit difficult to understand the first time I learned them. 

For my TED talk, I had decided during Cycle 5 that I wanted to make the inspiration the heart of my speech. My inspiration for the project was mostly my Robotics team. I also added the fact that most apps on electronic devices nowadays run on Java. I plan to use this fact as the hook for my talk. Other than this, I also plan to show some of my programs and talk about difficulties that I had with the project. This is really exciting and I cannot wait to give my talk to the class!

The next thing I did was refresh my mind on previous topics that I learned. One of the concepts I had difficulty grasping was the introduction to programs (Cycle 4). I did not understand at first ow to make introductions to different types of programs. For example, the main introduction I studied was "import static java.lang.System.out;". This is an introduction to a program that displays text on the screen. I now know that I have to alter the "java.lang.System.out;" part to tailor the intro to different programs. This would be based on the class, or topic, of the program (For more on classes, see Cycle 2). After figuring this out, it made it a lot easier to understand the rest of the programs I studied.

Another topic I had difficulty with were operators. These were functions that allowed me to add, subtract, multiply, and divide numerical values. At first, I did not understand operators like "+=", and "*=". These are operators that add and multiply values and keep the resulting value. I did not understand how to implement them into my programs. Now, however, I understand that I need to use them with variable in order to make them work. This cleared up my confusion, and helped me understand the programs more thoroughly.

Finally this cycle, I learned one more new technique. In my book, it teaches switch statements with a very good example. Thanks to them for this example:

switch (verse) {

case 1: 

out. println ("That's because ...")

break;

Okay, so let me explain a switch statement. The above program displays repetitive lyrics for a song. Instead of typing the same lyrics over and over and over again, I can put a switch in there. The switch tells the computer, in this case, to go back to the main verse of the song. This way, a programmer doesn't have to continually type the same lyrics more than once. This is useful for writing efficient, easy-to-understand code, and I'm glad it exists. I wouldn't want to type repetitive song lyrics!

So, throughout the six weeks, I have learned how to write basic to slightly advanced Java programs. This has led me to truly understand and admire the fact that Java is so versatile. I now know for sure that I made the right choice choosing Java programming for my project. I cannot wait to start using my new found knowledge to write programs outside of school.

See you soon, and remember,  use those switch statements!

Cycle 5

Welcome to Cycle 5!

I am excited to announce that I have began to write programs that will show during my TED Talk. They include all the techniques tat I introduced in earlier weeks. To make it less overwhelming, I decided to make simpler, more "to the point" programs, than one large program that does everything. I plan to show these during my talk and give brief explanations on what they do.

Other things I did this week were: I started looking at some more techniques and tried adding my own twists to the examples given in my book. For example, I learned about Java functions called loops. A loop is a function that tells the computer to do something over and over again until a desired outcome is displayed. Loops can be used in many circumstances, but in this case, I'll show you a guessing game. This is a small part of a guessing game program:

while (inputNumber != randomNumber) {
out.println () ;
out.println ("Try again") ;

This part of a looped program tells the computer to redo the original task, which, by the way, was to ask a player what the secret number was. This loop is put after the parts of the program that ask the player what they are going to do. This is because the computer needs to know what to ask before knowing what to do after asking.

Another technique I learned this week was how to save and reuse parts of programs, called code. I found this very interesting because I found out that I would have many problems with simply copying and pasting code into a new program. I learned that I would have to make the code fit with the new program by tweaking it to work with the context of the program. This was a bit complicated so I'm not going to show any examples, since it would be difficult to include many programs into this blog. Instead, I'll move on to my talk.

During this week I figured out what I wanted to do for my talk during class. I decided to speak about my inspiration from Robotics and the 21 century technology updates. This proved to be very motivational for me since I realized I could do so much with my programming. This, I decided, would be the heart of my speech. I thought I could also show some simpler programs that I shared in my blog during the past weeks to give the audience a sense of what I dove headfirst into. I hope to reach the minds of the audience members and motivate them to try programming because of its benefits.

So, I've definitely come a long way from week one. Next week I'll be finalizing my talk presentation and tying up some loose ends about what I learned about Java so I can speak about it on stage.

See you next cycle!

Cycle 4

Welcome to Cycle 4!

This week, I've been looking at some savvy new Java techniques. I studied different types of variable usage, such as operators, and decision making statements, like if/else statements. I also allowed myself to become familiar with my IDE so I could start using the things I had read about to start writing code.  The new things I have learned this cycle are more advanced than the fundamentals, which made it a bit difficult to understand, but once I put them into my programs, I should be able to understand the concepts.

This week, I started learning about operators. Operators are symbols that you can put between numbers, values, or variables in order to perform mathematical operations with them. The usual operators are +, -, *, and /, which mean, addition, subtraction, multiplication, and division, respectively. But there are other operators that can be used on top of these. These operators are symbol like > and <, which mean greater than or less than. These operators are useful when you are looking to ask the program to do a specific function when a certain value is greater or less than the other.

Now, I'll talk about if/else statements. These are lines of code that tell the computer what to do when it encounters a fork in the road. For example, let there be a program that played a guessing game with a player. The computer would pick a random number between 1 and 10, and the player would try to guess the number by typing it into the keyboard. This is a prime time to use the if/else statement:

if (inputNumber == randomNumber) {
System.out.println ("You win. Nice guess!") ;
} else {
System.out.println ("Sorry, but that isn't right.") ;
System.out.println ("Thanks for playing.") ;
}

This is only a part of the program described above. The if statement above tells the computer to check if the number the player put in was the actual number (inputNumber is the number that the player puts in, and randomNumber is the computer's number). If this is true, then the computer tells the player that they win. If the statement isn't true, the computer moves on to the else statement. Reading this, computer tells the player that they lost. If/else statements are great for use when the action needs two paths to fully address every aspect of the function. This is one of the most commonly used statements in most programs.

Another thing I learned this cycle was how to make an introduction to my programs. Think about introductions this way: If a lecturer started talking about a subject like Java programming without a proper introduction, the speaker would have to keep reminding the audience that he/she was talking about Java. With introductions, the audience would not have to be reminded of the topic. This is why Java introductions are so efficient. They allow a programmer to tell the computer that the program is mainly trying to do one specific function. This allows the programmer to omit certain lines of the code, since the computer already knows what it needs to do. Let me give an example of an introduction:

import static java.lang.System.out

This introduction lets the computer know that the program is about printing something on the computer screen. This means I don't have to put a certain phrase every time I mention a variable. It makes the code much more streamlined and easy to use.

This week has been really interesting for me. I started to learn about some new, advanced programs that reinforced the fundamental concepts and helped me move forward with my quest to lean about programming. As I mentioned, my IDE will be a great help to me now, since I actually know how to use some important features. By next week, I hope to start writing some of the simpler programs that I want to show during my TED Talk.

I hope my journey has been just as interesting for you as it has for me. See you back next cycle!

Take a look at my video blog to see how I started with my endeavor.

Cycle 3

Welcome to Cycle 3!

I have totally immersed myself into the world of Java and its object oriented greatness during this third cycle. The journey has been interesting, with me discovering new, hidden secrets about Java every day. This week, I went more into depth with the fundamentals of the Java programming language and then started to follow some instructions in my Java For Dummies book to make some basic data manipulation programs. So, fasten your seat belts, because you're in for a wild ride!

First, let me explain fundamentals i more detail. I'll build on what I covered last cycle. Some new fundamentals I learned about were different types, like "char," "double," and "boolean." I also learned about how to manipulate variables in my programs.

Types in Java allow us to describe certain variables to the computer. A variable, as the name suggests, is an object or numeral that varies depending on a certain input. In mathematics, we name variables as letters, like a, x, and n. In Java, variables can be named anything that "floats your boat." If there was a program that told people how many people could fit in an elevator, I could name the variable that examines how many people get onto the elevator "numberOfPeople," or "pie," or "peopleThatBoardElevatorsDefinitelyLoveJava!" It is also worth noting that variables that are multiple words are named without spaces. Also, the first letter is lowercase and the first letters of every other word are capitalized. Now, on to the types. I'll explain three types that are used in Java: the char type, the int type, and the boolean type. The char type is the way Java describes characters that are variables. For example let me show a demonstration:

class HowToUseTheCharType {

public static void main (String args[]) {
char theFirstLetter =  'h' ;
char theSecondLetter = Character.toUppercase (theFirstLetter) ;
System.out.println (theSecondLetter) ;
}
}

Okay, so this is a whole program that eventually ends up displaying "H" on the computer screen. This is a way to use the char type. For now, don't worry about what the "Character.toUppercase" means (I bet you can infer!). Concentrate on the formatting of the char variable. When describing a char variable, the value is enclosed in single quote marks. This can be used to store character values in the computer and use them later.

The next type is the int type, which describes variable values that are whole numbers. For example:

int tirePressureRating
int timeToRunCompressor

This would be part of a program that would figure out how much air to put into a car's tires. I haven't put the whole program in here for reasons of simplicity, but this is the basics of the int type. Before telling the computer what the values of the variables are, the computer needs to know if those values are decimals or whole numbers. By writing "int tirePressureRating" the computer figures out that the tire pressure of a car has to be  a whole number. This type is useful in situations where whole numbers are required or to use less processing power from the computer.

Finally, let's talk about the boolean type. The boolean type is used to evaluate true/false statements. For example:

int tirePressureRating
int timeToRunCompressor
int actualTirePressure

boolean actualTirePressure = tirePressureRating ;
System.out.println ("Your tires are ready to roll!")

Let us now analyze this piece of a program. The int variables are there to show that all of them are whole numbers. In the next statement, the boolean type is used to run a command on the screen; in this case, to display  "Your tires are ready to roll!" The boolean in this case needs to be evaluated as true for the display of the exclamation. If it is false, another part of the program would tell the computer to continue filling the car's tires. This is very useful in true/false situations, where precise quantities need to be measured in order to evaluate the statement.

These types will hopefully be helping me next week when I start to make more basic programs. I also plan to learn about the strategies for writing programs concisely next week. That'll help me make code that is easy to understand.

Just a quick side note: In my IDE, or developing environment, I am learning how to use new tools and functions that will help me jin my quest for programming. Refer to Cycle 1 for more information about IDE's.

See you back next cycle!

Check out these other cool projects!

I've commented on these blogs:

• http://oneill-luxem.blogspot.com
• http://quadroflcopter.blogspot.com
• http://heylookiwroteabook.blogspot.com
• http://dasgenius.blogspot.com
• http://sundrew.blogspot.com
• http://johnrecording.blogspot.com
• http://samkesgeniusproject.blogspot.com