The Agile movement was all about dropping the process hoop jumping and focusing on solving problems efficiently, that's why it was considered extreme. Too extreme, as the one true implementation to rule them all is worse than what the agile movement was revolting against. This is how the game is played, over and over and over again; any movement that threatens the narrative is embraced, corrupted and ultimately used as a weapon against its core values.
It does? Never made much sense to me; especially considering that it already means something useful, equality; which then becomes == and sticks out like a sore thumb. I prefer 'let' for assignment and generic '=' for equality; Cixl[0] adds '==' for identity, can't remember where I stole that one.
Hidden deep inside almost any other language sits a tiny Forth; often chained to a wall out of sight from user code and restricted to evaluating expressions and shuffling function arguments/results, but still. That's about as fundamental as you can get without dropping down to assembly. Ever since I realized this, I've been itching to see what a Lisp that embraces its inner Forth could do. I wouldn't be surprised if the people who came before me saw some aspect of the same archetype.
Agreed, that's one of the more important advantages of Common Lisp in my book. But the reason it works so well is that the standardized version was based on plenty of experience and experimentation, and that it's powerful enough to be extended from user code; same goes for C to some extent.
This is one of the fundamental features of Cixl [0]. I wish more interpreters would support emitting their host language; having the option of compiling statically linked executables in combination with a REPL running the same code is a very nice place to be.
Don't bother; he's playing his part perfectly so far, which means that so did you. If we can keep this shit storm going for a month or so, Zuckerbot Inc. is going down; and I have a feeling your student will do his best to help with that.
Besides basic semantics, there's not that much stack juggling going on really. Cixl offers four stack operators, drop, dup, swap and clear; the idea is to use more convenient constructs like let bindings, closures and multi methods to keep the stack tidy.
How can you be so sure that's the case? It's generally very difficult to get a wider perspective from within the fish bowl, you need to step out to feel the difference. What I found, and the reason I ultimately dropped out; is that social networks make me think less of others, because it makes them look stupid and desperate; and I'm pretty sure that goes the other way as well. The corporate incentives to fuck around with our minds for profit in these networks are just too much to deal with; the entire game is rigged, there's no way to win.
Not my intention at all, I have been writing code for 32 years, including several years of web/JS and I have yet to come across anything worse. If you can't even deal with other people having different perspectives on your choice of technology without calling them trolls, maybe you should consider untangling your identity from your choices.
There are several leaner alternatives for application scripting, is it really worth dragging V8 around to get that capability? Lua would be one alternative. The reason I'm asking is that I'm working on a more Forth-inspired alternative[0] for application scripting myself, and I'm curious about the reasons for defaulting to the crappiest language ever invented and an implementation controlled by one of the biggest corporate bullies around.
Are you saying that closing files is now a cargo-cult thing to do? There are plenty of resources that are more important to clean up than memory. This has nothing to do with C.
Many functional languages don't support explicit returns, Lisp requires introducing another level of nesting to get support unless you're already in a supported form. I find that this pushes me to write better code since it forces me to solve the problem rather than just slapping another return on it and calling it a day. The problem is often that the code is trying to do more than it should.
I find that's a pretty solid heuristic; if they're misinformed enough to base their business on top of Microsoft's crap, it's most probably not going anywhere I want to go.
If we could just sit down and agree to standardize most of the GNU extensions; nested functions, cleanup attributes and computed gotos to name some; that would take us much further than any attempt at reinventing the whole thing. I don't know if they all start misinformed, or if they get caught up in their egos along the way; but none so far has managed to produce anything that even comes close to replacing C.
Compilers and interpreters never really clicked for me until I ran into Forth, that kind of simplicity was exactly the foundation I had been looking for all along.
That's just not correct. It's an inability to focus on things that are not deemed interesting at the moment, and an inability to pretend otherwise. Give someone with ADHD traits a tricky problem that they believe in solving and you'll have to tear them away from it and force them to eat and sleep until it's solved.
The language is better off without them. Few features mess up a language implementation to the same extent as full continuations. It's a CS pipe dream; just because everything may be modeled theoretically using continuations, that doesn't mean it's a practical approach in the real world. Map and terrain, they're not the same thing.