Very early on when we gave talks about Julia, we sometimes did a bit about how text processing used to be a “programming niche” like numerical computing. There were specialized text processing languages like SNOBOL, Icon, Awk and Perl1 through Perl4. Then at some point people figured out how to do text processing well in general purpose languages and you had languages like Perl5, Python and Ruby which are definitely general purpose but also good at text processing. And that killed off the niche: today it would be strange to believe that text processing and general purpose programming are somehow at odds with each other and that if a language is good at text processing it cannot possibly be fit for writing a web server or implementing a GUI program. However, that was the apparent state of affairs in the 70s and 80s.
Replace “text processing” with “numerical programming” and I think you’re where we were up to the 2000s: many people believed that numerical/technical computing was a special niche and that languages that are good for it — like Matlab, R, or Mathematica — could not possibly be good for general purpose tasks as well. And indeed those languages are rather awkward to write web servers in. Of course, Python makes an interesting case here: it’s clearly general purpose and people are using it for numerical computing, but it does seem to sacrifice notational and behavioral comfort for the numerical stuff in order to be more general. Some people still believe that tradeoff is inherent. And in Python numbers are still very much special cased and built into the language, not something you can make more of yourself — you cannot create a new, efficient integer type, for example.
In some ways, Julia is an experiment to prove that numerical computing is not a niche: you can design a completely general purpose programming language in which types like integers and floats are not treated specially (aside from having literal syntax) — and an end-user can implement types that are just as efficient, which integrate just as smoothly as the “built in” types in terms of conversion, promotion, indexing, etc. It’s the answer to the question: What if we made numerical types like numbers and arrays not special at all and instead designed a language so that those kinds of things (small, immutable, efficient; complex, highly polymorphic) can be implemented in the language itself.
Anyway, it’s very nice to hear that you feel that Julia does text processing as well as languages like Icon that were specifically designed for that purpose . I’d love to improve the performance of text processing even more and there are some ideas that have been kicked around for a long time about how to do that, but it hasn’t made it to the top of the compiler team’s priorities just yet. Some day!