It's not a violation of any license to be critical of it. It _is_ a
violation to not only be critical but then to flout the license.
yeah.
I am sometimes critical of the GPL, but I also generally respect its
requirements.
hell, I would probably not have written my own 3D engine had I simply
been able to "disregard" the GPL on the already existing Quake engine,
as in my case my main reason for writing my engine as it exists was
because I wasn't really happy in some ways with the GPL.
See the link I provide below.
I've mentioned triviality a few times. As far as I know "triviality"
actually subsumes other copyright concepts: originality, similarity
tests, de minimus copying, and so forth. For example, the amount of
copying may be so trivial that it is below the threshold for a
substantial similarity test; the defense may then be one of de minimus
copying.
I meant both that, and also originality. If there really is only one way
to express given functionality, it may not even be possible to copyright
the code in the first place.
There is no set minimum amount of code established by any jurisdiction
I've ever heard of. that would make no sense. In many languages 80 lines
of code is a large amount and it's almost not possible to write
something trivial in 80 lines. But that ~80 lines of code you mention
above might have been unoriginal.
in C, 80 lines of code often is fairly trivial.
although the logic is often fairly dense, the semantic density of C is
often a bit lower, so one often has to write a lot more code to complete
the same tasks (or express the same "high-level" operation).
this is also a language where single functions anywhere from 50 to 250
lines are not uncommon.
this is different from Java, which although substantially more verbose
than C, and posing some rather awkward restrictions, does at least have
a merit:
the typical amount of expression per line of code is often a bit higher
(partly due to the heavy use of library functionality, one could almost
joke that Java is more a language for invoking library methods than
actually writing code in, but either way...).
the tradeoff is that Java is not as well suited to writing pure logic
code (it is fairly hard to get much done without either creating new
class instances or invoking methods).
OTOH, C tends to more favor plain logic code, given its lack of built-in
objects, a fairly minimal standard library, ..., which combined with a
more expressive core language (pointers and a wider variety of built-in
operations), leads to somewhat different coding practices (which often
has the consequence of leading to much lower-density code).
"well, I could write a function to look this thing up in a link list, or
I could just write out the logic for walking the linked list right
here." so, while someone in another language is off invoking a container
method or similar, maybe the C programmer is writing a "while()" loop to
walk through the contents of the linked list or similar (typically
leading to longer code overall).
however, I suspect it is actually thought, rather than code, which is
what is expensive. a person can spend very little thought but write out
several kloc of fairly dull code, or invest maybe many hours into
writing and thinking over the specifics of only 10 or 20 lines.
one can do far more work, in terms of volume, when they don't really
need to think, and it all becomes a semi-autonomous process (when the
mental clockwork starts going).
well, sort of, "getting really into it" and spewing out several kloc
over the course of a few hours can IME lead to temporary disorientation
and occasional flash-backs (where, at the moment, one can't really
remember what all code they wrote, but have flashes of large chunks of
code in their mind, and normal reality seems almost dream-like for a
little while until one can mentally recover, which often also restores
ones' memory of just what all they had proceeded to write).
could this be done with a higher semantic density? maybe not, they would
either require much more thinking (lower output rate), or end up writing
less code overall (if the same level of information is expressed in
fewer lines of code).
(refraining from going into "philosophy of life and coding" issues,
don't need to go too much on a tangent...).
reading code becomes similar, as one gets fairly used to quickly
scrolling through largish volumes of code and letting background mental
processes sort through it, and ones' mind will gloss over most of it,
boiling it down to its relevant core points.
however, the matter of semantic code density often also reduces the
ability to directly compare code between languages in terms of
measurable kloc.
probably 500 kloc of Java code is not the same as 500 kloc of C code
(either in terms of expression, or in terms of effort or approximate
time to write it).
so, a lot depends, 80 lines of C code could very well be trivial.
800, or 8000, lines would probably not be so trivial, however, it may
depend some on the specifics.
yep.
