Good illustration Richard, and I will pick up on your initiative for a
"fresh-ish start".
A truly fresh start would recognize that Opensource Software is very
closely related to Public Journalism with the Internet being the common
denominator. All of that and much more is a phenomenon of the New Age
which recognizes absolutely no absolutes. (Google it) The other Richard
wants absolutes because he is of the old school, pre-newage, as I am
also. I believe I am more tolerant of the new methods because I
understand the framework within which they function, or dysfunction as
the case may be. So I am not so surprised by the dysfunction as it
becomes evident.
Everyone is right in this debate, because we all view it from our
individual perspective or 'reference frame'. To understand why we are
all right and yet perhaps wrong, it must be acknowledged that our
individual perspective is carefully constructed from our unique
experience, then modified as required to justify contradictions to that
experience. Justifying the contradictions however, simply preserves the
perspective which may or may not be a good thing. Very frequently the
perspective is just plain wrong, and insistence upon preserving it leads
to the "paralysis" which we now find so puzzling in opensource
documentation for example.
There is no mystery. Resolve the contradictions. Doing so produces a new
perspective within which all relevant viewpoints may coexist without
conflict. Irrelevant viewpoints are simply discarded. Its called CHANGE.
The introduction of opensource was such a change which resolved many
contradictions, but the nature of change is that it introduces its own
contradictions which are different, but no less destructive.
Unless that is, they are recognized as prompts for more needed change.
It certainly does not mean going back to the failed perspectives of the
past, and preserving the present is guaranteed to clash with the ever
approaching future, as should by now, be self evident to all observers.
BG
Richard Gray wrote:
Forgive my picking up the thread here, but the discussion was so deeply nested
I felt that a fresh-ish start was warranted.
I must admit that I'm a bit puzzled by the paralysis the (admittedly poor)
documentation seems to have caused...
About two weeks ago I installed the SDCC rpm on my linux workstation and wrote
a trivial program to see what happened when I compiled it. I must admit that
there are still one or two things that I don't understand properly, but I
consider that I've got a workable route from a C source to an EPROM and I can
go from an edit to an EPROM in less than a minute now. All that with crap
documentation too! I have probably only spent some six hours or so on this
whole affair, to date.
I've always felt that because I'm moderately intelligent (and far too
modest!), all I really need with these things is a punt in the right
direction to start me on my way. The rest I'll pick-up as I go along.
Haphazard as this is, it's a method that has never failed me yet, and the
documentation such as it is gave me exactly what I needed - a punt in the
right direction - and in that respect I would say that it's a resounding
success. Sure, there are lots of inaccuracies, but I have a pretty good idea
what these are now, and at some point I might even be in a position to
offer/make some corrections to the manual, if only because that's the kind of
participation that Open Source tends to encourage. In time to come, the
manual will be better than it is now because people such as myself are able
to put their real experiences into it.
Here's the program code that I used to get started (called test.c) - it's
mostly un-commented; but was intended to give the compiler and the eventual
target machine a good workout (hence the recursive factorial routine), and
it's written in such a way that I can watch the progress fairly easily with a
logic analyser.
#include <z180.h>
__sfr __at (Z180_IO_BASE+0x70) WDTRST; /* Watchdog timer reset */
static long Results[11];
void ConfigureCPU()
{
CNTLA0=0; /* Switch off serial port & clear RTS */
}
long Factorial(int X)
{
long F;
if (X>1)
{
F=X*Factorial(X-1);
return F;
} else return X;
}
void main()
{
int N;
ConfigureCPU();
while (1)
{
char T;
T=WDTRST;
CNTLA0=CNTLA0 ^ 0x10;
for (N=0; N<=10;N++)
{
long R;
R=Factorial(N);
Results[N]=R;
}
}
}
There's a tiny bit of assembler startup code required to make this work
properly on my target machine; but this was all I needed to get to a position
where I can actually now start to write some software that does something
worthwhile with an adequate understanding of what SDCC can do for me.
A bit of (not so bold) experimentation yields usable results very quickly, I
would say.
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Sdcc-user mailing list
Sdcc-user@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sdcc-user
