On Tue, Aug 18, 2015 at 2:53 PM, Buck Calabro <kc2hiz@xxxxxxxxx> wrote:
Yes, I do believe there's consensus. What disagreements there are seem
to be stylistic rather than substantive.
I guess I am still too much of a newbie to recognize what counts as
style and what counts as substance. But I suspect there are things
which experts consider "stylistic differences" which really make a
substantive difference to newbies, and as such, it may help to keep
these in mind when trying to teach said newbies.
Not all the disagreements fall neatly into that dichotomy either. For
example, when you describe binding directories, you make it sound very
newbie-friendly.
ILE was designed to do stupendous things. [...]
I don't need /all/ of the infrastructure of ILE, only enough to compile
*PGMs without having to remember a maze of compiler options each time.
Um, OK. I'm not seeing how that is a response to what you quoted from
me, but, fine.
The issue for new ILE players is that the documentation doesn't really
describe a minimal set of recommendations. Which makes ILE look like a
behemoth.
Totally agree with this.
But when Alan or others talk about Make tools (and
the futility and frustration of binding directories), that certainly
sounds newbie-friendly as well.
The advice I give for program development reflects my simple needs.
There are most assuredly developers in the RPG community who need more
than I do. For those developers, a slightly more complex environment
demands slightly more complex tooling.
I think you missed what I was trying to say. And that may be due to
the fact that you're knowledgeable and experienced (despite your
"simple needs") while I'm really naive. My point was actually this:
The way Alan describes Make (irrespective of the complexity of the
Make tool itself, and irrespective of its *full* capabilities), he
makes it sound like *using* Make is simple and easy. What it sounds
like to me is, for the cost of throwing in some compiler instructions
at the top of my source, I can use MAKE to build anything.
Right now, I'm still tethered to PDM/SEU, and I really like just being
able to issue option 14 (with preferably no parameter futzing) to
build anything. I could certainly map a custom PDM option to MAKE and
be just as happy, if not happier (since I imagine I only have to issue
MAKE once for a whole program, not once for potentially each object
that needs to be compiled and linked into that program).
(Maybe it's worth mentioning that I have never used any Make tool on
the i; I'm just going purely by Alan's description, plus my undergrad
experience with make in Unix.)
So, if you've followed me, then you'll see that what Alan has
described sounds very friendly to newbies and to those with simple
needs. But I'm fully prepared to find out that the devil is in the
details, and that managing the instructions for Make actually turns
out to be much less simple than I'm imagining.
I don't see this as a variance from the consensus. Rather, I see this
as a realisation that one (simple) size does not and can not fit all
needs.
Sure, though if we're talking specifically about trying to help
newbies get started out with service programs, that ought to limit the
variance somewhat, I would think.
It's not a stark, either / or sort of choice, where your
decision will lock you on a permanent path to either irredeemable doom
or everlasting glory.
A lot of choices don't have much lock-in, but some kind of do. I mean,
if your shop has rules for how to organize things into libraries, that
isn't usually something that coexists well with other organization
schemes. Naming conventions are another. Sometimes these things have a
sizable influence over the workflow or choice of tools.
John Y.
midrange.com
