Oh, the poll, I voted for the OpenGL way. On the shader language both languages are way beyond previous assembly languages. If you try high level languages for some time, there's no way you're going back. So either language should make you satisfied for the time being. There are a number of things that make my favor the OpenGL approach.
First of all, that it targets the underlying hardware instead of assembly shader versions. Better utilisation of the hardware and encourages hardware innovation.
Also that it allows shaders of any length and does away with many uninteresting hardware specific limitations.
Then that the vertex and fragment shaders are linked together. This way you can share variables across both the vertex and fragment shader. This way you can also ditch the sematics tags on inputs and outputs, which makes the language cleaner and ensure you don't make any mistakes. The driver will assign them to interpolators appropriately. In DX9 HLSL you can be up for long debugging sessions if you for instance accidentally use the TEXTURE1 instead of TEXTURE0 semantics, trust me on that one. Linking them together also lets the compiler remove dead paths across both shaders that would be impossible for DX9 HLSL to detect, and of course issue a warning if certain outputs are written but never read, or are read but never written. DX9 HLSL simply can't do anything such.
And then you have the problem that HLSL is way too liberal in what kinds of constructs it allows. It allows assignment from vectors to scalars and scalars to vectors without a typecast. Then when vector variables are simply called float3 and scalars float it's very easy to make a mistake. And you might be up to an endless debugging session if you do, trust me on that one too. In OpenGL on the other hand you don't make such mistakes as easily since it's float vs. vec3, so the distinction is much clearer, and then you must have a typecast, which makes any mistakes easy to spot.
Hope the poll works!