Hacker News new | past | comments | ask | show | jobs | submit login

What I want is for the editor to be aware of the semantics of the language and offer me language-unique tools to edit code, also to generate and work on macros, in the language it's editing, or at least one that is close enough to it I don't have to switch gears in order to get a tough task done.

Otherwise it really doesn't improve on a text editor. All of these things would require a ton of work, so I stick with Sublime for now. Text isn't that bad.

IDEs are kinda close, but I've yet to see one that could effectively work with dynamic languages. RubyMine is interesting-looking, but seems to want to impose a lot of its opinions on your workflow. I don't really see how RubyMine would really be that much better than Sublime and a terminal.

Have you looked at the likes of MPS from Jetbrains? https://www.jetbrains.com/mps/?fromMenu

It lets you build a language and an editor that forces you to follow the syntax and semantics of your language. Pro tip: Your language can be based on java :)

Author here. Your are right. Graphical editor is just a favor of myself and happened to make implementing this features easier. If you are skilled enough to parser code in text and build a tree underneath, it's definitely the same result that you got smart IDE that helps write code faster.

BTW, I don't know much about building IDEs, so I won't analyze code by myself and let the editor recognize the code. Could be very tough work.

Have you tried VSCODE, their open language server protocol means that most popular languages have code completion, refactoring, code lens and debugging support.

It's totally free and open source. I was a hard core JetBrains user but vscode has been amazing. They even got minimap like sublime in last release.

Every month they move at an amazing velocity working on features devs ask for. I feel it's the modern democratic IDE

No. But I have a friend who writes in C# and he showed me quite some tips on VS Code. I know it's very smart and IDE understands code in semantics, that can be a lot better than Stack Editor that only recognize the structure. I will keep an eye on that.

Language Server, which parent mentioned, is kinda independent from VSCode and provides the groundwork for most of the fancy language level stuff. You could look into integrating langserv into your editor to get the best of both worlds.

In terms of context sensitive info...well let's put it this way: If you don't see what utility RubyMine offers beyond Sublime, you haven't used it. It's not perfect (obviously), but it's generally quite good; I think I'm more often baffled by just how well some stuff works than I am disappointed in things working poorly (at least when it comes to context sensitive info).

That said, it's not the perfect text editor. I don't know that it really imposes any particular workflow (beyond obvious requirements like having access to the libraries you require), but there are certainly many things that you can do in Sublime that aren't going to work in RubyMine.

This is how editing was done in the InterLisp-D environment on Xerox Dolphins, Dorados and Dandelions (the last being sold commercially as the Xerox Star).

Not surprisingly the first thing I did when I arrived at PARC in 1984 was write an Emacs for Interlisp.

In my experience, Clojure + CIDER are pretty much exactly what you're describing. Especially once you get into the advanced evaluation features. I no longer think in terms of s-expressions or text, but I think in terms of the actual semantic objects I'm dealing with on screen. It's neat.

You're describing the Common Lisp, emacs and slime combo. But that's only for lisp, though.

> I've yet to see one that could effectively work with dynamic languages

That is a hard nut to crack, a dynamic language will frustrate static analysis.

Lisp languages cheat on that by pulling relevant metadata from the image after you loaded the code in. So if you just open a project as text, SLIME won't help you find e.g. a list of places that call a particular function - but after you load it into your Lisp image, cross-referencing features become available.

This is true under the hood of most static language IDEs as well. If they are not using a custom compiler (like JDT Core in Eclipse) they end up implementing a partial compiler to support features beyond ctags. ctags itself is the tokenizing and partial parsing step of a compiler.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact