On Mar 28, 7:51 am, Lee Spector <lspec...@hampshire.edu> wrote:
> > Dependency management and other garbage are definitely garbage, but I know 
> > of no nontrivial programming language that doesn't have its share of it.  
> > If you know of any magical environments that eliminate such administrivia, 
> > do share.
>
> A lot of the programming I've done in a variety of languages hasn't required 
> me to deal with dependency management but that was mostly because there 
> weren't any dependencies except the language itself (e.g. in Common Lisp), 
> the language's own libraries which it knows how to find (e.g. standard C 
> libraries), or my own code (which would be in the same file or the same 
> directory). So the issue didn't arise.

This.

I am not an expert in the term "dependency management" because I don't
want to be an expert in it.  So for these purposes I will define the
term as "a bunch of bureaucratic crap I have to do that actually has
nothing to do with programming."  Anyway, the only place I ever
experienced it before was a job I took once where they had Microsoft
Visual C++ Studio or something like that.  This thing sure was
ridiculous, and after two days of trying to figure out how to get it
to use it's OWN libraries (never once writing a single line of code),
I threw it out the window, told the boss "I'm using something else,"
and that was that.  I've worked at large operations (IBM, AT&T) but
never had to do any of this "dependency management" crap (I don't
doubt that somebody, somewhere, might have had to do it - probably a
full time employee PAID to do it - but I didn't have to do it).

But with any other language I've ever used, at most I include a
library I need in a directive at the top, or I include my own code in
a similar directive.  For instance, with Erlang you just say
"module(whatever)" at the top.  I mean, that's ALL you do.  And the
documentation for the function you are using tells you the "whatever"
to put in.  And to tell you the truth, I thought THAT was a load of
B.S... until I dealt with Java, heh.  With J I either say "load
'whatever'" or "require 'whatever'" and that's it.  It knows where to
go and find the 'whatever'.  With APL and Prolog, I don't think I had
to ever declare anything.  I've used dozens of languages, and this is
the pattern with any language I've chosen to use of my own volition.
The one exception was the Visual C++ crap (something I wasn't using of
my own volition), but I threw it out the window.  Another exception
WOULD have been Java, except that I decided I wouldn't even do it for
money.

One pattern I've noticed is that the more a language requires you to
do "dependency management" garbage OUTSIDE the code, before you even
get to the code, the more it also requires cruft INSIDE the code.  For
instance, look at a Java program sometime, with REAMS and REAMS of
declarations like "public.static.void.main.blah.blah...."  First time
I saw that, my jaw just hit the floor, and I said "you mean people
actually sit there and code in this garbage?"  I guess more than 50%
of the code in a language like this is cruft?

At any rate, I will give Shantanu Kumar's recommendation a try, and
report back to here if it works or not (my idea for this thread was to
compile a list of things that worked or didn't work for future
reference for newbs).

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to