> From: "[email protected]" <[email protected]>
>
> > I agree that if the names are saved in many places you have a mess.
>
> Let me agree, too.
>
> There is another reason why I never use PM to build standalone...
>
> I *do* value the Package Manager for maintaining projects!...
>
> Project files neatly describe what belongs to a project. What is...
>
> "Standalone scripts" though: the sooner those die, the better. Go...
It is a little confusing: you advocate projects, but condemn stand-alone
scripts. Aren't projects there to produce stand-alone scripts?
I understand, the only true purpose of a project is concatenation of
multiple files into one.
The only other alternative to projects, I see, is not to concatenate,
and have only a single source of truth approach. What you describe as
schizophrenic about JAL is actually happening with projects--you write
code in one place, but it is loaded and executed from another and you
have to chase the bugs back to the original source, which BTW is not
present during the run time.
In the project-less approach, you break down your component into scripts
which are balanced by size and similarity of content. What will help
with larger amount of script code in manageable is the use of horizontal
indentation instead of --- separators between verbs and globals browser
(which can also be a side bar tab). So where you write your code is what
is loaded and executed. When you find a bug during run time and fix it
in the code--whose place you find by another feature of identifying the
source script from a J locale name (which can be another locale browser
side bar)--that's the same scripts which is the source, and you just
have to check it into SVN.
> I feel the same is wrong with the JAL process. There is this, pardon
> my words, STUPID chain having the J code in ...
> ... the J SVN repository or some checked out dir at some developer
> ... packaged form as created by the "build" process
> ... published packaged form created by revving up VERSION
> ... downloaded/installed/depackaged form at all those users.
>
> All this ensures is a dichotomy between the scripts that are installed
> and the scripts which are SVN-mainained. It's schizophrenic. For
> developers, it's an additional burden to test whether the installed
> variant really works; end-users running across some bug have litttle
> motivation to download the source version of their code and putting
> improvements at the right place.
>
> Or am I awfully wrong and JAL authors do indeed receive a stream
> of patches or even new features from users of their code? Please
> let me know if the system *does* work.
Yes, you just don't get it. As I described above for project-less approach,
the script automatically installed in addons--you don't need to think
about "build", packaging and archives, it happens behind
the scenes, so even I don't think about it--is your source.
So to change it, you just edit it in the run-time addons folder,
and when you are done, just sync the addons folder with the SVN folder
and check it in. To verify it, you just run the Package Manager and it
places your changes into the addons folder--again automatically.
The project approach is when you make changes in the *SVN folder*;
you build and run from it too during development. What you are done,
you just check it in and, for a final test, update addons from
Package Manager and load the code from addons.
I don't see how either of the approaches is more difficult than
development process and production environment testing used in
other settings like Java or C++/.NET development. On the contrary,
it is even more productive, since you do much of the edit/debug cycle
in the same live J session.
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
