Click here to view scrolling ticker

There’s probably a handful of plugins that will achieve the same result, but as you will see there’s not much code needed to do it yourself. Let’s look at the code now.

The first thing we do is create two feed objects. These objects consist of a url and a type. The url points to an external service (Twitter or YQL) that returns the JSON we will use for each item in our feed ticker. The Yahoo Query Language (YQL) service is a really handy tool that allows you to give it an RSS feed url and it then returns JSON. So I’m giving it Scott Guthrie’s RSS feed link. And it now gives me JSON.

I am also using the Twitter service to get tweets from Scott Gu as well. Twitter is nice enough to give us JSON back from their API.

The next thing to do is use jQuery’s jQuery.getJSON() to call the YQL and Twitter services. These services return JSON arrays, which we then loop through. With each iteration we build an item object and add it to our feedItems array. When we are done our feedItems array will hold all the items for each line in our feed ticker.

The jQuery.when() method is perfect here, because it provides a way to execute callback functions based on one or more objects, usually Deferred objects that represent asynchronous events. Which is exactly what we have here. So when BOTH asynchronous events are complete we call the BuildFeedReader method.

Within the BuildFeedReader function we call $.shuffle(). As the name implies this takes and array and shuffles up its items. This takes our RSS items and our Twitter items and shuffles them up. You can skip this if you don’t want random results.

Next we iterate through our feedItems array building our html string. When done we add the html string to our ticker DOM element.

The last thing we do is add the mouseenter and mouseleave event handlers. On mouseenter we stop the ticker and re-animate it on mouseleave.

The last bit of code was our shuffle function used to random up the results of an array.

You are done. Hope your enjoy your RSS feed / Twitter feed ticker.

- ASP.NET (both Web Forms and MVC)
- C#
- Ajax
- jQuery
- Windows Communications Foundation (WCF)
- ADO.NET
- ASP.NET Web Services
- LINQ and Entity Framework
- IIS
- Unit Testing, debugging and deployment
- Application state, session state, and request state (for example, ViewState, ControlState, Cache object, cookies, and client-side persistence)
- Globalization – designing to support local, regional, language, or cultural preferences

There’s probably more that I’m forgetting. Bottom line is wow, it’s a good thing that I have played with [most] of this stuff at one time or another because you aren’t just going to get lucky when it comes to passing this test.

Some questions include:

You need to recommend appropriate technologies for designing Web forms for entry and retrieval of news items.
Which technologies should you recommend? (Each correct answer presents a complete solution. Choose two.)

A. ASMX and SOAP
B. WCF Data Services and jQuery
C. ASP.NET MVC 2 and Microsoft AJAX
D. Entity Framework and Microsoft Silverlight

Answer: B and C

You are designing an ASP.NET MVC 2 Web application. You have the following requirements:
“Type safety must be validated at compile time.”
“Code must not require explicit run-time type casting.”
You need to pass data between the controllers and the views within the Web application. Which approach should you recommend?

A. Use the View Data Dictionary class
B. Use the Temp Data Dictionary class
C. Use strongly typed view model classes
D. Use dynamic object view model classes

Answer: C

You are designing a deployment process for a new ASP.NET Web application.
The company requires the application to be compiled to a single DLL for deployment.
You need to design a deployment process that meets the requirement.
Which approach should you recommend?

A. Use MSDeploy
B. Use the Web Deployment tool
C. Use a Web Deployment project
D. Use the ASP.NET Compilation tool

Answer: C

You are designing an ASP.NET MVC 2 application.
You need to centralize the logic for handling and logging unhandled exceptions.
Which approach should you recommend?

A. Use try and catch on every method
B. Override the One Exception method of each controller
C. Decorate all controllers with a custom Handle Error attribute
D. Decorate all controllers with the default Handle Error attribute

Answer: C

You need to design a solution for incorporating NTFS permissions in the Web application.
Which two approaches should you recommend? (Each correct answer presents part of the solution. Choose two.)

A. Grant the Network Service account only Read permission to the root directory
B. Grant Read permission and Write permission to the root directory
C. Grant the Network Service account Full Control permission to the Upload folder
D. Grant the Network Service account Read permission and Write permission to the Upload folder

Answer: A and D

You need to design a solution for capturing an exception. Which approach should you recommend?

A. Use a Page_Error method
B. Use a HandleError attribute
C. Use a CustomErrors element
D. Use an Application_Error method

Answer: B

Good luck to all, you’re gonna need it…

The navigational menu that we are going to rebuild is the one for the Rock Bottom Brewery restaurant that we love here in Denver.

Have a look at their main menu. It’s the one with: Home, Find A Restaurant, Menu, Beer & Spirits and Contact Us. You might be thinking, “What? Works just fine.” Yes is does, but why settle for “just fine” when we can make it better?

Now look at our Re-factored main menu. Once again, at first glance both menus work and look reasonable, but stick around and let’s see what makes the re-factored menu better.

Sprites

The original Rock Bottom Brewery (RBB) menu uses an image for each and every menu item. It then uses another image for the hover state. That’s ten total images just for the main menu; even more for the sub-menus. That means on-page-load they went to the server ten times just for the main menu.

If we use a tool like Firebug we can see that they actually went to the server a whopping 81 times (see screenshot). Gulp! That’s not acceptable in my book and it certainly is not necessary. Every time you make a web request to the server that’s a performance hit.

If we use a tried-and-true technique that Dave Shae taught us way back in 2004 called sprites we can reduce our entire navigation, main and sub, into one image and gain significant advantages. The first advantage is obvious, the less trips we take to the server the better. In addition to greater performance we gain two more nice benefits:

1. The cumulative file size of all their images will be greater than our single image. That’s because for each image it has to store off all the colors used. So if you have 5 buttons that use the color green then you have to save green 5 times. In a single image, that’s right, we save green one time. This can add up quickly when you’re using gradients.

2. If you were to clear your cache and revisit the RBB website, then mouse-over one of the main menu links you might notice a delay as the menu is loading up the hover image. When you use a single image for both hover and default state there is no delay because you already have the image. Do not miss the significance of this. It’s a huge benefit to a UI. Anyone that calls themselves a UI person needs to understand this.

Okay, so we now know there are great benefits to using sprites, let’s talk about how it’s done.

Here’s my image sprite for the navigation.

Yep, that’s it.

We can then use some CSS background positioning with height and width properties to only show the portion of the button needed for each state.

See what’s going on? We bring the image up -55px for the over state. An easy little trick with a big pay off. Sprites are a must technique for any UI developer.

Check out these sprites by: Google, Apple and Amazon.

You can read more here:

• http://www.alistapart.com/articles/sprites/
• http://www.smashingmagazine.com/2009/04/27/the-mystery-of-css-sprites-techniques-tools-and-tutorials/

Sliding Doors

Like sprites, sliding doors is nothing new as a technique, but it’s one that must be understood and mastered by the front-end web developer.

I’m not going to go into detail here on sliding-doors, it’s been covered well elsewhere, but the bottom line is that if we structure our images correctly and use some CSS code we can create dynamic sized navigation tabs, amongst other things.

For more info on sliding doors read these articles:

• http://www.alistapart.com/articles/slidingdoors/
• http://www.jankoatwarpspeed.com/post/2008/04/30/make-fancy-buttons-using-css-sliding-doors-technique.aspx

Using @font-face to embed fonts

The Rock Bottom Brewery menu is guilty of another far too common mistake: placing the text in the image. Adding text to an image is something that should not be used that often and almost never be used in a menu link. Here’s why:

1. Search engines can’t read images, they’re just blobs to a search engine, so your text goes unnoticed. That’s just bad SEO.
2. Screen readers for the visually impaired can’t read images either. So that’s just rude. Sure you can use ALT properties, but it doesn’t carry the same Lose Weight Exercise as text does.
3. Font size adjustment – hold down the ctrl-key and move the scroll-wheel on your mouse up. Now view the RBB menu and the re-factored menu. If you do this on the RBB menu the text becomes pixelated. On the re-factored menu, it remains crisp and clear.

Here’s the good news! We now have the ability to embed fonts on our pages so we can still use those fancy fonts AND yet please the search engines and screen readers.

Check out my fun with fonts Halloween example. Did you notice that you can select the text with your mouse and cut/copy and paste it?

Have a look at the CSS:

I simply embed the font called ‘MatchbookMatchbook’ and then reference it in my links.

You can find many free embeddable fonts at the Font Squirrel.

You can read more about embedding fonts here:

• http://soyrex.com/articles/tutorial-using-font-face-to-embed-fonts.html

CSS3 Spiffiness

So now that we have our font embedded let’s use some more CSS to fancify it.

Using the CSS3 property text-shadow we can give our text a nice drop-shadow.

This property works in most modern browsers. If it’s not supported in an older browser, no problem, the text is still there, just no drop-shadow. We can live with that.

Just for fun, try this:

That one creates a glow-like effect to your text.

Conclusion

This article has reintroduced us to a handful of oldie-but-goodie techniques that seem to have been skipped by a generation of developers. I guess all this grey hair is good for something.

For starters Steve Job’s article, Thoughts on Flash, is full of truth and fiction. The biggest part that rubbed me the wrong way was his lack of distinguishing between Flash and the SWF file format that Flash produces; Jobs conveniently leaves this out. Of course the average person knows nothing about the distinction between Flash, the tool that is used to create a SWF file and the actual SWF file that is used on a website. The SWF file is ‘open’ and there are other products, not made by Adobe, that can create SWF files. So it is fair for Abobe to wave the ‘open’ flag.

As far as Apple being ‘open’. Not so fast there Jobs. I can’t even use the SDK on my Windows machine. You must own a Mac if you want to create applications for an iDevice.

Is there anyone that truly believes Apple could not get Flash to play on their devices if they wanted to? Just say it Jobs, I don’t want to support Flash. Period.

Now my final thought and it’s not a good one for you Flash developers is this: Flash is dying, but it’s not Apple that’s killing Flash. It’s three things: 1.) Ajax 2.) jQuery and 3.) HTML5. These technologies have been slowly killing Flash the last few years. Look around, sites that once used Flash have fazed it out: Yahoo, MSN, IGN and many many others. Because of these technologies, Flash’s strengths are no longer there. It’s been relegated to advertisements and entertainment sites.

Still not convinced? Here are some additional benefits of this architecture:

Benefits of the Architecture

1. Unlike an ASP.NET UpdatePanel we only pass what we need; we only receive what we need. We don’t pass ViewStates, in fact we don’t even have a ViewState. We also don’t pass entire HTML chunks and receive HTML chunks we don’t use. For more on this; read: Why ASP.NET AJAX UpdatePanels are dangerous.
2. By using jQuery to call the web service directly, we’ve eliminated over 100 KB of JavaScript and three extra HTTP requests that’s included when you use ASP.NET Ajax.
3. Less dependencies – because all our code is simply xHTML we could switch to a PHP or a Java backend and none of our code for the UI would have to change. That’s right, there are no server-controls; that means no GridViews, no Repeaters, no ListViews, nothing that uses runat server will be found on the page. Not even a ScriptManager.
4. Usability – We can create RIA interfaces AND maintain usability, giving us the best of both worlds.
5. Cross-Browser friendly – We use nothing but xHTML code and jQuery which works across browsers.
6. The entire presentation for the UI is done via CSS. Change the CSS and the entire UI can look different.
7. We maintain a ‘Separation of Concerns‘ – this means we have 3 distinct and wholly separate code bases. A content or HTML level. A presentation or CSS level and a behavior or JavaScript level. We don’t have code mixed together in a web-page jambalaya.
8. Switching architectures from Web Forms to MVC is a breeze.

Hopefully you are salivating at these benefits enough to decide to get your feet wet and follow along.

In this article will be leveraging these technologies to build a grid (or what looks like a table). Later on, in future articles, I will then show you how to implement sorting, paging and filtering on the grid. I have divided this article up into four sections: 1. Sever-side code (ASP.NET). 2. HTML 3. jQuery and lastly CSS.

ASP.NET

In this article I will be using LINQ to SQL to query the database and return a collection. LINQ to SQL allows you to model a relational database using .NET classes. You can then query the database using LINQ, as well as update, insert and delete data from it. LINQ to SQL fully supports transactions, views, and stored procedures. If you’re not familiar with LINQ then I will refer you to these articles: Using LINQ to SQL (Part 1) and LINQ to SQL – 5 Minute Overview.

The goal of this article is not to teach you LINQ. But I will say that if you are not using LINQ and you are still using a DataReader or DataSet to access your data then shame on you. Simply put, I believe LINQ is the coolest technology Microsoft has come out with in recent years.

And the best news is, it’s EASY to use. Let’s look at the code:

The first thing we do is create a class called CourseReservations. This class contains all the properties we will need to create our grid on the client. In other words, these will become our columns. The next part is our LINQ statement. This code uses LINQ query syntax to retrieve a sequence of GolfReservations for a given course. Note how the code is querying across the GolfReservations / GolfCourse / Aspnet_User / GolfUser relationships to retrieve all the data we need from our tables, and we didn’t have to write any SQL filled with JOINS to do it.

We then return a list of CourseReservations. What’s important to note is that our list will get automatically serialized to JSON. How fantastic is that? Before we move on, also note the name of our method: GetGolfCourseReservations(). This is what we will call via Ajax using jQuery.

HTML

That’s right, just a simple unordered list with an id of “reservationsList” and class of “stripedList”. We don’t use any controls, nothing with runat=”server” will be found on the page. This way we don’t have any ViewState taking up load time, nor do we have Microsoft inserting JavaScript into our page without our consent. Our page, at least on the front-end, is devoid of ASP.NET or any other language. Nothing but pure HTML. If we ever have to port to PHP or JSP we wouldn’t have to change a single thing on the UI side.

jQuery

Let’s look at the jQuery code now. Bit by bit.

Notice the SendAjax() method’s signature. It takes three parameters, the first urlMethod is the path to the Web Service followed by the name of the Web Method. It should look something like “webservice.asmx/webmethod”. The second parameter jsonData will be exactly that, your JSON data. More on this later. The final parameter returnFunction will be the function you wish to call after the return trip from the server.

The $.ajax() method performs an asynchronous HTTP (Ajax) request. You can read all about it here, but for now, just know it’s the liaison for the client / server relationship; or the Ajax call.

We will use this light, but powerful SendAjax() method over and over again each time we wish to go to the server.

This function is simply used to stripe the rows. Every other row will be colored differently in our grid. You pass it a list, it then finds all the list items in that list and removes a class. It then adds a class to all the even list items. The reason why I removeClass() from all list items first is so that if you ever add or remove list items (dynamically) to the grid you don’t get them all messed up colorwise.

If you are new to jQuery then you need to start by understanding $(document).ready(). You can read all about it here. But the bottom line is that everything inside this method will load as soon as the DOM is loaded and before the page contents are loaded. This is extremely efficient because we don’t have to wait for images or content to load, just the DOM elements. Again, if you are new to jQuery start by understanding the $(document).ready() method.

We are telling it to call the method GetGolfCourseReservations() as soon as browserly possible.

The three lines in the GetGolfCourseReservations() method will become very familiar to you in this methodology. Recall that urlMethod is the path to your web service and your web method. You do remember our .asmx file contains a web method called GetGolfCourseReservations? Good. The next line with jsonData is the JSON that we are passing in. Note that if you are not passing any data, as we are in this case, you must still have the empty curly brackets. Finally, the third line is our call to SendAjax() method. Notice the third parameter: ReturnGetGolfCourseReservations. This is the method to be called on the round trip from the server. Conveniently you will find this function one line down. I always keep to this standard.

In our ReturnGetGolfCourseReservations method we loop through the returned JSON and create our rows or list items. We then drop our list items into our unordered list and lastly call our method to strip the rows.

TIP: Two tools that are indispensable for this methodology are Firebug and this JSON checker. Without Firebug you will not get far. It allows you to see all your Ajax calls, the post, the request and the returned JSON. Get it and learn it.

CSS

Lastly, let’s look at the CSS involved to make our grid look pretty. Do note that we could have used a table instead of a list very easily. It’s your choice.

Most of the CSS is pretty straight forward; we stylize our list-items and use spans as our cells. The classes .c1, .c2 ect. allow us to assign a width to each column.

The Take Away

What I really want you to take away from this article is all the benefits gathered from this methodology. When I build Web-based apps the thing at the front of my mind is speed. It’s all about speed. Nobody likes to wait for anything these days, on the web or off. This is about as fast as you can do things. In addition, we have nice clean code that adheres to the separation-of-concerns. On the front is just good old HTML, probably the first thing you learned when creating websites. On the back-end is our Web Service that does our actionable request: get, save, update and delete. That’s all it does, it knows nothing about the UI, unlike a typical ASP.NET page with its CodeBehind page that is all aware of the UI and talks to it. If we ever had to change over to an Apache server and use PHP we wouldn’t have to change a thing on the front-end, simply our methods on the back-end would change.

We allow our CSS file to control the way the entire application looks. Once again, compare this to many typical ASP.NET apps that use Web Controls and want you to set presentation properties either in the .aspx page or the CodeBehind page. Yuck. Never do that.

Lastly, not only is our code fast and clean, but it’s also lean. When you get good at this methodology there is usually a lot less code. Less code is always a good thing.

Over the past month I have been reading jQuery Enlightenment by Cody Lindley. Let me say now, that if you use jQuery or are thinking about using jQuery then you should most certainly buy this book. It’s a quick read (122 pages) that includes colorized code samples, easy to follow examples and solid explanations.

Author Cody Lindley is a member of the jQuery team and explains why he wrote the book.

jQuery Enlightenment was written to express, in short-order, the concepts essential to intermediate and advanced jQuery development. Its purpose is to instill in you, the reader, practices that jQuery developers take as common knowledge. Each chapter contains concepts essential to becoming a seasoned jQuery developer.

This book is intended for three types of readers. The first is someone who has read introductory books on jQuery and is looking for the next logical step. The second type of reader is a JavaScript developer, already versed in another library, now trying to quickly learn jQuery. The third reader is myself, the author. I crafted this book to be used as my own personal reference point for jQuery concepts. This is exactly the type of book I wish every JavaScript library had available.

I would argue that this book is perfectly suitable for beginners too. It’s simply a must have jQuery book. It’s the only one you need; it will take you from beginner to competent user.

I do ASP.NET / C# web development where I build web-based software for school districts. My preferred architecture is one in which I use NO server-controls. That means no GridViews, no Repeaters, no ListViews. If fact, nothing that uses runat server will be found on the page. The page will only consist of XHTML. So there is no need for a viewstate either. We end up using jQuery a lot in this architecture. We use jQuery / Ajax to call Web services that then query the database using LINQ to SQL and pass our data back to the client where we can then populate our XHTML controls. It works great and is extremely fast and efficient. The code couldn’t be cleaner. In addition, this methodology would allow you to easily change to a PHP or Java backend and you wouldn’t have to change a single thing on the frontend. I will give a full example on this methodology another time, but the point is – you need to learn jQuery.

For more information on the jQuery Enlightenment book, including a breakdown of each chapter go here. I would recommend buying the full color book from lulu.com as it’s well designed and very handy to have on your desk.

Try any of those footers from the Google search above in IE8 or Opera (some don’t work in IE7 either). Load the page then grab the bottom of the window (not the side or corner of the window) and drag it up or down and you will see that the footer usually sticks in the wrong place, messing up the display.

Now try it on my old original sticky footer version (circa 2003 which pre-dates all those above) and you will see that my version is working in all browsers including IE8.

Before we get into details I should first explain what a sticky footer is.

What is a Sticky Footer

A sticky footer is one that sits at the bottom of the viewport when there is not enough content in the page to push the footer down. If there is a lot of content then the footer sits at the bottom of the document and will be below the fold as usual. Why this is desirable is because on short content pages you won’t have a footer right at the top of the screen looking very strange indeed as shown from Figure 1 below.

Figure 1 – normal footer close to content.

Figure 2 – Sticky footer at bottom of viewport.

Note that a “fixed positioned” footer is not the same thing as a sticky footer as a fixed positioned footer is one that sits at the bottom of the viewport at all times and never moves. Don’t get confused between the two.

Overview

Before we get into the nitty gritty detail I will briefly explain the concept in getting a sticky footer to work.

The first thing we need to do is create a 100% high container which is achieved by setting the html and body elements to 100% height and then creating a container that is a minimum of 100% high. The footer is then placed after this container which means it will be invisible as it will be below the fold of the page but by the magic of negative margins we can bring it back into view at the bottom of the viewport.

Of course this means that the sticky footer must be a fixed height (pixels or ems will do) so that we know how to accommodate it with the exact negative margins that bring it into view. This also means that our footer is now overlapping content on the page so we will also need to protect this content with either padding on an inner element, or some other similar approach as you will see when we get into specifics later.

That’s basically all there is to it except that we have to squash a few bugs on the way to make it work everywhere.

When to use a Sticky Footer

Sticky footers are best suited for fixed width sites with small copyright messages and horizontal menu links that keep the footer at a relatively small size. The technique will work with a large height footer but the chances are that if you have a very large footer it will always reach the bottom anyway by the time you’ve got your header and content in place. It will also work with percentage width footers but remember that if the content in the footer is squeezed into making the footer higher than it was then the negative margin routine won’t match any more and the layout will be misaligned slightly.

Creating The Footer

Now it’s time to get your hands dirty with the code and I will break the method down in easy steps.

1) Create a 100% high wrapper to fill the viewport.

This is accomplished by removing the default margin and padding from the html and body elements and then setting a height of 100% so that our wrapper element can base its height on this. We then use min-height:100% on our page wrapper and not height:100% because our container would never grow otherwise but we will still need to address IE6 as it doesn’t understand min-height at all. (If we didn’t apply a height to html and body then our container would collapse to auto height and would not stretch to the bottom. The margins from html and body must also be removed because they would increase the height and thus ruin the effect as we want an exact 100% height only.)

As mentioned previously IE6 doesn’t understand min-height therefore we provide a rule for IE6 only (using the star selector hack to target IE6 and under only) using the height property instead. We can do this because IE6 treats height as a minimum and will always expand an element to accommodate its content when overflow is set to visible (which is the default). We must also hide this height rule from other browsers because this would limit them to only an initial 100% and therefore the element would never expand with content.

Don’t be tempted to use the !important hack to provide the height property to IE6 because the routine causes IE7 to be buggy with 100% height and won’t resize the footer when the viewport is resized vertically.
i.e. Do not do this:

css

< view plain text >

1. #outer{
2.     min-height:100%;
3.     height:auto!important;
4.     height:100%;
5. }

Do not do this either:

css

< view plain text >

1. #outer{
2.     min-height:100%;
3.     height:100%;
4. }
5. html>body #outer{height:auto}

Both the above will fail in IE7 due to an obscure bug and should not be used in this routine.

The result of this code is that we now have a container that stretches to 100% height of the viewport quite nicely but the footer is sitting under this element and therefore under the fold of the page.

To bring the footer into view we first have to give it an appropriated height and then using a negative margin we drag it back into view. The negative margin can be applied in either of the following three methods.

1) A negative top margin on the footer itself
2) A negative bottom margin on the main wrapper
3) A negative top margin on the main wrapper

The first two methods are basically the same and just cause the footer to slip up over the bottom of the wrapper by the appropriate amount. Remember that the negative margins must match exactly the height of the footer. As a consequence of pulling the footer upwards it may indeed overwrite any content that was above it so you would also need to add some padding to the content above. The padding couldn’t be added to the main wrapper because that means it would be too high and therefore the padding must be added to an inner element instead or just added to the element above the footer.

The third method mentioned above uses a slightly different tack in that the whole wrapper is moved upwards with a negative margin thus allowing the footer to fall into view at the bottom of the viewport but with the consequence that our wrapper now starts above the top of the viewport and out of sight. We therefore need to soak up this space on an inner element much the same as we did with the other two methods.

In 99% of cases you will most likely have a header element at the top of your page and you can use this element to soak up the extra space. My preferred method is to use a solid border on top of the header to do this because unlike padding it would not interfere with any absolutely positioned children should there be any.

Assuming our footer is 40px high the code to accomplish this is shown below:

The top border soaks up the space that is above the viewport and allows content to start in the viewport where it should be. This is exactly what we wanted and is quite a slick way to do this as we no longer need to worry about any overlap of the footer.

To make it easier to follow here is the code so far:

With the code shown we are very close to have a working footer and indeed the code above will work in IE6/7 and Firefox with no problems. Try out the above and see for yourself.

The problem with the above code is that it doesn’t work properly in IE8 or in Opera. If, as already mentioned, you move the window by grabbing the bottom of the viewport (not the side or the corner) then the footer becomes mis-positioned or doesn’t move at all.

This is the behavior seen in all other sticky footers but it doesn’t occur in my original demo. The clue to why my old demo is still working will provide us with a neat solution that can be wrapped into this specific footer routine.

Back in 2003 not many browsers understood min-height and to accommodate these browsers I used a min-height hack which was basically a 100% high float that was 1px (or even 0px) wide. This held the browser open to the initial 100% height quite nicely without affecting much else as long as we took clear of clearing issues. The 100% height float triggered opera into resizing the page correctly once the viewport was moved and caused the footer to be drawn into the correct position.

Today (and thanks to the quiz I set at sitepoint) we can apply that 100% float using the pseudo element “:before” and negate the need for any extra html mark up at all.

The code above places a 100% high float that has no width as the first element on the page. This enables Opera to resize nicely and keep the footer where it should be. To negate any possible clearing issues on normal page content we use a negative top margin to pull the float high above the viewport (32767px is Opera’s limit so don’t use any more than this). Even with the negative margin applied Opera still continues to resize the page nicely.

IE8

The last browser to address is IE8 as it won’t play ball with this method although it does understand the pseudo element :before, it doesn’t apply the 100% height to it as required. Therefore we need another fix and again the answer is quite simple and logical and we supply IE8 with height:100% but declare the element as display:table. This will enable the element to be 100% high initially but also to expand if content dictates which is exactly the way that tables work.

As IE8 is the only one that needs this rule we will use conditional comments to supply this rule to it. In order to tidy up we can also remove the IE6 hack we added earlier and put it in the conditional comments as shown below.

If you are not familiar with the first line of the conditional comments shown above then in English it basically says “If less than or equal to IE6 or If greater than or equal to IE8 then use the code below“.

As IE6 doesn’t understand display:table then it is simply ignored by IE6 and it gets the height:100% rule only. IE8 on the other hand understands both and gets both just as it needed. This saves using two sets of conditional comments and keeps the page nice and tidy.

Here is the full code with comments to make it easier to understand or you can view source from the Full live version.
Full Code

Just in case you are thinking that there is too much code overhead in this if we look at the html needed you will see that there aren’t really any extra elements (apart from assuming that you have a header in the page.) The minimum html is as follows.

I don’t think you can get neater than that!

Although I have shown the example in a fixed-width format you can use it in a percentage or fluid width page as long as you take care with the footer dimensions and don’t let the footer height increase with content. To enable text-resizing you could size the footer and negative margins using ems but that would assume you were basing them on the same font-size, etc.

Things to watch out for

Remember to take into account the effect of collapsing margins on the first and last elements in the wrapper because these may have an impact on the position of the parent or the position of the footer.

I also often see problems where authors have tried to make space at the top and bottom of the page by simply moving the wrapper down the page. The result of this is it moves the whole 100% down the page and ruins the effect. Everything has to happen in the 100% high wrapper and if you want space at the top then you would need to reduce the space at the bottom or be creative in other ways.

Here are just a few various examples.
Main Version
Example 1
Example 2
Example 3
Example 4

I hope you have enjoyed this article and if you have any questions then post away and I’ll try my best to answer them.

Of course we all love our iPods and Blu-Ray players and doing research before Google came along was slow, often times requiring you to get in your car and go to a library. Anybody remember using library tools such as card catalogs and Microfiche to perform research? Now we can do it from our beds, simply by entering a few words into our mobile device and get instantaneous results; fantastic, no doubt.

Today’s cell phones look like something out of Star Trek. Actually, they look better and have more options.

We truly live in marvelous times. But, what does it all add up to? Technology is supposed to make our lives easier, more productive and in some areas eliminate work altogether. And for the most part I think we can say it’s worked. So how come I, like you, still work forty plus hour work weeks? In fact, since World War 2 the number of hours worked per week has grown. In her recent book, “Willing Slaves – How the Overwork Culture is Ruling our Lives“, Madeleine Bunting states that from 1977 to 1997 Americans working full time have increased their average working hours from 43.6 hours to 47.1 hours each week. (This does not include time required to travel to and from their places of business).[1] How can this be? In addition to working longer hours, many families have both family members working. The United States Bureau of Labor Statistics states that between 1950 and 2000 the number of individuals in the active labor force grew 227 percent from 62 million to 141 million.[2]

The whole goal of a software developer is to make someone’s life easier. If we’re successful our software or device will allow a user to be more proficient, saving them time and allowing them to get more work done. But does it really matter if the user is now able to get their work done faster if the end result is still working forty hours? What does it matter if you can get twice the amount of work done? Forty hours is forty hours. I’m sure that by increasing the amount of work we are able to get done each day that someone benefits, someone higher up, but it isn’t you and it isn’t me.

It seems like life just keeps moving at an ever accelerated pace. Like a merry-go-round that started off slow and built up speed. Perhaps it’s moving so fast now that we can’t jump off? Or maybe we still don’t feel we need to jump off?

Author Daniel Quinn in his book Ishmael gives us a parable that may explain what has happened. It’s certainly interesting.

Terpsichore is among the places you would enjoy visiting in the universe. This was a planet where people emerged in the usual way in the community of life. For a time they lived as all others live, simply eating whatever came to hand. But after a couple of million years of living in this way, they noticed it was very easy to promote the regrowth of their favorite foods. You might say they found a few easy steps that would have this result. They didn’t have to take these steps in order to stay alive, but if they took them, their favorite foods were always more readily available. These were, of course, the steps of a dance.

A few steps of the dance, performed just three or four days a month, enriched their lives greatly and took almost no effort. As here on earth, the people of this planet were not a single people but many peoples, and as time went on, each people developed its own approach to the dance. Some continued to dance just a few steps three or four days a month. Others found it made sense for them to have even more of their favorite foods, so they danced a few steps every second or third day. Still others saw no reason why they shouldn’t live mostly on their favorite foods, so they danced a few steps every single day. Things went on this way for tens of thousands of years among the people of this planet, who thought of themselves as living in the hands of the gods and leaving everything to them. For this reason, they called themselves Leavers.

But one group of Leavers eventually said to themselves, “Why should we just live partially on the foods we favor? Why don’t we live entirely on the foods we favor? All we have to do is devote a lot more time to dancing.” So this one particular group took to dancing several hours a day. Because they thought of themselves as taking their welfare into their own hands, we’ll call them Takers. The results were spectacular. The Takers were inundated with their favorite foods. A manager class soon emerged to look after the accumulation and storage of surpluses — something that had never been necessary when everyone was just dancing a few hours a week. The members of this manager class were far too busy to do any dancing themselves, and since their work was so critical, they soon came to be regarded as social and political leaders. But after a few years these leaders of the Takers began to notice that food production was dropping, and they went out to see what was going wrong. What they found was that the dancers were slacking off. They weren’t dancing several hours a day, they were dancing only an hour or two and sometimes not even that much. The leaders asked why.

“What’s the point of all this dancing?” the dancers said. “It isn’t necessary to dance seven or eight hours a day to get the food we need. There’s plenty of food even if we just dance an hour a day. We’re never hungry. So why shouldn’t we relax and take life easy, the way we used to do?”

The leaders saw things very differently, of course. If the dancers went back to living the way they used to, then the leaders would soon have to do the same, and that didn’t appeal to them at all. They considered and tried many different schemes to encourage or cajole or tempt or shame or force the dancers into dancing longer hours, but nothing worked until one of them came up with the idea of locking up the food.

“What good will that do?” he was asked.

“The reason the dancers aren’t dancing right now is that they just have to reach out and take the food they want. If we lock it away, they won’t be able to do that.”

“But if we lock the food away, the dancers will starve to death!”

“No, no, you don’t understand,” the other said with a smile. “We’ll link dancing to receiving food — so much food for so much dancing. So if the dancers dance a little, they’ll get a little food, and if they dance a lot, they’ll get a lot. This way, slackers will always be hungry, and dancers who dance for long hours will have full stomachs.”

“They’ll never put up with such an arrangement,” he was told.

“They’ll have no choice. We’ll lock the food away in storehouses, and the dancers will either dance or they’ll starve.”

“The dancers will just break into the storehouses.”

“We’ll recruit guards from among the dancers. We’ll excuse them from dancing and have them guard the storehouses instead. We’ll pay them the same way we pay the dancers, with food — so much food for so many hours of guarding.”

“It will never work,” he was told. But oddly enough it did work…

So here we are today, dancing away and no amount of technology seems to matter. We keep creating better and better technology and yet we dance more and more.

I love being a software developer. I love coming up with creative solutions to peoples problems. Over the past ten years I have been fortunate enough to work on a variety of projects ranging from POS software, market analysis software, life and health insurance software and educational school system software. For the most part the feedback has been positive. But I’ve yet to have anyone say “thanks to your software I am now able to spend more time with my family.” In the end I don’t know that I have made anyone’s life better. I may have allowed them to get more work done in a day by speeding up their processes. I may have simplified their work life and improved their experience, but have I made their life any better?

“I submit that Egyptian workers, relatively speaking, got as much out of building Khufu’s pyramid as Microsoft workers will get out of building Bill Gates’s pyramid (which will surely dwarf Khufu’s a hundred times over, though it will not, of course, be built of stone).”

“It took Khufu twenty-three years to build his Great Pyramid at Giza, where some eleven hundred stone blocks, each weighing about two and a half tons, had to be quarried, moved, and set in place every day during the annual building season, roughly four months long. Few commentators on these facts can resist noting that this achievement is an amazing testimonial to the pharaoh’s iron control over the workers of Egypt. I submit, on the contrary, that pharaoh Khufu needed to Lose Weight Exercise no more control over his workers at Giza than pharaoh Bill Gates Lose Weight Exercises over his workers at Microsoft.”

Throughout time man has asked – Who are we? Where did we come from and where are we going? Perhaps these questions are more pertinent now more than ever…

What are your thoughts?

[1] http://en.wikipedia.org/wiki/Work-life_balance
[2] http://en.wikipedia.org/wiki/Working_time

jQuery is not all that difficult to learn. The biggest thing you have to understand is all the different “selectors” that are available to you. Using selectors developers can query, in a CSS like way, for HTML elements, and then apply “commands” to them.

For example, the below JavaScript uses jQuery to find a <div> element within a page that has a CSS id of “rightSide”, and shows it and “leftSide” and hides it.

As another example, the JavaScript below uses jQuery to find a specific <table> on the page with an id of “datagrid1″, then retrieves every other <tr> row within the datagrid, and sets those <tr> elements to have a CSS class of “even” – which could be used to alternate the background color of each row:

This next example gets all links <a> in a specific <div> and attaches an onclick event to them:

Being able to traverse the DOM and locate HTML elements to attach events, behaviors, animations and CSS is priceless. But what about ASP.NET controls like the RadioButtonList, GridView, ListView, Repeater, and many others that we as developers like to bind to? How do we traverse them when they all get their ids auto-generated? That’s what we will look at now! And with jQuery it’s not that hard!

When you add an ASP.NET RadioButtonList control to a page, like below:

The browser renders the control to the code below:

As you can see, we don’t have control over the generated items id tag. It would not be an easy task to guess what the auto-generated id tags are going to be. There’s simply too many ways it can very depending on if you are using master-pages and or web-controls. The one thing that we do know is that somewhere in the id will be the id we gave to the control; in this case “rblCaseControl”. Lucky for us this is all jQuery needs to go to town. Look at the code below:

This code uses jQuery to get all radio buttons that have “rblCaseControl” somewhere in their id tag. We could get the selected value of the radio button list using this code:

With this code we have now found the selected value from our ASP.NET RadioButtonList control using jQuery. Perhaps now we want to send that value to a web method in our codebind page using Ajax? Well we could use jQuery for that too! But, that’s another article.

Further Reading:

• http://weblogs.asp.net/scottgu/archive/2008/09/28/jquery-and-microsoft.aspx
• http://weblogs.asp.net/mikebosch/archive/2008/02/15/asp-net-mvc-submitting-ajax-form-with-jquery.aspx
• http://www.chadmyers.com/Blog/archive/2007/12/13/using-jquery-with-asp.net-mvc.aspx

This scene is all too familiar for those of us that work in an urban downtown area. Do we stop and listen or just hurry on about our business?

But wait, this was not your typical panhandler. No one knew it, but the fiddler standing against a bare wall was one of the finest classical musicians in the world. In fact, the musician was Joshua Bell. Whom just three days before he appeared at the Metro station, had filled the house at Boston’s stately Symphony Hall, where merely pretty good seats went for $100. The very violin that he played was worth more than most of the passer byes would make in their lifetime. The violin was handcrafted in 1713 by Antonio Stradivari and the price tag was reported to be about $3.5 million.

Joshua Bell, one of the worlds top classical musicians, equipped with his million dollar Stradivari violin played one of the most difficult violin pieces ever. AND THE WORLD WAS TOO BUSY TO NOTICE…

This experiment arranged by The Washington Post struck a cord in me. Probably because I fear that I would be one of the many that was too busy with life to see or hear the beauty that was right there in front of me.

This is one of the reasons for the less frequency of blog post these days. The other reason is the birth of my second child. In the words of Ferris Bueller, “Life moves pretty fast. If you don’t stop and look around once in a while, you could miss it.”

The life of a software developer is fast paced for sure, maybe that’s why they call them sprints in the Agile dev methodology. Make sure you are stopping from time to time to smell the roses or hear the music. Work to live. Don’t live to work…

Be sure to read the entire Washington Post experiment here. It’s well worth your time.

Code Breakdown

This gets the class .down-list and sets its width equal to the width of the .dropdown-menu’s width minus two. As you may already know or were able to deduce the dollar sign ($) is used to select HTML elements in the page. The $ method accepts a CSS selector(s) as argument(s), so if you want to select a specific element by it’s id or it’s class as in the case here you can use the $(“#myElementId”) code which returns a reference to the DOM element. Learning all the jQuery selectors is very important in mastering jQuery, but is not the scope of this article.

This code attaches the hover event to all .dropdown-menu classes. Short and sweet. The hover event uses two functions: over and out. Whenever the mouse cursor is moved over a matched element, the first specified function is fired. Whenever the mouse moves off of the element, the second specified function fires.

The first function is called when someone mouses over a dropdown menu. It adds the class slide-down to the menu and then animates it by sliding down. The 100 in the slideDown method is the speed of the animation measured in milliseconds.

The second function is called when they mouse out. The part to notice here is the additional function in the slideUp method. This is a callback function; it fires when the animation is complete. So in this case when the user mouses off our dropdown menu it will animate up and then remove the class slide-down. And that will wrap up our dropdown menu.

As you can see, very little code to achieve this common web effect thanks to jQuery.

Let’s start by looking at the code in its entirety; the people that just want to grab the code and use it can do so. I will then explain the code.

The Setup

Add the System.Net.Mail namespace. The System.Net.Mail namespace contains everything we need to send email using a Simple Mail Transfer Protocol (SMTP) server for delivery.

Modify the Web.config file to include the below:

The kicker and not well documented part to note is the from=”admin@company.com” in the smtp tag. You can change the from address later, but the MailDefinition class needs this here.

That’s it for setup. Now let’s look at the first chunk of code.

Create The Plain Text Version

The MailMessage class represents an email message that can be sent using the SmtpClient class.

Pretty straight-forward. This just assigns the From, Subject and To properties to our mail message.

In this example they have the option of sending the email to more than one recipient. So we perform a check on the four optional text-boxes to see if they have email addresses and if they are not empty then we add them to our MailMessage instance. In addition, we append them to our StringBuilder instance which we will end up using later.

Here we simply create a string which we’ll use as our plain-text email message. But remember, we only want to use the plain-text version of the email if their mail client does not support HTML. Therefore we use the AlternateView class and add it to our MailMessage instance. We could have chosen not to use the alternate view and just made it the body of our MailMessage instance, but not this time.

That’s it for the plain-text version, now we will handle the HTML version.

Create The HTML Version

Notice we use the MailDefinition class this time and not the MailMessage class as we did with the plain-text version. That’s because it’s the MailDefinition class that allows us to to create an email from an HTML file. Notice the BodyFileName property that we have set to our “email.htm” file. This is just a regular old HTML file. Lastly, we set the IsBodyHtml property to true.

The above code adds two images to the HTML file. The EmbeddedMailObject represents an item to embed in a mail message. Notice the Name property. This is important because in our HTML file (email.htm) we have this <img src=”cid:hdr” alt=”" /> code which is where it maps to the image. This way of adding images to our MailDefinition object will send the images with the email. If you don’t wish to send images with your email you may choose to simply add absolute paths to your images in your HTML file like normal. Just make sure the paths are absolute.

This is an important part. This is where we pass in fields to our HTML template. Within our HTML file we find this <%EVENTDATE%> . This is a placeholder that we use to pass in content. Pretty cool eh? Almost like a mail-merge in Word. So all the above gets mapped into our HTML template. Now we see the power of this solution. It sure beats creating a huge string. We have a regular old HTML file with the placeholders that we pass in the content. Any future changes can be done right in the HTML file. Nice…

Now the last code section:

The CreateMailMessage method creates the email message and does the merging of our replacement list with the placeholders. We also pass in the string that we created earlier. Remember the string held all the email recipient addresses. The last parameter is looking for a control that owns the MailDefinition. We don’t have one so we just pass in a dummy control.

All that remains is to send the email message via the smtp protocol. If everything in your Web.config file is set up correctly your email should be on the way.

First I get the, “Additional plugins are required to display all the media on this page.” bar, which is not a problem in and of itself. I realize I need to get the Silverlight plugin. So I try to do so and get this error message.

[ Click to enlarge ]

I’m not going to switch browsers in order to view videos people…

Oh Microsoft, why do you do this to yourself? I can’t keep defending you forever…

In December 2008, 40% of respondents said they got most of their news about national and international issues from the Internet, up from just 24% in September 2007.

Pew said it was the first time since it started surveying that consumers relied more on the Internet for news than on newspapers.

Television was still the main source for national and international news, at 70%.

For young people, however, the Internet now rivals TV as a news source. Nearly six out of 10 Americans younger than 30 said they got most of their national and international news online; the exact same percentage said TV was the main way they got their news.

Stephane Grenier was kind enough to send me a copy of his new book Blog Blazers – 40 Top Bloggers Share Their Secrets. I’m glad he did, it’s a very enjoyable read. It’s a lot like what the Random Bits podcast offers its listeners. In fact the book interviews both Jonathan Snook and Yaro Starak which have been interviewed here before on the Random Bits podcast. You’ll also find interviews with notables like Seth Godin, Neil Patel, David Seah and 35 other top bloggers.

The books main goal is to provide you and your blog some insight into what it takes to be successful. Reminding you that “A new blog comes online every 1.4 seconds” it sure doesn’t hurt to learn from some of the most successful bloggers to date.

In Blog Blazers, you’ll learn the secrets of 40 top bloggers, as they all weigh in on such questions as:

- What’s your best tip for writing a successful blog post?
- What are your main avenues for marketing your blog?
- What was your most successful blog post ever?
- What’s the most common mistake new bloggers make?
- What turns you off most when visiting a blog?
- What’s the best way to make money from your blog?
- Which books and websites do you recommend to new bloggers?
- Which five blogs do you regularly read?
- and many more!

It’s a quick and easy read and well worth any bloggers time.