Thoughtlab Blog

Geek Scooter Project

Jared Bouck — Mon, 05 May 2008 21:49:00 GMT

A year ago we had the opportunity to produce a promotional product for one of our clients using a new vino scooter and some geek know-how. The end result was a rolling system capable of long distance war driving, GPS navigation, Skype calls on the road as well as recording your favorite TV program so you don’t miss Lost because you are lost. This is just an overview of the project. It covers a lot, but we will be producing a full how to article so check back soon!

Bench testing the computer: The ITX form factor is really a great platform to work with. It's small, compact, feature- filled, and is a low power consumer. Due to the low wattage consumption, we were able to pack a 1 GHZ system into this scooter easily without worrying about the heat output from the VIA CPU.

Here we are doing some custom acrylic work to create the “Brain Frame” to hold all the components of this system. Working with acrylic is very easy if you have the right tools for the job. Make sure your tools and blades are specifically for plastics or acrylic so you don’t have to worry about cracking the material.

The assembled Brain Frame. Using this vertical form factor we were able to put a ton of equipment into a small space very easily. Building a lot of servers and systems in house, we always have a plethora of screws and mounting posts left over. Using a 1/8th drill bit, we marked and drilled holes for all the parts and simply screwed in a motherboard post in the acrylic. We were able to get the motherboard, Power supply, power distribution, access point, FM tuner, WIFI Card, blue tooth, USB hub, USB Camera, Electric Guitar interface, GPS, LCD Readout and PVR TV tuner all in this small space without any trouble.

The first major step in assembling this project is the tear down. We latterly striped this scooter down to the frame. Almost every major body part had some custom work done to it to facilitate all the gadgets in this project.

Here at the rear of the bike you can see we have: extended wireless access point antennas, our jack for our FM antennas, our GPS and 20DB Gain War driving antenna. We choose the Garmin GPS unit primarily for the sync time. It’s the fastest USB receiver we could find when it comes to satellite acquisition.

Jared and Kevin burning the late night oil. We had 2 days of totally construction time in between our normal daily load. Admittedly, it was a very fun and rewarding project for the extra time.

Here we have the USB Camera pointing out of the front of the scooter where the horn normally would be. We simply changed the angle of the horns mounting arm to give us ample room for our USB Camera.

The main install: With the modularity of the brain frame, we were able to just drop this into the scooter and start connecting power and all the accessories and antennas.

The power on test: This is always the point where we get nervous. Yah it worked on the bench, but will it work now that it’s installed? Of course we didn’t have anything to worry about but that doesn’t mean we didn’t hold our breath anyway. Oh, and the bios on this motherboard has an unusual pause on post. So take a deep breath.

So 1:00AM we finished the project. The furry of drilling, cutting, soldering, heat shrinking and rummaging through a mountain of components more or less left the project area a wreck.

So once we got the project finished, we took those final celebratory glamour shots. Pretty sexy right? We had a lot of fun with this project. This is just a teaser of the full project though. So are you thinking of doing something like this on your own? You’re in luck. We will be posting regular updates and providing a full how to article right here at the ThoughtLab blog so you can make your very own geek scooter!

Here is a flyer with all the details of this project. Just click the above image to view it larger.

Foiled Again!

Jared Bouck — Mon, 05 May 2008 20:51:00 GMT

Deborah went out of town for the weekend on a nice little trip. Some of the team decided to stay a little late on Friday to leave her a nice welcome home present.

Top 10 Reasons Websites Fail

Deborah — Fri, 02 May 2008 23:20:00 GMT

Don't have a Website.
Goals ... what goals?
False hope: "If you build it, they will come."
(Insufficient marketing.)
A programmer is not a designer and a designer
is not a programmer.
It is too confusing to use.
Out of date.
Even after they get there, users can't figure out what it is you do.
Are you sure your nephew really knows what he is doing?
Slow load = long wait.
Hidden security flaws and unknown liabilities.

Top 10 Ways to Improve Search Engine Optimization

Deborah — Fri, 02 May 2008 22:17:00 GMT

Provide unique, interesting content
Frequently update your website's content
Get many quality websites linking to your website (back-linking)
Use links within the content of your website to link to other parts of your website (cross-linking)
Have a site map
Use readable, search engine friendly website addresses (URLs)
Use title and meta tags appropriately
Promote your website on social networking websites
Avoid trying to cheat--search engines will penalize you
Actively analyze and optimize your website, but be patient...it can take up to two months to start seeing the results or your efforts.

If all else fails... Build a shrine to Google in your office and send them a picture of it.

Flash: Broadcasters & Listeners

Deborah — Fri, 02 May 2008 20:48:00 GMT

Write-Up by Danny Staten

Introduction:

Broadcasters and Listeners are one of the most powerful tools for dealing with asynchronous events in flash. Any time you have coded an onPress or onEnterFrame function, you have been listening to a broadcast event. Their true power comes when you start using them to create custom broadcasting and listening. By the end of this article, we will be discussing advanced topics like how to implement your own broadcasting and listening.

The Basics:

So what is a broadcaster, and what is a listener? Think of the broadcaster like somebody with a radio transmitter. They can speak into a microphone, and anybody tuned into their frequency can hear what they say and react as they choose. In reality, this is a simplified analogy that doesn’t accurately describe the actual implementation used for broadcasting. It is however sufficient to describe them for our purposes. So in order for the broadcaster to work, it needs to have subscribed listeners.

You might be inclined to ask why broadcasters are so important. They are very important in flash due to the order code executes. Code written in a frame starts on that frame, but a command started on a given frame often finishes many frames later. A simple example of this is the following tween:

var myTween=new mx.transitions.Tween(clip_mc,”_alpha”,mx.transitions.easing.Regular.easeOut,0,100,12,false);
trace(“object faded in”);

At initial glance, one might think that the trace saying that the object’s fade in will show up once the tween is finished. It should be obvious to any who have programmed a tween that it doesn’t work that way. All the code written in a given frame begins execution during that frame, but this tween finishes 12 frames after the code that fired it actually executed. If you want that trace to fire when the tween is done you have to use a listener.

var myTween=new mx.transitions.Tween(clip_mc,”_alpha”,mx.transitions.easing.Regular.easeOut,0,100,12,false);
myTween.onMotionFinished=function()
{
trace(“object faded in”);
}

This example is not as clear an example of a listener because it takes advantage of the fact that the tween object will hear its own broadcast events. The following example does the same thing, but is clearer for instruction:

var myTween=new mx.transitions.Tween(clip_mc,”_alpha”,mx.transitions.easing.Regular.easeOut,0,100,12,false);
var listener_obj:Object=new Object();
myTween.addListener(listener_obj);
listener_obj.onMotionFinished=function()
{
trace(“object faded in”);
}

Here we see the broadcaster-listener behavior more clearly demonstrated. I create an object that I will then subscribe to the myTween object. That means that I can then set that object up to react to any message sent by the myTween object. In this case it reacts to when the tween broadcasts “onMotionFinished”. It is important to note that a subscriber listens to just its object’s broadcasting. For example if you have two tween objects myTween and myTween2, you can consider it as if they broadcast on separate frequencies. You can have one listener listening to multiple broadcasts simultaneously if you subscribe it to both.

Another valid item to listen to for this tween is onMotionChanged
listener_obj.onMotionChanged=function()
{
trace(“fade in progress”);
}

Not all objects broadcast messages. The tween object is implemented by Macromedia and happens to be set up to broadcast several events. The two events, onMotionFinished and onMotionChanged turn out to be the most useful.

Examples:

Here I will show some interesting concepts that can be used with broadcasters and listeners. The examples will generally increase in complexity and usefulness.

One tween for multiple objects.
It is quite common to want to do something like move a clip 200 in x, 100 in y for example. At first glance it appears that you need two tweens to do this, one for the x and one for the y. In reality, it is very easy to set up one tween that drives any number of related attributes for any number of movie clips. Consider the following example:

Var tween_obj:Object = new Object();
tween_obj.cur=0;
tween_obj.move_x=200;
tween_obj.move_y=100;
tween_obj.startX=myMovieClip_mc._x;
tween_obj.startY=myMovieClip_mc._y;
tween_obj.target_mc=myMovieClip_mc;
//tween_obj is going to be the listener I use
Var myTween = new mx.transitions.Tween(tween_obj,”cur”,mx.transitions.easing.Regular.easeOut,0,100,12,false);
myTween.addListener(tween_obj);
tween_obj.caller=myTween;
tween_obj.onMotionChanged=function()
{

/*one trick to look out for is the scope inside these functions. When inside an event function for an object the ‘this’ keyword is actually the object. In this case this refers to tween_obj. */

//note that the tween object’s cur variable is being changed by the tween

            var stepX:Number=this.cur/100 * this.move_x;
            var steyY:Number = this.cur/100* this.move_y;
            this.target_mc._x=this.startX+stepX;
            this.target_mx._y=this.startY+stepY;
}

tween_obj.onMotionFinished=function()
{
/*You should always clean your own memory up. Theoretically flash has garbage clean up, but true to the rule of thumb, garbage clean up is not to be relied on. */
delete this.caller;
delete this;
}

This particular example actually is considerably more code than just using two tweens, and it likely won’t provide any real performance benefits. However the concept allows you to do advanced tweening where your code ensures that all the needed motions are synchronized across as many objects as you can keep straight in your head.

Bending a Line:
An example of using this concept in a more powerful way is to create a tween that bends a line. Click here to download the example fla file.

This is a simple example of something you couldn’t animate programmatically without using broadcasting and listening. If you were to now do a tween that actually drives both the curveX and curveY values you could get something where the line bends and stretches in any direction.

Snapping the Line Back:
Now let’s say that you want to make it so that after the line bend is complete, it then snaps back to a straight line. The example fla file is available here. The only changes to the code are in the onMotionFinished function.

An important thing to note is that the memory clean up for these animations is deferred to the second onMotionFinished event. It is also a good idea to attach any items you will want to delete to your listener object so you can make sure that you have a pointer that is in scope when you do your memory clean up. This is a better example of how you can use one tween to drive multiple parameters.

Making the Bending and Snapping Dynamic:
So you are probably thinking, “that looks like a lot of work for something I could do with a timeline animation.” You have a point, but even with the examples you have seen so far there are powerful advantages to programmatic animation.

This is mathematically very clean and precise.
This particular animation would likely be very challenging via the timeline and would require shape tweens and or lots of key frames.
Coded animations are much easier to reuse, and modify. If you take time to code them up properly, you can modify your animation in unlimited ways in seconds.

One thing that you cannot do in pure timeline animation is make an animation that interacts with any user input. The following example will demonstrate something that you couldn’t possibly do without broadcasters and listeners. Download the source file here.

There are some nifty things to notice in this code. One is that you can overwrite your listener events at any time. Use this to turn off an object’s response to one event if you still want the object to catch other events. Also be aware of the trickiness with the this keyword. Remember that it is always in reference to the variable space for the specific object whose function is being called. Many events can pass variables if your listener provides them as parameters, but I tend to move things into my function spaces by attaching them to my listening object. That way you can have whatever data you want available in an event, and not just what a broadcaster has set up to send as a parameter.

This example is also an example of how mouse clicks can cause undesired effects if the user clicks while the snapping animation is running. You will notice that if you click, drag, let go, and then click really fast your line will be permanently bent. See my other article on disabling mouse clicks to find a pretty powerful solution to most problems of that nature. With slight modifications, that technique can prevent the glitches we can create here, but that is beyond the scope for this article.

Custom broadcasters:

Up to this point, we have really been using listeners and taking advantage of broadcasters that are already implemented. Think about the cool stuff that can be done with listeners and then think that we have only begun to harness one half of the sweetness that is broadcasters and listeners. If you really want to get so you can have fun with this idea, you will want to learn how to do your own broadcasting.

The following are a few core principles to be aware of:

· Almost anything more than a simple variable can be a listener. For example you can subscribe a movie clip to a broadcaster, but you shouldn’t subscribe a number. (I never have tried to make a number a listener, so I can’t say what the results will be, but it will likely destroy the number’s data or fail to respond to events or both.)

· You can subscribe any number of items to a broadcaster.

· A listener can subscribe to any number of broadcasters simultaneously. This can be nice, but you have to be careful.

· Make sure to use broadcasting_obj.removeListener(listener_obj), where broadcasting is the name of whatever object you have broadcasting, and listener_obj is your own listener. Do this when you no longer need a listener to respond to broadcast events. Forgetting to remove a listener can cause challenging bugs when you have an old object’s listener events firing long after you are expecting them to.

· Not all objects can be set up as broadcasters, and simple variables should never be broadcasters. (I don’t think it is possible, but I also haven’t ever tried.) When you make something a broadcaster you are adding functions to the object. I have yet to find any native objects that cannot be broadcasters (I have been able to make a movie clip a broadcaster or even _level0). However, instances of 3^rd party classes may not allow you to make them broadcasters. The class describing the object either has to be dynamic (which allows its objects to have new variables and functions attached to it), or it has to already have the correct functions with the correct signatures set up in its code.

Why Use Broadcasters?

Okay so why would you want to do your own broadcasting? I have found them very valuable in the following applications.

Site animation control: My favorite application deals with large dynamic web sites or applications. In this case, the time it takes to remove a dynamically generated page can vary greatly depending on the amount of content or the style of animation or both. If you have your code to remove a section broadcast an event such as “onRemoveFinished”, then you can easily wait until any section has removed before drawing the next section to be brought in.
Advanced animation needs: Another really interesting application can be extended from the bending line examples. To see the bending line extended via custom broadcasting, check out the Martin Doors flash application, and pay attention to the light grey boxes. In this case, the code in question broadcasts when the bending line’s start and end points have changed. That allows the lines on the side of the boxes to listen to that and redraw to stay connected. The result is an animation that has all the benefits of being dynamic, extremely flexible and configurable, while still being interesting and relatively complex.
Custom class development: If you get involved in creating your own custom actionscript classes, you will find broadcasters are indispensable. Imagine how useless the Tween would be without onMotionFinished or onMotionChanged events. Sure it could probably do its basic animations, but there would be no means for code that uses a Tween object to know what is going on. Broadcasters allow custom classes to send messages to your main code. There are very ugly and unhappy ways to try and do the same thing with your custom classes, but for practical intents and purposes, broadcasting makes things possible that cannot (or at least should not) be done in other ways.

How To Use Broadcasters.
To make something a broadcaster you simply make the following call:

AsBroadcaster.initialize(myObj);

Where myObj is whatever object you wish to make a broadcaster. Keep in mind that the broadcaster has to be visible to all listeners in order for them to subscribe to it. For management of events that happens across multiple sections of a web site, you will want something that is going to be around in all areas that will need to listen for your events.

Say for example you have movie clips as follows:

Contents_mc.sectionA_mc.lots_of_child_clips
Contents_mc.sectionB_mc.lots_of_child_clips
Contents_mc.sectionC_mc.lots_of_child_clips

Suppose that you have animations that remove section A, and broadcast when that is done so code can draw either section B or C. It would make sense in this case to make Contents_mc your broadcaster.

Once you have made something a broadcaster, it is very easy to use.

AsBroadcaster.initialize(broadcaster_obj);
Var listener_obj:Object=new Object();
broadcaster_obj.addListener(listener_obj);

listener_obj.onHello=function()
{
trace(“hello event caught”);
}
broadcaster_obj.broadcastMessage(“onHello”);

The example code above is so trivial it is not inherently useful, but it demonstrates how to create your own custom broadcasting.

Making Custom classes broadcasters
For situations where you want to make your own custom class a broadcaster, there is one more thing to be aware of. The class must either be declared as follows:

dynamic class className{…….}

An object created from a dynamic class can have variables and values attached to it at run time. This can be very handy, but is not always the best idea. The other way to do it is to add the following member variables to your class:

public var addListener:Function;
public var removeListener:Function;
public var broadcastMessage:Function;

Final Thoughts

I hope this article proves useful for you. It brings me to tears to think about some of the truly painful and ugly ways I found to survive without taking full advantage of broadcasting and listening. If you are willing to spend the time to figure them out, and then start thinking about how you can use the tools they open up to you, you will be amazed at the doors they open up to your flash development.

Flash: Navigation Control

Deborah — Fri, 02 May 2008 18:08:00 GMT

Write-Up by Danny Staten

Introduction

Mouse-mashing users can easily break many flash pages with their click-happy ways. The ability to properly react to inputs during animations has long been a frustrating problem for flash development

The standard solution is to explicitly disable all clickable movie clips whose click events can mess up the animation, and then enable them when the animation finishes. This solution works, but has many limitations including:

For large lists of clips to disable (say a very large navigation), it has the potential to influence performance.
For dynamically generated content, it can be very difficult to determine all the clickable items to disable/enable.
For dynamically generated content, it can be very difficult to manage the state of all the clickable items for all cases.

An unobvious but very simply and elegant solution does exist. It can be used to disable all mouse clicks by region or for the entire flash stage. Generally I use it to disable clicks for the entire stage, but it can be done in other ways to disable specific regions.

The Basic Solution

The Solution can be thought of like a glass panel that you put on top of the page. It takes advantage of the fact that a movie clip with a fill drawn in clickable even if it has an alpha value of 1. I will call that clip the glass panel.

The basic solution utilizes two globally accessible functions.

disableNavigation():

This function creates a movie clip to act as the glass panel. A simple implementation is to create it at the root with a hard coded depth of 1000. Obviously, that detail of the implementation is entirely flexible. I generally try to organize my clip creations so that they are organized inside a small group of clips. If you have 1000 clips right in your root level you are probably not organizing your clips effectively.

enableNavigation():

This function basically just calls removeMovieClip on the glass panel.

Basic Solution's Code

function disableNavigation()
{
            createEmptyMovieClip(“glassPanel_mc”,1000);
            utilities.draw_box(glassPanel_mc,Number(0xFF0000),0,0,0,Stage.width,Stage.height);
            /*utilities.draw_box takes the movie clip to draw to, the color, alpha, cornerX, cornerY, width, and height as parameters. For the disable clip functionality you can either have the fill’s alpha at zero, or fill it and then set the clip’s alpha to zero. Either one works. I like to have it actually fill red for debugging purposes. You can change the alpha to 25% and get a visual identifier of when your navigation is disabled for testing. */

            glassPanel_mc.onPress=function()
            {}
            /*the empty click function is important. If you don’t give this a press event function then it won’t intercept the click event and other items that are lower in depth will still get clicked on.*/
            glassPanel_mc.useHandCursor=false;
            /*This last part is purely an aesthetic effect, but it makes the final touch to make it cool. This way the user is actually triggering a click event when they do click, but they don’t know they are because the mouse cursor doesn’t change at all.*/
}

function enableNavigation()
{
removeMovieClip(glassPanel_mc);
}

This solution is very powerful, and can be modified to disable specific regions of your stage very easily. Any time you need to disable clicks you can call disableNavigation and the mouse press events will not cause you any grief. To turn them off simply call enableNavigation.

The More Robust Solution

The basic solution is nice and all, but it doesn’t quite reach the power that I was looking for. I basically wanted to simulate event driven programming where multiple events can all have input to when to disable and enable your navigation.

Say for example, that I have a data call via flash remoting, and an animation running. I want to wait until both of those have finished. The trick is that the data call is often faster than the animation, but there are occasions where the remoting call can be slower than the animation. We need a way for the glass panel to only remove itself when both events are done. I wanted a means that could be extended to n asynchronous items as a general case.

Now suppose that every time you call disableNavigation, you are also putting a marker on the glass panel. Every time you call enableNavigation you then remove one marker from the panel. If the panel has no markers on it then enableNavigation removes the panel. You can have every event that needs to ensure the user clicking is disabled to function properly put a marker on the panel. Then when the event finishes it removes a marker. As long as every event has one disableNavigation and one enableNavigation call, then a simple counter will suffice.

We can solve this problem quite elegantly by adding a few lines of code to our functions. Basically you add a counter to the glass panel when it is created. Every call to disableNavigation will increment this counter, and every call to enableNavigation will decrement it. If the counter gets to zero in the enableNavigation call then it is removed and navigation is active again.

Robust Solution’s Code

Important Note

This solution does have some challenges too it, but its simplicity in implementation means that it is usually what I go with rather than implementing more complicated alternatives. The challenge is that it is very easy to accidentally lock your navigation. It is up to you as the developer to ensure that there is a corresponding enable for every disable. If you have too many enable calls, then your navigation can unlock too early, and if you have too few enable calls then your navigation will be permanently locked. Depending on the complexity of the logic in your code, this may not be trivial. In the first iteration of this solution, you can call disableNavigation multiple times and one call to enableNavigation will unlock the interface. That is nice for a lot of things but doesn’t solve more complex management issues. This solution allows for more complex management, but it also makes it very easy to accidentally lock your navigation.

Even more complicated versions are always a possibility, but none that I have found have had enough benefits to justify the effort.

Of course, if you want to take the time to identify segments of code where you are absolutely certain the navigation should be enabled, you can enforce that as well. Simply wrap removeMovieClip(glassPanel_mc) in a function such as masterUnlockNavigation() to abstract the details of the implementation from the main code of the program. I have never had cause to do that. Generally speaking, if you manage your glass panel properly you shouldn’t need to force it to enable.

Final Thoughts

I hope you have found this bit of information useful. For the longest time, I was busting my tail trying to manage individual clips enabled states to control user input. One day as I was trying to solve why something was clickable when I couldn’t see it, the synapses in the brain started firing and my interface management frustrations were a thing of the past. So if you have already got a better solution, I would love to hear it. Chances are that if you are reading this article it is because you have been frustrated by the same issue. So I hope this prevents a few headaches for you.

Recommended Graphic Artist System Spec

Jared Bouck — Fri, 02 May 2008 17:43:00 GMT

Graphic arts systems need lots of stuff to make those pretty pictures. Multiple monitor types can help for color checks and for viewing references while you work. Oodles of ram work nicely with a powerful CPU to run demanding programs like Photoshop, Illustrator, Painter, Quark, and others. Fast file reading and writing speed is also nice. No serious graphics machine is complete without a nice stylus for refined image work. Adding a mac sticker allow a designer to pretend they are on a Mac, but they are optional.

Component	Component Description	Vendor	Price	Qty	Total
Case	Thermaltake Armor VA8003BWS	Newegg	170	1	170
Motherboard	ASUS P5K-E LGA 775 Intel P35	Newegg	139	1	139
CPU	Intel Q6600 Kentsfield 2.4GHz Quad-Core	Newegg	220	1	220
Ram	Crucial Ballistix 1GB 240-Pin DDR2 1066	Newegg	37	4	148
DVD-Rom	LITE-ON IDE DVD-ROM	Newegg	17	1	17
Floppy Drive	SAMSUNG Floppy Drive	Newegg	7	1	7
Hard Drive	Seagate 160GB 7200 RPM SATA 3.0Gb/s	Newegg	55	4	220
Videocard	EVGA 256-P2-N445-LX GeForce 7300GT	Newegg	55	2	110
Sound Card	Onboard	Newegg	0	1	0
Network Card	Gigabit Onboard	Newegg	0	1	0
Keyboard	Microsoft Natural 4000 Black	Newegg	35	1	35
Mouse	Logitech MX518 Optical Mouse	Newegg	40	1	40
Monitor	ViewSonic Pro Series VP950b Black 19"	Newegg	340	3	1020
Mouse Pad	XTRAC XTRAC ZOOM V2 Mouse Pad	Newegg	11	1	11
Speakers	SENNHEISER DJs HD202 Circumaural	Newegg	25	1	25
Powersupply	CORSAIR CMPSU-750TX 750W	Newegg	130	1	130
Other

Overview:
Est System Cost: $2292.00
Submitted By: Jared Bouck
Submit Date: 5/5/2008
Complexity to Assemble: Very Experienced
Software Configuration and Optimization: Level 10 Geek
Estimated Productive Life Span: 2 years

Recommended 3D artist System Spec

Jared Bouck — Fri, 02 May 2008 17:43:00 GMT

3D animation systems need as many pipes as they can cram onto that video card. Specialized video cards usually don’t support the latest visual effects for games, but boy can they push those polygons through the pipeline. 3d work can push the best CPU to its max with high poly scenes and test renders so look for a good CPU and lots of ram and fast hard drives to prevent bottlenecks.

Component	Component Description	Vendor	Price	Qty	Total
Case	Thermaltake Armor VA8003BWS	Newegg	170	1	170
Motherboard	ASUS DSGC-DW Dual LGA 771	Newegg	400	1	400
CPU	Intel Xeon L5320 1.86GHz Quad	Newegg	360	2	720
Ram	WINTEC 2GB ECC Fully Buffered	Newegg	81	2	162
DVD-Rom	LITE-ON IDE DVD-ROM	Newegg	17	1	17
Floppy Drive	SAMSUNG Floppy Drive	Newegg	7	1	7
Hard Drive	Seagate 160GB 7200 RPM SATA 3.0Gb/s	Newegg	55	4	220
Videocard	EVGA 256-P2-N445-LX GeForce 7300GT	Newegg	55	2	110
Sound Card	Onboard	Newegg	0	1	0
Network Card	Gigabit Onboard	Newegg	0	1	0
Keyboard	Microsoft Natural 4000 Black	Newegg	35	1	35
Mouse	Logitech MX518 Optical Mouse	Newegg	40	1	40
Monitor	ViewSonic Graphic Series VG1930wm Wide	Newegg	250	3	750
Mouse Pad	XTRAC XTRAC ZOOM V2 Mouse Pad	Newegg	11	1	11
Speakers	SENNHEISER DJs HD202 Circumaural	Newegg	25	1	25
Powersupply	CORSAIR CMPSU-750TX 750W	Newegg	130	1	130

Overview:
Est System Cost: $2772.00
Submitted By: Jared Bouck
Submit Date: 5/5/2008
Complexity to Assemble: Very Experienced
Software Configuration and Optimization: Level 10 Geek
Estimated Productive Life Span: 2 years

Recommended Developer System Spec

Jared Bouck — Fri, 02 May 2008 16:34:00 GMT

Software development systems are designed to facilitate efficiency. Multiple monitors have been shown to dramatically improve efficiency for software development. Fast CPUs help speed up builds, and lots of ram will help with many software development tasks and multitasking. Gigabit ethernet connections will speed up loading large projects over a network. Last, and sadly often overlooked for those poor decrepit programmers is ergonomics. Can we include a nice Herman Miller chair in these specs?

Component	Component Description	Vendor	Price	Qty	Total
Case	Thermaltake Armor VA8003BWS	Newegg	170	1	170
Motherboard	ASUS P5K-E LGA 775 Intel P35	Newegg	139	1	139
CPU	Intel Q6600 Kentsfield 2.4GHz Quad-Core	Newegg	220	1	220
Ram	Crucial Ballistix 1GB 240-Pin DDR2 1066	Newegg	37	4	148
DVD-Rom	LITE-ON IDE DVD-ROM	Newegg	17	1	17
Floppy Drive	SAMSUNG Floppy Drive	Newegg	7	1	7
Hard Drive	Seagate 160GB 7200 RPM SATA 3.0Gb/s	Newegg	55	4	220
Videocard	EVGA 256-P2-N445-LX GeForce 7300GT	Newegg	55	2	110
Sound Card	Onboard	Newegg	0	1	0
Network Card	Gigabit Onboard	Newegg	0	1	0
Keyboard	Microsoft Natural 4000 Black	Newegg	35	1	35
Mouse	Logitech MX518 Optical Mouse	Newegg	40	1	40
Monitor	Acer AL1916WAbd Black 19" Widescreen	Newegg	180	3	540
Mouse Pad	XTRAC XTRAC ZOOM V2 Mouse Pad	Newegg	11	1	11
Speakers	SENNHEISER DJs HD202 Circumaural	Newegg	25	1	25
Powersupply	CORSAIR CMPSU-750TX 750W	Newegg	130	1	130
Other

Overview:
Est System Cost: $1812.00
Submitted By: Jared Bouck
Submit Date: 5/5/2008
Complexity to Assemble: Very Experienced
Software Configuration and Optimization: Level 10 Geek
Estimated Productive Life Span: 2 years