>Forpedo is a preprocessor for Fortran 90 code, written in Python. It can handle some typical preprocessing tasks, like including code from one file in another, but it is mostly designed to provide advanced techniques to pre-Fortran 2003 versions of the language. In particular, there is support for C++ like generics (templates), and run-time polymorphism from Object-Oriented Programming (OOP) (click here for more details on OOP in Fortran). The output of Forpedo is pure Fortran code, which should work with any standard compiler.<:

What's good and bad about a language is context-dependent. If you're using mouse when you edit code, probably Lisp-family language isn't your choice.   It still isn't your choice even if you're cursor-key oriented.

When I first saw a long-time Lisp programmer editing (and debugging) his code on Emacs it blowed my mind.   His code was flying.   Basically, once you get used to, you won't work on (and think on) per-character basis anymore.  Instead, you work on per-expression.   No matter how complex the expression is, spanning many lines or nested so deeply, you can treat the whole expression with a few keystrokes---e.g. cutting an expr, skip next two exprs, paste the original expr, then adjust the whole indentation; or sending a whole expression to interactive REPL and check the result; or factoring out a subexpression and turning it into a local function.   You get a feeling you are grabbing the code itself, not the characters on the screen.

For your original question: probably it's easier to appreciate what's special in Scheme by shifting your viewpoint from a language user to a language designer---the former is to accept the language features as given and unchangeable, and tries to write all the solutions in it; while the latter first look at the problem, think about what language is suitable to describe the problem, then write the language using the base language.

> Pythonistas seem to be much more willing to share their code, and
> engage in collaborative efforts than Schemers. This is also true for
> Perl. I wonder why that is. Python is bursting at the seams with
> modules, and there are frequent software offerings on
> comp.lang.python.announce. Yet these kinds of announcements are rare
> on Scheme and Lisp newsgroups.

I have looked at this too. Right now it seems there are more announcements in comp.lang.ada than here. I think I have an explanation for this: Of the scheme software I've downloaded, most has required tweaking to work on my scheme of choice (mzscheme). That's one thing. Another, far more important thing to my eyes, is that programs are written in very, very different styles. Scheme is suitable for functional, imperative, declarative, message-parsing and/or object-oriented styles, plus a couple of dozen that aren't invented yet. On top of that you get personal idiosyncrasies like all programmers have, so if a scheme program nevertheless is easy to read, it's probably because the author happens to use the same styles as you. (The lack of standard libraries is also a problem, although most non-trivial programs I've downloaded use slib.) So perhaps scheme's flexibility is it's greatest problem?