Racket and Common Lisp seem way more difficult than Python. I learned Python in a very short amount of time, and it was very easy (it's just functions, classes, C-like syntax, and boom, you're writing programs in Python).
Tried learning Scheme and Lisp a couple times and just ran out of steam. (While I'm here: any advice on making it stick?)
I think you're correct, but that there are trade-offs. Take Python, for example. They have "batteries included", and when modules make it into the std lib, they pretty much stop evolving. However, on the up-side, Python gains users who like having everything packaged up nice and neat so they don't need to go looking for modules quite as much.
Perl takes the popularity hit of not having too many batteries included, but benefits from the darwinian element that works to make the 3rd-party modules better. So, perlers need to spend more time asking around (or checking cpanratings), and also dealing with it when there's turnover (the module that they chose a few years ago is eclipsed by a competitor, or stops being maintained, and now they need to rewrite some of their code).
To provide some small examples, I often use Perl, and it gives me some syntax that saves me typing, such as:
* `my @other_list = @a_list[3, 1, 4]` to return just those items from a list (item 3, item 1, and item 4)
* `$str =~ s/$foo/BAR/g` to do string replacements (in string $str, replace all ocurrences of contents of variable $foo with "BAR")
* `my $thing = $colored_objects{red}->[2]` to get item 2 in the list of red-colored objects ($colored_objects is a mapping of color names to lists of items of that color)
* `my $error_msg = "Sorry, but $thing1 doesn't work with $thing2."` to interpolate the values of those 2 variables into the string
* `for (reverse(1 .. 10)) { say "Counting down: $_"; }` (counts down from 10 to 1)
I suppose I've always just guessed that operations like those in a Lisp language would require multiple lines and procedure calls, which would become tedious to write after a while. Is that the case?
Like many folks, I'd reckon, I've really meant to learn Lisp or Scheme better, but it just seems like -- with the lack of syntax -- it would be tedious to write out every single operation as a function/procedure call.
Is Lisp/Scheme as tedious as I'm assuming? I'm not talking about readability -- surely one can get used to the parens and indenting and read (and write) it just fine -- I'm talking about tedium of everything having to be a procedure call.
Aside: would've been neat to see a "version control by OS" pie chart for GNU/Linux.