start	end	text
0	8000	Detail Equipment User Society presents this recording from the 1990 Fall Symposium, December 10th through 14th, in Las Vegas, Nevada.
8000	13000	The following is for informational purposes only and is subject to change without notice.
13000	20000	Neither DECUS nor its authors assume any responsibilities for the material, its use, or its applications.
30000	59000	Okay, if you want to leave your card up here with me or with Franz,
59000	65000	our speaker, he'll see that you get more notes.
65000	71000	He'll send them to you.
71000	76000	Okay, should I say that?
76000	82000	Yeah, we may also have them published in the newsletter as well.
82000	86000	Whatever your address is here.
86000	88000	I'm sure he'll give it a shot.
88000	100000	I'm a fellow countryman, as I understand.
100000	129000	I can officially say good afternoon at this exact moment.
129000	134000	Everyone here, you are in Unisig Session 8.
134000	149000	The title is Migration of Software from VMS to Unix.
149000	155000	Our speaker today is Franz Hubber, and he's from Accelerate.
155000	173000	Okay, Franz, take it over.
173000	174000	How about now?
174000	177000	Yeah, that's better.
177000	183000	Accelerate Technology Corporation is a company that specializes in providing migration tools
183000	186000	for going from VMS to Unix.
186000	188000	We're based in Denver, Colorado.
188000	192000	And I'm going to be talking about this problem that you're facing,
192000	197000	all the obstacles that you're facing when you're moving from VMS to Unix.
197000	202000	And in a sense, I'm talking a little bit more on the practical side.
202000	205000	I'll show you what you have to overcome.
205000	210000	And you have heard in the previous talk some of the difficulties of how to implement
210000	212000	some of the things that you need to do.
212000	215000	I'm not going into that detail.
215000	222000	But I'll give you a little bit more of how difficult it is to take really a program
222000	227000	to compile it on the other side with a compiler that's available on a tech station, for instance.
227000	232000	So in that sense, I almost feel like it would have been maybe better to have my talk first
232000	236000	and then have your talk because you went into some more of the detail
236000	241000	of how to implement those constructions.
241000	242000	Okay.
242000	246000	Now, when we are...
246000	248000	Obviously, we're looking at two operating systems.
248000	250000	On one end, there's VMS.
250000	251000	And you're familiar with that.
251000	254000	And it's a very extensive operating system.
254000	257000	It contains all the facilities that you need.
257000	262000	On the other hand, we're looking at the Unix operating system,
262000	266000	which, as you have heard also, it kind of gives you the basics.
266000	269000	And then many of the things you have to build around it.
269000	271000	So it's not as extensive.
271000	275000	On the other hand, that has always been said that that is one of its strengths.
275000	277000	That makes it so nicely supportable.
277000	280000	You can do everything that you want to do with it.
280000	284000	But nevertheless, for the practical purposes for the user,
284000	288000	you find yourself looking for tools, for add-ons,
288000	292000	for adding things to the operating system many times.
292000	296000	And the reasons why we want to migrate was also pointed out.
296000	298000	We share the same view.
298000	302000	It is strictly the cost benefit.
302000	310000	And now, what areas and who is impacted by the migration?
310000	315000	I like to characterize this and put it into three groups.
315000	318000	Affected are the users, obviously.
318000	321000	And that is, I mean, here the programmers.
321000	325000	I mean, the more casual user, like a scientist,
325000	328000	is running his programs that was written on a wax
328000	333000	and now suddenly it has been moved to a DexStation 3100, say, that has Alteryx.
333000	337000	And now he's running the same program on that.
337000	342000	And the areas where the users are impacted,
342000	354000	as immediately as the command line, which is a very visible obstacle to overcome.
354000	358000	On one hand, we're looking at, on the VMS, TCL,
358000	362000	which is a very basic looking type language.
362000	364000	Everything is nicely spelled out.
364000	370000	On Unix, we're looking at a more cryptic command language.
370000	375000	And obviously, the next thing that you immediately run into is,
375000	377000	you have a different set of editors.
377000	381000	You are used to EDT and those kind of editors.
381000	383000	On the Unix, you have different editors,
383000	386000	and it's just a shame to yet learn another editor.
386000	392000	And nowadays, all the computers are networked together on local area networks,
392000	395000	and again, there's different tools available.
395000	398000	There's TechNet on one side, there's TCPIP on the other side.
398000	401000	The tools that come with it are a little bit different, et cetera.
401000	407000	So those are kind of the things that are immediately visible to the users, to the programmers.
407000	412000	I'm not talking much more about this here, what goes on,
412000	416000	except just to say there are products out there in the marketplace.
416000	419000	They should be fairly easy to find for you and to evaluate.
419000	425000	There are some command language interpreters that give you VMS commands on a Unix platform.
425000	431000	There are EDT emulators that give you the EDT editor on a Unix platform.
431000	437000	So you can look into those, and they can help you greatly in that area.
437000	442000	The second area that we're running into is that we want to migrate and move programs
442000	445000	that were originally written on VMS running on a VAX,
445000	453000	and now are being moved over to a Texas 3100, say, on the Alteryx.
453000	456000	Now, there are obstacles to that.
456000	460000	And the two obstacles are the VMS extensions to the languages,
460000	465000	and then the use of the VMS runtime libraries and system service calls.
465000	469000	And those we go into some more.
469000	475000	And then, lastly, I want to just talk to you a little bit about the data.
475000	480000	Usually, after we have moved a program and a whole application,
480000	484000	there will be some data files that need to go with that application.
484000	486000	There's either some input data that is needed,
486000	492000	or in many cases, also, we find that not always a whole application is moved off.
492000	496000	Only a part of the application is moved from a VAX to the Unix.
496000	500000	And usually, it is the computationally intensive part.
500000	502000	And some other part may stay on the VAX.
502000	509000	So the data that the programs generate have to then go back to the VAX,
509000	512000	where they are then post-processed, plotted, et cetera.
512000	516000	So we have some data movement that needs to take place.
516000	520000	And between the VAX architectures and the Unix architectures,
520000	522000	there are obstacles with that.
522000	526000	And I'm going to point those out and suggest some solutions to that.
526000	528000	Okay, now that's the agenda.
528000	537000	Let's start with the moving programs from VMS to Unix.
537000	539000	There are, of course, various ways.
539000	545000	One way, as was pointed out in the talk before, is you can translate.
545000	547000	You can use translators and say,
547000	552000	I'm going to translate the same of my program that was written in Fortran into C.
552000	555000	And C is a more portable language,
555000	559000	and C compiler is available on my deck station, and I use that.
559000	563000	Another way, of course, is by saying, well, let's look what's available.
563000	567000	And I'm using here as an example of Fortran.
567000	572000	It applies to practically all the other languages, high-level languages.
572000	580000	But Fortran seems to be the easiest language to describe what goes on here.
580000	584000	So the other way of going about it would be saying,
584000	588000	well, let's look what is available as a Fortran compiler on the deck station.
588000	592000	And let's move the source over to the deck station,
592000	597000	then compile it over there and do it that way.
597000	605000	So we have one barrier there, and those are what we call the VMS extensions.
605000	608000	As you are familiar with,
608000	613000	digital has made extensions to the languages, practically all the languages,
613000	616000	beyond the standards.
616000	620000	In the case of Fortran, the standard that nowadays everybody works with
620000	623000	is the Fortran 77.
623000	627000	Digital has made extensions beyond the Fortran 77.
627000	633000	And those VMS extensions are going to create some problems.
633000	639000	And the second area then would be the use of the VMS libraries and system services.
639000	644000	That is when your programs contain calls to the lib dollars, the sys dollars,
644000	652000	OTS dollars, string dollars, math dollars, SMGs, those kind of things.
652000	655000	A little bit more to the VMS extensions.
655000	660000	I like to characterize the VMS extensions into three levels.
660000	665000	It kind of suggests the difficulty they are going to present
665000	669000	if they are not available on your compiler.
669000	674000	The first level, the syntactical extensions,
674000	677000	those are just merely some extensions that were done
677000	683000	to make the program more readable and easier to document.
683000	686000	The simplest example I can give you there is
686000	691000	the use of the exclamation mark to make a comment on the same line.
691000	697000	That is not a standard Fortran 7.
697000	703000	You have to make a separate line starting with the C in column one.
703000	708000	The debug line is also an extension.
708000	712000	So those are simply syntactical extensions.
712000	715000	The reason I characterize those into level one
715000	718000	is not that I am saying those are not as important.
718000	721000	Obviously they are, because if you have a million lines of code,
721000	726000	you are going to have a lot of work to do if those extensions are not there.
726000	729000	Because all those lines have to be decoded.
729000	736000	However, at least those extensions can be getting rid of in a mechanical fashion.
736000	740000	What I mean here is somebody can sit down and just go and do it.
740000	742000	You don't have to understand the program.
742000	746000	You don't have to tear apart the logic and put the program together again.
746000	752000	You can just go in and or if you want to you could also write yourself a program that does that.
752000	756000	So that is why I characterize those into level one.
756000	763000	Just to give you a little bit more idea, another one would be the length of variable names,
763000	766000	which is 31 characters on the VMS.
766000	770000	While it is still the seven characters on Fortran as it always was.
770000	775000	So very, very short in the way VMS programmers are used to naming things.
775000	778000	Seven characters just does not make it.
778000	779000	Dollar signs are not allowed.
779000	782000	VMS loves dollar signs and names everywhere.
782000	787000	So those kind of things would be syntactical extensions.
787000	793000	The level two, extended facilities and differences in implementation.
793000	799000	Extended facilities here means something that was added to the whole new constructs
799000	801000	that were added to the language.
801000	804000	Again, to make it easier to use.
804000	809000	The example there is structures and records.
809000	816000	A facility that comes in very handy because it lets you put all the variables that logically go together
816000	820000	into a structure and refer to it by one name.
820000	824000	Especially handy when you're using index files.
824000	831000	This is, for instance, how the CI some routines like to handle things.
831000	833000	So a very handy concept.
833000	839000	If that is not available, you will have to recode those things into common blocks,
839000	845000	work that way or find some other way, listing them all out.
845000	851000	So extended facilities would be one example, records and structures.
851000	853000	Differences in implementation.
853000	859000	That gets now a little bit more difficult because usually it's not so visible.
859000	865000	Differences in implementation comes about because the standards, any language standard,
865000	870000	as you know, does not specify of how you have to implement things.
870000	874000	A standard only defines what has to be implemented.
874000	878000	The example and the things that you should know about,
878000	885000	it's something that you will find in many programs that VMS does,
885000	889000	that's an example because it's important, is a logical variable.
889000	894000	The standard defines that there is something called a logical variable.
894000	898000	And if a variable is declared as logical, then it can have two values.
898000	900000	It can be true or it can be false.
900000	907000	However, a standard doesn't go beyond that of saying how such a thing has to be implemented in a compiler.
907000	911000	So implementers are free to choose how to do that.
911000	918000	You could represent a false as a word that is all zeros and a true that's all ones, for instance.
918000	924000	Or you could implement it as zero and a minus one.
924000	926000	Wide open.
926000	930000	Whatever works because it needs to only have two kind of states.
930000	940000	However, the VMS implementations have chosen to implement logical variables by only one bit.
940000	942000	One bit is sufficient.
942000	948000	And so all the if statements in a Fortran that's written under VMS,
948000	951000	they test only the least significant bit.
951000	956000	That means all the rest and all the 31 bits are now open for other information.
956000	961000	You can put other things in it and it will not disturb the value of the logical variable.
961000	963000	And that is used extensively.
963000	969000	This is what digital does with condition codes.
969000	975000	If you look at the condition codes, you will notice that the least significant bit toggles are around very conveniently
975000	982000	with the severity of the error so that you can put it just into an if statement and it will work.
982000	988000	And then all the rest of the word contains facility number and the error code,
988000	994000	those things that let you then formulate this nice error message.
994000	998000	So those would be one example of a difference in implementation.
998000	1005000	And I'll show you actually a segment of code in the next slide so that you can see some more of what that looks like.
1005000	1010000	Level 3 is probably the most bothersome.
1010000	1020000	And the only title I could think of to put to this would be idiosyncrasies of the VMS Fortran.
1020000	1026000	Obviously, any implementation, any compiler, any translator has its own idiosyncrasies.
1026000	1032000	I do not mean here to fault digital on saying it's bad, because they're always there.
1032000	1035000	However, we have to be aware of them.
1035000	1043000	And I give you on the next slide the example that you will most likely run into.
1043000	1052000	Now, on this slide, let me just point out, like I said, the testing of the integer variables in an if statement.
1052000	1058000	You're probably very familiar in the documentation, in the manuals, in digital manuals,
1058000	1060000	where it shows how to write a program.
1060000	1063000	It shows that this is a typical sequence here.
1063000	1067000	When you say status, it's declared as an integer, by the way, is equal.
1067000	1069000	We're making a lip dollar call.
1069000	1072000	And now this lip dollar call returns a status.
1072000	1076000	In the next line, you just do an if not status.
1076000	1083000	And we go to call lip dollar signal, let it handle the error.
1083000	1089000	Now, such a statement will not work on a compiler that is on a UNIX platform.
1089000	1097000	And the reason again is because this statement relies on the fact that you're only testing the least significant bit,
1097000	1100000	because status contains all kinds of other information.
1100000	1104000	It's not only a zero or a one.
1104000	1109000	So this statement here, when you have that in your program, that will have to be recoded.
1109000	1114000	Another obstacle that you will run into is omitted arguments.
1114000	1124000	Omitted arguments are very useful in the use of the, especially SysDollars and the LipDollar routines,
1124000	1130000	because they have a very large number of arguments, and not all of them are always needed.
1131000	1134000	Remember, in a lip dollar, you can even lop them off.
1134000	1138000	You don't have to put in all the trailing commas.
1138000	1144000	If a lip dollar call has 10 arguments, for say, but you need to only specify the first one and the rest, you say,
1144000	1152000	use the default values, you just need to put in the first argument, close the parenthesis, and you're done.
1152000	1157000	Now, that creates another problem for Fortran compilers, and that leads us to the next one,
1157000	1162000	which is it creates actually a call with a variable number of parameters.
1162000	1165000	In this case, as I said, we're passing one parameter.
1165000	1175000	However, if you specified more, then again, the compiler would have to generate that call
1175000	1182000	so that the routine that's being called can find out how many actual parameters were passed.
1182000	1186000	And that is not something that Fortran compilers do that are based on Unix.
1190000	1196000	The next one that I listed here is something that we have learned by experience
1196000	1204000	that seems that just everybody seems to have in their code without even knowing.
1204000	1210000	And that is passing an integer that was declared as an integer star 4.
1210000	1212000	It's a 4-byte wide integer.
1212000	1221000	And you're passing that into a subroutine, and that subroutine was written to expect a 2-byte integer, an integer star 2.
1221000	1227000	And usually, well, let me explain it this way.
1227000	1232000	This will work on a vax for two reasons, normally.
1232000	1238000	One is the reason that this parameter was declared in the subroutine as integer star 2
1238000	1242000	is because the coder knew that only small numbers are going to come over here.
1242000	1247000	It's probably a mode parameter that only has a value of 0, 1, 2, or 3.
1247000	1251000	And then there's a computed go-to to branch to three different locations.
1251000	1255000	So he knows there's only small values coming over, so why waste the space?
1255000	1257000	Let's declare this integer star 2.
1258000	1264000	Now, the other programmer that's calling this routine, he may not remember that or not even know that.
1264000	1267000	He just knows this is an integer and that it's a mode parameter.
1267000	1271000	Well, he might just put there a literal.
1271000	1278000	He might just put there 1, while the literal 1 is translated by the compiler into a 4-byte wide integer.
1278000	1286000	Now, that 4-byte wide integer, what's going to happen now is to do the vax architecture,
1286000	1293000	which is a, you may not know this, but the little Indian byte ordering.
1293000	1302000	It's such that the subroutine will actually fetch the least significant half of that integer.
1302000	1307000	And since you're normally working with small numbers in this situation, you've got the right value.
1307000	1313000	Now, everybody else in the world out there, except for DEC and a few exceptions,
1313000	1319000	but by and large everybody else has a byte ordering which is referred to as the big Indian.
1319000	1321000	And the big Indian is just the opposite.
1321000	1326000	So your routine now suddenly on the DEC station 3100, you will not have the problem
1326000	1331000	because DEC selected to run the MIPS computer chip in the little Indian mode.
1331000	1337000	But if you're going to a MIPS computer system, which is basically the same internal machine,
1337000	1343000	you will run into the problem because now it will fetch the upper half of that integer,
1343000	1346000	which you'll find out will always be 0.
1346000	1350000	And suddenly everything compiled, everything loaded, everything seems fine,
1350000	1354000	except that you get runtime errors or you get wrong values.
1354000	1362000	And it's a very bothersome idiosyncrasy that's happening
1362000	1366000	because compilers cannot give you any warning of this.
1366000	1368000	They don't know when you're doing that.
1368000	1371000	Fortran is not a strongly typed language.
1371000	1375000	It doesn't let you declare of what parameters have to be.
1375000	1378000	And therefore compilers cannot give you any help.
1378000	1383000	And usually you find those things one by one by trying out to run your program.
1383000	1388000	Another obstacle, of course, is the use of index files.
1388000	1394000	If you're using programs that need to read and write index files,
1394000	1399000	then again on Unix you do not have, Unix itself does not have the support for index files
1399000	1403000	because Unix just does not go beyond the flat file
1403000	1410000	and doesn't implement any structure beyond the bytes.
1410000	1414000	And so you have to find a solution to that.
1414000	1420000	The solutions to that would be most people are going to the CI some routines, adding that, do that.
1420000	1426000	And again, we've already heard for those of you who have been in the previous talk,
1426000	1429000	that isn't as easy either.
1429000	1435000	Interfacing to the ISAM some routines will take some time to get used to also.
1435000	1441000	And then lastly here I've put something down that I've also found in very many applications
1441000	1445000	and many people complaining about the following,
1445000	1454000	that Unix base compilers do not allow you multiple initializations of data in common blocks.
1454000	1460000	Now that is something which again standard FORTRAN doesn't say you can do.
1460000	1463000	However, you can do it under VMS.
1463000	1466000	And the reason that people are running into this so frequently is
1466000	1469000	because it's very convenient to make an include file
1469000	1473000	and declare all the comments that you need in that include file
1473000	1476000	and put the data statements also in that include file.
1476000	1480000	Well, but that means then whenever you use this include in every program,
1480000	1487000	the data statement is going to be there and you're trying to initialize that common area multiple times.
1487000	1490000	And that is absolutely no problem under VMS.
1490000	1496000	You get, if you do that, even if the values would change in the data statements, no problem.
1496000	1503000	You will get the values that were put into this common area with the first program that you hit,
1503000	1506000	that you're loading, that's what you get.
1506000	1513000	Well, I do not know any Unix base compiler except for some translators,
1513000	1516000	but not compilers that let you do that.
1516000	1518000	They will all generate load errors.
1518000	1521000	And that means you have to go in there and change all your include files around
1521000	1525000	and find another way of writing your programs.
1525000	1530000	So again, it is not that you can't do it, it's just making you a lot of work.
1530000	1534000	So I just want to point out to you that you have a little bit of a flavor of what goes on here.
1534000	1539000	If you're going from, if it's a Fortran application and you're going, it's running on a VMS,
1539000	1542000	you have acquired a Textation 3100.
1542000	1547000	On there is a Fortran compiler that originally was developed by Mepps Computer Systems.
1547000	1549000	And I know that compiler real well.
1549000	1551000	I've worked with Mepps on that compiler.
1551000	1552000	I know the extensions.
1553000	1555000	The extensions are fairly good.
1555000	1557000	You have the records and structures.
1557000	1559000	You have the omitted arguments.
1565000	1572000	And the index file support, for instance, was taken out.
1572000	1576000	So on the Textation 3100, Fortran does not allow you,
1576000	1580000	there is no such thing as key access is equal, keyed.
1580000	1582000	There is no such thing.
1582000	1584000	So that was taken out.
1584000	1589000	There's a few other small errors or problems, bugs that I'm aware of.
1589000	1595000	For instance, you cannot use a comma, an omitted argument,
1595000	1599000	if that is the first one in the list of arguments.
1599000	1601000	That would just generate a syntax error.
1601000	1603000	But it works everywhere else.
1603000	1606000	So there are certain problems still.
1606000	1609000	And I have worked a lot with those compilers.
1609000	1614000	And all I'm telling you is if you get to the point where you want to do this,
1614000	1616000	I will be happy, if you give me a call,
1616000	1619000	I'll be happy to tell you what to expect and what to avoid.
1622000	1626000	Now going on, the next step of making our program run
1626000	1630000	would of course be then to load the program together.
1630000	1634000	And this is where we hit then the next obstacles.
1634000	1641000	And those were the use of the VMS library and system service routines.
1641000	1646000	The SysDollars, the LipDollars, the SMGDollars, StringDollars,
1646000	1649000	MathDollars, all those wonderful things.
1649000	1654000	The VMS concepts of logical names, event flags, mailboxes,
1654000	1660000	the ASTs, the QIOs, the process handling, LipDollar, Spawn,
1660000	1663000	screen management, those are the SMG routines,
1663000	1667000	string and math routines, all those things are not on UNIX,
1667000	1672000	at least not in the same form as you were used to and had on the VMS.
1672000	1677000	So there we have to, again, we have to do something to work around them.
1677000	1680000	And if you were here in the previous talk,
1680000	1685000	we had a very good description of some of the things that you have to do,
1685000	1689000	what the problems are to implement event flags,
1690000	1696000	what the problems are to implement or do a really good AST implementation.
1696000	1698000	Not all that easy on UNIX.
1698000	1700000	Not that UNIX can do all those things.
1700000	1704000	Sure, you can do it, but it has to be done in a different way.
1704000	1708000	What that means is that you would have to tear apart your program.
1708000	1711000	So far I've been talking about VMS extensions,
1711000	1713000	and I've told you this kind of mechanical thing.
1713000	1715000	The compiler will give you errors.
1715000	1718000	You have to go in the code and maybe change lines around.
1718000	1721000	I've told you a few things to look out for.
1721000	1723000	Now it gets real serious.
1723000	1728000	If you have used a programming structure that expects those ASTs and works that way,
1728000	1730000	you don't have them on UNIX in that form,
1730000	1733000	you will have to really rethink of how to do this thing on UNIX.
1733000	1737000	And you would have to tear the program apart, put it back together again,
1737000	1741000	and that usually comes close to rewriting it.
1742000	1752000	In those cases, we tell everybody that you should look at the tools that are available to do this.
1752000	1759000	There's a small number of companies that are making this VMS system services
1759000	1763000	and libraries that run on UNIX.
1763000	1766000	They should be fairly easy for you to find out who they are,
1766000	1769000	and you can evaluate them.
1769000	1774000	I believe that a good implementation of some of the things,
1774000	1779000	like mailbox event flags, ASTs, is probably beyond the individual user.
1779000	1785000	It takes a lot of working and working with many users after using it
1785000	1788000	and finding out what the problems are to get this thing right.
1790000	1792000	So that's that hurdle.
1792000	1798000	Once we have done that and have added the VMS system services to it,
1798000	1801000	we should have now a running program,
1801000	1804000	and it should produce the same results as we had on the VMS.
1804000	1808000	That's the ideal outcome, of course.
1808000	1813000	I'm not telling you that this will go without any problems.
1813000	1818000	Unfortunately, it's not a very automatic thing.
1818000	1824000	You may have to go in there and tweak things here and there in order to get it really to run.
1825000	1827000	Okay.
1827000	1829000	Now, once we're at that stage,
1829000	1836000	we have a program that runs now on our DeX station 3100, say.
1836000	1842000	Usually, it needs some input data, which is also now still on the VAX,
1842000	1846000	and it may produce some output that needs to go back to the VAX.
1846000	1856000	And let's look into this area of the data sharing between VMS and UNIX environments.
1862000	1866000	By now, there are tools available to move data around.
1866000	1870000	It means the connectivity issue is pretty much solved.
1871000	1874000	We have network tools.
1874000	1878000	In the arena we're talking about, when we're talking about UNIX,
1878000	1881000	maybe with the exception of the Cray computers,
1881000	1889000	UNIX and VMS, you're finding that you will have an Ethernet-based network.
1889000	1894000	And there will be, on that Ethernet, you will either have a TCP IP protocol running,
1894000	1897000	or you'll have the TECnet running on it.
1897000	1901000	In some cases, they may be running both on the same Ethernet.
1901000	1909000	And nowadays, both TCP IP and TECnet are readily available for each end.
1909000	1916000	You can buy from about half a dozen manufacturers TECnet implementations for UNIX computers.
1916000	1921000	And again, there's half a dozen manufacturers that make TCP IP,
1921000	1927000	including digital, TCP IP, for VMS, for VAXs.
1927000	1930000	So you can choose whichever way you go.
1930000	1936000	You can buy the things off the shelf to solve the connectivity issue.
1936000	1941000	Now, with these network software, there always come tools.
1941000	1946000	And those tools will be, if you have one of those, they will be familiar to you.
1946000	1951000	The tools are, well, the digital one is called the VMS Alteryx Connection.
1951000	1955000	That really consists of an FTP and an NFS.
1955000	1958000	You know, the FTP, which is the Fire Transfer Protocol,
1958000	1963000	which is part of, it's one of the applications of TCP IP.
1963000	1968000	In TECnet, you have the copy command with the equivalent of that.
1968000	1973000	NFS, the network file sharing, which was pioneered by Sun,
1973000	1978000	that lets you mount files on a remote computer and read and write to them.
1978000	1981000	Those tools are readily available.
1981000	1985000	You can buy them from several sources.
1985000	1988000	So the connectivity issue is solved.
1988000	1995000	What I mean here is that we can use those tools to move the files physically from one end to the other.
1995000	1998000	Well, however, there are barriers.
1998000	2002000	And those come to, if we want to use them,
2002000	2013000	then we might find out that these tools leave us with something that's not quite ideal to use.
2013000	2018000	To explain this, let me go a little bit into, as you're aware of,
2018000	2026000	on VMS, we're dealing with a very well-defined file organization and record structure,
2026000	2029000	because it is part of the operating system, the RMS files.
2029000	2031000	It's very well-defined.
2031000	2033000	On UNIX, there is no such thing.
2033000	2038000	UNIX doesn't define beyond a stream of bytes of what files else might look like.
2038000	2040000	So there's a problem there.
2040000	2047000	What should the files, when we're moving a sequential organized file from a VAX to a UNIX,
2047000	2049000	what should it look like on the other end?
2049000	2051000	UNIX doesn't define such a thing.
2051000	2053000	So what does it look like?
2053000	2058000	Fortunately, they have some de facto standards involved.
2058000	2060000	For instance, I'll give you just one instance.
2060000	2063000	And that is, take a text file.
2063000	2067000	A text file that was generated with an EDT editor on a VAX.
2067000	2070000	That is in a variable length record format.
2070000	2076000	What that means is there is a byte count, and then come all the characters that are in that line.
2076000	2082000	Now, when you use FTP to move that file over to the UNIX platform,
2082000	2087000	it will look at that byte count, and it will throw it away,
2087000	2092000	and it will put the characters in, and then put the line feed at the end.
2092000	2096000	So it's changed the record format into a stream line feed record format.
2096000	2102000	And that is what every text processing type thing that's out there in the market for UNIX,
2102000	2105000	the VI editor, as an example, what it expects.
2105000	2109000	So that is the logical thing to translate something into.
2109000	2113000	Now, in other areas, we're not as fortunate.
2113000	2118000	In index files, there isn't really a really good de facto standard,
2118000	2128000	except that everybody seems to be adding the CISAM package to UNIX when they need to do the index files.
2128000	2132000	Or the other alternative, which you have mentioned earlier, the DISAM.
2132000	2139000	So we could use that to reproduce index files on UNIX.
2139000	2147000	However, what I want to point out is that FTP will make the translation for text files
2147000	2153000	from the VMS format into UNIX format.
2153000	2157000	And that's why you'll be very happy with FTP moving around program files
2157000	2163000	or files that were written with formatted statements in FORTRAN.
2163000	2166000	You can move those back and forth, and you won't have any problem.
2166000	2170000	The problem comes in when you're dealing with binary files.
2170000	2174000	Binary files, now suddenly we're talking about not just characters with it.
2174000	2180000	There may be characters, there may be integers, there may be a floating point in the binary representation in there.
2180000	2187000	And in these cases, FTP will, because FTP does have a verbatim mode,
2187000	2193000	it will let you move such a file, but it will not do anything to the content.
2193000	2196000	It will just move it as is, byte for byte.
2196000	2206000	And that means if you're moving an index file from the VAX with FTP in verbatim mode over to a UNIX platform,
2206000	2211000	you get the tree structure, bytes and pointers, everything.
2211000	2214000	That means it would take somebody to know what that structure is,
2214000	2219000	to figure out on the other end, on the UNIX end, to know what to do with it.
2219000	2221000	So that is the problem.
2221000	2227000	Beyond those problems there are, and that is what I'm referring to the barriers as the file organization.
2227000	2232000	Now beyond that, we have differences in the computer architectures.
2232000	2239000	And those differences are, we have different, well, in most UNIX machines,
2239000	2242000	I told you we have differences in the byte ordering.
2242000	2245000	One is called the little Indian, the other one is called the big Indian.
2245000	2249000	We have differences in the floating point representation itself.
2249000	2259000	UNIX uses the IEEE format, which is not exactly the same as your F floating point and the D and the G and the H floating points.
2259000	2262000	In some cases they're very similar, but not the same.
2262000	2264000	So we have those problems.
2264000	2266000	And then we have data alignment problems.
2266000	2273000	Look out whenever your program, if you do this, whenever your program doesn't work, it runs, but it gives you weird data.
2273000	2277000	Look for alignment problems.
2277000	2280000	VAXs do not align data.
2280000	2287000	Any other machine, the modern architectures that are out there, especially RISC architectures, will align data.
2287000	2292000	That means data cannot start at just any given byte address.
2292000	2299000	An integer star 4, for instance, will have to start at a byte address that's divisible by 4.
2299000	2304000	So that means we're creating gaps in the data.
2304000	2306000	And that's what's expected on the other side.
2306000	2309000	So look out for that.
2309000	2316000	And that's another barrier when you're transporting a binary file from VMS that has no alignment in it.
2316000	2319000	Now, on the other end, you need the data aligned.
2319000	2324000	Who is that going to do for you?
2324000	2333000	So those would be the areas that we need to find solutions to are the architectural differences and then the differences in the file organizations.
2333000	2338000	There are some solutions that are available commercially out there.
2338000	2342000	And those are file transfer and translate programs.
2342000	2348000	So in other words, programs that are not unlike FTP, that are just moving this thing over byte for byte,
2348000	2354000	but that actually go in and change the content around so that then on the Unix platform is usable.
2354000	2362000	And going back from Unix to VMS, making the required changes again.
2362000	2369000	In order for such tools to work, you have to realize that there's no magic out there.
2369000	2374000	If you need to go into a data file and you need to change its internal representation of it,
2374000	2377000	you have to know what these bytes represent.
2377000	2383000	In other words, you have to know what the data looks like inside the files.
2383000	2388000	And somehow that has to be described to those programs.
2388000	2394000	It has to be described as an example that the first four integers are an integer.
2394000	2397000	Because if they're an integer, then they have to be byte swapped.
2397000	2401000	If the first four bytes are characters, nothing is done to them.
2401000	2409000	And there's absolutely nothing in binary files that will let you get any clue of what bytes represent.
2409000	2413000	There's no data typing within binary data files.
2413000	2417000	So there has to be an external description for that.
2417000	2423000	So for any of these tools to work, unfortunately you have to know what this data represents.
2423000	2428000	If this data has been generated by your own programs,
2428000	2432000	well, if you don't remember what's in there, you can go back to the source code and figure it out.
2432000	2436000	Just look at the right statements and you see what's being written out.
2436000	2441000	The problem only comes into when those data files are generated by some third-party software,
2441000	2447000	and that information therefore is not readily available either because the company doesn't exist anymore,
2447000	2452000	or if you call them up and say, no, this is highly proprietary, this is our knowledge,
2452000	2461000	we're not giving that away, then you're finding that you're going to have problems in translating those kind of files.
2461000	2474000	Another way of dealing with it would be instead of transferring a whole file and translating it,
2475000	2482000	to leave the file, say, on the VAX, have the VAX as your central depository of all data,
2482000	2488000	and then the programs running on the Unix workstations should be able to, whenever they need to read a record,
2488000	2494000	just go over to the VAX and get that record translated in the form that is needed
2494000	2498000	and presented to the program so they can handle it.
2498000	2503000	So that would be a remote file and record access.
2503000	2510000	Again, now that is similar to the concept, if you're familiar with, the concept would be similar to NFS,
2510000	2513000	but NFS, again, would not do any data translation.
2513000	2519000	NFS will let you write files onto a VAX, but they will be in Unix format.
2519000	2522000	That means a VAX program can read them.
2522000	2529000	So if you want to have a file that's readable by both the VAX and the Unix workstation, then you need more.
2529000	2534000	You need not only the remote file capability that NFS gives you,
2534000	2539000	but in addition to that, you need this translation that needs to take place.
2539000	2543000	And again, there are commercial solutions out there for both of that,
2543000	2549000	for the file transfer and translate and for the remote file access and translation.
2549000	2555000	So I urge you to look into those areas when you get to that.
2555000	2561000	Okay, that's the end of my forum presentation. I invite any questions that you have.
2561000	2566000	Please step up to the mic here and state your name and the company you're affiliated with.
2566000	2571000	Turn the tape over now to continue with this program.
2571000	2574000	Compact Computers.
2574000	2581000	Isn't VAX 11 Fortran compiled for the RISC architecture at this point?
2581000	2586000	For the RISC architecture, there are two kinds of compilers available.
2586000	2588000	The one from digital I'm talking about.
2588000	2590000	You're talking about the one from digital?
2590000	2595000	I'm not sure which one you're talking about because I've always been told by digital it's not been released yet,
2595000	2598000	and I'm not even supposed to know about it.
2598000	2610000	But I've read some time ago that digital is working on a VMS Fortran compiler for the RISC platforms.
2610000	2614000	And as much as I know, they're fairly close to it.
2614000	2625000	Two symposia ago, someone from IMSL got up and talked about their cross-migration of VAX deck architecture to their RISC MIPS box using the VAX 11 Fortran compiler.
2625000	2630000	I was just wondering, I really thought that had been released. I mean, I've got a copy of it in a house.
2630000	2634000	Yeah, maybe that is another one that I'm not familiar with.
2634000	2643000	I know the MIPS Fortran compiler, which is very good in the VMS extensions,
2643000	2648000	but of course it doesn't solve some of these idiosyncrasies like testing of the if statements.
2648000	2650000	It doesn't do that in the way VMS does.
2650000	2652000	I thought the VAX compiler was there.
2652000	2654000	Oh, the VAX, okay.
2657000	2660000	David Jones, Tom Software.
2661000	2666000	You mentioned that the CISAM is available under UNIX.
2666000	2677000	Do you know of any RMS emulation packages available under UNIX or any other alternatives for index files?
2677000	2685000	I don't know any personally, but you may want to ask the representative here from Software Solutions.
2685000	2689000	They have talked about some RMS implementation.
2689000	2694000	I have never used any. I have not gotten any.
2696000	2698000	Michelangelo, Compact Computers.
2698000	2702000	Why would you want to actually port a Fortran code over to the VAX?
2702000	2707000	I mean, it'd be like taking gasoline and putting it in a jet, I mean, moving it onto a RISC platform.
2707000	2710000	It'll run, but it won't run well.
2710000	2715000	It's not optimized for, or the compilers don't optimize as well for the operating system.
2716000	2723000	Well, I didn't have the impression that they don't optimize as well.
2723000	2727000	I mean, the technology, I mean, the RISC box has only been out, what, a year and a half now?
2727000	2729000	Right, right.
2731000	2736000	The way I see it, what I see it out there is the, you know, in all the languages,
2736000	2745000	all the compilers are anymore implemented in the form of a language preprocessor and a code generator.
2745000	2748000	And the code generators are the optimizers.
2748000	2752000	The optimizer, for instance, in the case of the MIPS-based platforms,
2752000	2762000	the optimizer technology is one of the most crucial technology for that particular RISC implementation.
2762000	2767000	It's as important as the silicon implementation of it.
2767000	2776000	And on top of that sits a Fortran compiler that just translates into this intermediary code.
2776000	2781000	And so the optimizer, all the languages share.
2781000	2790000	A C program on a MIPS computer system, for instance, will share, will have the same optimizer, run the same optimizers.
2790000	2794000	So the deficiency usually comes in the front end.
2794000	2797000	You know, does the language have all the constructs that you need?
2797000	2803000	And in the case of moving from VMS to Fortran, it's those VMS extensions.
2805000	2806000	I guess I'll step to the end of the line.
2806000	2807000	Yeah.
2807000	2809000	Michael Angel Compact, still.
2809000	2818000	The current implementation of the UNIX file system doesn't include the extensions that AFS is going to provide that digital is working towards.
2818000	2821000	Once that comes into play, this is just information.
2821000	2824000	Once that comes into play, that should take care of some of the RMS problems.
2824000	2826000	I was just curious.
2826000	2833000	You mentioned that logical names, QIO, event flags, mailboxes, process handling, screen management resources,
2833000	2837000	string and math functions, and several other things aren't available under UNIX.
2837000	2839000	Actually, they are.
2839000	2842000	They're just called different things from what DEC does.
2842000	2850000	They're there very well, very properly implemented, very highly optimized.
2850000	2854000	They're actually in the kernel, and they work reasonably well.
2854000	2862000	The other question I had is, does the Fortran 77 option to the VAX 11 VMS Fortran compiler still work?
2862000	2870000	I mean, if you're going to write code that you want portable, you typically don't include a lot of LibDollar mumble frats on it or stuff like that.
2870000	2874000	You typically write it, and you put your Fortran 77 option on it, and you say,
2874000	2878000	okay, yes, this works, no, it doesn't work, and you do it that way.
2878000	2880000	Yeah, that would work.
2880000	2891000	If you've done it that way, you probably experience many less problems than people have used everything that you can do on VMS.
2891000	2898000	Last thing, there are a lot of public domain database management things that will create ISAM files,
2898000	2902000	the stuff from GNU or UUNet source tapes.
2902000	2904000	You can get the public domain stuff.
2904000	2908000	It's reasonably well optimized, and that's why they wrote it.
2908000	2910000	Have you had any experience with that?
2910000	2912000	No, I have no experience with that at all.
2912000	2915000	I have some experience with the CISAMs, but I have no experience with the others.
2915000	2924000	Yeah, thanks.
2924000	2926000	Mike, Cory Conoco, Incorporated.
2926000	2932000	Could you clarify the discussion you had just a little earlier about the digital Fortran product?
2932000	2940000	I was under the impression that DEC had one, and I think that that would be only for the VAX in the line and not the RISC in from what you said.
2940000	2942000	Is that correct?
2942000	2959000	No, what I said is that presently the only announced Fortran compiler on the RISC platforms is the compiler that's based on the MIPS compiler technology.
2959000	2971000	That one is pretty good in the VMS extensions, but it doesn't have all the idiosyncrasies that the VMS Fortran compiler has.
2971000	2973000	It differs there.
2973000	2981000	What I know is, and it has been written up in some trade papers as kind of like a rumor,
2981000	2991000	that digital is working to take a VMS Fortran compiler that has all the VMS extensions, everything there,
2991000	2995000	a VMS Fortran compiler, and make it work on the RISC platforms.
2995000	2998000	But that one, to my knowledge, has not been released.
2998000	3005000	However, they're fairly close because I know one salesman in an office has a copy and is working with it.
3005000	3009000	But he told me I'm not supposed to know about it.
3009000	3011000	Michael Angel, Compact.
3011000	3016000	Actually, what they started off doing was they took the Fortran compiler from MIPS and they retrofitted a lot of things.
3016000	3023000	The actual developer for that compiler happens to be out on the exhibit hall floor, and if you want to hunt him down, his name is Sid Maxwell.
3023000	3025000	Sid Maxwell, yes.
3025000	3027000	You can go beat him up about it and complain about it.
3027000	3029000	Okay, I will.
3029000	3031000	I talked to him on the phone several times.
3031000	3033000	Glad to hear he's here.
3037000	3039000	Well, thank you.
3039000	3043000	Applause.
3045000	3047000	That concludes our program.
3047000	3049000	Now fast forward to the end of this side.