CTRLALT313373.com

Updating Channels in MythTV

David A. Osborn — Sun, 07 Jun 2009 17:16:18 GMT

This is one of those blog posts that is getting written mostly for my future reference, but someone out there may possibly find it useful as well. Recently Mediacom, the local cable provider, decided to move around a few channels and I found myself needing to update my MythTV box so that it knew the proper channels to record my shows from. This turned out to be fairly simple. I logged into the box via ssh and executed a su command to elevate myself to the root account. Then I executed the following command:

$ mythfilldatabase --do-channel-updates

After a few minutes of updates, everything was taken care of. There was no need to reboot the computer and my records still existed unharmed.

The framework is dead. Long live the framework!

David A. Osborn — Wed, 01 Apr 2009 01:49:54 GMT

Over the last couple of years I have been involved with companies that have built their own frameworks using the .Net Framework to encapsulate such functionality as data access, security, and even UI elements such as page management and common list box controls. In their purest forms I think frameworks are great to have and can bring a lot of positive things to a project and a development team, but in practice what I seem to be finding is that frameworks turn into a brick wall to getting things done, a crutch for bad habits, and a roadblock to innovation.

Here are a few positives that come from a framework when done right:

Concise code where common functionality exists in one place.

Duplicate code means duplicate bugs, more lines to dig though, and more lines to tests.
A strong foundation for projects that allows milestones to be reached quicker.

Time is money in every industry and what ever gets you in the right direction the fastest will save you money. (Notice I said the right direction.)
An abstraction layer so that new developers don't need to learn everything before getting started on a project.

It can take new developers time to get up to speed and contribute to a project. If they have a framework that abstracts the details of certain areas away from them to start out they can more quickly begin adding value.
A standardization that guides projects in a consistent manner.

Assuming the framework is consistent, then the way you interact with it helps to structure your program and give projects a similar look and feel.
A time tested code base that evolves to be trusted and bug free.

Well maybe not completely bug free, but overtime and use we start to trust code more and feel more comfortable deploying it. If a framework gets a good work out on multiple projects then it tends to become fairly stable.

Here are a few of the negatives that I see that really happen with frameworks:

Too much stuff gets put into the framework that doesn't get used.

People start rolling stuff into the framework because it has potential to be reused, but even if the item can be reused, it involves so much customization for a particular client or project that it is no longer the original piece.
Items go into the framework that aren't documented and in turn the functionality gets reproduced somewhere else.

I'm starting to see this one over and over again and it is partially a side effect of frameworks getting too big. People don't know what's in the framework, whether it be because they are new or simply because the framework is so big and has so many people working on /with it. People end up reproducing the same functionality someplace else.
Existing framework functionality is not maintained well and becomes a hindrance down the road when new technology comes around that doesn't mesh well with the framework.

A framework in .Net 1.1 becomes a framework in .Net 2.0, which then turns into a framework in .Net 3.5, but the code stays the same. Technology advances and the framework elements need to as well, but the mentality of "if it ain't broke, don't fix it", seems to hang out with frameworks.
Developers never learn how to code outside the framework.

I actually worked with a young developer at a previous employer who, when it came time to leave the company, realized that he didn't really know how to get data out of a database without the framework. I considered him a decent developer for his level of experience and a person with a lot of potential, but he'd been stuck using the same framework for all of his short development career so there were many things he never needed to know how to do.
Old, Fat, whiny people get worked up even at the thought of making a change to the framework. (They're not always old or fat, but they tend to always be whiny.)

Really is there anything else that needs to be said here? You know the exact type of person I mean and if you don't then say hi to them in the mirror while brushing your teeth in the morning.
The framework becomes the solution to every project even when it shouldn't be.

This is the using a sledgehammer to kill a fly type problem. People get a one track mind and big or small the framework is the solution to every project's needs. Worst yet, project specifications start getting tailored to what the framework can and can't do.
New developers don't feel empowered to make changing or additions to the framework.

This doesn't even necessarily need to be new developers either. Frameworks seem to take on this bigger than life image that makes people feel like they are unworthy to make a modification. Either the developer modifies their code in a way they didn't want to in order to interact with the framework, or they do something crazy like copy the functionality out of the framework into their custom project and make changes to it. I've seen classes that were directly copied, with the namespace even duplicated and then minor changes being made to the copy to handle functionality that the developer wanted.
The framework is rigid.

Come on; mark a few methods virtual people!

Well I know I listed a lot more negatives than positives, but the positives definitely score highly. Having a reusable framework that handles a lot of common scenarios that come up with your projects can really help shorten the time to delivering a milestone. At each employer that I have worked at the projects during that time were fairly similar, needing the same type of functionality, and these types of scenarios benefit from a quality framework. Projects can get from point A to point B much faster, which translates into less money. Client and managers always like things to cost less.

I think the best solution to the negatives is to have individuals that have the key responsibility to maintain and grow the framework. Without individuals that have defined ownership in the framework it becomes a tool that is neglected. The "regulation" of the framework needs to fall someplace between a communist leadership and a capitalistic society. An individual utilizing the framework needs to have input into what is going on and provide feedback into what is needed, but in the end there needs to be a smaller group of individuals who decide what should be included and what shouldn't be. The framework in general is going to be driven by what developers need for a project and a client, but the framework needs to expand beyond the needs of a single client and project. Contrary to what some people believe, I've noticed in my career that if there isn't someone to go to that provides the firm yes or no, then nothing tends to happen. Problems get discussed, solutions get discussed, but nothing goes forward. Either no one feels empowered to take the reins or no one wants to be the fall guy if things don't work out.

Overall, I really do think a framework can be a positive thing, but it needs to be managed and budgeted for just like any other project the company works on, especially if it starts to become an integral part of most projects that are being done.

Email, it’s the new phone call….

David A. Osborn — Tue, 31 Mar 2009 00:54:31 GMT

Hello Mr. Osborn, how are you today….How's the weather there in…Iowa"….Please hold while I look up your information…Sorry sir, my computer is really slow today….Hold on while I go talk to my supervisor…..

Okay, I'm an introvert, I'll admit that, but isn't it time that email is elevated to the status of the phone call? In my opinion an email is simply an asynchronous phone call when it comes to business related conversations. I'm busy throughout the day and I'm sure everyone else is too, but I do have a few minutes of down time here and there when I'm waiting for data to load or a project to build and I utilize that time to get some other tasks done. What I don't have time for during a build process is to sit on hold or wait for a receptionist to look up some information. The weather is either too hot or too cold and I'm sure your kids are great. Oh, you're computer is slow? No, I don't want the credit protection plan. Half the time I am probably going to get someone's voicemail anyways, so why not just send them my questions in an email in the first place. Sure in some cases a phone call can be quicker or the urgency requires a phone call, but in most cases a few emails will suffice and it allows me to space out the time into the random free minutes I have throughout the day. Sure I could just put you on hold every time my build finishes and take you off hold when I am waiting on data to load, but most likely you would find that extremely rude.

The problem I am running into is that apparently other individuals don't consider an email on the same level as a phone call. Don't get me wrong, I don't expect an immediate reply, but there are a few things that I would like to be able to start expecting.

If you're out of the office for more than a day, I would like to receive an out of office reply.
If I send you an email before 2pm on a work day, I would at least like to get an email before 5pm saying that you are looking into it and when you will be getting back to me.
If there's a document you need me to sign, then scan it and email it to me. If I don't have the time to call you then I sure don't have the time to stop by your office.
Don't send any data like a credit card number or social security number to me in an email unencrypted. If you need that information then you won yourself a phone call (or I'll decide it wasn't that important).

Is that too hard to expect? Obviously there will always be exceptions, but I would say that they are pretty simple to adhere to. The great thing about email is that people don't really want to type very much, which is great because I don't really want to read very much, so they keep their answers as concise as possible. I think most people want that phone call initiated because they feel they are going to have to do a lot of explaining, but it is most likely the case that I'm not going to retain the big long explanation you provide over the phone, so just answer my question via email which I have most likely phrased in the form of a yes or no question and save us both some time.

Seriously, am I way off base here?

$12,500 Twitter Client

David A. Osborn — Sun, 29 Mar 2009 04:09:13 GMT

Well I got a little bored this evening and started to play around with the Microsoft Surface SDK. Nothing too exciting in this first iteration, but I wired it up to my Twitter account and started pulling down new tweets every couple of minutes. With a little styling I was able to get each of the messages to look like a handwritten Post It note. The messages are created using the ScatterView control which is a Microsoft Surface specific WPF control that allows each item to be picked up, dragged, resized, and even thrown around the screen. Microsoft uses this control a lot during demos of the Surface, wiring it up to pictures to provide a table full of photos type environment. Why is this a $12,500 Twitter client? Well because that is how much it is going to cost you to get a MS Surface, or $15,000 for the developer version. Though, if you buy one in the next 15 minutes, I'll throw in this nifty Twitter client for free.

Surface SDK

David A. Osborn — Fri, 13 Feb 2009 02:20:29 GMT

Well after a bit of work and some help from this blog post, I was able to get the Microsoft Surface SDK working on my 64bit Vista machine. The documentation for the SDK says that it needs to run on 32bit Vista but Steven Robbins seems to have figured out the steps to get around that. Now that I have it up and running I hope to put up a few blog posts on doing Surface development and hopefully I won't run into any issues using 64bit. If anyone would like to donate me the money to buy an actual Surface unit I would be grateful, but until then the Surface simulator appears to be a decent environment that allows you to hook up multiple mice to act as different finger touches. The below sample application comes with the sdk and allows you to select a picture to create a puzzle out of and then put the puzzle together. I can't wait to get my hands dirty and create a Surface application of my own.

Deep Zoom Example

David A. Osborn — Sun, 07 Dec 2008 17:21:38 GMT

With the release of Silverlight 2.0 also came the functionality of Deep Zoom. Deep Zoom optimizes the viewing of large images in a smooth manner by partitioning an image into tiles and levels of resolution of the original image. Using this method allows for the browser to download a lower resolution image for a faster download speed and then only grab the higher resolution image if the user zooms in. When the user does zoom in the tile that represents that section of the higher resolution image is download to the browser again saving the viewer download time and enhancing the user experience.

In order to begin working with Deep Zoom the first thing we need to do is prepare an image for Deep Zoom by creating tiles out of the image of different resolutions. This would be a bit cumbersome to do by hand so luckily Microsoft has provided us with the Deep Zoom Composer which you can download for free. This allows us to create the Deep Zoom images and even allows us to create a collage of image in Deep Zoom. We will be doing the latter, using the numerous amount of photos that I took while traveling through Europe for the month of September.

The first thing we need to do is create a new project in Deep Zoom Composer. Do this by running the Deep Zoom Composer and selecting new project. After doing this you will see three tabs along the top – Import, Compose, and Export. If you are not already on the Import tab, select it, and then we need to add the images that we want to work with. In my case I will be adding in all my pictures from Rome. Click the Add Image… button on the right and select the images that you want to add. Remember that you can select multiple images at once to get your images imported in faster.

Once the images are imported we then switch over to the Compose tab. The tab allows you to create how the final image will look in your Silverlight Application. Select your imported images from the side and place them on the canvas how you would like them to appear. You can zoom in and out on the canvas and place your photos at different depths, even embedding them within each other. For instance I have an image of the Coliseum from the distance with a sign that is on the side of it. I then have a closer image of that sign as another picture. The Deep Zoom composer allows me to embed the more detailed image of the sign into the image of the Coliseum.

In the composer you also have the ability to associate tags with the images. I have associated various tags with all my images. Through the composer you can only apply one string as a tag, so I have used this field to enter multiple "tags" separated by commas. In a future tutorial I will demonstrate how to create a tag filter to filter down images shown in the MultiScaleImage.

Once we have exported the images from Deep Zoom Composer it is now time to get our hands dirty in Visual Studio 2008. In order to work with Silverlight 2.0 applications you are going to need 3 things, Visual Studio 2008 SP1, the Silverlight SDK, and the Silverlight tools for Visual Studio 2008. Fire up vs2008, go to File->New->Project and under Visual C# (or if you prefer you can select VB) select Silverlight. Then select Silverlight Application on the right, name your solution, and select where you want to save it.

Next a window will appear that will ask you if you want to add a new ASP.NET web project to the solution or generate a test page at build time. Every Silverlight application needs to be hosted inside a web application so we will let Visual Studio add a project to our solution for this purpose.

If you now look in the Solution Explorer you will see that we have an empty Silverlight Application called DeepZoomExample2 and a ASP.NET web project called DeepZoomExample2.Web. The web project has two pages that were created for us, an aspx page and a html page that hosts our Silverlight Application.

Next we need to add our exported images to the web project. Add a new folder under the ClientBin folder on the Web Project and call it GeneratedImages. The ClientBin folder is where the compiled .xap file from your Silverlight will live so this is the easiest place to put our exported files. Now go into your exported folder from the Deep Zoom Composer and open up the generated images folder and copy the dzc_output_files folder, and the dzc_output_images folder along with the three files, dzc_output.xml, Metadata.xml, SparseImageSceneGraph.xml into the new GeneratedImages folder that you created in your web project. If you used a lot of images this may take some time to copy. Your Solution Explorer should now look like the following image.

Now it's time to start writing some code. First we add a MultiScaleImage to the Page.xaml file. The Source property will be directed at the dzc_output.zml files that we copied into our GeneratedImages folder.

< Grid x:Name ="LayoutRoot"Background="White">

< MultiScaleImage x:Name ="msi"ViewportWidth="1.0"Source="/GeneratedImages/dzc_output.xml" />

</ Grid >

This is all we need to do to get the basic images on the screen, but that isn't very exciting so lets wire up some zooming using the mouse button. In the Page.xaml.cs file we need to add a few variables to store some information:

//This variable is used to know if the user has just click the left button or has clicked and dragged

private bool mouseIsDragging = false;

//Indicates if left mouse button is down

private bool mouseButtonPressed = false;

//Starting Point of the Drag

private Point dragOffset;

//Get Current ViewPort position of MSI

private Point currentPosition;

//Last Position of Mouse

private Point lastMousePos = newPoint();

public double ZoomFactor

{

get; set;

}

We then have three mouse events that we need to handle, LeftMouseButton down, LeftMouseButton up, and Mouse Move. Then we need to handle the actual zoom.

/// <summary>

/// Handles Left Mouse button down event

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void LeftMouseButtonDownHandler(object sender, MouseEventArgs e)

{

//Indicate that the button is down

mouseButtonPressed = true;

//Reset Dragging

mouseIsDragging = false;

//Set Starting point of the drag if the user start dragging

dragOffset = e.GetPosition(this);

currentPosition = msi.ViewportOrigin;

}

In the left mouse button down even, we first set the indicator that the button is pressed. We then reset the dragging indicator, get the current position of the mouse, and finally get the current position of the MultiScaleImage.

/// <summary>

/// Handles Left Mouse button up event

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void LeftMouseButtonUpHandler(object sender, MouseEventArgs e)

{

//Change flag to mouse button no longer pressed

mouseButtonPressed = false;

//If the user wasn't dragging then we do zooming

if(!mouseIsDragging)

{

//Check if shift was pressed. If so we zoom out, otherwise we zoom in

bool shiftDown = (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;

ZoomFactor = 2.0;

if (shiftDown) ZoomFactor = 0.5;

Zoom(ZoomFactor, this.lastMousePos);

}

When the left mouse button is lifted we change the flag that indicates that the left mouse button is down and if the user was not dragging. We then check to see if shift was pressed. If shift was not pressed we zoom in by a factor of 2, but if shift was pressed we zoom out by a factor of .5. We then call our zoom function (which we have yet to create) with the zoom factor and the last point the mouse was at.

/// <summary>

/// Handlers the moving of the mouse

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MouseMoveHandler(object sender, MouseEventArgs e)

{

this.lastMousePos = e.GetPosition(this.msi);

}

With the mouse move function all we need to do is capture the position that the mouse is at. Finally in the below Zoom function that is called from the LeftMouseButtonUpHandler, we do the actual zooming.

public void Zoom(double zoom, Point pointToZoom)

{

Point logicalPoint = this.msi.ElementToLogicalPoint(pointToZoom);

this.msi.ZoomAboutLogicalPoint(zoom, logicalPoint.X, logicalPoint.Y);

}

As you can see above we have to translate the mouse pointer relative to our MultiScaleImage and then we use the ZoomAboutLogicalPoint method to handle the zooming for us. The last thing we need to do is wire up the events to the MultiScaleImage control in the Page constructor which will look like the following:

public Page()

{

InitializeComponent();

//Wire up events

this.msi.MouseLeftButtonDown += LeftMouseButtonDownHandler;

this.msi.MouseLeftButtonUp += LeftMouseButtonUpHandler;

this.msi.MouseMove += MouseMoveHandler;

}

If you now run the application you will get the layout of all images on your screen as seen in the first picture below, and if I click on the picture of St. Peter's Square in the center of the image the MultiScaleImage control will zoom in on that particular image as seen in the second picture below. Holding down the shift key while clicking will zoom the MultiScaleImage back out.

In order to enable panning we need to augment a few functions that we have already created. Obviously we need to modify the MouseMoveHandler. Initially all this event was doing was updating the mouse position so that when we zoomed in or out we knew where the mouse was pointing. Now we are going to have it check to see if the mouse button is down to indicate that dragging is occurring. Also if the mouse is dragging we need to update the position so that the MultiScaleImage is centered on to where the mouse is dragging. Our new MouseMoveHandler appears below.

/// <summary>

/// Handlers the moving of the mouse

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MouseMoveHandler(object sender, MouseEventArgs e)

{

if(mouseButtonPressed)

mouseIsDragging = true;

this.lastMousePos = e.GetPosition(this.msi);

//Update this View of the MultiScaleImage is dragging

if(mouseIsDragging)

{

Point newOrigin = newPoint();

newOrigin.X = currentPosition.X -

(((e.GetPosition(msi).X - dragOffset.X)/msi.ActualWidth)*msi.ViewportWidth);

newOrigin.Y = currentPosition.Y -

(((e.GetPosition(msi).Y - dragOffset.Y)/msi.ActualWidth)*msi.ViewportWidth);

msi.ViewportOrigin = newOrigin;

}

In our left mouse button down handler we are already handling the dragging functionality by initializing the mouseIsDragging variable to false, and setting dargOffset to the initial point that the mouse was at when dragging was started. In the left mouse button up handler we need to update the dragging indicator that was set to true in the left mouse button down indicated. The new handler appears below:

/// <summary>

/// Handles Left Mouse button up event

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void LeftMouseButtonUpHandler(object sender, MouseEventArgs e)

{

//Change flag to mouse button no longer pressed

mouseButtonPressed = false;

//If the user wasn't dragging then we do zooming

if(!mouseIsDragging)

{

//Check if shift was pressed. If so we zoom out, otherwise we zoom in

bool shiftDown = (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;

ZoomFactor = 2.0;

if (shiftDown) ZoomFactor = 0.5;

Zoom(ZoomFactor, this.lastMousePos);

}

mouseIsDragging = false;

}

We now need to add one more handler. If the mouse goes outside the MultiScaleImage we what to stop the panning so we need to add a Mouse Leave event handler. In the handler I am also going to reset the mouse down variable when the user leaves the MultiScaleImage. This way if they leave the image, lift up the mouse button, and re-enter the image, it won't continue to pan.

/// <summary>

/// Handles the mouse leave event

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MouseLeaveHandler(object sender, MouseEventArgs e)

{

mouseIsDragging = false;

mouseButtonPressed = false;

}

We now need to assign the event, so in the constructor where we wired up the other events we need to also wire up the MouseLeave event of the MultiScaleImage:

public Page()

{

InitializeComponent();

//Wire up events

this.msi.MouseLeftButtonDown += LeftMouseButtonDownHandler;

this.msi.MouseLeftButtonUp += LeftMouseButtonUpHandler;

this.msi.MouseMove += MouseMoveHandler;

this.msi.MouseLeave += MouseLeaveHandler;

}

There you go. Adding panning was that easy. Now if you fire up the site you can click and dragging the image around and still zoom in and out using click and shit click.

The next thing we need to do is add zooming with the scroll wheel. We are going to do this by using the MouseWheelHelper class provided by Peter Blois. So grab this class and add it to your Silverlight Application. With Silverlight 2.0 the silverlight application can reach into the DOM using the Sliverlight DOM bridge and listen to events in the class, abstracting that away from us.

The first thing we need to do is create an event to handle the mouse wheel. Inside this event we set the event to handled so that the system knows that the event has be taken care of, we set the zoom factor by checking the Delta value that is passed to us from the MouseWheelHelper class. Finally we call the Zoom method passing the factor that we want to zoom by and the point we are zooming at, just like if the user had clicked the mouse button to zoom.

/// <summary>

/// Handles the mouse wheel events

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void MouseWheelHandler(object sender, MouseWheelEventArgs e)

{

//Notify that we handled the event

e.Handled = true;

ZoomFactor = e.Delta > 0 ? 1.2 : .80;

Zoom(ZoomFactor, this.lastMousePos);

}

Lastly we wire up with event in our constructor just below where we we wiring up the rest of the events. The newly modify constructor appears as follows:

public Page()

{

InitializeComponent();

//Wire up events

this.msi.MouseLeftButtonDown += LeftMouseButtonDownHandler;

this.msi.MouseLeftButtonUp += LeftMouseButtonUpHandler;

this.msi.MouseMove += MouseMoveHandler;

this.msi.MouseLeave += MouseLeaveHandler;

new MouseWheelHelper(this).Moved += MouseWheelHandler;

}

If you now build and run the application you'll see that the ability to have zoom with the scroll wheel of the mouse is now present. Hopefully this has demonstrated that working with the Deep Zoom functionality and Deem Zoom Composer is fairly simple and can greatly enhance the user experience for a web site. The even better news is that Deep Zoom composer will now generate all this functionality for you wrapped into a Silverlight 2.0 application when you export your Deep Zoom image. This particular sample was pieced together from what I learned from Kirupa Chinnathambi blog who is currently a member of the Expression Blend team at Microsoft.

Yielding to Your Colleague’s Expertise

David A. Osborn — Sat, 18 Oct 2008 08:53:42 GMT

This isn't a post about blindly following someone, but this is a posting about acknowledging and yielding to your colleague's specific knowledge in an area. We all don't and can't know everything and each of us as individuals has spent time developing our knowledge in specific areas of expertise. I sit in countless meetings where everyone feels the need to question and understanding everything. Once you realize that you can't understand everything, you then get to limit your scope and you are going to find that your life is a lot easier (and meetings much shorter and productive). One of the important reasons that we have teams is that each individual brings a unique set of skills to the table and at some point when you don't understand something you need to yield to the "expert" on your team, or possible outside your team, on the subject matter. I use the term expert loosely because I consider very few people I know to be a complete expert on any specific subject matter, but I do consider people around me to be experts over me in a subject matter. Just as we yield to a master chef to prepare a meal properly, we need to yield to our colleagues in their areas of expertise. Sure most of us know how to prepare a hamburger, but there are obviously much more complicated dishes that we could/should never attempt. I am not a master at UI design and I don't claim to be. Sure I can put a button and a grid on the screen, but I have no problems yielding to an "expert" colleague in this area. This doesn't mean that you can't way in when you think something is a completely bad idea, but when the conversation/debate continues to drag on and a decision needs to be made then the "expert" needs to be yielded to. This also doesn't imply that everyone on the team has an expertise. Some members are still too green, and unfortunately in some cases a team member has enough problems staying up with the basics to ever dive deeper into a topic. These individuals just need to realize that they can't understand everything right away and sometimes they just need to sit back and listen. I understood about 10% of the IADNUG meetings when I first started attending and it took me a better part of a year before I fell in stride with the other members. I'm not saying you shouldn't ask questions, but sometimes you should sit back, absorb the information, and realize that you don't understand it now, but in the future when you seen more examples, more applications, and have absorbed more you might and until then you can yield to the "expert". Of course all this still leaves you needing to decide who are the "experts" on your team and what are they "experts" in….

Just Finished Reading….

David A. Osborn — Mon, 06 Oct 2008 00:45:03 GMT

In continuing with my postings on books that I have finished reading, not those that I have just simply started or skimmed, I just finished the book Founders at Work by Jessica Livingston. The book is a series of interviews with various founders of technology startup companies such as Apple, Lotus, Flickr, and PayPal. Not without its slow points the book was a very interesting read and I would recommend it to anyone who is interested in technology and entrepreneurship. If you are looking for the key to creating a successful startup I'll warn you that several of the philosophies suggested by interviewees in the book contradict each other. This apparently indicates that there is no surefire way to create your startup. Most of the interviews were of perfect length for reading in one sitting so it was a good book to read for awhile and then not get back to for a bit. Pick up a copy today and keep it on your coffee table for when you can't find anything good on tv.

Day Five in Spain

Wed, 10 Sep 2008 23:23:36 GMT

Well today is the end of day five in Spain (I suppose really only day four as the first was all travel time.) The first day consisted of 4 different flight that took me from Des Moines to Chicago to Boston to Madrid and finally to Marbella to meet up with my host parents, Manuel and Maria Luisa, the sister of Maria Luisa, and the daughter of my host sister, Gabriella. I left DM on a Saturday and arrived on Sunday. Sunday was mainly spent adjusting to the seven hour time difference and working on my rusty Spanish. The highlight of the day was being able to see Africa from our patio. The two other days spent in Marbella consisted of laying on the beach and eating. I was able to eat some authenticate Spanish paella, not as good as what Maria Luisa makes but better than what I make. I also took a walk on the beach and took some photos of Antonio Bandaras's house though he didn't invite me in for drinks. Today was spent riding in the car up to Madrid. It took about seven hours including stops which suprised me as I would have thought it was less than that to cross the whole country. Other than that the evening was spent settling into the house just outside of Madrid and trying to get a trip to Lisbon figured out. If things work out this post should also contain a photo of us at lunch the second day in Marbella. Going from my right in the photo we have Maria Luisa's sister, Gabriella, Maria Luisa, Manuel, and two friends of my host parents.

Knowing Your Dreams and Achieving Them

David A. Osborn — Mon, 28 Jul 2008 02:55:56 GMT

Today I set aside an hour and fifteen minutes and watched the famous last lecture titled "Really Achieving Your Childhood Goals" by the late Randy Pausch a computer science professor at Carnegie Mellon University. In August of 2006 Pausch was diagnosed with pancreatic cancer and he passed away on July 25, 2008. I encourage you to watch the lecture and then ask yourself the question "Am I achieving my childhood goals?"

I've been pondering this thought for about 6 months now, wondering if I have achieved anything that I intend to so far in my life. This is a tough concept to contemplate. I know personally that I find it very easy to know what I don't want to be doing and what I don't like, but I find it difficult to know what exactly I want to be doing. I think it is all too common that society expects us to clock in and out of our 40 hour a week job and we're suppose to believe that this is what it is all about. Is that really what life is about? If you found out tomorrow that you were going to die in the near future what would you do?

Personally I don't feel like I'm working towards a dream. What I am working towards is my mortgage payment, health insurance, and achieving society's expectation of being a standup citizen. I'm beginning to believe that by working toward these goals I am failing myself and my dreams and I think that this is the case for most people. We get stuck doing what is expected of us and locked into financial concerns that prevent us from achieving our dreams. Working towards society goals causes us to lose sight and motivation for our own goals. When this happens then was life really worth it?

I think that a lot of factors add up to us achieving our dreams. Knowing the dream – this can sometimes be the hardest. The daily noise seems to drown out the internal part of us that causes us to dream. I'm so busy accomplishing "tasks' during the day that the only thing I dream about doing is sitting down and doing nothing. Havingthe means to accomplish the dream – Accomplishing a dream can be a financial and time consuming task. Even when accomplishing the dream does not require a direct financial investment the time that is required for a dream could have an overall impact on things either financially or otherwise. Motivation – It's strange to not be motivated to accomplish your dreams, but the shear challenges faced in accomplishing a dream can affect the desire to complete it. Support from others – Support from others to achieve your dream can have a powerful impact. I've found that most people are negative towards the concept of me accomplishing my dreams, either because they feel it is impossible, or because the dream goes against society's norm. If one person I trusted pulled me aside and told me to per sue one of my dreams now it would probably be enough motivation for me to go do it.

Are you achieving your dreams?