I've seen many people on SO leaving comments under language-specific VS Code questions vehemently saying that VS Code is not an IDE ("Integrated Development Environment") (often paired with a statement that if the asker wants to do development in <X> language, they should go use "real" IDE <Y>). But I've heard enough people call VS Code an IDE as well to be confused.
Who is right? Or is it not as clear cut who is right or wrong?
Oldest first — sorts top-level replies by their creation dates, with the oldest at the top.
Newest first — sorts top-level replies by their creation dates, with the newest at the top.
Latest activity — sorts top-level replies with recent threaded replies or edits at the top.
Highest score — sorts top-level replies by their total votes (highest first).
Your sorting method preferences will be saved.
The essence of things is not about words, IDE or something.
The idea of the IDE is valid, but VSCode architecture renders the classifications of things into IDE or editors invalid. First and foremost, this is a kind of a plugin architecture.
Roughly speaking, it is not an IDE, but it dynamically becomes IDE as you install and tune extensions.
There's a simple way to look at this. You're editor is either aware of your programming language or it's not. This line can be blurred if your editor accepts plug-ins that are aware of the programming language.
By aware I simply mean your editor either knows your text is code for your particular language or it doesn't. It either knows how to work with the text as code or it doesn't. Compiling, refactoring, analyzing, syntax highlighting, code completion, anything that requires that it knows the text as code. Without something like that it's just a text editor.
That said, there's nothing wrong with developing using editors that are simply text editors. It's still a development environment. And sure, you could argue that it is integrated in some way. But if the editor doesn't know about your programming language it isn't integrated the way people meant when they coined the term Integrated Development Environment.
In my point of view, an IDE (Integrated Development Environment) should be able to (besides editing the code):
compile the code with a click
debug the code step by step and set a breakpoint
The freshly installed vscode can only be used to edit the code, so it's not an IDE; with cpptools, it can compile the code, step-by-step debug, therefore it's an IDE.
VS Code comes with builtin extensions that include debugging for JS. See my main reply in this discussion.
I would go for ... no. Because of the "I" in IDE. Integrated. An IDE like Visual Studio or IntelliJ comes with the tools on board so you can start developing and deploying right away, that fulfils the I of the IDE. They are also tightly designed to support development of the narrow scope of programming languages they are built to serve.
Visual Studio Code is an editor at its core and you give it IDE-like capabilities by installing one or more extensions and you are at the mercy of the plugin developer exactly how deep the language support is going to be. It's essentially a click-it-together-yourself development environment trading in stability for flexibility.
There actually used to be an active push against calling things an IDE from the developers of such tools themselves, because IDEs were associated with heavy resource usage, sluggishness and slow startup while code editors were leaning heavily on lightweight design and speed.
VS Code is editor with extensions which try to mimic capabilities of IDE like Webstorm. IDE is built from ground up to have very deep understanding of the state of your code in all project and within file, but specifically the project. It's much easier to do quality refactoring of code with IDE vs code editor. The knowledge of your code is just different, IDE has broader and deeper knowledge of it which leads to better refactoring tools, debugging, find for usages of things and else. Though IDEs usually takes more resources, can't run in browser as simple js plugin and historically were usually more expensive.
VS code does not seemed to be having many features in build when compared with IDEs. But it does shows up good capabilities when we work with VS code enabled with extensions. Based on the question, VS code do support many language developments, but with the right extensions it will work very similar to language specific IDE. So without extensions VS code would not really be a IDE.
I think such arguments fall under the No True Scotsman fallacy.
VS Code is most likely a bit (underpowered, "under-integrated", etc.) out of the box for any given language, but it does have a pretty vast marketplace for tools that can provide the missing support/integrations.
Ultimately, though, whether you can call it an IDE or not is much less important than if VS Code is a useful tool for you as a programmer in some given situation.
whether you can call it an IDE or not is much less important than if VS Code is a useful tool for you as a programmer in some given situation.
Well, sure. But it's kind of the whole point of this discussion. You could make that kind of argument for a lot of things in a way that just feels strange. Ex. "Is Windows Terminal a terminal? Is PowerShell a shell? It doesn't matter! Call it whatever you want! As long as it's a useful tool to you!"
I think the heart of the matter to me, is that a "not an IDE" claim is just clickbait/buzzword messaging unless it also includes a mention of what feature/tool/integration is missing.
The label is only useful insomuch as it directs us to either improve our tooling, or recognize the deficiencies in our tooling so that we can find better tools.
Instead of "VS Code isn't a real IDE", I'd much rather see "VS Code doesn't support database integration without complicated plugin setups. It's a lot easier in PyCharm." Then we can have a real discussion about things that matter, rather than hiding behind buzzwords.
Edit: one more thought. "Integrated" in IDE depends a lot on what you need to integrate to. VS Code could be "fully-integrated" for everything some projects need, but be missing integration for things needed by a different project. Its very context dependent, so again, let's skip the buzzwords and get to the details that matter.
VSCode has a highly energetic and engaged development team; it entered the market at a time when a new generation of developers were interested in using smaller tools that work well, à la Linux, rather than the monolithic, full-featured (some might even say bloated) IDEs that had become de riguer among previous generations.
Specifically, Microsoft was looking to compete with the newest generation of text editors (which were self-consciously not word processors for reasons similar to the aforementioned revolt against IDEs). Flexible and extensible tools such as Atom and Sublime were quickly becoming popular among developers who were rediscovering the joys of the command-line, tmux and shells such as zsh and fish, all the while finding ways to make CLIs more usable, more useful, and even more beautiful, than ever.
In this context, then, MSCode might be considered not an IDE so much as it is a mainstreaming of a certain kind of anti-IDE.
On the other hand, many of its plugins are designed to add capabilities that traditional IDEs typically have, such as IntelliCode, which—I'm a fan— may have been the greatest single contribution to programming since vi.
In my understanding it's not quite a clear cut yes or no answer.
VSCode can be used as an full IDE but the idea of VSCode is to have a light weight program to code easy parts of your full functional program or easy programs. For example a simple web page there's nothing wrong to use VSCode. But once your site gets more advanced and you need to include many libraries and frameworks, you should consider to use a full functional IDE.
In order to use VSCode as an IDE you'll need to include many extensions and it will become really heavy, why not use visual studio for example that's made for this?
I see it as ADS vs SSMS, you can do many things if not everything using ADS, but once your SQL Server get's more complicated, I would advise you to switch to SSMS as it's made for this.
I don't think there is a single authoritative definition of what exactly an "IDE" is. Wikipedia itself says:
The boundary between an IDE and other parts of the broader software development environment is not well-defined
The things out there that brand themselves as "IDE"s are all unique in their feature sets, designs, and goals. But there is some consensus that generally, an "IDE" typically provides text editing, build automation, and debugging facilities.
VS Code obviously provides text editing. As for everything else, in general, VS Code is designed for extensibility. VS Code itself implements the common user interface models, logic, and views for those extension-oriented features, and provides an extension API for extensions to provide implementations of / integrations for "integrated development" facilities through. Extensibility is one of VS Code's core design goals- to the extent (🥁) that you may very commonly see feature-request issue tickets raised to the main VS Code GitHub repo where a maintainer (politely) declines the feature-request, suggesting instead for it to be implemented through an extension.
Extensions can provide:
See the following documentation pages if you want more details:
Extensions can contribute a lot more than that. They can contribute basic/extended source control management integration (there's a builtin Git support extension, and many other ones extending its functionality, such as Gitlens). They can contribute colour themes, keybinding sets, and with custom webviews, you can build your own custom UI sections. The list really goes on.
Some of those development-tooling-support extensions come built in and don't need to be manually installed- such as the builtin TypeScript language support extension.
A lot of other editors are also extensible like VS Code is- to varying degrees, and for varying components and with varying designs. But I think many people with a more traditional idea of what an "IDE" is will think of something that is targeting a specific development ecosystem / programming language, and so don't require you to install extra bits ("extensions", "plugins", "addons"- whatever they call them) for "basic development facilities". Ex. Visual Studio, or IDEs from the Jetbrains family (which have a different model, being individually distributed, but based on the same core), both of which are also extensible, in different ways.
I don't think VS Code's own maintainers really explicitly call it an "IDE". Actually, here, they write this:
Visual Studio Code is a streamlined code editor with support for development operations like debugging, task running, and version control. It aims to provide just the tools a developer needs for a quick code-build-debug cycle and leaves more complex workflows to fuller featured IDEs, such as Visual Studio IDE.
Due to the design for extensibility, in a weird way, I guess you could think of VS Code more like a shell built specifically for housing IDE components inside itself, with some that already live there by default. But I'm lazy and just call it an IDE, or "extensible IDE".
Here's a miscellaneous list of links to various peoples' definitions of what an "IDE" is (I swear many of these must be copying their basic definition from some common source...):
As for the people who say that new programmers should use a "real IDE" instead of VS Code, I can see where they're coming from. They really mean well, have their own ideas of what a valuable or useful way to learn programming tooling are, and just want to help a newbie. Though I don't agree with all the things they say, there is usually a significant aspect of objective truth to the things they say. I think all code editing technologies have their strengths and weaknesses. I just am more familiar with those of VS Code and have learned to work with it.
I mean, the maintainers also work for a company that has an interest in pushing companies toward paying for visual studio, it's not surprising they want to market vscode as not being a full IDE or somehow being lesser.
Technically is only a source-code editor due to the lack of native code compilation capabilities.
Though through the power of friendship plugins it has the same capabilities as an IDE.
