What a semester.  Finally done with all finals and I finally have free time.  This semester in Into to Unix was quite interesting.  I expected the class to be somewhat like ECE1574 or 2574 where we simply just code in a unix environment.  It turned out to be somewhat of a surprise as I learned much more than that.  I didn’t even know what piping was before coming into class.  I’m also much more knowledgeable on many aspects of the Ubuntu.  I might be using bash commands a good number of times in the future.  Learning python was also a good refresher.  I had only known about simple python programming beforehand.  Learning about the history of unix and its impact on the world today was also a big eye opener.

I also realized that c++ on unix is very different from a windows environment.  I had only used visual studio before on windows.  The coding itself is the same, but using g++, gdb, makefiles, etc, makes it a completely different process.  Very enlightening.

With regards to the Final Project, we will be fixing it up soon.  We’ve read the comments and appreciate the feedback.  All of us had many finals so there hasn’t really been much time to edit the project. We will be getting to that soon.  Don’t think we were ignoring comments. =)

Hope everyone has a good break.  I’m out.

I saw the “advertisement” for lynda.com on the front page of scholar the other day.  It intrigued me a little bit so I decided to check it out today.  Turns out it’s quite interesting.  There are many tutorial in many different fields.  Photography, video editing, animation, music production, it’s all there.

More notably, they have a very large selection of software guides.  There are guides for probably anything you can think of. There’s mobile development, python 3 tutorials, even a tutorial for Unix for Mac users.  And a guide for github.  I didn’t know github was extensive enough for a guide.  The video for it is over 6 hours long…..

Anyways, you guys should go check it out. You have to log in with your VT account though. Just click the lynda.com icon on the following page:

http://www.olcs.lt.vt.edu/lynda/

Ever since I started using Ubuntu, I have been discovering little things about it that I really like.  For example, when I’m ready to shut down my laptop, now I’m almost exclusively using the command “sudo shutdown -P now.”  Interestingly, this method takes way longer than if I just hit the shutdown button, but using the command gives me a sense of satisfaction.  I prefer using this method over the button, even though I have to enter my password every time.  I also really like the way commands are set up.  Typing ./ and then tabbing to autocomplete when I run an executable or script is very convenient.  It really helps to facilitate coding and debugging.  The bash interpreter/commands are way better than those on Windows.  Additionally, I really like how the terminal is laid out.  It seems very friendly and different types of files are distinguishable from each other through colors. Unnecessary info is displayed unless I want it to, unlike in Windows.

However, there is one thing in particular that I absolutely hate about ubuntu.  I believe the GUI is one of the worst interface I have ever used, especially on a laptop with limited screen space.  Placing shortcuts on the left side is stupid and adding running programs to the same bar is also stupid.  I’m sure I would be able to tweak a setting something and change the functionality, but for now I don’t use the linux environment enough for me to take the time and do it.  Whenever two minimized programs are overlapped in the same screen area, clicking on one of the programs will cause it to show.  When you click on the other, that one shows.  One would assume that both are now no longer minimized and are overlapping each other on the screen and you can just move the top one. NOPE.  The first program gets re-minimized automatically.  In 3574, later testing of your code usually requires 5-6 instances of the program.  This is a COMPLETE pain when things get automatically minimized.  Also, the shortcut on the left bar to the program tells you how many instances are open. Good right? No, not really.  The little arrow that tells you how many are open stops are 3, even if there are 6 open.  All 6 get consolidated to one shortcut…..

Anyways, long story short, terminal? great. GUI? bad.

I guess it was meant to be that way anyways.

In the research for my futures paper, I came across the fact that operating systems based on Linux are now widely used in many industries.  I decided to do some follow-up research and see exactly how widely used it is.  To my surprise, Linux is not only widely used in commercial industries, but also many other surprising places.  A notable article I came across listed 50 places that Linux is used.  The article can be seen at:

http://www.comparebusinessproducts.com/fyi/50-places-linux-running-you-might-not-expect

Among some of the largest users of linux include the U.S. Department of Defense, the U.S. Navy, governments of foreign countries/cities such as Spain and Munich, Germany.  Even the bank of China uses linux, something which came as a big surprise.  I never would have thought that a country such as China would ever sponsor Linux.  Even Cuba uses it, even though it is a proprietary development.

With respect to education, it seems like many foreign school systems and universities have also switched mainly to some form of Linux.  This is surprising since one would expect that United States educational systems would be leading adopters.

The article rounds out by listing many retailers and other companies that use linux, as well as research applications of linux. This article was written 2 years ago so things might have changed since then, but I still think that it may be very reflective of the current state of linux usage.

I’ve tried not to list too many details about the article in this post. I was hoping to just incite some interest and get you to check out the article yourself.

Throughout the course of this semester, we’ve studied many aspects of unix, linux, and ubuntu.  There are alot of defining aspects that one can easily see but we’ve never really defined the actual difference between linux and Windows.  It’s obvious to see that Ubuntu and Windows are completely different, but it seems like many of the main differences are hidden and skipped over completely.  One can clearly see that the entire GUI layout is different in a linux environment, but what if someone simply added a GUI layer onto Windows and added aliases for the commands? Would Linux and Windows then be the exact same thing? Obviously not.

Almost all Windows instances these days run the NTFS file system while some older systems still probably run FAT32.  Linux instances, on the other hand, usually run on a version of the EXT file system.  What exactly are the differences between the two?

Additionally, another obvious difference is the boot up and run speeds of the two operating systems.  Windows usually takes my laptop about a minute or two to boot up fully while linux requires only a couple seconds.  A simple explanation would be that Windows runs alot more services and programs on startup but I don’t think this is the only reason.  The difference is so dramatic that I think there must be some architectural difference that causes this.

A study of the mechanisms of actions between the two operating system would be a really stimulating subject.  Linux and Windows are so different that I feel they need to be placed in perspective and compared to truly understand the differences and how each accomplishes the same task.  In the end, both operating systems still get the job done and it may come down to personal preference.  Knowing the advantages and disadvantages of each would really be helpful in certain situations.

Here is my haiku describing the unix design philosophy:

Modularity,
But just keeping it simple,
these are important

and my limerick:

Unix, Unix, oh what a class

Hopefully with an A I shall pass

I had fun while learning bash

learning python was just a flash

I definitely gained some brain mass

Reading the other blogs, it seems like not that many people have heard of makefiles either.  I guess it’s one of the things that people skip over since it’s not one of the main things you worry about when coding, though it does make your life alot more convenient.

I’ve been wondering how a makefile or makefiles for large scale projects would work.  The makefiles I’ve created so far for the two assignments have been relatively short compared to how big it could be.  However, in both of these makefiles, it seems like both have required me to list essentially every single file that’s required to make the program run, as well as their object files.  This makes sense, since it’s logical for all filles to contribute to program functionality, but one must consider that these have been really small projects.  In a project with less than 10 files or so, the makefile can be very manageable.  Anything more becomes alot less manageable.  For reasonable large scale projects, such as one with 100 files, who can imagine a makefile with over 150 entries?  Even just looking through the makefile would be a pain.  Of course, a potential solution would be to use multiple makefiles, but then if everything is in one directory you wouldn’t be able to differentiate the makefiles.  If there were multiple directories, you would still require one really large makefile that indexed all the other makefiles in other directories.  Editing so many makefiles can still be a really big hassle.

Perhaps it’s time for someone to create a makefile management system.  I haven’t ever heard of a system that manages makefiles, but I think it would be relatively easy to create. The initialization could create makefiles based on existing files in the project, and then provide a gui interface which showed how makefiles linked to each other as well as allowed editing  This could really help out someone with a project of say, 500 files.

Over the course of the last several weeks, I’ve been slowly realizing that there is a really large difference in embedded software design(done in classes such as ECE2534) and just regular software design(ECE 2574, ECE 2524).  Both types of design can utilize similar languages or even the same language (C vs C++), yet have completely different purposes and methods in implementation.  When I was coding in C for the ECE 2534, I realized that nothing I was doing was similar to any of the other programming classes I had taken previously.  Almost every function called and every method used had some sort of physical manipulation of the attached microcontroller.  I say “physical” mostly because everything done has some sort of external effect, such as a pin wired high or setting an external bit in a register.  This is in contrast with conventional coding where everything is done within the computer itself, which I think is more “virtual.”

Rethinking what I just typed, I guess both types of design are also essentially the same.  The both read from some sort of memory or register where data with some meaning is stored.  Embedded design just takes it from an external source while conventional software design is all internal.  At the lowest level, all the processes and actions that occur are the exact same. Despite this, the additional extra layer of accessing pins and registers on an external device when coding embedded software still seems to completely change the way it’s designed.

I guess what it all really comes down to is the high level approach to coding and this seems to be the defining difference between CS majors and CPE majors.  Even though both practices utilize the same programming languages and skillsets, the difference in embedded and conventional software design at the highest level is just so different. I doubt that a CS student would be able to do the coursework of an CPE student without having to learn a large amount of material, and vice versa.

I just realized that g++ is not only limited to uses in linux and other unix enviroments.  When i was coding for ECE2534,  I noticed that MPLAB used the g++ command to compile my c files.  It’s interesting to note since MPLAB runs natively on windows, which was what I was running on at the time.  Some of the flags and modifying options looked very familiar also so I doubt that they just happened to name their compiler g++.

This makes me wonder how much its actually used without public knowledge.  Alot of programs could be using g++ without giving it much credit.

Unfortunately, I’ve had a massive workload over the last couple of weeks and as a result I’ve completely forgotten about this blog and haven’t posted to it.  I will try to post as much as possible over the next couple of weeks to make up for this.  Since I do alot of coding for my classes, I usually have a large amount of subjects to blog about.  The first subject, I would like to talk about is commenting code. As everyone knows, comments can make or break the code.  It allows the reader to know exactly what you’re doing and how each part of your code contributes to the whole.  Since comments are so important, I’m finding the lack of standardization on comments a little disturbing.  While there are various guidelines to how one should comment code, I firmly believe that there should be some sort of industry standard on code commenting, especially between different programming languages.  Even in the same programming language, there are so many different ways to comment your code and every person has a completely different way of doing it. For example, when coding in C, I prefer to add a short comment at the end of a line with // where I need to explain anything.  However, some of my professors like to use /* */ blocks on top of the code section, even when very little explanation is required.  I find that this sometimes disrupts the flow of the code.  You may be reading something and all of a sudden a big comment block pops up out of nowhere, and it potentially might not tell you anything important.  Additionally, different commenting styles can result in random placement of code that results from differences in indentation.  Someone may be using tabs and // after lines to comment and it may look perfectly fine in one development environment, but someone else opening the file up may have skewed commenting due to different screen sizes and tab/space differences.  Without some sort of standardization, individual commenting styles can be cluttered and messy. I also think there should be some sort of standardization across programming languages.  For example, python coding uses #, C coding uses either // or /**/, and I believe HTML uses <!– –>.  While it is understandable that they are all different for different reasons, if all coding languages had the same comment markers, it would streamline the process.  Adding that to a commenting standard that specifies where, when, and how to comment, it may potentially allow any programmer to read code in any programming language.  This can be good for both education and practical purposes.