Untested (untestable) 0.3

I’ve finally had time to sit down and finish my 0.3 release.  It’s way late and I know I have several people waiting on parts of this release.  Andor has mentioned in several of his posts the reason as to why this release is untested or untestable.  I wish I could’ve had time to get together and work on this more with the group but things always got in the way, especially exams.  Anyway, my commit for 0.3 can be found by clicking here.  The tickets can be found here.

To describe them quickly, they’re the camera, ortho, perspective and frustum functions.  They required some calculations.  What ends up happening is after the calculations, the information gets put in a 3d matrix (which is essentially a 16 slot array).  I also created a primitive 3d matrix stack.  I’ll add more functions as they are required.  If you have any function requests for the stack, please place them in the ticket.

Now, this release will probably need more upgrades.  I can safely say that already because MinyXO created a PMatrix3D object, which makes for easy use of 3D matrices.  I’ll have to modify the functions and variables I’ve created to reflect that addition to Processing.js once it’s added.  So, that will probably be part of my 0.4 release as I’ve indicated on my tickets already.

Hopefully, with more free time over the holidays, I can talk to some of the group and get some testing done for my release.

Obsolete already?!

My most recent addition to Processing.js can already be considered obsolete.  Not even two weeks after the release, my fifteen minutes of fame will be coming to an end.  This is due to someone coming along with a better and cleaner implementation.  This may seem like a disgruntled post but it really is more of praise.  I was looking through the code and learned a few new tricks with using JavaScript that I never knew before.  It’s my way of showing praise to this new community member.  While F1LT3R might be a little busy to add Sephr’s new code at the moment, I already have my tests working under the new code.  Essentially, I was just using it to test the new code to make sure it didn’t break but I just left it there for when F1LT3R does have time to look at it.

Moving On…

Since my time with PVector is over, I’ve moved on to other things.  Last I mentioned, I’m working on the camera() function for the 3d objects in PJS.  While it’s not supposed to be too amazingly difficult, I’ve forgotten much of what I learned in my GAM programming class with COM objects and whatnot… So I’ve been doing some research, mainly in the Java Processing code and came across this.  It’s a Matrix object which is needed for 3d worlds and somewhat lacking in the PJS code.  Further research within the code, I saw that matrices were being used but mostly as 2d arrays.  So, I went into IRC and asked for some consensus as to whether we should implement a matrix object.  Andor was the only one that responded (him being our most 3d webgl expert).  He mentioned that we needed a 3d matrix stack for more general use.  There’s already a stack built within Canvas but I don’t believe it handles anything remotely 3d.  So we need one for our project in order to calculate and properly handle the transformations.  I’ve taken it upon myself to make the 3d matrix stack.  Now depending on how long this will take, I may have to push back some of my other functions (ie ortho, perspective) to the next release date.

Flimsy 0.2 Release

… not to mention late.  I was making promises for this release that I didn’t keep.  I was hoping to finish some other functions, but for now all I was able to do was complete PVector.  Hence, the name of this new post being “flimsy”.  Basically, I was stuck and I didn’t follow through on Dave’s teachings “to trudge through these times”.  I could’ve kept going and found some other functions to work on, but instead I just stopped working.  This can be seen by the fact that I haven’t made a blog post in almost a month.  Well, enough about berating myself over the past.  What’s important is learning from it and using it in the future; which I will do by getting a head start on my 0.3 release.  I pushed back my camera releases to get a better handle on it and the fact that there was no easy way to test 3d features before the 0.2 release.  This was all thanks to Andor and his work.  I’ll be looking at a whole bunch of 3D functions for 0.3 and hopefully I can follow through this time.

Now for PVector… reinvented!

That’s right, it’s brand spanking new!  The images above are examples of Processing PVector along with it’s JS Counterpart.  If you wish to see the new PVector, click here.  And just so you can compare the two, click here for the old PVector.  I was also actually stuck on a problem for PVector.  It was solved the Monday/Tuesday of the 0.2 release week.  I was able to finally sit down and talk to Al (aka F1LT3R).  He was able to show me the way to get myself unstuck from my problem.

Let me, first, describe to you what was happening.  We’ll focus on the add() method of PVector.  Here’s a copy of the old PVector add method below:

p.PVector.prototype.add = function add(){

	if (arguments.length == 3){
		this.x += arguments[0];
		this.y += arguments[1];
		this.z += arguments[2];
	}
	else if (arguments.length == 1){
		this.x += arguments[0].x;
		this.y += arguments[0].y;
		this.z += arguments[0].z;
	}
	else if (arguments.length == 2){
        var a = arguments;
        return new p.PVector( a[0].x + a[1].x,
                              a[0].y + a[1].y,
                              a[0].z + a[1].z );

	}
};

Now, above is a depiction of handling the three different uses of the add method; which can be found here.  The problem I was having was the prototyping function within Javascript’s objects.  I was using prototype to link this method in a clean way to the original object.  Now, the problem occurs when using PVector.add(v1, v2).  The method simply doesn’t exist due to the nature of prototyping.  To be able to use it that way, I’d have to type PVector.prototype.add(v1, v2); which is definitely a problem because this is a port of an existing application.  The number one rule of “ports” is to make it functional in the same way as the original.

Now you would think it’d be easily solvable by removing prototype, but another problem occurs due to the breaking of another object operator called “this”.  Removing prototype breaks the link to the original object, which in turn, breaks the functionality.  It wasn’t an easy problem to solve but Al, with his JS prowess, showed me a way to make PVector a wrapper and be able to use the functional language properly.

function PVectorAdd(){
    var a = arguments;
    return p.PVector( a[0].x + a[1].x, a[0].y + a[1].y, a[0].z + a[1].z );
}

function vectorStuff(){
    arguments = arguments[0];
    this.x = arguments[ 0 ] || 0;
    this.y = arguments[ 1 ] || 0;
    this.z = arguments[ 2 ] || 0;

    this.add = function(){
        if (arguments.length == 3){
            this.x += arguments[0];
            this.y += arguments[1];
            this.z += arguments[2];
        }
        else if (arguments.length == 1){
            this.x += arguments[0].x;
            this.y += arguments[0].y;
            this.z += arguments[0].z;
        }
    };
}

p.PVector = function PVector(){
      return new vectorStuff( arguments );
}

p.PVector.add = PVectorAdd;

I realized that there was room for redundancy removal and that specific calls went through specifically to how the method was used and split some of the code.  It might be a little less cleaner looking but the necessary checks are removed and I feel it’s cleaner overall.

The following link are the tests for PVector working properly (feel free to go through them all):  click here!

Also, I’m willing to give contrib credit to anyone in the class wanting to test the object extensively and give me some feedback!  Just leave a post!

Introducing the new PJS Object: PVector!

Well technically, I’ve already talked about this object a couple of times week alone.  There were some major issues with some of my code.  Mainly, certain parts just stopped working while I was trying to implement it from it’s lone source to the actual processing.js hub.  With a lot of help from Al (AKA F1LT3R),  I was able to debug most of my problems.  The resulting new processing.js library can be found in my repository.   The actual changes can be noted in the diff section.  Some of the additions in that section weren’t actually mine (I think they’re MinyXO’s; something about forking his repository) , but for some reason aren’t being seen by the repositories.  I’ve no clue how that happened but only the PVector part is what I’ve done (the big long green part at the bottom).

I do have some working demos; mostly just the examples given by the Processing reference page.

Add()   ver 1, ver 2
Sub()   ver 1, ver 2
Mult()  ver 1, ver 2
Div()   ver 1, ver 2

They’re definitely not as good as Andor’s 0.1 Release Demos.  I was looking for something more visual that would involve acceleration and velocity.  But, I wasn’t able to finish the whole object.  I’ve still got to work out on returning objects to be used.  Even with ideas from F1LT3R, returning objects is still giving me problems.

Earlier problems were resolved with the re-addition of “this”.  Sorry Dave, but it was simply easier to keep it in.  With the proper use of “this”, my functions started operating as normal again.

Looking ahead…

For 0.2, I’ve got to finish and work out the kinks out of PVector and I’ve also signed up for more.  Click here for the list of items that still need work.  When I finish PVector, I will probably focus on beginCamera(), camera(), and endCamera() functions.

More like release week!

I was a little presumptuous on my last post, thinking that the due date for this first release was on Monday.  I didn’t see the “week of” part on the due date.  Well that means I’m somewhat ahead of the curve.  I’ve got my working object in javascript and I’ve got the link to the actual object now that I’ve got my matrix account up and running again.  If you want to take a look at PVector in just in it’s entirety, click here.  Now that’s the semi-tested, though working, and uncommented version.  I’ll finish it soon as I finish testing, which I’ll be working on today.  It’s also the version that hasn’t been changed to stop using the “this operator” as suggested by Dave.

I can see the cause for concern with the operator… it doesn’t work the same way as I’m used to with Java and C# Object Oriented Programming.  However, there are instances where I am having trouble thinking of a way of taking them out.  Particularly, the instances when a method is referencing the main object.  Like in this particular method:

PVector.prototype.mag = function(){

	return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);

}

If I keep it to just (x*x + y*y + z*z),  I don’t think it’ll take the attributes of the prototyped object.  I’m not completely sure, as more extensive tests need to be done.  However I will for sure be taking out the “this” keyword in this sample code:

PVector.prototype.get = function(){

	return this;

}

I wasn’t sure that would work to begin with.  I have yet to see an example to show me that it does work.  So, that will be changed for sure.  Anyway, back to testing for me.  If I can get this working properly soon and all the tests pass, I’ll be looking to make a demo with hopefully some vector math (such as acceleration and velocity).  I’ve still got some work to do before then though.

0.1 Release Day!

So I’ve fallen back into old bad habits… basically, my previously closed source ways.  I procrastinated and failed to follow the mantra:  “Release early, release often”.  I did finish my object, without too much testing done, however.  I’ll give you some sample code from the actual object and then upload the code itself at the end of this post.  Despite my procrastination, I was able to finish the object in about two days.  This includes all the research for Javascript and some of the vector math needed to be implemented.  Now to show off some of my code work…

function PVector(){

	this.x = 0;
	this.y = 0;
	this.z = 0;

	if (arguments.length == 3){
		this.set(arguments[0], arguments[1], arguments[2]);
	}
	else if (arguments.length == 2){
		this.set(arguments[0], arguments[1], 0);
	}

	return this;

}

That was the main body of the PVector object.  Now, it looks a little horrible due to the formatting removal but it’ll have to do.  Now you know it’s an object, instead of a regular function, through the variables being created with the “this” command.  The variables are pretty self explanatory due to the nature of vectors.  The second part of the object are constructors or some type of overloaded constructors.  There is not a way to actually put different types of parameters into functions with the same name (which is ludicrous in my opinion because it’s a functional programming language).  However, I was able to work around that with the help of David Humphrey and Anna Sobiepanek.  They were discussing the very same thing in the #processing.js channel and Anna was kind enough to put up her findings in this post.  You will find a great many of the methods within this object require the system of using arguments because most of them are originally overloaded for many different uses.  In particular, I’ll show you one of the methods I struggled with… the mult() method.

PVector.prototype.mult = function(){

	if (arguments.length == 1){
		if (typeof (arguments[0]) == 'number'){
			this.x *= arguments[0];
			this.y *= arguments[0];
			this.z *= arguments[0];
		}
		else if (typeof (arguments[0]) == 'object'){
			var v = new PVector();
			v = arguments[0];
			this.x *= v.x;
			this.y *= v.y;
			this.z *= v.z;
		}
	}
	else if (arguments.length == 2){
		if (typeof (arguments[1]) == 'number'){
			var v = new PVector();
			v = arguments[0];
			v.mult(arguments[1]);
			return v;
		}
		else if (typeof (arguments[1]) == 'object'){
			var v1 = new PVector();
			var v2 = new PVector();
			v1 = arguments[0];
			v2 = arguments[1];
			v1.mult(v2);
			return v1;
		}
	}

}

I took some time to try and format this (I don’t know if it’ll work once I actually post it though), so that it’ll be somewhat easier to read.  Now, there were two main issues of concern for me while doing this method.  One of them was the fact of determining what kind of parameter was being passed through to the function.  This was due to the mult() function having the same number of parameters for different values.  I had to insert a nested if statement that would somehow figure out the type of parameter being passed.  I, initially, had no clue as to how to do this.  Fortunately, asking in IRC helped.  Our newest member, Daniel Hodgin, helped point me to the right direction of the typeof operator.  I, also, found a good example of usage at this site.  Now that I have that resolved, implementation wasn’t too difficult.  I, actually, had the same problem with the set() method but I decided to leave that one later and move on… but once I figured it out for mult, set was pretty simple as well.

Now, the second problem I came across is the fact that in the mult description (linking here again so you don’t have to scroll up) they were asking for two vectors to be multiplied into each other.  My first thought was “How is that even possible?”  A few years in engineering taught me that vector multiplication didn’t exist, aside from multiplying a scalar into a vector.  Research into the subject gave me the same thing.  All I kept finding were how-to’s on dot product and cross product.  Which, in the end, wasn’t what Processing was asking.  It took for me to look into the original Processing PVector source code to make sense of what was being asked.  Now, I may not be fond of what was being done, but I did it anyway because we’re only supposed to be transporting Processing to Javascript… not modifying it.  Basically, it asked to multiply each component of the vector into the components of the second vector (ie. x with x and y with y…)  to come up with a new vector.

After overcoming those two problems, the rest of the methods were pretty simple.  Some of them were as easy as a few lines like the following:

PVector.prototype.mag = function(){

	return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);

}

However, through looking at the source code, I found out that the references on the Processing site were a little outdated.  It wasn’t updated with some of the further overloaded functions that I saw and didn’t really have time to implement (ie the toString method).  I will implement these and fix any bugs found for the 0.2 release as well as taking up some more functions that need implementing.

I promised to have my source code uploaded, but I’m having trouble putting it up to Matrix at this point… so I will put it up in the near future.  As well, I will put up some sort of working demo for this as soon as I figure that out as well.  It’ll be soon, I promise.  One thing I can say about me working… once I DO eventually get started, I keep going until I have no more fight in me left.

*EDITED to make formatting easier to read.

PVector – Initial Project Plan

What is Processing.js?

Well to sum it up in one line, Processing.js is a Javascript port from the original Processing program written in Java.  That, however, doesn’t specify what Processing is.  Here is an excerpt from the main Processing page:

Processing is an open source programming language and environment for people who want to program images, animation, and interactions. It is used by students, artists, designers, researchers, and hobbyists for learning, prototyping, and production. It is created to teach fundamentals of computer programming within a visual context and to serve as a software sketchbook and professional production tool. Processing is an alternative to proprietary software tools in the same domain.

To learn more about the Processing tool, click here.  Processing.js is trying to solve the problem of  having load a Java applet to use the tool.  Instead, with the help of Javascript and CSS, Processing.js will be available almost instantly within most browsers.

I have chosen this project mainly because of the exposure this could get once finished.  It is part of the revolutionary movement that Mozilla and Google are trying to achieve that, through the internet, personal applications aren’t necessarily needed anymore.  Everything can be done through a browser, over the net.  Secondly, I’m very interested (my game developer side is) in the WebGL process and I believe this would be a good place to start immersing myself in it.

How can you keep up with my work?

The main way to see my work progress is through this blog.  I will be posting the ins and outs, the goods and bads, the  small and big problems and accomplishments right here in this very blog.  There is also a wiki page setup on the CDOT wiki specifically set up for Processing.js.  There’s also the list of things to be implemented on the main Mozilla wiki, which can be found by clicking here.  The list has more specific details on the items being implemented and needing to be implemented.  I may also make a specific page on this blog for more details.

What is your timeline for this project?

I’ve thought of a main release schedule and a backup release schedule.  This all depends on what I can accomplish by my 0.1 release.  I’ve picked PVector class, which can be found by clicking here, for my main focus on my 0.1 release.  Now, the way my release schedule differs is how difficult this initial release will be.  If it’s simpler than anticipated, I will pick several different functions to complete for my 0.2 and 0.3 released.  If it’s harder than anticipated, my next few releases will be completing the different methods for the classes.

0.1 Release (Oct 19, 2009)
Main release schedule:  Finish the PVector object
Backup release schedule:  Finish the PVector constructors

0.2 Release (Nov 16, 2009)
Main release schedule:  Finish other functions for Processing.js
Backup release schedule:  Finish several PVector methods

0.3 Release (Dec 7, 2009)
Main release schedule:  Finish more functions for Processing.js
Backup release schedule:  Finish the PVector object

What do you need to learn for each of your releases?

The main thing that I would need to learn for this is Javascript, and learn the processes of a functional language.  The main process that I need to learn this would be to just jump right in and play with code.  Learning by immersion is the best way to learn different languages and coding styles.

Collaboration and Contribution

With the help of David Humphrey and Al MacDonald, I hope to achieve my goals.  I also have a team of other students working with me and their information can be found on our Processing.js wiki paged linked above.  I will also include their blogs on the sidebar to the right for easier access.  If you wish to help or participate in the creation of this program, feel free to leave a comment and some contact details.  Or get on IRC on the Mozilla server in channel #processing.js.

What barriers stand in your way?

The biggest barrier would be learning a new language and way of coding.  One thing I’m uncertain of is the difficulty of the scope of my goals.  The only way to find out is to dive right in and do some work.  Overcoming both problems would be easily solved with lots of hardwork and research.

Firefox Build cont.

Alright, when I left off yesterday, I was having trouble with the libnotify library.  Dave was kind enough to give me direction on how to continue with my build.  He provided me with the library name I needed to install.  I was able to continue by putting in the following command:

yum install libnotify-devel

And I present to you my first problem solved:

My second problem was easier to figure out as the error gave me direction:

So I just obeyed the instructions given to me by the error and I downloaded the wireless-tools-devel package:

My last problem was harder to understand.  The build had been running for a while and was displaying some seemingly unintelligible things, if you’re not used to it.  For a while, I thought I found the error (which is highlighted in the following):

It wasn’t until I received advice from Dave on Moznet IRC that I was able to move forward again with my build.  He said that I haven’t seen the error yet and what I was looking at was not the error.  Here’s an excerpt of what he said that made me chuckle:

[15:51] <@humph> nope, you’re missing it
[15:51] <@humph> it’s higher
[15:52] <@humph> get on your ladder and climb higher in that window

He was right, of course.  My terminal cached only 512 lines so the error was getting cut off and I wasn’t able to see it.  I increased the line count to something along the line of 9000 lines.  Lo-and-behold, I found the error:

At first, I thought it was my fault because I, admittedly, didn’t check tinderbox the night I cloned from the repository.  I let Dave know and he told me to give it a try using the hg pull -u command.  I did that and rebuilt.  Still no luck.  Fortunately, Ted had some free time and was able to chime in.  He mentioned bug 517566 which was the same problem I was having with the webGLContext.h and webGLContext.cpp.  Ted mentions that I would need to install the mesa-libGL-devel package.  Looking at the comments in the submitted bug, it seems that the problem is on its way to getting fixed.  At least, I saw the following header check being thrown around that will be helpful to people move on from the obstacle I encountered:

AC_MSG_ERROR([Can't find header GL/glx.h for WebGL (install mesa-common-dev (Ubuntu) or mesa-libGL-devel (Fedora));])

So after resolving that problem, I was able to continue my build and eventually finish it.  It took roughly about two hours altogether after I was able to get it continuously going (granted it probably would have been ten times faster had I allocated more hardware resources to my virtual machine).  I was able to get Firefox to run but not without kinks:

Did I succeed in my build?

AC_MSG_ERROR([Can't find header GL/glx.h for WebGL (install mesa-common-dev (Ubuntu) or mesa-libGL-devel (Fedora));])

Firefox Build

To start this build, I downloaded VirtualBox.  I figured I wouldn’t use Linux as an OS too frequently; mostly just to build stuff for this course.  So, I didn’t want to install it as a separate partition on my HD.  It was mentioned in class that a build on Linux on a virtual machine was ten times faster than the build on a Windows non-virtual machine.  I decided that this would be the perfect setup for me.  So, I installed the virtual machine and put Fedora on it as the operating system.  No major hiccups there.

I began the Mercurial Exercise and was able to finish that without any problems as well.  I tried doing the Simple Firefox Build next.  I came upon my first problem.  It said the yum was being used by another application.  I figured out that it was because I decided to update Fedora before I tried the build.  So, my next move was to wait for the update to finish.  At that point, I started this blog.

Next, the Firefox build begins.

sudo yum groupinstall 'Development Tools' 'Development Libraries' 'GNOME Software Development'
sudo yum install mercurial autoconf213

Those first two commands gave promising results… as can be seen in the following screenshots.

Then, came grabbing the source and updating the Make and then using it…

hg clone http://hg.mozilla.org/mozilla-central/
cd mozilla-central

echo '. $topsrcdir/browser/config/mozconfig' > mozconfig
echo 'mk_add_options MOZ_OBJDIR=@TOPSRCDIR@/objdir-ff-release' >> mozconfig
echo 'mk_add_options MOZ_MAKE_FLAGS="-j4"' >> mozconfig

make -f client.mk

At that point, I encountered a problem.  It’s on the following photo:

I’ve even highlighted what I think the problem is… I’m going to leave this blog post up tonight and maybe I’ll have some helpful comments tomorrow when I pick this back up.  If not, I’m going on a search!

Catching Up

So I’ve fallen behind on some of my work.   I’ve been busy with some other school projects.  This means the list I’ve whittled down last week has grown considerably large again.

• Consider creating a Twitter account in conjunction with your blog (not considering doing)
• Comment on another student’s blog
• Watch online lectures/readings
• Complete lab by Friday
• Watch two online lectures
• Read document on Mercurial
• Read up on GCC
• Read the How to Make
• Build Firefox
• Pick a project
• Complete the Initial Project Plan

While that list doesn’t look too much larger than last time, falling behind on readings isn’t too fun because you then have to do double the amount of readings.  As like last time, I’ve crossed off all the things I’ve done so far.  Let’s do a run down.

I’ve crossed off joining Twitter, even though I really haven’t joined.  I’m not too into the whole Twitter system.  While I understand that it may have closed some doors to a certain part of the community, I don’t think it’s expressly needed.  I believe I have access to what I need with the blogs, wikis and IRC channels.  I’m not too fond of Twitter so there will be no alerts following me.  If you really wish to follow me, you can just use the feeds on my blog as this is where I’ll be publishing the important parts of my work and life.

I’m always willing to leave a comment on a blog post that interests me.  It’s part of the whole blogging community.  I know it’s nice receiving feedback on what you’ve written, so it’s only natural to do so when you’re inspired by what someone’s written.  I did this on a blog post that a colleague of mine did.  I was initially on the fence about what project to work on.  I couldn’t decide on whether to help with Processing.js or to stick to my C/C++ programming background and work on some bugs there.  I was also thinking of working on the mobile side of Mozilla with Fennec.  Carlos‘ blog post gave me what it was I was I needed.  It was the inspiration to work on something new and innovative.  Also, the courage to learn a new language and a new style of coding.  So with that, I was able to cross two items off my list.  I put my name down for Processing.js!

I finished my lab, albeit a little late, with the help of buddhatron through IRC.  My page on the CDOT wiki is now updated.  In the process, I was able to use pastebin and tinyurl as was part of the learning experience for the lab.

Now, the rest of my catching up had to do with a lot of reading and watching online lectures.  My first online lecture, about the Mozilla Community, would cause my Firefox browser to crash.  I was able to start it up at school but couldn’t at home because I hadn’t downloaded and installed Quicktime.  I talked to David about it and he said he was switching the video formats.  So hopefully, I’ll be able to see it soon.

The next online lecture I watched was called “Learning to be at the festival.”  It was a lecture given by David Humphrey and it’s a great summary for what he’s been trying to teach us during the first couple weeks of this course.  The best way to learn in the environment of the Open Source Community is to just jump right in and get your hands dirty.  You learn through experience.  It’s a great lecture for anyone apprehensive about the course work and project, which I’m sure most of us are.

I watched this week’s lectures as well.  They were not as interesting to me.  They were How the Mozilla Build Works by J. Paul Reed and Mozilla’s Build System by Ted Mielczarek.  As you can guess, they were both about Mozilla’s build system and how it works behind the scenes.  I couldn’t run the video for preed’s lecture so I just listened to the sound recording.  Unfortunately, I couldn’t follow along too well because the slides posted aren’t available anymore.  Ted’s video lecture was better, in terms of being able to access it.  However, I noticed that I wasn’t paying attention too much to either lecture.  While I can understand that being knowledgeable in what you’re diving into is important, I just wasn’t interested in the behind the scenes work.  For me, it’s kind of like Discovery channel’s How It’s Made.  It just wasn’t very interesting.  I sat through them though, not absorbing all too much.

The stuff I haven’t crossed out, I’m in the process of doing.  I was in the middle of going through the GCC reading, when I spotted another blog post that inspired me to just dive right in.  So I decided to take the first plunge and while writing this blog I was downloading and installing my virtual machine courtesy of VirtualBox.  I, then, downloaded Fedora to install on the vm.  It’s now running smoothly in the background, minus the fact that I can’t change the resolution past 800×600.  Anyone have suggestions or is this the limitation of a vm?  Anyway, I’m going to start on Mercurial and then try to build Mozilla.  I’ll update more later!