[Info-vax] BLISS, was: Re: VMS on ARM, was: Re: Small x86-64 servers, PCs

[John Dallman]

In article <i8gjluFeutU1 at mid.individual.net>, bill.gunshannon at gmail.com
(Bill Gunshannon) wrote:

> I think the real problem isn't the limited number of people familiar
> with them as much as the very limited number of people willing to
> become familiar with them.

Having read the 1987 BLISS Reference Manual, I agree. Most young
programmers don't want to learn assembly languages, and while BLISS is
not an assembly language, it is - quite deliberately - rather close to
the metal.

It is similar in intent and capability to BCPL ("Basic" in BCPL has
nothing to do with the BASIC programming language), which uses the same
kinds of data types. However, BCPL feels more like a higher-level
language, while BLISS feels more like assembler. What make me think that?


BLISS keywords are shown as all UPPERCASE in the manual, and while there
is a hint that you can use lowercase, the point is not clearly addressed
that I can find. This is hard on the eyes of people used to lowercase
languages. This is only a question of what you're used to, but it's an
initial barrier. 

More assembler-like features include the "." operator, which is easier to
miss than BCPL's similar "!" operator, and the rules on when you don't
need it are more complex than they seem to need to be. The ability to
have imperative, rather than advisory, register declarations, is also
rather like assembler. 

The syntax for data structures is powerful, but rather arcane, as well as
having significant differences between architectures, It's more capable
than the BCPL version, but unforgiving of mistakes. Much the same goes
for linking, where BCPL is minimalist, while BLISS is built to cope with
a rather gnarly multi-language environment. 

BLISS is visibly built for a style of computing where memory is in very
short supply, so packing stuff tightly and using bit-fields for
everything is sensible. The world has changed, and simpler memory access
patterns are needed for performance, until you get a long way down into
small embedded systems.

The need to hand-optimise by choosing SELECT or CASE is something a
compiler could readily take over. 

Being an expression language is interesting, but hasn't been a compelling
feature of any language that had it AFAIK. The syntax creates places
where the presence or absence of a semi-colon makes a difference to
semantics, and the compiler can't really warn the programmer. BLISS seems
a very unforgiving language. 

The manual uses lots of words explaining concepts that are just simpler
in C-family languages. It seems to have been through several generations
of enhancement, having started as a much simpler language which was
enhanced without an overall plan. It all feels /primitive/ and I can see
why the development of VMS for Alpha and Itanium used increasing amounts
of C. 

It was an interesting read, and showed me where Windows' Structured
Exception Handling feature comes from, but I have no desire to do any
BLISS programming. I've done a fair amount of assembler in my time, but
writing assembler-like code is now only appropriate for quite specialised
work. 

John