- full remote development suite with source synced onto remote server while IDE utilizes remote libraries and and remote compiler tool chain for code analysis.
>Can you please list the other 90% of must have capabilities for day to day development ?
- find definition
- find usages
- rename
- extract method
- detect code duplication
- highlight unused symbols(vars or functions)
- understand frameworks and libraries
- can suggest useful transformation or code simplification
- Intellij can understand type documentation like JSDoc and PHPDoc and use it in completion and highlight errors if using the wrong type or object member
- smart spellchecking, spellchecking that understand when it is in a comment or if it is a symbol name
- good VCS support(diff, commit, push)
- good debugging support
- IDEs have by default a lot of linting and code analyzing tools setup, trying to go from Intellij to VS Code defaults is a big downgrade , maybe it could be partially fixed by installing many plugins but I personally want to pay for a good program made by professionals and keep them profitable(and not have JetBrains fail or get bought by Google or Microsoft)
Emacs has these covered, especially when using LSP modes
> - extract method
I don't know what this is, sorry
> - detect code duplication
> - highlight unused symbols(vars or functions)
This is what linters and static analysis tools are for, and emacs integrates with them nicely via flycheck.
> - understand frameworks and libraries
not sure what this implies, sorry
> - can suggest useful transformation or code simplification
> - Intellij can understand type documentation like JSDoc and PHPDoc and use it in completion and highlight errors if using the wrong type or object member
More static analysis tooling, doesn't need to be built-in to the IDE, just hooked in with something like flycheck.
> - smart spellchecking, spellchecking that understand when it is in a comment or if it is a symbol name
emacs can kinda do this via flyspell but it's not perfect. You're right, this is a good idea.
> - good VCS support(diff, commit, push)
magit!
> - good debugging support
I'm mostly clueless here, sorry.
> - IDEs have by default a lot of linting and code analyzing tools setup, trying to go from Intellij to VS Code defaults is a big downgrade , maybe it could be partially fixed by installing many plugins but I personally want to pay for a good program made by professionals and keep them profitable(and not have JetBrains fail or get bought by Google or Microsoft)
aye, there's the rub. I suppose the "I" in IDE is the real value: the package deal with all the linters and analysis tools already hooked in. Various LSP modes have made it vastly easier to reach feature parity with this stuff in emacs with minimal effort, but I also definitely understand why things like Intellij are desirable and useful.
You mark/select/highlight some lines of code and then you hit a key, and this creates a method out of the code. The IDE is smart enough to see what is the "input" and what is the "output" of these lines of code, and will create a method with the right parameters and with the right return value. But usually, the IDE doesn't support all such code blocks, for example, if there is more than one "output".
So imagine you are using something like React/Angular or other templates you want your IDE to understand this templates and not highlight the syntax as errors, if you use a function/object defined in a js file in a template you want the IDE to make the connection. So when you want to see where a symbold defined in a .js file is sued you want to be found int the template file. You could have 2 different components that both have a thing called name - you want the IDE to not confuse this and consider this 2 different things as the same but be correct.
When I mean an IDE understand a library an example is jQuery, an IDE can have a plugin or just analyze the libraries you use (like analyze a .dll/.jar) and help you, my point is that the IDE is not limited to only the text files in your src folder, it can analyze your lib/vendors/node_moduloes folders too.
>More static analysis tooling, doesn't need to be built-in to the IDE, just hooked in with something like flycheck.
The IDE seems to work very fast as you type with incomplete code that would just fail if you run it through an external tool, not sure if this language servers stay up in background and keep state or each time you need to ask them to re-analyze everything and how fast and well works with incomplete code as you type.
About debugging support, for most stuff you just put breakpoints and press a Debug button, the code will stop and you get a nice overview like you get this days in browsers , including an eval repl in the current context where the program is paused. Super cool to understand soem complex library or framework you run it line by line and see how the framework inits, where it reads it's config , how it setups things , and all those steps that happen before your own code runs.
Extract method. maybe you work on some code that is not that clean, like some super long function and you can sport that this 12 lines of code can be made a function with some inputs and an output, you highlight the lines and use the Extract method, it will create a function from those lines and use it at the current place.
Or you have stuff like a missing parameter in the JSDoc the IDE offers to fix it , or you want to add JSDoc the IDE will create it for you, fill the types if it can detect them.
Most of this stuff are plugins , and you can turn things on and off, exclude folders, add your own rules etc - it is not a giant monolith that is not configurable.
> So imagine you are using something like React/Angular or other templates you want your IDE to understand this templates and not highlight the syntax as errors, if you use a function/object defined in a js file in a template you want the IDE to make the connection. So when you want to see where a symbold defined in a .js file is sued you want to be found int the template file. You could have 2 different components that both have a thing called name - you want the IDE to not confuse this and consider this 2 different things as the same but be correct.
Why imagine? I have emacs open and it's doing this with React right now (tide mode).
>Why imagine? I have emacs open and it's doing this with React right now (tide mode)
Cool, so Emacs understand that there are 2 different components and not get confused by react/angular sepecial syntax ? At this point is Emacs still a text editor as the initial comment that start this thread said or it become an IDE buy extending it with enough plugins? (see how this comment thread started)
No, it's completely single threaded. There's basically a GIL stopping it from ever being multithreaded without a serious rewrite/redesign. For long-running blocking tasks you have to use external processes (or the new dynamic module API to write an extension in C with pthreads).
* New variable 'main-thread' holds Emacs's main thread.
This is handy in Lisp programs that run on a non-main thread and want
to signal the main thread, e.g., when they encounter an error.
* 'thread-join' now returns the result of the finished thread.
* 'thread-signal' does not propagate errors to the main thread.
Instead, error messages are just printed in the main thread.
* 'thread-alive-p' is now obsolete, use 'thread-live-p' instead.
* New command 'list-threads' shows Lisp threads.
See the current list of live threads in a tabulated-list buffer which
automatically updates. In the buffer, you can use 's q' or 's e' to
signal a thread with quit or error respectively, or get a snapshot
backtrace with 'b'.
These are cooperative threads, not kernel threads which can actually run at the same time. It uses threads for its abstraction as a concurrent task. Ruby and Python also have "Thread" classes which don't make system calls and are just useful as a programming pattern. Maybe one day Emacs (and Python and Ruby) will have real threads, so the idea might be to switch the implementation over to real threads without requiring any client code to be rewritten since it follows the same API as real threads.
- Visual representation of data structures
- Navigating in binary libraries
- Architecture diagrams with two way editing
- Integration with ticket and source control systems, so that I can relate an issue with a branch and respective set of changed lines of code
- Live unit tests
- Live static analysis, as one types
- Incremental compilation, when hitting run almost everything is pre-compiled
- SQL database integration, ER diagrams, OR mappings generation
- Management of server instances and cloud services
- Memory profilers
- GC tuning tools
- Code metrics
- Graphical debuggers for GPGPU programming
- Graphical debuggers for threads, tasks and processes
- Handling of processes as single project for micro-services debugging
And a couple of other stuff, basically the kind of goodies one gets with Visual Studio Enterprise.