The start of this course is showing us why C is such a powerful language, with regards to the problems we are attempting to solve. At this point, it seems that both languages can be used for our requirements. Although I am sure we will get closer to the machine, and we will see why C is such a versatile language.

So far, we are recreating the cat command on the unix command line. The logic behind doing so is similar to logic we have previously had to employ throughout our CS experience. But for me, instead of just including stdio.h like I usually do, we included other header files, that stdio.h includes and uses, giving us specific functionality instead of blanket including everything. Understanding what tools are required specifically for any problem, and being able to identify them, is a skill I soon hope to excel at.

After making a simple version of the cat command in C, we were challenged to come up with an addition to it that allowed the user to view line numbers given the argument. Through this simple version, we introduced command line arguments to our command. However, I could not seem to get the line numbers to show up properly. I could get the loop to spit out every line number, starting with the second line. It would display that line with the number properly, all the way through the last line.. plus two more lines for some reason. I could not get the first line number to effectively match with the first line of the “cat'd” file. I will have to look into that a bit more.

Next, we started our own implementation of the who command. So far, we have gotten it to print out the current user info, one at a time. It cycles through current user information when the desired key is pressed. I am interested to see where we can take this program. I am also interested in getting our first project so that I can take what we are learning and apply it more.

This week we completed implementing the who command in class. Our version is almost identical to the shells version of this command now. I am learning a lot about reading manual pages and the useful information they provide to us. As of now it is a little daunting, but I am sure that I will grasp it relatively soon.

We also implemented the list command, after finishing the who command. We got it to work properly in class, but I must have missed something as mine gets a seg fault when I attempt to run it. I will just have to comb through it more in order to figure out what is causing this issue.

Our first project was also assigned this week. We have to apply the change mode command in C. Luckily for us there is a function in the manual page that does this, given the correct parameters. So far, I can get mine to work properly so long as I tell it what modifications to make, and what file to change the permissions of before I run the program. I enter string literals into character arrays because you cannot initially an array with a variable. I need to figure out how to get the command line arguments I need into character arrays for the function to read. Once I can do this, most of my work will be done. If I can complete this relatively soon, I should be in good shape to complete the first project on time.

I found that our implementation of ls requires additional arguments to scan certain directories. It does not default to the current directory as the unix version does. So that takes care of that issue that I was having. We worked on it a little bit more last week.

I also finished my project. I got the command line arguments to process correctly as strings. I found a way to effectively store input from the command line into character arrays for the program to read from, in order to modify file permissions. After that, getting the verbose argument to work was the most difficult. the help and version were simple enough. I pretty much had to double the size of the program when I added in that argument. At the end of the day though, The program works as intended. I also feel a lot more comfortable browsing manual pages and looking for specific solutions to problems that I encounter.

This week we have to come up with a way to efficiently find the prime numbers up to a certain value. We were given two methods to use and had to come up with out own method to use after that. Our interpretation is supposed to be optimal as the other two are more rudimentary. The first implementation is using a brute force method in order to determine if a number is prime. The only efficient part is that if a number is determined to be not prime, it will cycle to the next one. It does this for an amount of times equal to the input number. After that implementation, I implemented the square root method. This is similar to the previous one, except for the fact that instead of going until the number you’re checking the primality of, you go to its square root. This method appeared to be a lot faster.

With my own interpretation, I decided to use the Sieve of Eratosthenes. With this approach, you find a prime number to start, say two, and eliminate every number in your list of generated numbers that are a multiple of that number. This method is by far the fastest. However it is the only one that uses arrays, so with that it is giving me problems. After a certain limit, I get segmentation faults and I am currently trying to figure out why. I refuse to go to a more straight forward method because now I don’t want to lose time when it comes to efficiency. I’ll keep having to mess with array sizes and the way in which the data is stored and parsed.

I have solved the implementation of Sieve of Eratosthenes with a little bit of help. After learning I had a few of redundant logical sequences, and two massive arrays of which I only needed one, I shortened the solution significantly. But I could not seem to get it to work, it would not allow me to assess values of certain limits. To fix this, I had to allocate memory rather than declare an array in order for it to work properly. After doing this, everything worked as planned. The run time of the Sieve was significantly faster than any of the previous implementations.

This week we started to take a look at forking our programs. We have to take the brute force methods and the square root methods that we had implemented last week, and make them much more efficient through the process of forking, allowing two or more algorithms, or multiple implementations of the same one to run simultaneously. This will in turn reduce the run time of the program by 40ish percent. At this point, I am still trying to wrap my head around how exactly to do this. In class we had an implementation that I mostly understand, but running an algorithm, especially parsing information from the command line to do it, it a little more tricky. I think that I have to just look at it a bit longer in order to grasp fully what is going on.

I have gotten a good grasp on how to implement a program that utilizing threading when finding prime numbers. So far I have finished the brute force method, aside from putting the thread outputs back in order. I am thinking that I can put them in strings like I did when running them under different processes. I am just not completely sure how it is managing memory so I would like to get confirmation that I attempt to implement the solution to that problem. I know implementing the square root threading program will be simple as I have the core concepts down. I am much more comfortable using structs as well as the arrow operator in my programs now too.

I think a big mental hurdle for me occurred last week when implementing multiple child processes. Wrapping my head around what goes on in a program that you write without explicitly seeing it was new for me. I couldn’t look at my program from the top down and analyze what was happening, I had to think about multiple things happening at the same time. Threading takes the same mental approach and since I have, at least in my opinion, gained a new perspective when approaching problems, the solution came a bit easier. After looking at it for a while and studying what threading is and the syntax to accomplish it, I surprisingly had no logical errors on my first compile. I can’t remember the last time that has happened. I am confident that going forward with this project I can finish it without rushing last minute.

Last week we also started to take a look at sockets. I have a feeling that sockets are going to throw me for another mental curve ball. We only started getting it set up, and I can’t even recall what exactly we did in class. I can definitely wait for that project to come around.

As an aid, feel free to use the following questions to help you generate content for your entries:

• What action or concept of significance, as related to the course, did you experience on this date?
• Why was this significant?
• What concepts are you dealing with that may not make perfect sense?
• What challenges are you facing with respect to the course?