skewer-mode

I've come close to setting up https://github.com/skeeto/skewer-mode several times. Things like this always demo better than they actually improve my productivity, though. Especially with modern frameworks that don't let you redefine everything. (Odd that common lisp is still head and shoulders above most languages with how much you can redefine at runtime.)

> Why are we stuck with blindly editing text files It's inherently more portable and composable. > waiting for compilation There are many languages that are interpreted that are mainstream. > that restarts the whole world You can program in mainstream languages without restarting the world. See skewer-mode[1] for example, for programming in javascript without restarting/refreshing. You can change top-level definitions and send them to override the previous definitions. You can do this with any language that allows overriding functions at runtime, IOW late-binding languages with an eval function, like python and ruby. This way of programming is probably very non-mainstream, though. The reason why it's not more popular is probably because most of us are working with programs that take little to no time to restart and get to the same state.

This is trivial in the right environments. Not shockingly, in emacs I get that. It actually takes a little getting used to at first, that up literally just moves the cursor up into the output of the previous command. Nowdays, it is severely restricting to have the same commands move the cursor that change the current command. (That is, left/right move cursor, up/down do a ton more in most terminals. That is not the case in emacs shells.) Really, though, the repl is a fun stepping stone to just sending function definitions from the file you are working on into an environment. https://github.com/skeeto/skewer-mode is a fun video showing the idea for javascript, amusingly. That said, there was a fun video a while back of the guy that did Minecraft live coding a video game. Basically, the game would be running, and he could make a chang

I wrote a somewhat similar tool for use with Emacs many years ago, SwankJS: https://github.com/swank-js/swank-js See this demo, for example: http://emacsrocks.com/e11.html It was not dependent on Chrome features and even did work with IE6 at some point. Too bad REPL-based programming is not very useful for modern JavaScript. There's a successor, though: https://github.com/skeeto/skewer-mode

Maybe you can use skewer-mode, probably not out of the box.. https://github.com/skeeto/skewer-mode/blob/master/README.md

I still use emacs in '-nw' mode because, I don't know, I'm old, but re: your criticism, skewer-mode[1] is available. Presuming your output is targeting some form of HTML, this enables you to retain the ability to at least present your information locally (on your own file system), to colleagues (authenticate via your existing SSO or whatever), or even to a public site (via a simple git-push to via a standard httpd on a container). I'm sure there are other modes out there, (hell, you could write something from scratch in a few minutes with inotify to cater to all your specific needs). I'd say it'd be more accurate to qualify your statement as such: "the value of org-mode documents decreases as a platform to manipulate (but not distribute) your data outside of emacs"[2]. [1] https://github.com/skeeto/skewer-mode [2] And even then, modern ce

Am I missing something with compile-to-javascript languages, or does this kind of heavyweight tooling and build system preclude most on-the-fly repl/console use for development? I'm far from a professional webdev, but have been attacking it recently with the goal of shortening my idea-to-implementation time for side/portfolio projects (I'm tangentially in ops at a tech company now, but want to move into programming). Coming from a lisp background, the immediacy of the JS console in the browser seemed like a huge win, and I can't really imagine javascript-heavy webdev without using https://github.com/skeeto/skewer-mode or something similar, or at the very least heavy use of the browser's javascript console. Don't you give up a lot of efficiency/speed when you compile to JS instead of using JS directly? Or do I misunderstand the trade-off a

Isn't this basically asking for skewer mode? https://github.com/skeeto/skewer-mode That is, you can already integrate quite well with some editors. I think IDEA has something similar, as well. Most of this is not in creating all new protocols and whatnot, but simply setting up reasonable defaults in tools you are already using.

I haven't used any of these, but curious if this compares to emacs': SwankJs https://github.com/swank-js/swank-js JsSlime https://github.com/segv/jss skewer-mode https://github.com/skeeto/skewer-mode

i think skewer-mode is close enough: https://github.com/skeeto/skewer-mode for live editing. I don't think that inlining feature really help much. Generally, if you want to access a css element in Emacs, you jump in, edit and jump back in an instant to see your result. See also web-mode: http://web-mode.org

How is it faster than Projectile? Demos in here: http://tuhdo.github.io/helm-projectile.html. With Projectile, I can jump to any file quickly, even with source tree as large as Linux kernel with more than 36k files. If a file is in a project, regardless of where I see it, even in a plain .txt file, I can jump to it: http://tuhdo.github.io/static/helm-projectile/helm-projectil... If you want that live web stuff, you can try skewer-mode: https://github.com/skeeto/skewer-mode