
                           
                           
                           Note:  To make this website free to the public 
                           please click on an ad to support my sponsors or you 
                           can make a tax-deductable donation using Paypal 
                           (click on the donation icon on the left).
                           
                            
                           This video shows a robot 
                           writing a linked list program. There are no sound in 
                           the video because I wanted to show the viewers how 
                           the robot thinks while writing a software program.
                           Students in college 
                           learn linked lists in the second course of computer 
                           science. You can say that linked list are fundamental 
                           data structures that serves as building blocks for 
                           any software program. You can build simple programs 
                           like hello world or complex programs like an 
                           operating system using data structure and 
                           object-oriented programming.
                           It takes a tremendous 
                           amount of intelligence in order to understand and 
                           write a program using a linked list. The robot read 
                           books and attend lectures to learn about linked list 
                           (and other CS topics). He formulates diagrams, 
                           animations, static data, and flow charts on linked 
                           lists in his brain. For example, the understanding of 
                           a linked list is based on a primitive movie of what a 
                           linked list looks like and what it does. The robot 
                           might have a image of a train and each cart is linked 
                           to each other. This image represents what a linked 
                           list is.
                           Also, the robot has 
                           static data on linked list. For example, there are 
                           basically several parts to a linked list: node class, 
                           list class, and the main body. He has a general 
                           knowledge on linked list, as well as, a detailed 
                           knowledge on elements of a linked list. In the list 
                           class, he knows that there are methods to manipulate 
                           data in the linked list, such as: append(), delete(), 
                           or print(). And within each method are even more 
                           details.
                           In the video, the 
                           robot writes ideas and logic on a notebook. He wants 
                           to remind himself what he has to accomplish. By 
                           writing things down on paper he is able to organize 
                           his thoughts. First, he has to interpret the meaning 
                           behind the assignment. The robot tells himself the 
                           most important things he has to do. Next, he applies 
                           knowledge about computer science (especially linked 
                           list) to the assignment. Then, he creates the 
                           structure of the software program. First the 
                           structure of the program is general, then he includes 
                           the details of every single statement of the program.
                           In the video, the 
                           robot first constructs a general program structure: 
                           1. node class. 2. list class. 3. main body. After 
                           writing all three parts, the robot focuses on the 
                           details. The 3 methods in list class was done last 
                           because they were the hardest to write. During the 
                           robot's writing, he constantly looks at his notes to 
                           remind himself what he has to do. Think of the notes 
                           as guidance for the robot. He breaks up his program 
                           structure into steps and follows each step 
                           systematically. Sometimes the robot changes his plans 
                           and ignore steps in the notes or he might create new 
                           plans because the original ones were wrong.
                           This video on writing 
                           a linked list is very long and has 2 parts.