Write some kind of simple wrapper to the shader variable. The wrapper checks if the vairable is present (only once, after the shader has been uploaded and compiled) and just ignore unmapped variables.

Here's some pseudo-code:

class ShaderVariableLink {

private:
  int positionOfVariableInShader;

public:

ShaderVariableLink( ... idOfShaderProgram, ... variableName) 
{
   // get shader program
  ...
   // check if variable is present
   if(checkIfVariableIsPresent(variableName))
   {
     positionOfVariableInShader = getVariablePosition(variableName);
   } 
   else
   {
     // not present
     positionOfVariableInShader  = -1;
   }

}

void setFloat(float myFloat)
{
   if(positionOfVariableInShader>=0) 
  {
     loadFloatVariable(positionOfVariableInShader, myFloat);
  }
}
}



// example
myShaderId = uploadAndCompileShader(...);

// create new link
ShaderVariableLink* myAlphaVarable = new ShaderVariableLink(myShaderId, "my_shader_alpha_variable_name");

// link now
myAlphaVarable->setFloat(123.45f);

Or are you proposing to have a ShaderVariableLink for every program?

Yep, this is the way to go. You can embed the links in a ShaderProgram-class, but eventually you are using links for every compiled shader program. The benefit is, that you can play around with the shader code without adjusting your game code. This way I can reload shaders on-the-fly, which is really helpful when testing new features or debugging a shader.

You could just query every program in your "grouping" for every offset value. If you don't yet have an offset value for that variable, then store it, or if you do have one, then assert that the current program's offset value is equal to the one that you already have.

Then you'll end up with your variable->offset mapping, with only variables that aren't used by any program missing (and you'll be sure that the driver is complying and actually using the same offsets in every program).

Personally, I'd just use std140 though