Computers are A Devolutionary Scam

   / Computers are A Devolutionary Scam #61  
Glueguy,

Sounds like you guys take advantage of the tools available. I haven't gotten down to asking the whats and whys at the development level. Dare I say that I assume that they take advantage of all possible optimization via compiler switches.

As PMs, we have been slapped mightily about the face and head when "going" into developer territory - hurumph, hurumph... How dare we ask such questions.... /w3tcompact/icons/shocked.gif Low-life, non-technical scum that we are... /w3tcompact/icons/wink.gif

Terry
 
   / Computers are A Devolutionary Scam
  • Thread Starter
#62  
<font color=blue>All of the early Tandem systems had a CPU architecture that separated "code space" from "data space". So the stack and all data structures by definition went into the data space. Only the memory manager was allowed to write into code space, which was under kernel control.</font color=blue>

And they say lawyers are responsible for the devolution of the English language.

If Lewis Carroll is a member here, perhaps he could pipe up and explain these three sentences.
 
   / Computers are A Devolutionary Scam #63  
<font color=blue>a CPU architecture that separated "code space" from "data space"</font color=blue>

That kind of "high technology" came much, much later for us, Bill.
smile.gif
The computer portion of our production "systems" consisted of a 6502 microprocessor, 4K of RAM, 4K of PROM, a couple of VIA's and a handful of discretes, all mounted on a 4" x 6" circuit board.

Amazing how much trouble we could cause with such small stuff.
wink.gif
 
   / Computers are A Devolutionary Scam #64  
Glennmac,

Uh. I don't know if I could put that into lay terms....

But you know what memory is. Right? Well, you load programs into memory. Those programs have instructions (AKA "code"), and data (AKA data). When the code executes, it manipulates the data. A perversion that some clever soles have done (as explained by Harv), was to have instructions that create new instructions, and then execute those (self-modifying code).

When I was referring to "space" I was dividing the memory up into that portion that is code (the instructions), and that portion that is data. Theoretically, code should only be code. The minute you modify it, you are treating it as data, and all heck can break loose.

All operating systems have a portion of themselves that is referred to as "the kernel" (AKA the core, the main thing, the big honcho). This part of the operating system contains all the core components, and are the final authority of control (you could say it's the main cop in the OS). The kernel generally has more authority to do things than any other entity, especially lowly application programs. At least with the so-called "good" ones it is this way.

So the way that good operating systems function is to allow the kernel to write into the portion of memory that is reserved for programs (the code part). The programs themselves are allowed to write into their own data area, and that is all (they are not allowed to modify themselves).

I bet I just made it worse.... /w3tcompact/icons/crazy.gif
 
   / Computers are A Devolutionary Scam
  • Thread Starter
#65  
This post is long-winded even for me. Don’t read it.

This whole subject of software development is quite nostalgic for me at many levels. I actually know somewhat more about computers and software than it might appear. But only in an educated layman’s sense, and my knowledge is somewhat dated.

I was an in-house lawyer for IBM for 17 years, and most of that time was spent in development labs, not in headquarters locations. In 1982, it might have been fair to say—just might—that I was the most knowledgeable lawyer in the world about software matters. I had just finished a 3-year stint as the lawyer for IBM’s largest software lab in San Jose. I worked on nothing but software matters during 1979-1982, a time when virtually no lawyers knew anything, professionally, about software. During those three years I essentially lived every hour of my working life surrounded by programmers. I like programmers.

It was my favorite job of all time. I came in late, left early, and took long lunch breaks to jog in the Almaden hills, shirtless in the ubiquitous sunshine. The Santa Teresa Lab has a stunning modern architecture—very un-IBM—and it was like a college campus. Only the managers wore ties, in an otherwise starched IBM culture where wearing a striped dress shirt was usually a career risk. Guys and girls even held hands walking around the grounds. Very, very un-IBM.

In order to give legal advice about software matters, one has to understand the technicalities of the software development process at some level of detail. One of IBM’s big concerns then—they were under antitrust suit from the federal government and 25 private plaintiffs at the time—was to avoid illegal software “tie-ins”, which is an antitrust concept that no one at the time knew how to apply to software. The reigning legal example of a tie at the time was from the 50’s. Ford then had a requirement that you couldn’t buy one of their cars without one of their Delco radios being included (“tied in”). The supposed competitive evil of a tie is that it deprived Zenith and Philco the opportunity to sell their radios into Ford cars. Ford lost the case and was forced to offer cars without radios at all, so that consumers could choose a Delco, a Philco or whatever. So, it then became the rule that it was legal for Ford to tie a carburetor into a car, but illegal to tie in a radio. Carburetors are more “kernel-like”.

With software, however, which embedded functions are more like carburetors and which are more like radios? I had to draw up a set of guidelines for the company. My guidelines would not have allowed a browser to be embedded in an operating system, which is the most current example of this still-ambiguous area of antitrust law. My first guideline asked whether someone else was offering, as a separately-priced product, the function which IBM was proposing to embed in the softare package.

One of my real career highlights came when the Lab Director told me that they were beginning to suspect that the Japanese, Fujitsu and Hitachi, were copying IBM’s software en masse. I said how do you know that. He said because they compared the hex object code and found many modules to be identical. I said what’s hex, what’s object code, what’s a module, etc. Well, a year later, I was giving courses on it.

Indeed, we could print out the JCM hex code and found it to be identical to IBM's module, except for a blank rectangle in the hex printout. Then we realized the blank rectangle was the space that used to contain the legend: “Copyright IBM Corporation”. The JCM's had literally copied the code, merely deleting the IBM copyright legend. I was a big hit in the legal department, and court, when I would slide transparencies of the JCM hex over the IBM hex to show this.

None of my legal superiors understood any of this at first. I once created a huge flow chart on about 10 sheets of large flip chart paper and paste it on the wall of an executives office in Armonk. The chart demonstrated hex, BAL and HLL’s, and how code could be compiled and assembled, and also decompiled and disassembled. I had to explain how and what was being copied. I had to explain source code, commented source code, and how the coding merely implements an underlying logic or algorithm.I was of the opinion that copyright law at the time could probably protect against the copying of the source and object code, but that it was unlikely to protect the detailed logic of the program. Thus a pirate could steal the real value of the program, the algorithm, simply by making the code sequences different enough to fool a jury. I published my copyright views in a 50-page article in the Houston Law Review in 1983. Six years later I was proved largely correct. Pirate M$ appropriated much of Apple’s operating system ideas—windows, pull down menus, icons, etc.—but implemented the ideas with sufficiently different code statements to avoid copyright.

I had to explain all this to endless legions of software-ignorant IBM lawyers and sales executives (who ran the company in those days—technical guys only got so far), because my primary recommendation to stop the copying was not a legal thing, but a business thing. In those days, IBM shipped all software in source code form. I recommended shipping object only, as the most practical way to deter copying. I had to explain how shipping heavily commented source was a roadmap for the pirates. I also recommended implementing licensing restrictions against reverse assembly and reverse compilation. This was heresy to the sales executives, of course, because the all-important customers NEED the source. Well, in the end, IBM adopted an object-only policy for most of its programs.

What fun, though I didn’t know it at the time. It’s also the time I grew to love Northern California. I should never have left, and didn’t want to. However, I was too insecure and chicken to look for another job in those days. Thus began the devolution of my IBM career.

Well, this was a huge waste of time. I’m mad at my new Mac again because the magnetic cover latch is broke and I can’t figure out the Powerpoint incompatibilities.

I’m typing this in MS Word and will copy it into the TBN paragraph-destroying text box to see what happens. The paragraphs all got destroyed. I had to recreate them in a post-post edit.
 
   / Computers are A Devolutionary Scam #67  
Glenn, thanks for OCO! I remember well when IBM came out with Object Code Only. It was one of the happiest days of my life. Products arrived on fewer tapes, so there were fewer to store. The biggest benefit was that it brought to an end the habit the place I worked for was so fond of. Taking IBM source code, adding a patch area at the end of a load module, then 'improving' IBM's code by adding a branch statement to the patch area, doing various and sundry things, then branching back when done. It was great fun to write the assembler code, but it made it very difficult to apply IBM software maintenance tapes or go to new releases.

Why did we do this? Because we had source code. What kind of things did we do? One of the last things I wrote was I modified IBM code (in many, many places) to permit the JCL option of not only deleting a file, but overwriting it with zeroes. Deleting a file doesn't really delete it, rather it just deletes the VTOC (Volume Table of Contents) entry for the file. While such options are comon now, this was a long time ago and we were one of the few places that cared about such things. I had to modify JES2 to accept the new option and write the channel program to find all the extents on disk and then write the zeroes to the disk. I probably still have the punched cards around here somewhere. /w3tcompact/icons/smile.gif
 
   / Computers are A Devolutionary Scam #68  
Glenn,

Thanks for your enlightenment... it was very very interesting...

Why couldn't you go back now even with all this hindsight...?

18-35197-JD5205JFMsignaturelogo.JPG
 
   / Computers are A Devolutionary Scam #69  
OK Glennmac, you got me there.

As a matter of fact, I was renting a room from an IBM programmer (back in '76 or so), while he was working in one of their labs in Palo Alto. I'd just gotten a divorce, and my ex, and her lawyer had taken all my money. Renting from this guy allowed me to survive.

I was forced to move when he got moved down to the Santa Theresa labs. One benefit was that I got invited to the open house when they did the big opening. Quite a stunning facility. I was curious about all the "big computer rooms", every time I went down to the lower level, there was a big glass wall showing a large computer room. I think the second or third time I went to the lower level I realized that there weren't a bunch of them; only one. The large open area between the towers was the computer room. I also liked the way they color coded each of the almost-identical towers. I could see how people might get lost were it not for the color coding.

Thanks for the enlightenment. I can see now that you were toying with us (to some extent), and maybe (just maybe) venting some frustration... /w3tcompact/icons/smile.gif
 
   / Computers are A Devolutionary Scam #70  
How the uses of computers have evolved, devolved, revolved. When I started out in academic research, any calculation carried out on a computer was suspect, unless one could verify what the algorithm was doing. That meant you had to have, and be able to read, the code, and do the calculation by hand. After all, you were publishing these results under your name. It was your reputation. We checked to make sure that any changes to the system, be they hardware or software such as compilers, gave executables which produced calculations consistent with the original, known-good systems. These days, many academic types use packaged programs which are equivalent to word processors in their transparency. Few graduate students, even in such computer dependent areas as physical chemistry, write their own programs or are able to read the code of the programs they use, in the unusual circumstance that they even have the code. However, this, and the fact that most of them also have no idea how the instruments they use work, which I see as a related topic, probably means I have job security for a while./w3tcompact/icons/smile.gif


Chuck
 

Tractor & Equipment Auctions

2018 GENIE GTH-5519 TELESCOPIC FORKLIFT (A51242)
2018 GENIE...
2016 Ford E-350 Enclosed Service Van (A50323)
2016 Ford E-350...
Takeuchi TL140 (A47384)
Takeuchi TL140...
LOT LOCATIONS (A51222)
LOT LOCATIONS (A51222)
RIDE AND DRIVE INFO (A50774)
RIDE AND DRIVE...
UNUSED CFG Industrial MH12RX Mini Excavator (A47384)
UNUSED CFG...
 
Top