"BANCStar actually came with a "screen generator" that was supposed to be used to construct applications. But the 5.1c version of the generator was so limited that experienced programmers soon began to pry off the covers and modify directly the intermediate code that the run-time module actually executed."
All of the numbers you're looking at are an object code for a VM that (apparently) allowed for user-defined screens in the BancStar product. Programmers found themselves reverse-engineering the meanings of the different numbers and began to build the text-format object-code by hand.
This doesn't appear to have ever been intended to be a programming environment in this form.
I feel like this is an important point. One could easily say "omg look at this horrible programming language I have to deal with --
30001000: 55
30001001: 8b ec
30001003: 6a ff
30001005: 68 90 10 00 30
3000100a: 68 91 dc 4c 30"
When it's just x86 and nobody is supposed to be using it directly. Of course, we have workable tools that sit on top of machine code so we don't have to, and apparently that wasn't the case for OP, but I think that's more of a statement about their inability to do the one thing makes progress in computing possible: create abstractions.
There was certainly a time that people wrote assembler, and even machine code, directly.
People of course still do write assembler directly (but not as much as they used to!), but I don't think many have written machine code directly for a while. (Maybe for some specialized hardware?).
But yeah, it's good to note that this underlying sort of vm code wasn't intended to be written by humans... but I wouldn't say the customers were wrong, exactly, to successfully use it to do high business value things with the product they were locked into, that they couldn't otherwise.
It does make one think how happy the customers would have been if the vendor had provided an actually intended fleible scripting or 'macro' language, and then to think about the aspects of the market that still didn't lead to the vendor doing so.
There was a text-based GUI but the application programmers never used it. It was too limited and wouldn't let them accomplish what they needed to do, at least through the GUI. That is an interesting point: the underlying VM mechanism was more capable than could be exploited through the GUI. The method of working with text files described here had been established prior to my arrival. I was given training on the GUI, and then advised not to use it.
Why didn't anyone ever write a compiler for a saner (probably custom) language that targeted this VM for its output? Certainly that would be my first thought if the only choices were a GUI that was insufficiently capable or writing a bunch of comma-separated integers by hand.
I assume either the transition was too gradual so nobody quite realized the absurdity to a sufficient degree, or everyone was too busy running around with hair on fire getting the day's tasks done to spend any time on long-term improvement, or management forbade it as a waste of time. I'm curious which it was, or if it was something else.
You correctly identified the causes. Mostly, it was lack of time; keeping up with compliance changes is a full-time job at any bank, and there wasn't time for 'science projects'. What tools did get written were done to scratch a personal itch, and were done late at night and on weekends, outside of work hours.
I think, as I said in an earlier comment, that there was a general lack of awareness amongst the programmers on the team that anything better was possible. Most were not computer science graduates. Professional programmers they were. But I'll bet money that most had never heard of trees.
Management interest evolved over time from indifferent to actively hostile. The first generation LIST annotator improved productivity of the team and reduced errors probably at least fifty percent. Management took no notice at the time. Improvements to the tool, also developed out-of-hours, finally met with angry demands from management to stop and bury the results. Shortly afterwards the entire team was laid off.
Thanks for the details. I find these environments fascinating, although I'm sure they're best observed from a great distance in both space and time.
One more question, if I may: once you got used to it, what was the productivity like? I imagine these sorts of things as taking days or weeks to make the simplest of changes, but maybe the horror I imagine becomes routine after a year or two of experience.
It took less than two weeks to become fluent (I started writing the annotator tool around that time). Probably, it was the well-developed---if informal---methodology that Annie, the experienced programmer who took me under her wing when I arrived, taught me. She made a little ceremony of it, giving me my copy of the binder that held all of the accumulated knowledge about the reverse-engineered language in its photocopied pages, showing me how she used different coloured highlighter pens to tie together things in a listing, and giving me little example programs to understand. I studied diligently; it was like working crossword puzzles. About two weeks later, I was promoting my first changes to the test environment.
Edited to add: I never got over the white-knuckle feeling of it: everything global, limited supply of working-storage variables that were constantly being re-used, and interactions that could bite from a distance. One of the most useful features of the LIST annotator was that it generated an ordered cross-reference listing that could be directly compared. That feature made choosing safe working-storage variables a much safer activity.
> the underlying VM mechanism was more capable than could be exploited through the GUI.
I don't think that is uncommon. VM's are (almost?) always more capable than whatever language compiles to them (as are processors). I particuarly annoying example I have had to deal with is the Java VM. It has an instruction to take/release a lock on a variable. However, there was no language level feature that exposed this directly; and the synchronized construct added try/catch blocks so that you released the lock in a different scope than you took out the lock. This was espesially annoying because I was working on a 'decompiler' based on the idea of compiling JVM bytecode to Java source code. This meant that I basicly had to resort to pattern matching how javac compiles synchronized, so my solution was non generic. Also, Java for some stupid reason does not let you subclass Enum.
Edit: The examples on the wikipedia page make it look less crazy than it is. For example every keyword can be abbreviated to a single letter, and was abbreviated to a single letter in the code I had to read. Also, each variable is connected to a global database which (in 1990) had no ACID properties or staging system, so better hope your undebugged program didn't delete any patient data (or worse, randomly modify it).
oh, and if we're discussing a certain emr company in madison...
in the beginning, in the 70s or so, ram was very tight and the source was interpreted, not compiled; variable names were shortened to save memory. So the oldest core routines have single letter variable names
variables aren't declared; when you use a name, the interpreter just travels up the call stack looking for somewhere that variable is defined. so if you accidentally use the wrong name, especially with the strong bias to very short variable names, in nested enough code you will find that variable. This led to some amazing bugs
the prefix of the command to delete a node in the internal db (really just global sparse arrays) deleted everything. A coworker fat fingered that in a customer's prod systems and took down a hospital chain you've heard of. I just heard him wail, "Oh SHIT" and sprint out of our office; I later found out he ran for the recovery team.
they also had 15mm lines of vb6
oh, and they love h1b slave labor. Bring them over, abuse them, threaten to fire them if they don't work their asses off, and leave them with no transferable job skills. I presume the ceo uses her billions to salve her conscience.
That same company refused to even consider me for a job after I graduated from the University of Minnesota because they thought my GPA was too low. So instead, I ended up in Seattle at Microsoft where I managed a good chunk of the Visual Studio IDE.
It wasn't until years later that I realized I'd totally dodged a bullet.
I never understood h1b slave labor. I had personal experience seeing just how hard corporations will work foreigners, and casually fire them if they daren't.
First hand experienced it here I got my own stories to tell. An interesting story about government cheating on each other, and people wanting you to take the blame on it.
Every time they have an "X language is terrible" link, people slag off MUMPS. I program in a modern variant of MUMPS almost every day. It can be obfuscated as in the examples, but with proper programming practice (conventions for declaring variables, function names, not using goto where not appropriate, etc.) it's really not all that bad.
What I miss the most from other programming languages are features like public/private variables/methods, objects/classes + inheritance, type-checking, first-class functions, etc. (It does support try-catch and exception handling, however.) Even the above gripes aren't entirely 100%, as Intersystems extended MUMPS to have object-oriented features with Cache Objectscript, however, no one uses these so as not to be locked in to one vendor's non-standard implementation of the lagnguage. When comparing to say, Fortran-77, there's just no contest in my mind- out of everything I've programmed in, including VB, I hate Fortran by far the most.
lol - I love how he defends it then writes "What I miss the most from other programming languages are features like public/private variables/methods, objects/classes + inheritance, type-checking, first-class functions, etc."
I think it's over-criticized as a language, but I'm not going to be dishonest in describing what features I think it lacks or where I think it is actually, legitimately bad.
You're referring to legacy MUMPS code. It's possible to write it more expressively (why do you think the examples on Wikipedia are like that?) People don't usually capture that nuance, sadly because many people don't care.
Yes, it's a bear to sift through poorly written MUMPS code. Yes, the language gives you more than enough rope to hang yourself. However, it's also possible to write code legibly and take advantage of abstractions that MUMPS provides (chiefly persistent arrays -- which are now ACID).
I'll second the above with a link to dlwicksell's node.js binding to M and the Intersystems version (Rob Tweed discussed the open source version by dlwicksell in the presentation):
There could be some very interesting things done with this, using M as a NoSQL DB with javascript jquery-style abstractions for interacting with the DB.
The question is: if you're going to work with MUMPS, what are your chances of getting to write new MUMPS code rather than maintaining legacy code? And even if you write new code, how much of it is going to have to interface with legacy code.
I'm pretty sure the answers are "really slim" and "all of it".
At my company, we write new MUMPS code all the time. Some of this is sanely written ANSI standard MUMPS, some uses the Caché extensions.
There are techniques and strategies for containing legacy code which are pretty well known in the community. At minimum, this would involve wrapping it in a sane interface. You'd want to isolate global variable state too. Alternatively in Caché you can wrap it in classes (whose semantics are close to Java/.NET)
It's on our list to rewrite the legacy code "some day."
The new IT slum of the world, Finland, is buying a new system that is based on MUMPS. It's almost amusing to think that only a decade ago we were thought of being pioneers of IT. sigh
In a sane society, this would mean that there're lots of business opportunities in Finland to fix this. Alas, the widespread stealthy corruption prevents that.
Out of interest, were you working for EMIS by any chance?
I had the joy of having to work with MUMPS systems for which the source was not available, so the first step was to find (and complete, as it was not complete) a decompiler. Fun times!
Yes, although I wasn't an employee of EMIS. I was working for a clinic with a MUMPS system supplied by them. It ran on some old [edit: not "old" at the time] Digital minicomputer IIRC.
A lot of BASIC variants back in the early personal computer days had that feature too.. you only needed to enter as much of a keyword as necessary to make it unique. Or they had other abbreviations, like '?' for 'PRINT'. Anything to save a byte.
That did not save a byte. Commodore Basic did not store source code; it stored tokenized source code, with 'print' taking a single byte (http://www.c64-wiki.com/index.php/BASIC_token)
While it's been a long long time since I've used it, I think that was not the case for TRS-80 Level I BASIC -- it didn't tokenize, so shorthand saved actual memory. And not using spaces saved bytes. Apropos of the conversation on variables, Level I BASIC only allowed one-character variable names: you had 26 integer variables named A-Z, two (yes, two) string variables, A$ and B$, and only one array variable, A().
It also had only three error messages: "WHAT?" (any syntax-related problem), "HOW?" (any execution error that wasn't syntax-related, like division by zero), and "SORRY" (out of memory).
And I thought 'EZ-C' was bad. Still, it was the worst I've used. As far as I know, a large retailer still uses the data format and libraries from an awful "4th generation language" called 'EZ-C'.
Fun parts:
There were a fixed number of variables.
All variables were global.
There were two control structures: if/then and goto
Imagine a Point-Of-Sale application written in such. A 100,000+ line Point-of-Sale program. Imagine the fun of chasing down re-use of a variable with no debugger.
EZ-C was supposed to be a simple language with built-in screen handling (via curses) and data file handling (with variant records and multiple indices). The theory was that you wrote code in EZ-C and debugged it, since the simpler syntax would reduce errors. EZ-C came with a program that would comple your source and link against EZ-C libraries. The best of all possible worlds - a nice interpreted language that compiled for blazing fast speed!
That was the theory. In practice, the compiler was broken, and so all programs ran via an interpreter called 'dparse'.
So (and I can hear you saying) I started to do what many of you would do: I started to write my own parser with the idea of building a compiler for the language. And that's when Mike, one of the older developers/admins/jack-of-all-trades/wise elders, stopped me. "Don't do that," he said, "because if you do that, we'll never stop writing in EZ-C."
> Fun parts: There were a fixed number of variables. All variables were global. There were two control structures: if/then and goto
It's just like BANCStar! I forgot to mention that one of the most useful features of the LIST annotator was to generate a cross-reference listing. That feature alone made the practice of re-using working-storage variables much safer, because you could compare the cross-reference indexes of two different programs at a glance easily. I strongly encourage the development of that kind of safety/error-detection/error-prevention tool in any environment whenever possible.
I Thought I'd repost some of losethos's comment, seeing as he is hell-banned, but the comment was quite relevant.
losethos:
Smart American kids my age had C64s and Apple IIs. We all entered 6502 machine code into DATA statements in BASIC programs. Everyone did it. It seems so fantastical and primitive to a monkey, doesn't it.
Generally, we used monitor program to disassemble and assemblers, though you had to buy an assembler. Every store had magazines with BASIC programs full of DATA statements with graphic and machine code data. People typed it in. We had xsum bytes on blocks.
The guy is an sad combination of brilliant and stark raving mad. If he were medicated, I think he'd be a decent guy. In the meantime, he appears to be a homeless guy wearing a sandwich board and yelling gibberish into a bullhorn. Who made a complete operating system.
Actually, considerably less mad. Try to read that, and then try to read losethos's comments. which can you at least get some sense out of?
Why, losethos - if you ignore the 'crazy' sentences. If you ignore the 'crazy' sentences in the above link, by contrast, you are left with only chapter numbers and the closing words "Paris, 1922-1939."
At least in Losethos there is something in between the 'crazy' stuff.
Anyway, why did I choose the above link for comparison?
Because it's James Joyce!
So returning to Losethos. He might be 'stark, raving mad', but at least there's something to read and understand if we ignore all the detours.
Anyone who dismisses him outright clearly doesn't have a liberal arts education grounded in having to read real nonsense. After reading some of his posts, I have nothing to declare about his mental health - and neither should you.
> I have nothing to declare about his mental health - and neither should you.
He told the world he was schizophrenic, as well as describing at various times his (clearly schizophrenic) rationale for certain things, such as the random number generator that he believes God uses to talk to him. It's not a secret, and it's not something anybody is just guessing about.
The person who willfully misinterpreted it in that utterly nonsensical way claims to have now done his homework, so he should have found it already. Losethos has left an easily-followed trail across far larger swaths of the internet than just HN.
Seems plenty specific to me. There's also [1]. And as far as I've seen, he's never disputed it anywhere.
You've edited it from your post now, but that he has strong credentials is neither in dispute nor relevant. Schizophrenia can present at different times in life, and even when its onset is early and obvious, it may not become anywhere close to debilitating for many years, even without any treatment at all.
Interesting. In spite of all the outbursts, still more readable than Finnegan's Wake, though.
I can also see someone doing this exact same thing while trolling. So, for now, I will not go from a look at some guy's weird comment history to making a medical diagnosis of a stranger over the Internet. And I don't think anyone else should either.
It would also be interesting for you to apply your diagnosis skills to religious claims throughout history that God has spoken to someone, if you are able to do so over the Internet.
Losethos's behavior is schizophrenic. That the behavior might be an artificial construct of a non-schizophrenic human is possible but unlikely. Such elaborate and prolific trolling kept up over the course of more than a decade is rare if not unheard of.
The idea that supposed prophets were often schizophrenic is hardly a novel notion to academia.
I'm unclear on your motive here. Do you want everyone to think he and anyone else acting similarly is a troll simply to be dismissed? Are you arguing for simply demonizing the mentally ill rather than offering any understanding, because there's a chance they might be trolls? And if they are trolls, might that not be a symptom of a different sort of mental illness?
I assume you're trying to accomplish some sort of goal you think worthwhile, but I'm at a loss to understand what it might actually be.
I've thought about your statements and probably you do have enough evidence to back it up. This is an unusual case, and the evidence should be reported more fully when it is stated. i.e. people shouldn't just claim this without reciting the facts in detail.
More generally, I would not try to read that much about people's personality from their writings on the Internet.
I suppose in an exceptional case like this you can. But isn't it enough to say that the guy cannot communicate without derailing himself onto delusional-sounding and off-topic religious interjections?
That would not require a diagnosis and would explain to everyone why the community regards him the way it does.
The problem is that losethos is quite obviously suffering from a severe mental disorder. His posts are not usually so racist, but almost always include a lot of religious, well, insanity. It's sad because a few lines of his posts are usually very much on topic, buried in a morass of debilitating drivel.
I don't know what he's like if/when he's on medication, but to me, it seems a shame that his posts end up not being seen. To that end, I appreciate someone having hoisted the salient portion.
I'm not sure there's enough substance buried in the racist drivel to be worth bothering in this case. More than a few of us here are old enough to have spent afternoons typing in BASIC programs with lots of DATA sections from the back pages of computer magazines.
I'm struggling to understand how an anecdote about that brings much that is 'relevant' or 'salient' to a discussion of truly oddball languages like BANCStar.
I get that he's mentally ill (I read up on his OS the other day), but I do take exception to the repost of part of his comment. Because his comment is ridiculous. "Monkey" is meant as a racial slur. "American" is meant comparatively (where the smart people learn assembler!), not just incidentally. Taking it out of context like that doesn't make it salient just because it's not as obvious what it means.
So it's fine, I guess, not to judge him, but we ought to keep judging his comments, which are hellbanned for good reason.
I haven't seen anything written by this guy. Can someone explain why people on HN seem to conflate mental illness with writing an operating system? Is this just the HN attitude of having just learned js/ruby yesterday and being afraid of low level details?
I used to work on a small kernel just as a fun hobby project. I haven't had much time to do much with it lately but it was a lot of fun. I would think that this should be encouraged instead of mocked.
You're way off base here - consider turning on showdead and reading some of his posts, or even just googling the guy, before making wild assumptions. Nobody is snarking on losethos and designating him mentally ill because he wrote an OS. losethos is genuinely mentally ill.
I feel like you're reading a different HN than I am. Can you link some concrete examples of someone 'making fun' of either losethos's mental illness, or his OS?
have you turned on showdead and seen some of his recent comments here on HN yet? seriously, you seem more interested in getting up on a soapbox and making wild generalizations about how the community 'makes fun of mental illness' - something I can't say I've seen much evidence of, quite the contrary in fact - than in actually familiarizing yourself with the guy in question.
I may have been tainted by the first thread I saw here making reference to this guy. Someone basically directly, flat out said you'd have to be crazy to write your own compiler and OS. I am searching on Google and using HN search and I can't find that thread. It was a few months back.
But in my searches I did find people making fun of the guy very directly, albeit a long time ago and in some cases downvoted:
Did you turn on showdead and read his comments as you were advised to, or did you just decide to remain willfully ignorant while drawing absurd conclusions?
I presume from your response that you're an arrogant, presumptuous asshole who can't conceive of the possibility that someone disagrees with your characterizations.
From reading this thread I see the original post was clearly off the mark but everything else that asveikau wrote after that seems more than reasonable to me (and not inaccurate either: I have seen plenty of people on HN make fun of losethos for both being mentally ill and writing an OS - both of which I feel are very wrong). On the other hand, you are the one that comes across as a compete asshole here.
Presuming I'm "OK with" horrible things based on no evidence is "more than reasonable" to you? Then it must be "more than reasonable" for me to presume you're OK with victim blaming in other contexts?
Initially, you didn't give me a lot of context when you dismissed me as a pompous ass. You didn't give me any reason to think you had read and understood my original comment. My reading of it, without that context, was to assume you were OK with dismissing people based on their health problems. This especially bothered me because I have a family member with such problems. I've seen so many people be dismissive of this kind of thing seemingly because they have never experienced anything like it, and without a lot of context in your reply I put you in that bucket.
When I saw your reply to my reply I understood a bit better, and so please allow me to say right now: I am sorry. At the same time I did kind of feel that you went a little overboard in your reaction.
Your very first post in this thread was a deliberate insult to the entire community dressed up as a request for "explanation".
On behalf of people with mental and neurological issues of all stripes, please shut up. We don't need your "kind words". Just the opposite. We need people who think they're "defending" us by being holier-than-thou assholes to stop talking.
> Your very first post in this thread was a deliberate insult to the entire community dressed up as a request for "explanation".
IMHO nobody's really made a convincing case that at least some small part of this community hasn't ostracized this guy for either his mental illness or for his interest in operating systems. Having looked at comments surrounding this guy I still see people doing both. I've gotten some nice replies from people who aren't trying to judge him but I still do see other users doing both. I wanted to speak my conscience about that.
No, no, he really is mentally ill and he really did write an impressive-looking operating system [1]. Also the post quoted above really is packed with racist vitriol. Take all of that literally.
Downvotes continue. I have seen this story before. For a self-styled "hacker" community this place values orthodoxy an awful lot. And passive aggressiveness to boot. I think it must come from an excess of javascript and VC bullshit. ducks
Also they are unable to tell when I am joking or exaggerating.
> Can someone explain why people on HN seem to conflate mental illness with writing an operating system?
Nobody here does. It's just that this specific guy happens to have written a simple graphical OS from scratch apparently without anyone else's help.
He also believes God speaks to him through random noise and posts random text created from mixing up Bible verses as being what God just said. He is, really, classic schizophrenic. There's no other way to say it. He hears voices nobody else can hear and he believes it is God talking to him.
> Is this just the HN attitude of having just learned js/ruby yesterday and being afraid of low level details?
No actually, I am not embarrassed to point out that this problem exists on HN. Read any comment thread that deals with low-level anything. It's painful.
Edit: Prerequisite: to feel just how painful it is, you must understand the topic being discussed.
LoseThos is a self-admitted schizophrenic who frequently posts racist and religious rants that are extremely diverged from reality. This has nothing to do with low level details of anything, and much more to do with the fact that LoseThos is genuinely mentally ill, yet also wrote a strange, beautiful, functional system.
You read some threads on HN about low-level details and they annoyed you, and so now you get to imply that I "just learned js/ruby yesterday and [am] afraid of low level details" because I used the words "OS" and "mentally ill" in the same sentence, context notwithstanding? Knowing what you know now and rereading my comment and your reply, can I expect better of you in the future? Perhaps a bit of due diligence and more charitable interpretations of other people's comments is in order...
My original comment wasn't necessarily directed at you specifically, it was a sort of open question based on having seen threads here discussing mental illness and writing an OS.
That said, it's not so much of a stretch to take a literal read of this:
> I get that he's mentally ill (I read up on his OS the other day)
... and conclude that there may be a link between OS and mental illness in the author's mind. I did find it a puzzling juxtaposition.
It's also interesting that whenever the subject of losethos is brought up, the discussions take a strangely reliable turn. Someone (or several someones) makes a comment that includes the words "mental illness", racist/racism, religous/religion, medication.
I've read most of this persons posts and have played with his operating system a little. I feel so sorry for them that their brilliant mind is caught up in noise. There's an enormous amount of insight in his posts.
Smart American kids my age had C64s and Apple IIs. We all entered 6502 machine code into DATA statements in BASIC programs.
Yeah, but (similarly to the 'environment' that is the subject of the post) those DATA statements contained the output of some sort of tool. Nobody wrote machine code this way.
It was not that unusual to "hand assemble" programs, as it was not that unusual to remember the codes. The 6502 has less than 60 documented opcodes (and quite a few undocumented ones with various weird but in some cases somewhat usable behaviour) and only a few addressing modes, and all opcodes are single byte, so knowing most or even all of them doesn't take that much exposure.
Some of those values are so ingrained that I still remember the decimal values, despite the fact that the moment I started using tools to work with assembly on the C64, it was all hex
e.g. 169 decimal is "load accumulator immediate" (LDA #[8 bit operand) on the 6502. (or A9 in hex)
It was not that unusual to "hand assemble" programs, as it was not that unusual to remember the codes.
Yeah, I grew up with 6502s, too.
You'll think I'm weaseling out here, but "hand assembly" isn't what I was talking about.
I feel the original comment implies that some people, intending to write significant machine code, sat down with BASIC and started typing in DATA statements. And I don't think that happened to any significant degree.
As in the case of the "programming environment" under discussion, machine language routines force-fed into BASIC DATA statements were the output of another tool or process -- whether assembled by hand or by machine -- and were an intermediate form that was never intended to be editable.
Chiming in with the others - I did. I didn't do a lot with it, but I did. Didn't even know what an assembler was - I just though everyone did it by hand.
I'd read some code that showed JMP $5000 and LDY 32 and figured people just knew that JMP was a particular byte, and LDY was a different one, and you just did it. While it did seem cumbersome, I didn't have much else to compare it to.
I wrote some small screen animation utilities (ASCII screencast recorders, essentially) and later some C128 'enhanced graphic mode' stuff, moving a pointer with a mouse. I think by that point I'd learned the C128 had a small assembler tool built in, so that made things easier.
I hand-assembled machine code for the 6502 for a couple of years in my youth.
I was 12, couldn't afford an assembler, and my school wouldn't pay for one. I wasn't exactly writing VisiCalc, so a notebook and a pencil were plenty good enough.
You've been contradicted a number of times now so sorry to pile on but here's a nice webpage about a classic videogame (in the UK in the 80s, at least) with an example halfway down the page of (literally) hand-written/assembled code: http://sandywhite.co.uk/fun/ants/
I can't express how startled I was when one lone teacher (thanks, Professor Nutt!) taught me how simple an assembler was to write, that the inner workings of a CPU can be understood by mortals, and bootstrapping a monitor and language interpreter atop bare metal is a thing you can do.
also if you look up for http://en.wikipedia.org/wiki/KIM-1 you will see how I entered code, all with calculating jumps and branches in head. It is actually fun exercise
Why is it misleading, when the racist drivel that surrounds it is clearly mostly or entirely a manifestation of his illness? (if you've followed his history, you'll have seen him much more lucid, and the religious and racist rants is something that has come as he's deteriorated)
Yes, I did read the original, and while it has some fairly disgusting content, I have also read a lot of what he has written and seen his deterioration to the point where I feel more sympathy than disgust despite what he writes.
I understand that it is hard for some people to accept any part of what he's writing when he's expressing himself like that, though.
He's one of a few reasons why I keep showdead on, as while I fully understand why he's banned and wouldn't advocate undoing that, I also feel he should not be fully ignored.
Oh yes, beeen there, did this. But at some point I wanted to build my own programs and wrote a real assembler in BASIC, because writing Z80 opcodes in DATA statements wasn't an easy to write programs, and even less to debug :)
This reminds me of one of the things we work with in our company, Amadeus EDIFACTs. I want to buy the person who initially wrote the parsing for it at our workplace a beer.
Example snippet, with fake data (AIR-BLK791;7A;;232;0750058720;1A1216900;007501\r\nAMD 0750068617;1/1;
\r\nGW759208;1A1216900\r\nNXC1A
4O0ORDT030;0751;XYZC7213P;67502886;XYZC7213P;67502886;XYZC7213P;67502886;XYZC7213P;67502886;;;;;;;;;;;;;;;;;;;;;;TA
4O0ORDT\r\nA-LACSA;LR 1330\r\nB-TTP/INV/T3/RT\r\nC-7906/
1833SEGS-1173LGSU-B-9--\r\nD-127531;121751;121751\r\nG-X
;;XYZXYZ;\r\nH-001;002OYYZ; ... continued)
Sigh.... I'd forgotten about this (used to do this in a previous job)
Parsing airline flight bookings straight from raw sockets was not fun.
Thing is, it does the job, and if you watch users requesting and making bookings with the system (or other similar travel service bookings using things like VT320 terminals), I'd bet a web interface couldn't actually be faster. But only if you know how to use it.
Rather ironically, about 4 years ago, they added a "web service" to this which just wrapped the console output directly in a single set of XML tags - I kid you not - no attempt to nicely separate atoms into separate tags.
Someone needs to invent a word for the job of gluing together horrific data formats and/or scrubbing that data with regex and trying to semantically parse it.
Anyone who hasn't had this job during their programming career is very lucky.
EDIFACT is a standard for tree-based message exchange used in the airline industry; think of it as a third-rate XML designed in the 80s. Airlines are very picky about using EDIFACT to specify the syntax of messages but usually don't bother to explain the semantics, which is why airline messaging is an n^2 problem. Every airline has custom code for exchanging messages with each of their partner airlines, even though in theory they're all using a well defined messaging standard.
The Brazilian bank industry uses it for processing automated payments and receipts, but thankfully the formats are fairly standard across banks. Writing a parser and generator wasn't particularly hard, after finding enough documentation online.
I'm not too worried about revealing a lot of proprietary information here, as only about ten people in the world can read this code:
and here I thought my friend's quip, "they're only about 500 of us in the world" who can write in the Q programming language (for kx systems, another financial system) was mind-boggling. (Q is also knows for having incredibly terse, nearly unreadable syntax)
Problem is, I don't want to tangle with a non-for-commercial use language (and I can't pay.) At least with the GPL (J) I could do what I need behind the scenes and use the language as I see fit.
Is Q really that difficult? It seems like it's just packed in a lot of common set and other math functions into every character possible. It doesn't look fun, but if your work lends itself to doing just that kinda stuff, maybe it works out alright?
Well, lets get crackin' and see if we can reverse engineer this bad boy. I've done a lot of assembly and only a little direct bare machine language coding.
There's no lines without a first column, unlike pretty much all the others. I theorize the first column is opcode. You're running a lot of 3001 so I'm guessing thats "load" and it seems like you're clearing something a lot and occasionally stuffing real values in.
The second to last column looks kind of binary flag-y to me. Like LSB and 2LSB somehow team up to mean "zero flag". In fact I'm guessing opcode 8500 is a conditional skip.
The second column has a strange affinity to 1316 and its neighbor, and occasionally uses totally different class of numbers. So I'm guessing its the equivalent of variable name or more likely memory address.
I have a gut level guess the 11000 series opcodes are some kind of ALU op. Probably add. And you can add a constant, and condition codes in the 2nd to last column do things based on add result.
Another gut level guess... you're using signed ints and the last column is some kind of conditional jump and the OS lives in the upper half of memory which would be a negative number as per the last statement returning to the OS. I think you put your global libraries in the 30000 range and this module or whatever happens to live around reserved range of 22000 ish.
Then again maybe its crystal clear and if you just translate it into octal, you'll see PDP-8 instructions. Probably not, but...
I have this gut level guess this is a practical joke, like I'm supposed to recognize based on pattern matching that its a recursive implementation of a factorial.
Well, thats interesting. I was working out of the wikipedia page not the github with more content.
I see the last column is for constant numerics and zero = 10000, interesting. I bet making a deposit or withdrawl of more than 10000 at a time takes some interesting code (or more likely, the UI hardcodes only 4 spaces)
Per the writeup, I imagine having 7 programmers on staff helped figure out what to do.
Well, I think this is nightmarish, from a purely context-switching type of thinking. I don't mind using letter opcodes, strings then are pretty clear to distinguish. But come on, number opcodes? Add 5 to B and store in AX (or whatever) turns into a nightmare of numbers. Of course, after a while you probably "get" that 3001 is a conditional. But I wonder how this affects the way you feel numbers from now on: what do BANCStar programmers think about the 2000 effect, 3001 Final Odissey (heh) or the TV show 24?
And these are the people that we trust to handle our money. Sometimes it amazes me that the whole financial system hasn't already collapsed in a smoldering heap.
It's basically machine language (i.e. lower level than assembler). I remember programming in machine language on an Apple II - I had no assembler, just a photocopied table of the OP codes, and I calculated them myself and entered the hex numbers and ran it.
I wrote part of a tetris clone that way (although never finished it).
Exactly. My very first thought was why on Earth would you even bother trying to program using that? Write an assembler, and then write a C compiler, for goodness sake!
With COBOL as the obvious alternative (at the time) for financial applications, then I have to ask; why on earth would any sane company choose this programming language?
They didn't. As noted in the article, they chose a higher-level platform, found it too limiting, and gradually started just writing code directly for the intermediate language used. It's similar to putting some inline asm in your C to do things not possible in C, then eventually hitting the point that your entire application is inline asm with no C left.
It was actually an underlying tokenized bytecode (double-byte code?) never intended for human manipulation. Before I joined the group, other programmers had discovered it, reverse engineered it, and began patching it. The attitude required to do that was not uncommon in mainframe shops, where the original IBM assembler or COBOL source code for many crucial production jobs was long lost; patching the object code was accepted practice. That is part of the reason why Y2K was a bugbear for banks; they didn't only recall COBOL programmers out of retirement---in some cases it required patching the binaries.
The real question is why haven't they written a library in a higher level language.
They have to be smart guys. If they didn't do it then there must be a good reason which is unfortunately ommited. Or they did it and this article is misleading and baity.
Most of the people on the project were vocationally trained ex-mainframe programmers. You could say there was a general lack of awareness that there was any other way to do things.
From Wikipedia: "The BANCStar 10.0 release changed the "Screen Code" format to binary, and rearranged the numeric codes into an opcode with a variable number of parameter integers. The 10.0 opcode encoded a bit mapped length value that indicated the length of the command in words."
I am a regular brainf*ck programmer and very interested in esoteric languages but this is beyond my expectations.
Maybe writing some kind of compiler would be a better idea. Or at least add a comment support and character check and more user friendly labels. They probably did that though (I hope they did).
Reminds me of the scripting system for the custom scenario editor for the computer game "Realmz". You had a list of 8 text fields to enter numeric commands in, and 8 fields for arguments. There was a dropdown to use for reference for what the commands meant. If you needed your script to be longer than 8 commands, you had to create "sub-macros" and call those.
Well...I used the word "environment" thoughtfully. It wasn't just the language, it was the dot-matrix printouts on continuous fan-fold paper (with no line numbers, you didn't want to get pages out of order), the hands-full of different coloured highlighter pens, the ring binder stuffed full of dog-eared photocopied pages (and pages and pages) of magic numbers, and the ever-present feeling of terror when you had to pick a "safe" working storage variable to steal the use of for a while.
I don't want to seem mean or anything. So, please don't take offence ^^; but: why didn't you parse it a more readable format and change it back into goobledigook when you wanted to use it?
That's a good question, and a fair one. I did take a few stabs at it, but other programmers resisted any changes to their workflow that would have been required if a different source code representation were used. They really could read that code by sight. The LIST annotator slotted right into their workflow by highlighting the numbers they wanted to focus on---the English-like representation to the right was almost completely ignored---the arrows and boldface highlighting in the numeric listing, along with the line numbers, were what they used. Editing still had to be done on the raw numeric files, in KEDIT.
Of all the tools I tried introducing, LIST was the only one that was adopted. It took off spectacularly well and was beloved.
Out of interest - for languages as horrendous at this, could someone not create an abstraction language, that essentially could compile to it, or be decompiled from it?
I mean, even if it was a simple abstraction that just made it a little more readable. Like ASM vs machine code.
The worst for me has been sitting thousands of miles away working on a VDI, watching the screen refresh line by line with every change in code. We spend 8 to 10 hours for 3 hours of productive work. :-(
I have to say that, having done Webforms over the summer, it's pretty bad but not that bad. Webforms does have some (a few) strengths. There are a lot of simple apps where the "just freaking synchronize it" model works well. You could probably got most of the benefit/ease[0] with some stuff on top of, say, Django.
Absurdities exist just so we can observe the absurdity. This is more a historical curiosity at this point, but I'm glad that it does exist. Just so I can be curious about it.
"BANCStar actually came with a "screen generator" that was supposed to be used to construct applications. But the 5.1c version of the generator was so limited that experienced programmers soon began to pry off the covers and modify directly the intermediate code that the run-time module actually executed."
All of the numbers you're looking at are an object code for a VM that (apparently) allowed for user-defined screens in the BancStar product. Programmers found themselves reverse-engineering the meanings of the different numbers and began to build the text-format object-code by hand.
This doesn't appear to have ever been intended to be a programming environment in this form.