But sometimes you just need a little force to make your styling ‘win’ from existing styling. The standard way of doing that is using !important. For example:

/* Define some different box styles */
.standard .box.style1 {
    position: absolute;
    left: 10px;
    border: 1px solid #f0f;
}
.standard .box.style2 {
    font-weight: bold;
    font-size: 1.2em;
    border: 1px solid #ff0;
}
.standard .box.style3 {
    padding: 10px;
    border: 1px inset #00f;
}

/* Reset some styling if there's a parent tag with the class 'alt' */
.alt .box {
    text-align: center;
    color: #fff;
    border: 1px dotted #000 !important;
}

In this example, we use .alt .box to redefine some styles, but the selector is not strong enough to enforce the border styling. That’s why we resort to !important. color and text-align do not need the same treatment at the moment, but if someone sets the color in the selector .standard .box.style3, its styling will trickle down, overwriting styling in .alt .box.

We can put !important after every styling declaration, but that’s verbose and downright ugly.

Normally I resorted to using something that makes the selector stronger like an ID. You’ll get something like this:

#root .alt .box {
    text-align: center;
    color: #fff;
    border: 1px dotted #000;
}

It works perfectly, but it has one drawback: it requires the ID to be in the DOM. That might not be a problem, but sometimes you have no control over het HTML that the serverside code spits out. Besides that: you are misusing a DOM element for other needs. A colleague might remove that ID without knowing what effect it would have on the styling.

Since I don’t have to care about IE6, I can use attribute selectors to mitigate that dependency:

.alt .box[class*="box"] {
    text-align: center;
    color: #fff;
    border: 1px dotted #000;
}

It makes no sense at first: if you select a an element in the DOM with the class box, it always has a class attribute, but that’s the beauty of it. The [class] selector makes the CSS rule stronger without requiring extra markup: the class attribute is implicitly available.

The only trouble left is that it’s not really self-documenting. It’s a CSS hack like *+html, so it’s still better to have structured CSS code

Update

Though awkward, this selector works as well: .foo[class][class][class]. Each [class] you add makes the selector rule stronger.

No related posts.

Yes, it takes some time and discussions between the disciplines but you can win so much time in the future if done right. Doing stuff right depends on some crucial things:

• Work interdisciplinary and as (almost) equals. It’s easy to say what you think out the whole plan yourself, but if you do that, others are not inclined to think with you. Each new idea becomes just another bump in the project instead of a good contribution to a discussion to get a better understanding of a problem. By putting your problem on the table and make team members real team members, you get a real discussion. And a better product in the end
• Make your work public. You also get a whole other situation if you know that other people (clients or the community) are keeping an eye on you. In the positive sense of the word, that is. You have to think (just like Twitter) what is really useful outside your little bubble. And you might get good feedback to make your code even better/stable/useful.
  By thinking hard how to make stuff usable for the outside world, you’re instantly making a very usable and learnable tool for anyone who’s going to work at your firm.
  Making open source software could also motivate people. They’re not just working hard for the company anymore, they’re also working on something that can also be useful outside of the company and the greater good. That can be the motivation to work a more on it outside work time.
• Results before deadlines or budget. Ok, projects with limitless budgets aren’t realistic. But making reusable code or applications without keeping an eye on its usability or not even testing isn’t realistic either. To get quality reusable code you do not only need to write it, you have to think it out, write it and rewrite it and rewrite it. If you’re not prepared to do that, just save yourself the trouble.
• Continuous testing. Don’t wait until the very end of the project to measure its quality. You cannot remove the concrete slabs below an ill-constructed house either. Everybody has to at least check the end result of the finished component before moving on to the next target.
• Reusability is epic. Don’t kid yourself: Most of the stuff you do now has been done in the past as well. Talk with designers, programmers and developers to aim for reusability while preventing that all websites start to look the same. Getting some framework that works for everybody is everybody’s priority.
• Keep it simple. Some projects need solid plans. Others don’t. Some stuff does not have to be written out in threefold as long as the basics are known and the outer borders have been drawn. Be wary if the 5th version of the plan is mailed in PDF form to all team members, project time already gets out of hand and no real work is done yet.

No related posts.

The demo page remains the same.

Related posts:

1. The jQuery plugin Ono List Pager reached version 1.0!
2. Preview Of A New jQuery List Pager Plugin
3. Ono List Pager 0.8 is out
4. New release: Ono List Pager 0.5

But since we live in the real world we really need filter styling. At least for now anyway. And yes, Less can handle MSIE filters although you may have to dig a bit deeper. The following mixin works in .Less (Less for ASP.NET):

.gp_opacity(@opacity: 0.5) {
	opacity: @opacity;
	-ms-filter: ~"'progid:DXImageTransform.Microsoft.Alpha(Opacity=" @opacity*100 ~")'";
	filter: ~"alpha(opacity=" @opacity*100 ~")";
}

Happy programming!

Related posts:

1. Cool cross-browser styling with CSS and IE’s filter

But with Less the CSS code gets parsed, combined and most likely minified. With Less or Sass you cannot trace back styling via your developer tools in a simple manner.

At the moment I’m building a HTML/CSS/JavaScript framework based on Less and ASP.NET. Because that framework will get a solid code convention I’m convinced that I can keep the issue of not being able to find the right CSS code to a minimum. But I’m pessimistic about the solidness of Less-code that is written uniquely for each website. Such code does not get the same tender love and care as the reusable code of a framework. Furthermore: it is often bound to deadlines and budgets which may lead to sloppy code.

In worst case scenarios the Less code becomes a black box that magically generates styling but cannot be edited because it hides its inner workings. The only way to edit the style is to add an exception at the end of the Less file and maybe adding an !important.

In short: the ability trace back code styling might get close to null.

My personal guidelines for Less

Make your styling findable

Use a code convention which enables you to trace back the original Less code. As an example: I’m creating a lot of components for a framework. Each component is a block of code written as a nested rule like this:

/**
 * Root styling for menu
 */
.gp_menu {
	ul {
		background: @gp_colorLow;
	}

	> ul > li > a {
		display: inline-block;
	}
}

In my personal code convention I committed myself to make only one level in a nested rules block and to use a unique root selector. So if I see in Firebug a selector like .gp_menu > ul > li > a, I can search in my project for .gp_menu { to get to the right nested rules block. Then I can use > ul > li > a to finally get to the right point in the code to edit.

Now the code you see up there is just the base styling. It needs more styling to make it a real menu. In my framework there are many components that share the same basic styling. Let’s add some code to create a horizontal and a vertical menu:

/**
 * Horizontal menu
 */
.gp_menu.gp_menu_typeHorizontal {
	min-height: 0;

	&:after {
		.clear;
	}

	/* ... lots of more styling */
}

/**
 * Verical menu
 */
.gp_menu.gp_menu_typeVertical {
	li.gp_active > ul {
		display: block;
	}

	/* ... lots of more styling */
}

Now if I open up my Firebug and find a selector like .gp_menu.gp_menu_typeVertical li li, I know I have to search for .gp_menu.gp_menu_typeVertical {. This way code conventions helps me to find the right Less code.

Be cautious using Less in quick ‘n dirty projects

Deadline pressure can easily make a person write bad, unstructured code. With Less it gets even worse: bad, unstructured code and really hard to debug. You should think twice about letting that intern build the base styling of a website, but think three times if you let that intern write Less code for a website. You will be the one who has to debug it at the end of the project!

Better like your Less parser, it might be your only one

Do you like your Less parser? That’s good, because your Less code might not get parsed by other Less libraries. I’ve written my Less code with .less for ASP.NET and tried to parse my code with SimpleLess. It failed to compile the whole bunch without a proper error message.

Part of the problem is that a bug in CSS (or differences in interpretation for that matter) are ignored in browsers, but Less parsers will throw a big fat exception. Exceptions can be a good thing but not if it differs between parsers. Maybe Less has to be adopted as a standard by the W3C?

Having a solid standard would be a good thing since Google just presented their own take on Less CSS with Closure Stylesheets. They already bended the informal JSDoc spec towards their own standards with previous Closure releases.

Update: LessCSS LinkedIn group

I created a LinkedIn group for LessCSS.

Related posts:

1. The last resort in CSS debugging
2. CSS debugging
3. Useful FileZilla tips

How to do mobile redirection

Mobile website != desktop website

In many cases the mobile website just contains a subset of the content that’s available on the main website. That’s because mobile websites are made with the mobile context in mind. This results in very short texts and location based services.

Moreover: there just isn’t much web traffic from mobile devices if you compare it to the traffic that browsers on traditional computers generate. So many organizations don’t see the necessity for a mobile website that is as comprehensive as the desktop variant.

This means that if you would land on a some web page, there will most likely be no mobile equivalent of that content. So there’s no reason to redirect the user. Unless mobile devices are likely to crash.

Users can redirect themselves

In the early days the differences in capabilities between handhelds and PC’s was very large. But now those devices are smartphones and are powerful hardware. Users can now choose between the predictable security of the main websites and the usability of mobile websites. It’s, bar some exceptions, a matter of preference now, not a necessity.

You can get away with redirecting users to a mobile website once, but don’t redirect them all the time. A user that visits the main website with a smartphone most likely just prefers the main website, so don’t keep him away from the content you want to disclose on the web.

Even better than redirecting: just add a link to your main page to your mobile website and vice versa. That’s a strategy that works as long both websites can be viewed on a smartphone.

Related posts:

1. Extending media queries with JavaScript

Problems with my current codebase

Well, I already have a codebase, but it has some problems. The important one is that it only covers the very basics. That’s because designs can be very diverse and as a developer I want to stay true to the design. So it’s hard to build a codebase with grids and blocks if all design differ from eachother.

Another problem major issue is something I have more control over: the codebase and the documentation is a bit scattered. The last problem I have is that I have no demo page of my standard CSS code, so there’s no easy way to check the template on browser compatibilities.

Now my jQuery plugin project has reached version 1.1, I had the time to do some thinking about a new codebase that would be solid, extendable, easy to deploy and would replace all other codebases and documentation.

Let me make it clear: this article is about my considerations about building a solid framework for myself. It may not apply to you and my ideas not unique either. It still may be helpful for you to get an idea of what sort of codebase you need.

Existing examples

The most important thing about a codebase is to decide how to set it up and how to store it. I like the way open source grids like Grid960 and YUI have organized their code into little reusable bits and have created a demo and test page for each and every component.

I must admit: I hardly ever used these grids. Most of those grids talk the language of the web developer, not of the designer. And the designers I know don’t have to limit themselves to a 24-column grid system. Not to mention the designers that are totally ignorant of such a system and whose task is to design a website and mail the Photoshop file to some other company that has to build it. Although I have my reservations towards grids, I like the way these codebases are organized. It can serve as a good Blueprint for my own codebase.

I also get my inspiration from Nicole Sullivan’s talk on Object Oriented CSS (OOCSS). OOCSS basically means that you build your components in such a way that they become extendable objects. Just like in real object oriented programming. Just have a look at her talk about OOCSS on Yahoo! Developer Network.

Prefix classes

By adding a (relatively) unique string before the name of the class you have created your own CSS namespace. It will minimize any interference of other CSS styling that is not part of your own code. Some real life examples can be found in the code that is generated by the CMS systems I have experience with: Sitefinity and Sitecore. The CMS Sitefinity for example prefixes all CSS classes with “sf_”.

Grids, blocks and text

All CSS code will be split into different categories that work relatively independently of each other. Until now I can come up with 3 of them.

Grids

Grids are the frameworks of placeholders in which we put our content. You know: header, visual, column1, column2, column3 and footer. There are lots of grid templates around like Grid960 and Blueprint. My view is that those templates only work if the designer agrees to work within the limits of that framework. My ambition is to write a framework that makes my work easier while still being flexible enough to keep the designers happy.

Blocks

There are as many block as the designer can come up with. I think it will be a real time saver to talk with the designer and write down all the types of blocks he thinks he’ll like to use often. Or even better: just open the last 20 or so web designs he/she made and destil the common blocks and its common features. like menus, news article lists, homepage spotlights, etc. Finally you create basic blocks of it in your template system.

Standarization is not always popular with designers but if it means that projects can be created cheaper there may eventually be budget left to build cool stuff. At least, I hope…

Text

Basic text styling is also a relatively independent component in CSS code. You always define a basic font color, family, size and line height that serves as a base styling for the whole websites. More specific text styling in blocks should be kept to a minimum and preferably relatively to the base text style. So if you have a base style of font: 1em/1.5em normal Arial, sans-serif, you ideally should style a header in a block like this: font-size: 1.5em; line-height: 1.2em;.

Although font-weight is not something you can set relative to a base style, it’s not likely that it will look ugly in combination with some design if you add font-weight styling to a block. Setting the font-family in the styling of blocks on the other hand will most likely interfere with design, since designs tend to depend heavily on a particular font.

Create base templates and extend themes

The code for each grid system and each block will be stored in a seperate base CSS file. Each grid or block can be extended with extra themes or styles. Each style extension will have its own CSS file and presumes that the base file is already loaded.

Optimizing CSS

Having all code seperated in small snippets is great for maintaining an overview. As long as you can see what a CSS file does by looking at its filename, its will be easy to add and extend styling to a website.

The template code is not optimized for speed, though. If we don’t do anything about the fragmentation, the server will have to load a bunch of little CSS files. It’s important to stress this: It’s not just the total filesize that matters, each http request costs time. Check out YSlow if you want to know more about this and if it affects your site.

YUI

That’s why all CSS in the website has to be exported, merged and its code minified to one single CSS file. Normally I use YUI compressor for it.

Less

But you can do more than just minification. Less is a system that extends the CSS syntax with stuff like variables, nested rules and mixins. Less was originally built in Ruby, but there’s also an ASP.NET port. I hope it will help me create very flexible grids.

By exporting CSS into optimized code, you can focus on making the most readable CSS source file because all comments and spaces in the code will be removed in the end. This is also what I do with JavaScript code and certainly will continue to do.

Related posts:

1. Too advanced CSS selectors
2. The last resort in CSS debugging
3. Tips for using and debugging of Less CSS code
4. Crucial stuff for your company’s internal projects

About the library

Its development took about half a year and in that time it has become a solid jQuery plugin with the following key properties:

• Works in IE7+, Firefox, Chrome, Safari and Opera. Most functions also work on IE6, but that browser is not actively supported.
• Supports gestures in mobile browsers.
• Supports arrow key events.
• Works with the principle of progressive enhancement, so your content is still also accessible to search engines and users without JavaScript.
• Very configurable and extendable.
• Open source and available on Github.
• The library size is just 30Kb. If your webserver uses gzip files, it will be even smaller.

Installation

• Get the library
• Read the manual
• View the examples on the demo page

Extending and improving the library

• The Ono List Pager on Github
• An overview of the code

Examples

Most websites that use the Ono List Pager are still in development, but a good website to show what you can do with it can be found on Estate 15 jaar.

An example of an Ono List Pager instance.

Related posts:

1. Preview Of A New jQuery List Pager Plugin
2. New download location for Ono List Pager
3. Ono List Pager 0.8 is out
4. New release: Ono List Pager 0.5

DEL is your friend

Those cases happen rarely but when they do, I always resort to a tested and tried technique: isolate the problem by removing or commenting all unneeded markup. Isolating the problem may take some time but when you have a web page with a minimum of HTML while keeping the styling bug intact, you get in most cases the bug fixed in no time.

Why does isolating code work so well? Well, most of the time you can find styling bugs by experience, but when you’re stuck, every bit of styling on a tag becomes suspicious and that’s just too much to test. The bug becomes a needle in a hay stack.

Removing the easy way

The best way to remove blocks in a page is by just adding a display: none to its styling via a developer tool like Firefox’s Firebug, Opera’s Dragonfly, Webkits developer tools or IE’s Web Developer Toolbar. Just cut away big blocks and each time you remove something, you test if the bug still persists. You continue until you find the block that is triggering the bug. Most of the time you’ll have to continue the same technique of removing bits of code within that block until you can isolate the problem.

Hiding a block by adding a 'display: none'

Removing a block of HTML completely

Removing the source code

Sometimes it’s better to have direct access to the source HTML than doing temporary changes in the developer tool. But if the HTML is (partly) created server side it’s hard to easily remove stuff. In those cases when I’m really desperate, I request the HTML source from the browser and save it in the directory the original web page resides. Then I can make dramatic changes to the code and test in multiple browsers without affecting the site itself.

Is this an efficient way of debugging? Definitely not, but sometimes you just need to do it. It happens to me once or twice a year or so and by debugging that way I always managed to find the root of the problem.

Related posts:

1. CSS debugging
2. Tips for using and debugging of Less CSS code

For example: progressive enhancement in practice means that if you want to implement rounded corners, you’d use the border-radius style instead of a stack of images of rounded corners. But what if rounded corners are one of the corner stones of the corporate design of the client? Loads of users on IE7 and IE8 would miss that recognizable feature of that corporate design.

The design choice of rounded corners are sometimes a matter of taste, but most clients care for their corporate identity. So if you are ready to slaughter someones design in IE7/IE8 with progressive enhancement as your alibi, make sure that the features that will be missed in those browsers are not an important part of their corporate identity.

Related posts:

1. Do you create your design in Photoshop or Notepad?