Virtual Lesson #2 – Logos & Branding Research

Task 1:


Task 2: 


This logo is an emblem type. Initially, Ferrari just copied the horse from the horse that was painted on a fighter plane of a heroic airman during the first world war. The logo is successful because it symbolizes the company perfectly. The horse is a symbol of speed and power. The green, white, and red colours at the top represent the Italian flag colours. The logo is interesting because it is extremely simple and doesn’t have too many letters. Also, all the colours on the logo complement each other. One prominent principle of design seen in this logo is balance. The majority of the logo is symmetrical and the horse is balanced on both sides. 


Berman, Nat, et al. “The History of the Ferrari Logo.” Money Inc, 25 May 2018,


This logo is figurative/pictorial, however, Google used to have a typographic logo for the majority of its history. The google logo only had minor changes until 2015. This is when they changed the type of logo. I think this logo looks better than the previous ones because it is more simple and smaller. An element of design used on this logo is colour. Again, the colours on the logo complement each other well. Furthermore, the colours are all primary except for the colour green. According to Ruth Kedar, the designer, it’s supposed to represent that Google doesn’t always follow the rules. 


Admin, Joe – LMW. “The Meaning of the Colors in the Google Logo.” LogoMyWay Blog, 3 Jan. 2017,


Instagram’s logo is also pictorial because there’s a camera to represent the app. It shows that the app is for people to take photos and videos to share across the platform to their family and friends. The older logos were more complex as they had more detail on the camera and the colour scheme was dull. The new logo is far more simple and visually appealing. The elements and principals of design this logo includes are colour, shape, and balance. The logo itself consists of two different shapes: a circle and a curved square. In terms of balance, the logo is almost perfectly symmetrical. Finally, as mentioned before, the colour scheme makes the logo vibrant and interesting. 


Task 3:


Pixel art can be described as when the artist is manipulating the image with deliberate control over the placement of each individual pixel. The best file formats for pixel art are GIFs and PNGs. Software to achieve this includes Deluxe Paint, GrafX2, GIMP, Microsoft Paint, and Krita. 


Vector graphics are computer graphics images that are defined in terms of 2D points, which are connected by lines and curves to form polygons and other shapes. Vector graphics are commonly found in SVG, EPS, PDF, or AI graphic file formats.


DPI stands for Dots Per Inch. The greater the value, the better its quality, however, it does take more space and ink to print these images. 


Because vector images are composed of paths rather than pixels, the quality of the image after its been printed is far better than a raster image. Also, vector images usually require less space than raster images. 

Home Still Life Composition (S)

Chosen Composition:

Class #1:
During this class, I spent most of my time setting up my composition with objects around my house. After the zoom check-in, the first 20-30 minutes involved me looking for objects that wouldn’t be needed for a week. I also made sure to find objects that had unique shapes and curves. A key element in deciding my composition was elevation and perspective. I wanted the objects to be oriented in different angles and kept close to each other to make the composition more complex and interesting. My goal was to make the right edge of the tissue box my focal point. Hopefully, this is seen in my drawing, considering the edges are a lot thicker than most other parts of the picture. I started observing my composition closely this class, trying to determine where to begin drawing and the proportions.

Class #2:

This class was entirely spent on drawing my composition. As seen in the picture above, I managed to finish most of the composition except for the plants and the other end of the mat. I decided to begin with the simple objects like the tissue box and the mug because it would make it easy to determine the proportions of each object relative to the edge of the paper. Because of my process, I left the most challenging part of the composition, the plants, for last.

Class #3:
Scanned Drawing

Attached above is the finished version of my drawing. I managed to finish my drawing by the end of this class. Most of this class was spent on finishing up the plants and just outlining the objects with a pen. I started by outlining all the objects with the same thickness. After doing so, I decided to outline objects that were closer to me multiple times to emphasize the difference in thickness. Outlining and the orientation of the objects in the composition, allowed my drawing to look three dimensional. I also tried to show this by making the plant pot smaller than other objects in the composition because it was further from me when drawing. I think I was successful in achieving this because it’s apparent which objects are in the foreground or background.


Still Life Composition Reflection:
Some of the biggest challenges were drawing the shapes of all the objects correctly. For example, the object in front of the tissue box is a unique shape, making it difficult to draw the curves accurately. Another significant difficulty I faced was drawing all of the details of the plants. To solve these issues, I had to split up objects into smaller parts, mentally. I also got close to the object I was drawing to observe the curves further.

Three tips:
1. Setting up the composition is more important than what you may initially think. It’s important to find objects that aren’t too complex, but also unique to create an interesting visual. The orientation of the objects is also significant in creating a visually appealing image.
2. Draw the simple objects first to get an idea of where each object should be with respect to the paper. This means that if you make a mistake, it can be fixed easily.
3. Draw the rough shape of all objects lightly first. After getting all the proportions correct, then make small adjustments to the shape of each object.

I’ve never considered myself to be good at drawing. Before this class, I’d often struggle to draw simple objects. But throughout this project, more importantly, this unit, I’ve learnt how important it is to observe before drawing. This one change I’ve made since the beginning of the year has made a massive difference in my drawings. Furthermore, I’ve also learned a little bit about how varying thickness can make a drawing look more three dimensional.

This project was relatively tricky because a lot of thought goes into the whole process. Before I began drawing, I needed to make sure my composition was not too complicated but still interesting. While drawing, I had to look at the proportions of objects and their position in the space around. After drawing, I had to focus on the edges around the objects to create a more three-dimensional representation.

Other than the techniques mentioned above, I also tried to make complex sections more simple. For example, I decided to only include the outlines of the plants. However, even though this made it slightly easier to draw the leaves, it doesn’t look very similar to the original composition. I think details are one of the major areas I still need to work on to improve my drawing.

I could improve my still life drawing by adding the details to the mat and to the tissue box. If I had more time, I would try to do this, however, adding these details would be too time-consuming. Furthermore, if I had a thicker pen or marker, I would try and make a portion of the background black to emphasize certain parts of my drawing, like the tissue box.

APCSA Final Project – Challenges and Solutions

My first challenge as explained on the google slides was that I was unable to display multiple elements of the hangman at once because each object was different. This is what my code looked like:

Here is the face and body of the hangman, however, as you can see I was only able to display one of them at once but struggled to display both at the same time. I then decided to make a class hierarchy where my “Body” class was the subclass of JPanel and all my other small classes (“Face” and “Arms”) were subclasses of the “Body” class. This helped me see all elements of the hangman at once, but the issue now was that I was unable to format it the way I wanted it. This was probably because I couldn’t overlap two JPanels so it wouldn’t let me move it close to the other JPanel. Here is what it looked like:

Finally, I decided to use one main JPanel called “container” that held all the other JPanels. This allowed me to see all the elements and format it the way I had liked. Instead of using multiple classes to create the hangman GUI, I decided to use one class and if-statements that determined how many elements needed to be displayed at once.


I had another major issue with my code which was making it impossible for me to refresh and repaint the JFrame after getting one question incorrect. The problem required a lot of different ideas and research, however, in the end, the issue was fairly simple: I didn’t tell the computer to add the new JPanels into the JFrame every time I got a question incorrect. The way I diagnosed this issue was by attempting to do the same thing, however, outside of the loop. This worked because the main method would update the JFrame after calling the playGame method. In order to fix this, I created a separate method called changeGUI, that would accomplish all of these tasks inside a loop.

APCSA Final Project – Design Thinking Cycle

The purpose of this project is to create a final product that covers everything we’ve learned throughout the year, specifically topics that we believe we didn’t show good enough understanding in. I want to show my growth in knowledge in terms of arrays, arraylists, abstract classes, and interfaces. For my project, I have decided that I will show my understanding of these concepts and build on this by using a different library to create a GUI to show I can implement what I’ve learned into something more useful.

My audience is anyone that’s bored and just wants to play a quick fun game. These days there are many times when people don’t have access to the internet or have nothing to do and just want to play a fun and simple game that is easy to understand. An example of this would be a long car ride, where a simple game can really make the time pass by quickly.

The app store on our mobile phones is full of games that fulfil its purpose and are targeted to my audience. One of my ideas would be to build the game Hangman with a GUI because it is such a simple game, yet it can never get boring. It’s the game that fulfils all of my requirements, while also being reasonable for me to create as a beginner of GUI. Other games that would fulfil my requirements would be Tic-Tac-Toe, Dots and Boxes, or some card game. However, due to the lack of time and knowledge, I think it would make sense to create a Hangman game.

To build a hangman game, I have to use a different library so that I can create my GUI. In the end, I decided to use Swing because it is a popular GUI, meaning that it would be easier to search up and fix any problems I encounter. If I have the time, I would ideally put everything in a GUI, however, if I don’t have enough time to finish the GUI, I may create the hangman drawing on GUI, while creating the rest of the game on the console as it would be more familiar to me.

Throughout the entire process, I will test each and every part of my game and eventually combine all of my segments of code into a final project. After I finish the project, I will test different inputs and options to ensure my code doesn’t break. After which, I will let some of my family or friends to test out the code in case I missed something.

APCSA – Array Lists

For this lesson, we needed to code a sequential sort program using ArrayLists. This meant learning new syntax and functions. This didn’t seem too difficult when we were required to use only one class, however, when asked to use two classes, I was unsure of how to run an ArrayList method. Before, when using basic data types (ints, strings, chars), to run a method we just needed to make an object and use the name of the method with brackets to run it: objectName.methodName(); But with arrayLists I was unable to do this. I tried to look up how to use multiple classes and arrayLists but I was unable to find anything to help me out.

Link to Github:

APCSA – Encryption and Decryption

For this project, I decided to code the Autokey Cipher because it was one of the most interesting ciphers I researched. At first, I wasn’t really sure on how the cipher would work as all I was given was a simple grid. But soon enough I found a pattern with the grid: The encrypted character corresponds to a value where the value of a character on the key plus the value of the corresponding character on the plaintext minus one.

Autokey Grid:

Although this cipher was invented by the same person who invented the Vigenere Cipher, the autokey is generally safer than the Vigenere Cipher. Additionally, because we use a key that is user-generated, it is very difficult to decipher this unless a hacker knows the key that was used. This cipher is, however, relatively simpler than some of the more complex ciphers out there.


This project was a great way for me to show everything I have learned in this class so far as I think I did a good job at showcasing most of what we have learned except for arrays (unless we include Strings and they are an array of characters). The reason I didn’t use arrays was because I didn’t need them in order to encrypt or decrypt.


August 30th, 2018 APCSA – Multiple Classes and Calculator

The videos below explain the new things I learned in class which expanded on our previous knowledge (from last class) on multiple classes. However, this time instead of making an object in the code itself, we used scanner to make the user’s inputs define the new object. The videos are explanations of the Hero project and our calculator.

August 22nd, 2018 APCSA – Variable Types & Return Function

In this class, we expanded our prior knowledge of arguments, learned about the different variable types and how to use them in Java, and utilized the return function to return values to the main function.

There are many different types of variables such as integers, strings, characters, floats, doubles, booleans, etc. Integers are whole numbers, while doubles and floats are decimal numbers, however, float variables are less precise as they are only 32-bit compared to doubles (64-bit). Strings are words, phrases, or sentences, while characters are a single letter. Finally, booleans have values of either true or false.

The return function is usually used in a function other than the main function. The purpose of “return” is to return the value to, most likely, the main function. In my example, I have a main function that simply prints the results. However, I also have separate functions that perform an operation to find the area of a shape and return the answer to the main function to print out the value. This helps organize the code as all the operations are done separately, while the displaying/printing is also done separately. 

The difficulties I faced in this class is common for most people learning a new language, syntax. Obviously different languages use different syntax to perform the same task, so adjusting to a new syntax is always difficult but over time it becomes less of an issue, similar to when I learned Python.

An argument is like an input in an array that can be used in the code to perform a function. So in my example above, I use arguments to determine what function to operate and what numbers to use in that operation. This is similar to a basic area calculator. Args can be named anything as it is similar to a variable determined by the user. Therefore, in the second line, I can change “args” into anything like “areaInt”.

August 20, 2018 APCSA – BlueJay

Today we learnt how to pass arguments through the command line in Java. The argument can pass a string if the main class is written like this: public static void main (String[] args){ }. This is because we use String[] in the parameters of the main class. In the command line, we can pass any string. There are many different methods to print the arguments. We can use a for loop or just “System.out.println(args[0]);”. The for loop is more effective when there are many arguments, however, if there are a few arguments we can just use “System.out.println(args[0]);

I found learning the structure of for loops difficult compared to python as the syntax for python was far easier. Hopefully, through practice, I should be able to learn Java syntax. Writing on BlueJay is also more difficult than other IDE’s because you have to write every character out, whereas, in other IDE’s, the IDE makes it easier to type code.