- The reality. Was: Hardware and DLL interfacing in BlackBox

From: [at]} <Rex>
Date: Fri, 18 Feb 2005 11:53:31 -0600

----boundary-LibPST-iamunique-140798883_-_-
Content-type: text/plain

        After my enthusiastic report on Wojtek Skulski's presentation, I thought you might be interested in a reminder of what it is like to face BlackBox for the first time, and why it might take quite a leap of faith to dive into it. Armed with his presentation, I persisted, but even with it, the task seemed a little daunting. I think you'll see why.

        And lest you think I was setting everyone up with my glowing praise, let me just say that I have a short memory, and had forgotten myself just how daunting it could be. I hope you will find my account humorous.

        I should add that the language and framework look pretty good, and the implementation is probably (mostly) there, but as a programmer you really have to know what you are looking for to enter. All the entry points seem like a huge front door of an imposing edifice. Make it inviting and people will come in.

        My programming aims are pretty simple. I want to read and write from files and the console and do some calculations. I need to be able to detect a pressed key so I can interrupt a process if necessary (and only if necessary). I might also need to do serial port I/O and graphics, but that's beyond this discussion. Notice I left out windows. Nice, but not always needed or even helpful.

        Where to start? Help/Roadmap seems to be the first thing of any substance. In there I learn that there are two kinds of components: commands and views. Huh? I think I can guess that input might be a command, while output might be a view. My guess is not quite right, as it turns out. What about files? Not mentioned. I get the idea that this is for serious Windows programmers only -- programmers who don't need files.

        The roadmap directs me to the user manual, but I'm not interested in that right now. I move on to the tutorial, where it starts by telling me that I need a graphical interface to make it user-friendly. I know about user friendliness, since I have to eat my own dog food. I was actually hoping for something programmer-friendly. So I keep reading and I find a chapter on texts, with sections on Reading and Writing. I find that pretty detailed and heavy slogging, and it doesn't mention reading and writing binary information. Besides, I was hoping for something that I can understand, like straightforward information on opening and closing files, and familar methods like "Read" and "Write".

        So I look at the examples. And there it is: "traditional text file I/O". There I find that they have written a library, with just what I want. Well, it's just a little demo, and pretty incomplete. And it's just reading and writing text files. I get the impression that maybe CP only deals with text.

        Still, armed with faith, I press on. The Case Study doesn't seem quite like what I am looking for, so I skip that section. I would hope for a chapter on I/O, or maybe some library references. Looking at the Developer Manuals, I try the Text Subsystem. That got me a little success before. Alas, the Developer Manual with its tutorial are not it. TextCmds or TextModels. That must be it! But I find another imposing edifice of code. Just where are these methods hidden? So I do a search for "Read". Nothing looks familiar there. As I find later, I have just missed it.

        OK, lets try the Developer Manuals again, this time from the beginning, under the unlikely title "Framework". Great. I find "In" and "Out". It looks like I'm getting close, but the first thing I see is advice not to use any of the methods. Still undaunted, and armed with years of experience, I sniff out "XYplane". Sure enough, there's my key pressed function (ReadKey), but again it is accompanied by advice not to use it. (And I do insist that because it returns a value, it's a function, not a procedure. But I digress.)

        But under "Framework"/"System Map" I find the word "Library", and under that "Files". Closing in. Well, maybe not. It looks pretty low-level. And the first written description says, "Most programmers never need to deal with files directly, instead they can use readers and writers (of module -> Stores)...."

        Most programmers never need to deal with files?! I am starting to get desperate. Desperate enough to look up Stores. (If only I had thought to look there in the first place!) The code doesn't look too promising at first, but a little more familiar as I scroll down. And at least there is some humor here in the "PROCEDURE" TurnIntoAlien. As I wonder what that means. Resistance is futile, perhaps? I finally read the Introduction, which begins, "Module Stores defines a data type Store, which should be used as base type of all storable extensible objects. When storing an object of an extensible type, it is necessary to store not only its contents but also its particular type. The type is needed to create an object of the correct type when reading the data in again." That sounds like a problem if I am trying to read an arbitrary file, but maybe it has to do with interacting with the rest of the world, which by now seems to be Borg.

        I wonder if it is ever going to just tell me how to read and write. The text continues like that for quite some time, but finally, there it is! Near the bottom, under a lot of unfamiliar procedures I find procedures such as ReadInt and WriteInt. At this point I forget what I'm reading and writing to -- whether a file, console, or some kind of window -- and how to open and close it -- but at least I'm convinced it's there -- somewhere. I'm still not sure if I'm allowed to detect a keypress, but I suppose I can probably use the disparaged "instructional" method.

        All set. Now where's the math library? What about complex numbers? Another search, I guess. Is it really there?

        So what's to be done with programming fossils like me? Well, I did some more looking, and I found Pow!, Opal, and the Oakwood standard. In Opal I found all kinds of wonderful procedures like ReadInt, WriteInt, right out where I could find them. It's not perfect, and a little limited (25-line limitation for a text output box--ouch, but at least it's scrollable). However, it was simple, useable, and I could easily understand it. And there was the math library. And right there in the Oakwood standard was all kinds of nice stuff, including functions of complex numbers. I do miss seeing things like MyFile.Write(MyRecord), but I guess that's life.

        So is there any harm in adding the missing libraries? Would it be difficult? Are they really missing? Or am I missing something? And is it just me, or is a comprehensible manual needed?

Sincerely,
Rex Couture, Ph. D.
Dept. of Earth and Planetary Sciences
Campus Box 1169
Washington University in St. Louis
1 Brookings Dr.
St. Louis MO 63130

Voice: (314) 935-4194
Fax: (314) 935-7361
rex{([at]})nowhere.xy

--- BlackBox
--- send subject HELP or UNSUBSCRIBE to blackbox{([at]})nowhere.xy



----boundary-LibPST-iamunique-140798883_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"
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=


----boundary-LibPST-iamunique-140798883_-_---
Received on Fri Feb 18 2005 - 18:53:31 UTC