🚀 go-pugleaf

When I got home from work last night there was a packet from Microsoft
announcing the availability of MSC 6.0.

If you have purchased MSC 5.1 prior to March 1, 1990 the upgrade fee is
$125.00 plus tax, shipping and handling.  Individuals purchasing MSC
between March 1, 1990 and July 1, 1990 will be able to upgrade for the
cost of shipping and handling by furnishing verification of date of
purchase.

The accompanying sales brochure did not talk about the compiler as much
as the new Programmer's Workbench which 6.0 is built around.  The concept
is a continuation of Microsoft's theme to provide a development
environement which can support large scale projects.  The workbench
allows access to the compiler, editor and a number of development tools
as well as hooks for accessing what they refer to as 'third party tools.'

Accompanying the upgrade is Version 3.0 of Codeview.  This is marketed as
a major upgrade of Codeview.  If support is provided in the form of
a machine with extended memory (80286 and up) the brochure claims there is
no limit (other than memory) to the size of the application which can be
handled.  Support is also available for platforms provided EMS memory
mapping although the brochure suggests this is at the expense of the size
of the application which can be debugged.  New features also include the
presence of a local variable window which automatically displays all the
values of the local stack frame whenever a function is entered.  Debugging
history is also provided as well as the ability to 'back up' if you should
happen to overrun the site of the bug you are interested in.  The ability
to set breakpoints based upon a combination of line number and variable
values is also supported.  In combination with the programmers workbench
an individual can supposedly cause Codeview to 'remember' where it was so
that you can return to the workbench, do some things and then return to
where you left off in the debugging environment.  Don't hold me to this
last part as I am not sure that I interpreted that portion of the sales
brochure correctly.

Microsoft seems to now be supporting NMAKE exclusively as the project
control utility from the Programmer's workbench.  In a somewhat nodding
acknowledgement to those of us who grew up with UNIX(c) style makes they
now claim to fully support us by providing 'a project control facility
that understands true dependencies.'

In addition Microsoft is providing a file browsing utility that incorporates
a function tree analyzer with object recognition (not in the OOP sense.)
My impression is that you invoke this file browsing utility on your project
in its sum total and it allows you to jump to any function regardless of
source module location and will also tell you the names and locations of
objects (variables, arrays and structures) as well as the ability to jump
to these sites.

The editor was not mentioned specifically as being ME.  Instead the brochure
commented that the workbench provided an editor which is both extensible and
fully customizable which also provides the ability to utilize the information
provided by the workbench about the project to speed editing.  One would
presume that the editor can probably access the source code using the
information tables developed by the file browsing facilities.

From the compiler standpoint emphasis was again placed on the code
generation capabilities of the compiler.  It was interesting to note that a
fair amount of emphasis was placed on the ability to alter how the compiler
deals with optimization.  An explanation was made concerning the problems
with aliasing and loop optimizations.  The brochure went on to explain how
the the development environment allowed the programmer to customize each
source module so that problems with aggresive optimization can be avoided
by reducing the optimization level on a per function or per source module
basis.  According to Microsoft new optimization enhancements in the compiler
allow for register parameter passing as well as global optimization.  One
wonders if this means that the compiler is going to be smart enough to do
global register allocation and optimization across all modules....

Microsoft claims of course that the compiler is ANSI compliant and that
extensions can be switched on or off at will.  There are two notable
additions to MS supplied language extensions: the first is the support of
in-line assembler code through the _asm keyword and the second is the
ability to use based pointers.

The in-line assembler uses the _asm keyword to set of a block of assembler
code.  An interesting (and conceivably useful) feature is the ability to
refer to variables by name within the assembler block.  The following
variable swap illustrates this:

                auto int var1 = 0,
                         var2 = 1;

                _asm
                {
                   MOV   AX, var1
                   PUSH  AX
                   MOV   AX, var2
                   MOV   var1, AX
                   POP   AX
                   MOV   var2, AX
                }

Not a very elegant example I am afraid but hopefully it provides an idea of
the resource that they are trying to provide.

My pager just went off so that is about all the information I can provide
for now, hopefully people will find it of use.  I am not sure what type
of lead time to expect before the upgrade shows up but I am not holding
my breath.

Does 6.0 make anyone else in the community feel inadequate?  Once of my
main concerns is finding the time to employ all this new technology.  I keep
telling myself that I have to start using all these productivity
enhancements but I still find myself sitting up at 2:00 am in the morning
with only my editor, compiler, linker, grep and diff at my side and of course
a whole bunch of printf's........

                                     As always,
                                     Dr. G.W. Wettstein
                                     NU013809@NDSUVM1

`The truest mark of a man's wisdom is his ability to listen to other men
 expound their wisdom.'