----boundary-LibPST-iamunique-2067531847_-_-
Content-type: text/plain
> Hello!
>
> > Excuse my apparant arrogance, but there is an existing infrastructure of
> > people out there who know about a little thing called WriteLn and ReadLn.
> > Millions of us. And if it ain't in Component Pascal, then we ain't using
> > Component Pascal.
>
> I agree that the most important feature of the Pascal language was the
> ReadLn/WriteLn feature. Dropping it from the language and pushing it
> into the runtime-library is a step way back! What is this, the Middle
> Ages?!
> : )))
Freepascal still uses readln and writeln, and everybody absolutely loves it.
It doesn't have to be in that exact syntax.. it could be something like this:
StdOut.WriteString
StdOut.Ln
StdOut.Read
i.e. a stdout MODULE
And a module for web programming..
WebWriter.String()
WebWriter.Ln()
However, the above seems needlessly complex.. why not:
WriteLn()
Write()
WebWrite()
WebWriteLn()
Oh, I guess that is too procedural and not modular enough.. okay, fine. I'm
willing to put up with a bit of modular religion. After all, it is one of my
religions.
There are 50 million Freepascal developers that visit my websites each day who
would immediately use Component Pascal if it had readln/writeln. Because FPC has
it, component pascal must have it. Programming is based on Cults. Cults walk
around from language to language occassionaly. The only way of making a cult
walk over to another language is if it has something that everyone has already
fallen in love with 50 years ago. Even the pure object zealots use writeln, even
though writeln goes against all object laws in the universe (since it is a
global system function not belonging to an instance).
(okay, fine, I don't know of 50 million freepascal developers.. but it is
roughly in that range, give or take 49 million).
>
> Seriously, though.
> How come the name Niklaus (Wirth presumably?) is in the subject? He
> didn't invent the Component Pascal language. He had nothing to do with
> the BlackBox either (to my knowledge).
Because Niklaus is listed on the Board Of Directors or something. I saw his name
on the web page. Because Standard Pascal missed a few important things.. and
component pascal missed a few.. I guess. So I had to shout his name to get
attention. The 255 string in Pascal wasn't enough, we needed also a wordstring
(65000string instead of 255string). The 255 string was nice, but we needed more
than that as an option. That, and an Ansistring, but no one had invented the
ansistring at that time. And wasn't standard pascal missing lots of stuff like
Open Arrays as parameters and funciton results.. my point is, Component Pascal
is missing an important thing.. stdout. Standard Pascal missed a few important
things... History is repeating itself.. :-)
>
> > Do I have to write the stdio routines myself? I've done it before using
> > winapi calls in freepascal for kicks and giggles. So I can do it for
> > component pascal. But why should I have to? Put yourself in the
> > developer's shoes of year 2007.
>
> Despite the admitted arrogance the author makes a good point. The
> BlackBox' Host subsystem can detect if the application has been run with
> a standard console attached. It could redirect Log/Dialog output to the
> console on that occasion. That also applies to the Kernel showing that
> MessageBox instead of reporting trap to the stderr if in console mode.
> The modules In and Out could also work with consoles, filling that stdio
> functionality of ReadLn/WriteLn.
> Apparently, console applications were not in minds of BlackBox
> developers, but I think they would accept that as a contribution, would
> they?
>
I was going to use component pascal to build a few CGI programs.. I guess I
should be using Oberon compiler that targets native out.. I realize that a cgi
application is the wrong application to write in component pascal, but you have
to realize that even in cgi programming a wickedly cool IDE like component
pascal is still useful to develop in. Also, I was thinking about installing
component pascal on the server some time sort of like how java does it (instead
of CGI, have something like a component pascal Apache module). Hey, it is a pipe
dream, but first I need sort of a testing ground area to play with component
pascal... cgi I already know well, and already have a few DLL's written in
freepascal that could be imported as modules into component pascal.
Of course, another issue is that blackbox doesn't run on unix.. so maybe Oberon
native compiler is more suited for my task. On the other hand, if I'm currently
happy with freepascal, why do I even bother? Well, one thing is that freepascal
developers are monolithic thinkers. THey don't see the whole plug-in philosophy.
I do.. after reading Niklaus's articles about Lean Software and about how things
should be componentized.. I almost had tears in my eyes. I have been saying this
for many years in my own rants and articles.
So it is not the language I'm after.. I'm already happy with the freepascal
language. What I'm after is the general attitude of the oberon developers, and
the general philosophy.. it's like oberon developers have solved all my
difficulties.. I've been trying to explain to fpc developers about the important
of components and about the importance that is implemented as a plug in has to
be a "class", and I've been trying to figure out what the braindamaged Java and
Ruby languages are trying to do by making everything an object, when in fact
some times we just need a good ol' procedure.. and then I go and read Niklaus
Wirth's articles and I see this component pascal stuff, and I just realize that
I have been hanging around in the wrong community for the past 3-4 years
(delphi/fpc is nice, but it seems component pascal suites my philosophies even
more - unfortunately, FPC offers real world code for real world developres,
while component pascal only offers academic code for academic developers.. just
exaggerating here).
I'm not such a fan of UPPERCASE reserved words either... and I'm not a fan of
double quotes " instead of ' single quotes for strings.. but hey.. I can put up
with that if the whole general philosophy of the Oberon crowd is like me. It's
the philosophy I'm after, and the whole modular idea. At the same time, there
are cases when I just want to build a monolithic app and freepascal is really
good for those cases, and freepascal at least has real world deveopers and not
just quiche eating academics.... tongue in cheek.
> > Yes, I know stdout isn't good
>
> How come it ain't good? A console is just another interface, which is
> quite good for batch processing. It is the ultimate weapon in Unix/Linux
> community.
>
> > If there is no standard out, no one will take blackbox seriously, ever.
>
> Well, that's just exaggeration.
>
Absolutely... I mean, many developers know STDOUT and they will still laugh at
component pascal for a while.. before they see some things like STDOUT. I mean,
we've all be using STDOUT and doesn't even Java have access to STDOUT? So we
should at least offer STDOUT I think. It should be optional to use stdout, not
mandatory obviously.. i.e. everyone still has the right to use log windows when
appropriate, or a combination of both at the same time even.
> > We've all been brainwashed into thinking that console programs must run
> > on std out, not in some log window in blackbox.
>
> You just need to be brainwashed again, no biggie.
>
How about CGI... I realize the ultimate solution would be to have component
pascal installed on the server without any direct cgi stdout calls.. rather
better would be a mod_apache style thing happening.. but the reality is CGI is
extremely easy to implement once access to stdout is available. I know everyone
is probably going to say CGI sucks and the best solution would be something
along the lines of component pascal residing on the server (like java does) but
hey, I'm a realist and I already have existing cgi source bases written in FPC
that are easily ported to component pascal and easily DLL'd into component
pascal.
How about automation where one runs several command lines in one shot, maybe
even piping the results to other commands? I don't do this often, and maybe it
is bad practice.. but can you tell me how I would do this in component pascal if
I had a bunch of batch things to do? Since I'm unfamiliar with it I will take a
wild guess:
write a procedure and invoke the procedure, which invokes several commands..
rather than using a batch file. Just use a procedure.. that is what a procedure
is for.
> > Even if blackbox log windows are superior .. that doesn't mean
> > brainwashed people are going to actually realize the power of blackbox
> > right away - first they need stuff like standard out.. the wrong stuff.
>
> Brainwashed people won't realize anything they weren't brainwashed to
> realize. Whole 'nother story is that the console is a well-known
> interface. I think it should be supported for completeness' sake. It
> would widen the range of tasks the BlackBox is good for.
STDOUT is well known, and everybody has been brainwashed into thinking that
STDOUT is the way to run most simple applications. All of use FPC developers
write command line console programs when we want to do something simple.. It's
just something we've been brainwashed into. For example, I want to parse 5000
web pages and when I'm done parsing I maybe run some other command in a batch
after...I think in component pascal instead of this I would make a procedure
instead of a batch system.. and just invoke the procedure. But still not sure.
After playing around with component pascal, I realized that STDOUT is limiting
my mind, and that log windows can be just as good.. but how about making use of
old code that uses STDOUT philosophy, and how about making use of dumb things
like CGI that are based on stdout. Again, I might be better off using an oberon
compiler, or sticking with freepascal - but this philosophy of modules, and this
philosophy that not everything is a Class.. (records can be extended), and this
philosophy that procedures are still useful and that not everything is a class
like in Ruby or Java.. this is what attracts me to the whole oberon component
pascal stuff. The other thing that amazes me is the ability to execute a
function inside a module by simply typing it on the screen and then executing
it.. with a native compiler, one has to compile the whole program and then run
the program to execute the procedure. Again, it is the coolness/philosophy
behind component pascal and oberon that make me so interested. Even with my
ridiculous arrogant stubborn nature, you have to understand that I'm a real
sucker for philosophies.. ideal ones even.
Right now I see Component Pascal like Minux. Minux philosophy is better than
Linux philosphy because Minux is more robust and uses modular drivers rather
than shoving them into a monolithic kernel. But Minux isn't used by many people.
Although, they recently released it under BSD license. Off topic.
L505
--- BlackBox
--- send subject HELP or UNSUBSCRIBE to blackbox{([at]})nowhere.xy
----boundary-LibPST-iamunique-2067531847_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"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----boundary-LibPST-iamunique-2067531847_-_---
Received on Thu Jul 12 2007 - 04:50:58 UTC