>> Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.
The point is that low-level languages like C and Fortran (and today, Java) are underpowered, and any sufficiently large project will evolve to the point where someone builds a (often vaguely Lisp-like) scripting language on top of it to allow developers to raise the level of abstraction, maybe without even realizing that's what they're doing.
I have seen this in action, a lot of companies build internal, proprietary scripting languages on top of their low-level programs. They may start out as configuration files, a build system, preprocessor macros, or a DSL, but over time as features get added they accidentally become Turing-complete, and eventually someone writes an interpreter and now you've invented something that serves the same purpose as Lisp, only worse.
More here: https://sites.google.com/site/steveyegge2/the-emacs-problem
No, that's not what it is about. It's not about programs needing a scripting language.
It's about the program (its framework, libraries, architecture, ...) itself. It will acquire features like:
* late binding
* symbols
* dynamic data structures
* serialization format
* a plugin architecture with loading of code
* advanced error handling
* first class function objects
* automatic memory management
* specialized numeric datatypes (large integers, ...)
* a dynamic object system
* more...
The implementation language will be extended by some framework, software layers, libraries with such features ... so that over time it will implement many of the standard features of Common LispNote that platforms like the JVM, .net and others nowadays provide many of that (and much more). Also language on top of those do: Java/Scala/... See for example how for Java dynamic loading of code has been implemented on top of custom class loaders.
It also has some things CL doesn't provide as part of the language: threading primitives; URL-handling; advanced calendrical calculations; basic crypto and so forth.
Other than this, however, it's a good example.
https://github.com/pusher/pusher-js/blob/2.2/src/defaults.js...
parser in https://github.com/pusher/pusher-js/blob/2.2/src/strategies/...
The main reason was that we were thinking about helping clients with server-supplied connection strategies. We could gather some metrics and tell the client in advance that, for example, WebSockets won't work due to some network issues. We also thought it could be useful for orchestrating migrations and working around potential load balancing issues. Injecting JavaScript was out of question, so I wrote this JSON DSL for connection strategies.
We haven't done that and it's probably never going to happen. The Internet has moved on, we dropped support for some ancient browsers, connectivity has improved and we haven't really felt a need for that feature, to be honest.
I agree that at the moment it's unnecessary.
I was originally in a team of 4-5 programmers, but the company slowly got rid of everyone except me. At that point I tried to leverage the situation and institute some changes in the programming languages, web stack and workflow automation; most of them were rejected by the boss on the grounds like "sure, we could switch to something better - like say, Ruby - but Ruby programmers are much more expensive than PHP."
It took me a lot of work and pain to eventually leave. My two biggest mistakes:
1) Not noticing when was the best time to go. There was a moment when the old project ended and they wanted to get me into a next one. Building it solo. From scrapped bis of metal. I should have left right there.
2) Being too afraid of changing jobs. I know that with my skills I can land a new programming job very quickly, but the process of job interviews scares me.
Oh, and 3) Singing that exit-level contract that ended up with me working my ass off in the evenings to finalize some contracted components.
Job interviews are a nuisance, but easily trainable. :)
x=filter(a,lambda(({ 'o }),
({ (#'>),
({ (#'call_other),
({ (#'environment),'o }),
"query_level"
}),
WL_APPRENTICE
})));
[1]: https://en.wikipedia.org/wiki/LPC_(programming_language)Before the bracket-syntax for arrays, this would have been awful to maintain.
(It's also worth noting that theme() hasn't worked this way since 2011; it now takes a more PHP-style associative array of named options.)
In all seriousness, I worked with a bright guy who was a lot of fun to work with, but every once in a while his exuberance for this sort of thing would find itself in code that other people had to read/maintain. One particular example, he implemented a small subset of Lisp encoded into PHP arrays and it was used throughout some test code.
He effectively proved you could write PHP in a Lisp style and that PHP programmers overwhelmingly hate PHP flavored Lisp.