An innovative tool that streamlines the process of converting higher-level expressions like variables into CSS is LESS. This tool requires Ruby for functionality. While I have not personally used it, it seems like a promising option to explore.

Alternatively, incorporating constants using server-side scripting languages such as PHP offers a more rudimentary approach.

In PHP, you can define constants in the following manner:

define ("MYBLUE", "#33CC99");

You can then utilize these defined constants by outputting their values where necessary, using <?=MYBLUE;?>

However, a notable drawback is that external CSS and JS files would need to be processed by the PHP interpreter, posing potential performance issues when handling high volumes of traffic. For websites with low traffic, this may not be a significant concern.

It seems like a tough challenge to accomplish this task. One possible solution could be developing your own CSS preprocessor using a server-side scripting language like PHP, or utilizing an existing one. However, implementing this method may require you to generate color codes dynamically throughout your entire website with PHP, resulting in less elegant scripts.

tag.style.backgroundColor = <? echo $myblue; ?>

This approach would translate into similar syntax within your CSS files as well:

.someClass {
  background-color: <? echo $myblue ?>
}

Alternatively, you have the option to explore different server-side script languages to achieve the desired outcome. As far as my knowledge allows me to comprehend, this appears to be the sole method for maintaining a consistent color constant across a website.

If interested, you can check out some available processors:

If you're interested, check out HAML and SASS. While you can't set variables for all three languages simultaneously, using these two can simplify the process of writing HTML and CSS.

To tackle this task, I would start by creating a CSS class.

.color_style {color: #33CC99;}

Next, I would apply this class in the HTML code.

<td class="color_style" />

Remember, you can assign multiple classes to one HTML element.

When it comes to JavaScript, simply call the class by its name.

document.getElementById('id').className = 'color_style';

Feel free to experiment with different ways of selecting elements. Alternatively, utilizing a JavaScript library might offer simpler solutions for applying CSS classes.

If you want to achieve this without utilizing any dynamic CSS methods (such as serving a PHP file with content-type text/css), the optimal solution is to segment the sections where you define the 'theme'.

<script type="text/javascript>
   var theme = '#003366';
 </script>>

Afterward, you can employ a JavaScript file to generate styles based on the chosen themes.

Nevertheless, if you have the capability to utilize a CSS pre-processor, it would be more advantageous. This way, you will enjoy greater flexibility and maintainability of your code. Personally, I frequently resort to using a PHP or JSP page for my CSS needs.

Many users have pointed out that achieving this in pure HTML, JS or CSS is not possible unless you pass all content through a CGI/PHP/ASP script - which actually isn't a bad idea as it makes maintenance easier.

One workaround is to use a query string in the file references for CSS / JS files - for example, '/css/stylesheet.php?timestamp=2010-01-01+00:00:00'. This will allow most clients to cache your CSS/JS files aggressively, minimizing any impact on loading times from parsing them in a scripting language (unless the site is expected to have high traffic).

If you are using Apache (which is common), another option is to utilize something like mod_set to dynamically rewrite all HTML, JS and CSS files. However, this may be more challenging to maintain if you are unfamiliar with configuring Apache (or using a different web server).

When it comes to naming tags:

In either scenario, it is highly recommended to implement a clear tagging system for dynamic variables (e.g. %MyBlue%) and consider using descriptive variable names (e.g. %HeadingBackgroundColor%, %FontColor%) even if they both refer to the same color (%MyBlue%). This approach prevents confusion in the future when making changes to values.

While using more verbose names might seem excessive initially, it helps avoid conflicts where colors clash unintentionally due to significant differences from the original scheme. Many mainstream software applications with skinning capabilities face this issue because of assumptions made about how certain values should interact, limiting the customization options due to unintended dependencies.

Before deploying my project, I like to process my CSS files using Freemarker during the build phase.

Uncertainty clouds my understanding of your ultimate objective. If the aim is to facilitate the selection of various themes for a website, you could consider employing multiple CSS files in conjunction with a cookie, session variable, or database record storing the user's preferred style sheet. This would allow you to easily incorporate something along these lines:

<link rel=<? echo stylepref; ?> type='text/css'>

On the other hand, if your ambition is to achieve complete site customization, then one of the aforementioned solutions would indeed be necessary.