Vladimir Vassilevsky said:
Tim Wescott wrote:
...
BTW, in the theoretical physics, they use the dimensionless units to
avoid the heavyweight dimension constants:
e = c = h = 1
How about that?
I knew someone who claimed to be a professor of theoretical nuclear
physics--- oh no, he really was --- who wildely objected
against this.
My scientific origins are in theoretical physics but I mostly worked
as a softwareengineer--- now lurking here to learn about DSP. What
baffled me again and again is how engineers (in Germany) approach a
problem: their question is ``where is the applicable formula''. I was
trained to ask: ``what is the mathematical modell that allows me to
handle this kind of problem.''
From studying mathematical modells, the physicist is probably just
much more trained to handle long symbolic calculations as the average
engineer and from this he has a stronger ability to analyze such
formulas ``at a glance''--- w/o inserting units. To him the essential
thing is the physical quality that is measured, like length or time,
not the units that someone happens to use.
Measured values just tell us how often some well defined object will
fit ``into'' the measured object; the sole purpose of units is to pass
along what object the one who measured happened to use for reference.
Thus I like to claim: all those units were completely superflous,
hadn't things been hopelessly messed up, starting at beginning of the
world, by merchants and engineers.
Comparing any speed to the speed of light in vacuum is perfect---
might even have some advantages, when on speed-limit signs a non-zero
digit does not appeare until the 9-th (or so) position after the
decimal point ...
...
C++ allows you defining the explicit types like "VOLTAGE", "CURRENT"
and such, so the dumb mistakes are avoided. However, this approach is
seen by many as the counter productive and resulting in the
inefficient code.
Strongly typed languages were designed to support this style of
programming. They come in two flavours: ``static typing'' and
``dynamic typing''. If you want to see powerfull representatatives of
both paradigms, just look at ML and Scheme.
Static typing gives you strict compile-time type check at no run-time
overhead; dynamic typing gives you strict run-time type-check .