我为什么要使用IDE？

In another question, Mark speaks highly of IDEs, saying "some people still just dont know "why" they should use one...". As someone who uses vim for programming, and works in an environment where most/all of my colleagues use either vim or emacs for all of their work, what are the advantages of IDEs? Why should I use one?

在另一个问题中,马克高度评价IDE,称“有些人仍然不知道”为什么“他们应该使用一个......”。作为使用vim进行编程的人,并且在大多数/所有同事使用vim或emacs进行所有工作的环境中工作,IDE的优势是什么?我为什么要用一个?

I'm sure this is a charged issue for some people, and I'm not interested in starting a flame war, so please only reply with the reasons you believe an IDE-based approach is superior. I'm not interested in hearing about why I shouldn't use an IDE; I already don't use one. I'm interested in hearing from "the other side of the fence", so to speak.

我确信这对某些人来说是一个充满争议的问题,我对开始一场火焰战并不感兴趣,所以请回答你认为基于IDE的方法更优越的原因。我没有兴趣听到为什么我不应该使用IDE;我已经不用了。我有兴趣听到“篱笆的另一面”,可以这么说。

If you think that IDEs may be suitable for some types of work but not others, I'm also interested to hear why.

如果你认为IDE可能适合某些类型的工作而不适合其他工作,我也很想知道为什么。

36 个解决方案

#1

It really depends on what language you're using, but in C# and Java I find IDEs beneficial for:

它实际上取决于您使用的语言,但在C#和Java中,我发现IDE有益于:

• Quickly navigating to a type without needing to worry about namespace, project etc

快速导航到类型而无需担心命名空间,项目等

• Navigating to members by treating them as hyperlinks

通过将成员视为超链接导航到成员

• Autocompletion when you can't remember the names of all members by heart

当你无法记住所有成员的名字时,自动完成

• Automatic code generation

自动代码生成

• Refactoring (massive one)

重构(大规模的)

• Organise imports (automatically adding appropriate imports in Java, using directives in C#)

组织导入(使用C#中的指令自动在Java中添加适当的导入)

• Warning-as-you-type (i.e. some errors don't even require a compile cycle)

警告你的类型(即一些错误甚至不需要编译周期)

• Hovering over something to see the docs

将鼠标悬停在某些东西上以查看文档

• Keeping a view of files, errors/warnings/console/unit tests etc and source code all on the screen at the same time in a useful way

以有用的方式同时在屏幕上保存文件,错误/警告/控制台/单元测试等和源代码的视图

• Ease of running unit tests from the same window

易于从同一窗口运行单元测试

• Integrated debugging
• Integrated source control

集成的源控制

• Navigating to where a compile-time error or run-time exception occurred directly from the error details.

导航到错误详细信息中直接发生编译时错误或运行时异常的位置。

• Etc!

All of these save time. They're things I could do manually, but with more pain: I'd rather be coding.

所有这些都节省了时间。他们是我可以手动完成的事情,但更痛苦:我宁愿做编码。

#2

Code completion. It helps a lot with exploring code.

代码完成。探索代码有很大帮助。

#3

The short answer as to why I use an IDE is laziness.

关于我使用IDE的原因的简短回答是懒惰。

I'm a lazy soul who doesn't like to do things a difficult way when there is an easy way to do it instead. IDE's make life easy and so appeal to us lazy folk.

我是一个懒惰的灵魂,如果有一种简单的方法,那就不喜欢以困难的方式做事。 IDE让生活变得轻松,因此吸引我们懒惰的人。

As I type code, the IDE automatically checks the validity of the code, I can highlight a method and hit F1 to get help, right click and select "go to to definition" to jump straight to where it is defined. I hit one button and the application, with debugger automatically attached is launched for me. And so the list goes on. All the things that a developer does on a day to day basis is gathered under one roof.

当我输入代码时,IDE会自动检查代码的有效性,我可以突出显示方法并按F1获取帮助,右键单击并选择“转到定义”直接跳转到定义的位置。我点击了一个按钮,启动了自动连接调试器的应用程序。所以这个名单还在继续。开发人员日常所做的所有事情都集中在一个屋檐下。

There is no need to use an IDE. It is just much harder work not to.

无需使用IDE。这不是更难的工作。

#4

I don't think it's fair to do the classic "text editor and console window vs IDE" when "text editor" is really emacs. Most features that are typical for IDE:s are also in emacs. Or perhaps they even originated there, and modern IDE:s are mainly interface improvements/simplifications.

当“文本编辑器”真的是emacs时,我认为做经典的“文本编辑器和控制台窗口与IDE”是不公平的。 IDE的典型功能大多数都在emacs中。或许它们甚至起源于那里,而现代IDE主要是界面改进/简化。

This means that for the original question, the answer is not so clear-cut. It depends on how people at the site in question use emacs, if they mainly use it as a text editor, or if they go all out and use custom scripting, learn the commands for the relevant modes, know about code tagging and so on.

这意味着对于原始问题,答案并不那么明确。这取决于有问题的网站上的人们如何使用emacs,如果他们主要使用它作为文本编辑器,或者他们全力以赴使用自定义脚本,学习相关模式的命令,了解代码标记等等。

#5

I come at this question from the opposite direction. I was brought up in programming with very few pitstops in Makefile+Emacs land. From my very earliest compiler on DOS, Microsoft Quick C, I had an IDE to automate things. I spent many years working in Visual C++ 6.0, and as I graduated into Enterprise Java, I worked with Borland JBuilder and then settled on Eclipse, which has become very productive for me.

我从相反的方向来看这个问题。在Makefile + Emacs的土地上,我很少参与编程,只有很少的进站。从我最早的DOS编译器,Microsoft Quick C,我有一个IDE来自动化。我在Visual C ++ 6.0上工作了很多年,随着我逐渐进入Enterprise Java,我与Borland JBuilder合作,然后选择了Eclipse,这对我来说非常有效。

Throughout my initial self-teaching, college, and now professional career, I have come to learn that any major software development done solely within the IDE becomes counterproductive. I say this because most IDE's wants you to work in their peculiar I-control-how-the-world-works style. You have to slice and dice your projects along their lines. You have manage your project builds using their odd dialog boxes. Most IDE's manage complex build dependencies between projects poorly, and dependencies can be difficult to get working 100%. I have been in situations where IDE's would not produce a working build of my code unless I did a Clean/Rebuild All. Finally, there's rarely a clean way to move your software out of development and into other environments like QA or Production from an IDE. It's usually a clicky fest to get all your deployment units built, or you've got some awkward tool that the IDE vendor gives you to bundle stuff up. But again, that tool usually demands that your project and build structure absolutely conforms to their rules - and sometimes that just won't work for your projects' requirements.

在我最初的自学,大学和现在的职业生涯中,我逐渐了解到,在IDE中完成的任何主要软件开发都会适得其反。我之所以这么说,是因为大多数IDE都希望你能够以他们特有的I-control-how-the-world-works风格工作。你必须按照他们的方式对项目进行切片和切块。您可以使用奇怪的对话框管理项目构建。大多数IDE管理复杂的项目之间的依赖关系很差,并且依赖关系很难100%工作。除非我做了Clean / Rebuild All,否则我一直处于IDE无法生成代码的工作版本的情况。最后,很少有一种干净的方法可以将您的软件从开发中移到IDE中的QA或Production等其他环境中。这通常是一个让您构建所有部署单元的狂欢,或者您有一些IDE供应商为您提供捆绑的笨拙工具。但同样,该工具通常要求您的项目和构建结构完全符合其规则 - 有时这对您的项目要求不起作用。

I have learned that, to do large-scale development with a team, we can be the most productive if we develop our code using an IDE and do all of our builds using manually written command line scripts. (We like Apache Ant for Java development.) We've found that running our scripts out of the IDE is just a click fest or an automation nightmare for complex builds, it's much easier (and less disruptive) to alt+tab out to a shell and run the scripts there.

我了解到,要与团队进行大规模开发,如果我们使用IDE开发代码并使用手动编写的命令行脚本完成所有构建,那么我们可以是最高效的。 (我们喜欢用于Java开发的Apache Ant。)我们发现从IDE运行我们的脚本只是复杂构建的点击费用或自动化噩梦,它更容易(并且破坏性更小)alt + tab out to a shell并在那里运行脚本。

Manual builds requires us to miss out on some of the niceties in the modern IDE like background compilation, but what we gain is much more critical: clean and easy builds that can live in multiple environments. The "one click build" all those agile guys talk about? We have it. Our build scripts can be directly invoked by continuous integration systems as well. Having builds managed through continuous integration allows us to more formally stage and migrate your code deployments to different environments, and lets us know almost immediately when someone checks in bad code that breaks the build or unit tests.

手动构建要求我们错过现代IDE中的一些细节,例如后台编译,但我们获得的更为关键:可以在多个环境中生活的简洁易用的构建。所有那些敏捷人员谈论的“一键构建”?我们有它。我们的构建脚本也可以由持续集成系统直接调用。通过持续集成管理构建允许我们更正式地将代码部署分阶段和迁移到不同的环境,并在有人检查破坏构建或单元测试的错误代码时立即通知我们。

In truth, my taking the role of build away from the IDE hasn't hurt us too badly. The intellisense and refactoring tools in Eclipse are still completely useful and valid - the background compilation simply serves to support those tools. And, Eclipse's peculiar slicing of projects has served as a very nice way to mentally break down our problem sets in a way everyone can understand (still a tad bit verbose for my tastes though). I think one of the most important things about Eclipse is the excellent SCM integrations, that's what makes team development so enjoyable. We use Subversion+Eclipse, and that has been very productive and very easy to train our people to become experts at.

事实上,我从IDE中扮演的角色并没有给我们带来太大的伤害。 Eclipse中的intellisense和重构工具仍然是完全有用和有效的 - 后台编译仅用于支持这些工具。而且,Eclipse独特的项目切片已经成为一种非常好的方式,以一种每个人都能理解的方式精神上分解我们的问题集(尽管我的口味仍然有点冗长)。我认为关于Eclipse最重要的事情之一就是出色的SCM集成,这就是让团队开发变得如此愉快的原因。我们使用Subversion + Eclipse,这非常高效,很容易培养我们的人员成为专家。

#6

Being the author of the response that you highlight in your question, and admittedly coming to this one a bit late, I'd have to say that among the many reasons that have been listed, the productivity of a professional developer is one of the most highly-regarded skills.

作为您在问题中突出显示的回复的作者,并且承认有点迟到,我不得不说,在列出的众多原因中,专业开发人员的工作效率是其中之一备受推崇的技能。

By productivity, I mean the ability to do your job efficiently with the best-possible results. IDEs enable this on many levels. I'm not an Emacs expert, but I doubt that it lacks any of the features of the major IDEs.

通过生产力,我的意思是能够以最佳结果有效地完成工作。 IDE在许多级别上启用此功能。我不是Emacs专家,但我怀疑它缺乏主要IDE的任何功能。

Design, documentation, tracking, developing, building, analyzing, deploying, and maintenance, key stepping stones in an enterprise application, can all be done within an IDE.

设计,文档,跟踪,开发,构建,分析,部署和维护是企业应用程序中的关键踏脚石,都可以在IDE中完成。

Why you wouldn't use something so powerful if you have the choice?

如果你有选择的话,为什么你不会使用如此强大的东西?

As an experiment, commit yourself to use an IDE for, say, 30 days, and see how you feel. I would love to read your thoughts on the experience.

作为一个实验,让自己使用IDE,比如30天,看看你的感受。我很乐意阅读你对这段经历的看法。

#7

Having an IDE has the following advantages:

拥有IDE具有以下优点:

• Compiling is usually "on the fly" which means no more switching to the command line to compile

编译通常是“即时”,这意味着不再需要切换到命令行进行编译

• Debugging is integrated, and having that in an IDE means that the step debugger actually uses your in-place editor to visually show you which code is executed

调试是集成的,在IDE中具有调试功能意味着步调试器实际使用您的就地编辑器直观地显示执行了哪些代码

• IDE's usually have more semantic knowledge of the language you're working in, and can show you possible problems while typing. Refactoring is much more powerfull than the "search replace".

IDE通常对您正在使用的语言有更多的语义知识,并且可以在键入时向您显示可能的问题。重构比“搜索替换”更强大。

There are much more, maybe you should give it a try.

还有更多,也许你应该尝试一下。

#8

IDEs are basically:

IDE基本上是:

• Editor w/code completion, refactoring and documentation

编辑带代码完成,重构和文档

• Debugger
• Filesystem explorer
• SCMS client
• Build tool

all in a single package.

所有在一个包中。

You can have all this (and some more) using separate tools or just a great programmable editor and extra tools, like Emacs (Vim as well but has a little less IDEbility IMO).

你可以使用单独的工具或者只是一个很棒的可编程编辑器和额外的工具来完成所有这些(以及更多),例如Emacs(Vim也是如此,但是它具有更少的IDEability IMO)。

If you find yourself switching a lot between one utility and the next that could be integrated in the environment or if you are missing some of the abilities listed here (and more completely in other posts), maybe it's time to move to an IDE (or to improve the IDEbility of your environment by adding macros or what not). If you have built yourself an 'IDE' (in the sense I mention above) using more than one program, then there's no need to move to an actual IDE.

如果您发现自己在一个实用程序和下一个可以集成到环境中的实用程序之间切换很多,或者如果您缺少此处列出的某些功能(并且在其他帖子中更完整),也许是时候转移到IDE(或者通过添加宏来增强环境的可靠性,或者不是。如果您使用多个程序构建了自己的“IDE”(在上面提到的意义上),那么就没有必要转移到实际的IDE。

#9

Eclipse:

Having code higlighting, compiling in the background, pointing out my errors as I go along.

代码高亮,在后台编译,指出我的错误。

Integration with javadoc, suggesting variable names with ctrl-Space.

与javadoc集成,使用ctrl-Space建议变量名称。

When I compile, I get errors right there. I can double click on an error, and it displays the appropriate line.

当我编译时,我在那里得到错误。我可以双击一个错误,它会显示相应的行。

Really well integrated with JUnit, ctrl-F11 runs the test, tells me the tests have failed. If there is an exception in the output window, I can double click on a line, and takes me to the line that failed. Not only that, but ctrl-F11 makes sure everything is compiled before it runs the tests (which means I never forget to do that).

与JUnit完全集成,ctrl-F11运行测试,告诉我测试失败了。如果输出窗口中有异常,我可以双击一行,然后转到失败的行。不仅如此,ctrl-F11确保在运行测试之前编译所有内容(这意味着我永远不会忘记这样做)。

Integration with ant. One command to build and deploy the application.

与蚂蚁整合。一个用于构建和部署应用程序的命令。

Integration with debuggers, including remote debugging of web servers.

与调试器集成,包括Web服务器的远程调试。

FANTASTIC refactoring tools, searching for references to a section of code. Helps me know the impact of a change.

FANTASTIC重构工具,搜索对一段代码的引用。帮助我了解变化的影响。

All in all, it makes me more productive.

总而言之,它让我更有成效。

#10

It definitely leads to an improvement in productivity for me. To the point where I even code Linux applications in Visual Studio on Vista and then use a Linux virtual machine to build them.

它肯定会导致我的生产力提高。我甚至在Vista上的Visual Studio中编写Linux应用程序,然后使用Linux虚拟机来构建它们。

You don't have to memorize all of the arguments to a function or method call, once you start typing it the IDE will show you what arguments are needed. You get wizards to set project properties, compiler options, etc. You can search for things throughout the entire project instead of just the current document or files in a folder. If you get a compiler error, double-click it and it takes you right to the offending line.

您不必记住函数或方法调用的所有参数,一旦开始键入它,IDE将向您显示所需的参数。您可以使用向导来设置项目属性,编译器选项等。您可以搜索整个项目中的内容,而不仅仅是当前文档或文件夹中的文件。如果出现编译器错误,请双击它,它会将您带到违规行。

Integration of tools like model editors, connecting to and browsing external databases, managing collections of code "snippets", GUI modeling tools, etc. All of these things could be had separately, but having them all within the same development environment saves a lot of time and keeps the development process flowing more efficiently.

集成模型编辑器等工具,连接和浏览外部数据库,管理代码集“片段”,GUI建模工具等。所有这些都可以单独进行,但是在同一个开发环境中将它们全部保存在一起可以节省大量的时间并使开发过程更有效地流动。

#11

I have used Emacs as my primary environment for both development and mail/news for about 10 year (1994-2004). I discovered the power of IDEs when I forced myself to learn Java in 2004, and to my surprise that I actually liked the IDE (IntelliJ IDEA).

我使用Emacs作为我开发和邮件/新闻的主要环境大约10年(1994-2004)。当我在2004年强迫自己学习Java时,我发现了IDE的强大功能,令我惊讶的是我真的很喜欢IDE(IntelliJ IDEA)。

I will not go into specific reasons since a lot of them have already been mentioned here -- just remember that the different people love different features. Me and a colleague used the same IDE, both of us used just a fraction of the features available, and we disliked each others way of using the IDE (but we both liked the IDE itself).

我不会讨论具体的原因,因为这里已经提到了很多 - 只记得不同的人喜欢不同的功能。我和一位同事使用相同的IDE,我们两个人只使用了一小部分功能,我们不喜欢彼此使用IDE的方式(但我们都喜欢IDE本身)。

But there is one advantage with IDEs over Emacs/Vim related environments I want to focus on: You spend less time installing/configuring the features you want.

但是,我想要关注的是与Emacs / Vim相关的环境相比,IDE有一个优势:您花费更少的时间来安装/配置所需的功能。

With Wing IDE (for Python) I'm ready to start developing 15-20 minutes after installation. No idea how many hours I would need to get the features I use up and running with Emacs/Vim. :)

使用Wing IDE(用于Python),我准备在安装后15-20分钟开始开发。不知道我需要多少小时才能获得我用完和运行Emacs / Vim的功能。 :)

#12

There might be different reasons for different people. For me these are the advantages.

不同的人可能有不同的原因。对我来说,这些都是优点。

1. Provides an integrated feel to the project. For instance i will have all the related projects files in single view.

为项目提供整合的感觉。例如,我将在单个视图中拥有所有相关的项目文件。

2. Provides increased code productivity like
   1. Syntax Highlighting
   2. Referring of assemblies

   参考集会

   3. Intellisense
   4. Centralized view of database and related UI files.

   数据库和相关UI文件的集中视图。

   5. Debugging features

提供更高的代码生产力,如语法高亮显示程序集的引用Intellisense数据库和相关UI文件的集中视图。调试功能

End of the day, it helps me to code faster than i can do in a notepad or wordpad. That is a pretty good reason for me to prefer an IDE.

在一天结束时,它可以帮助我编写比我在记事本或写字板中更快的代码。这是我更喜欢IDE的一个很好的理由。

#13

An IDE can be a 'superior' choice based depending upon what a developer is trying to accomplish.

根据开发人员试图完成的任务,IDE可以是一种“优越”选择。

A text editor can be 'superior' because IDEs are typically geared toward one (or a small selection) of languages.

文本编辑器可以是“优越的”,因为IDE通常面向一种(或少量选择)语言。

If a developer spends most of his/her time in a single languge or a 'cluster' of related languages (like C# and T-SQL), in one OS, then the GUI design, debug, intellisense, refactoring etc. tools offered by a good IDE can be very compelling. If, for instance, you spend most of your time working in VB.NET, with maybe a little T-SQL now and then, in a Windows environment, then you'd be pretty silly to not look at Visual Studio or a comparable IDE.

如果开发人员将大部分时间花在单个语言或相关语言的“集群”(如C#和T-SQL)上,则在一个操作系统中,然后提供GUI设计,调试,智能感知,重构等工具。一个好的IDE可以非常引人注目。例如,如果您花费大部分时间在VB.NET中工作,偶尔可能会使用一些T-SQL,那么在Windows环境中,如果不看Visual Studio或类似的IDE,那将是非常愚蠢的。

I have no prejudice towards those who prefer IDEs or text editors, both can be very productive and useful if learned well!

我对那些喜欢IDE或文本编辑器的人没有任何偏见,如果学得好的话,它们都可以非常高效和有用!

#14

I think it has mostly to do with scope of awareness for the developer. The IDE provides a macroscopic view of the developer's work context. You can simultaneously see class hierarchies, referenced resources, database schemas, SDK help references, etc. And with so many things affected by, and affecting, your keystrokes, and the expanding volume of architectures and architectural intersections, it gets more and more difficult to work solely from one island of code at a time.

我认为这主要与开发人员的意识范围有关。 IDE提供了开发人员工作环境的宏观视图。您可以同时查看类层次结构,引用的资源,数据库模式,SDK帮助引用等。由于许多事情受到影响,影响您的击键,以及不断扩大的体系结构和架构交叉点,因此它变得越来越困难。一次只从一个代码岛工作。

OTOH, "just me and vim and the man pages" gives me a much leaner microscopic - but intense and precise - view of my work. This is ok if I have a well-designed, well-partitioned, sparsely coupled highly cohesive codebase built in one language with one set of static libraries to work from - not your typical situation, especially as dev team sizes grow and reshape the code structure over time, distance, and personal preference.

OTOH,“只是我和vim和手册页”给了我一个更精简的微观 - 但强烈和精确 - 我的工作的观点。如果我有一个设计良好,分区很好,稀疏耦合的高度内聚的代码库,用一种语言构建,可以使用一组静态库,而不是典型的情况,特别是当开发团队规模增长并重塑代码结构时,这是可以的。随着时间的推移,距离和个人喜好。

I'm currently working on projects in Flex and .NET. One of the nicer things about Flex is how few different ways there are to accomplish a standard thing - pull data from a database, open/close/read/write a file, etc. (Yet I'm using the Flex Builder/Eclipse IDE - a typical heavy-weight example like VS, because I'm still learning the basics and I need the training wheels. I expect to evolve back to vim once I'm confident of my patterns.) In this view, I can do what I need to do professionally by knowing a few things really really well.

我目前正在从事Flex和.NET项目。关于Flex的一个更好的事情是,实现标准事物的方式很少 - 从数据库中提取数据,打开/关闭/读取/写入文件等等(但我使用的是Flex Builder / Eclipse IDE) - 像VS一样典型的重量级例子,因为我还在学习基础知识,我需要训练轮。一旦我对自己的模式充满信心,我希望能够回归到vim。)在这个视图中,我可以做什么我需要通过了解一些非常好的事情来做专业的工作。

OTOH, I can't imagine getting to that point with .NET because the view I'm expected to maintain keeps expanding and shifting. There much less conceptual integrity, and over several developers on a project over several months, much less consistency - but the IDE supports that, maybe encourages it. So the developer really needs to (and can more easily) know many more things adequately. Which also has the benefit of helping them answer (or even understand) a lot higher percentage of the questions on *. I.e. we can have a deeper knowledge stack. And we can respond to a wider variety of help-wanted ads.

OTOH,我无法想象用.NET来达到这一点,因为我期望保持的观点不断扩大和转移。概念完整性要少得多,而且几个月内项目上的几个开发人员的一致性要低得多 - 但IDE支持这一点,可能会鼓励它。因此,开发人员确实需要(并且可以更容易地)充分了解更多内容。这也有助于他们回答(甚至理解)*上更高百分比的问题。即我们可以拥有更深层次的知识库。我们可以回应各种各样的求助广告。

Things can go too far in both directions. Maybe with the "editor-only" scope, it's like "if you only have a hammer, everything looks like a nail". With the IDE approach, for whatever you want to fasten together, you have a broad selection of fasteners and associated ranges of tools to choose from - nals/hammers, screws/screwdrivers, bolts/wrenches, adhesives/glue-guns/clamps, magnets, and on and on - all at your fingertips (with a wizard to help you get started).

事情可能在两个方向都太过分了。也许只有“仅限编辑”的范围,就像“如果你只有一把锤子,一切看起来像钉子”。使用IDE方法,无论您想要固定在一起,您都可以选择各种紧固件和相关工具范围 - 零件/锤子,螺丝/螺丝刀,螺栓/扳手,粘合剂/胶枪/夹具,磁铁一直在你的指尖上(用一个向导来帮助你开始)。

#15

Don't think of it as exclusive. Use the IDE for the benefits it provides, and switch to vim/preferred text editor when you need some serious focus.

不要认为它是独家的。使用IDE提供它所带来的好处,并在需要认真关注时切换到vim /首选文本编辑器。

I find the IDE better for refactoring and browsing and debugging and for figuring out what to do. Small things are then done right in the IDE, large things I flip to vim to finish the job.

我发现IDE更适合重构,浏览和调试以及弄清楚要做什么。然后在IDE中完成小的事情,我翻转的大件事情来完成这项工作。

#16

I do not understand what you are asking. You ask "Should I use an IDE instead of...", but I don't understand what the alternative is - Vim and Emacs fulfil many functions any IDE will give you. The only aspect they do not handle that a larger IDE may are things like UI designers. Then your question boils down to simply "what IDE should I use" with arguments to be made for the simpler realm of Vim and Emacs.

我不明白你在问什么。你问“我应该使用IDE而不是......”,但是我不明白替代方案是什么 - Vim和Emacs实现了IDE会给你的许多功能。他们没有处理大型IDE的唯一方面可能是UI设计师。然后你的问题归结为简单的“我应该使用什么IDE”,并为Vim和Emacs的简单领域提供参数。

#17

In addition to the other answers, I love combining the developing power of an IDE with the editing power of Vim using something like the ViPlugin for Eclipse.

除了其他答案之外,我喜欢将IDE的开发能力与Vim的编辑能力结合使用,例如ViPlugin for Eclipse。

#18

IntelliSense, the integrated debugger, and the immediate window make me enormously more productive (Visual Studio 2008). With everything at my fingertips, I can keep the vast majority of an enormous project inside of my head while writing code. Microsoft may keep dropping the ball on their OSs, but Visual Studio is one of the finest products ever developed.

IntelliSense,集成调试器和即时窗口使我的工作效率大大提高(Visual Studio 2008)。随着一切都在我的指尖,我可以在编写代码时将绝大多数巨大的项目保留在我脑海中。微软可能会继续放弃他们的操作系统,但Visual Studio是有史以来最好的产品之一。

#19

For me, an IDE is better because it allows faster navigation in code which is important if you have something in your mind to implement. Supposed you do not use an IDE, it takes longer to get to the destination. Your thoughts may be interupted more often. It means more clicks/more keys have to be pressed. One has to concentrate more on the thought how to implement things. Of course, you can write down things too but then one must jump between the design and implementation. Also, a GUI designer makes a big difference. If you do that by hand, it may take longer.

对我来说,IDE更好,因为它允许更快的代码导航,如果你有想法实现的话,这很重要。假设您不使用IDE,则到达目的地需要更长的时间。你的想法可能会更频繁地被中断。这意味着必须按下更多点击/更多键。人们必须更多地关注如何实现事物的思想。当然,你也可以写下来,但必须在设计和实现之间跳槽。此外,GUI设计师也有很大的不同。如果你手工完成,可能需要更长时间。

#20

GUI-based IDEs like Visual Studio and Eclipse have several advantages over text-based IDEs like Emacs or vim because of their display capabilities:

基于GUI的IDE(如Visual Studio和Eclipse)与基于文本的IDE(如Emacs或vim)相比具有以下优势,因为它们具有以下显示功能:

• WYSIWYG preview and live editing for GUI design

用于GUI设计的WYSIWYG预览和实时编辑

• Efficient property editors (eg. color selection using a GUI palette, including positioning gradient stops etc)

高效的属性编辑器(例如,使用GUI调色板进行颜色选择,包括定位渐变停止等)

• Graphical depiction of code outlines, file interrelationships, etc

代码大纲,文件相互关系等的图形描述

• More efficient use of screen real-estate to show breakpoints, bookmarks, errors, etc

更有效地使用屏幕空间来显示断点,书签,错误等

• Better drag and drop support with OS and other applications

通过操作系统和其他应用程序更好地拖放支持

• Integrated editing of drawings, images, 3D models, etc

综合编辑图纸,图像,3D模型等

• Display and edit of database models

显示和编辑数据库模型

Basically with a GUI-based IDE you can get more useful information on screen at once and you can view/edit graphical portions of of your application as easily as text portions.

基本上使用基于GUI的IDE,您可以立即在屏幕上获得更多有用的信息,您可以像文本部分一样轻松地查看/编辑应用程序的图形部分。

One of the coolest things to experience as a developer is editing a method that computes some data and seeing the live output of your code displayed graphically in another window, just as your user will see it when you run the app. Now that's WYSIWYG editing!

其中一个最酷的事情作为一名开发人员体验正在编辑计算一些数据的方法,看到你的代码的输出住在另一个窗口中显示的图形,就如同你的用户将看到它时,你运行应用程序。现在是WYSIWYG编辑!

Text-based IDEs like Emacs and vim can add features like code completion and refactoring over time, so in the long run their main limitation is their text-based display model.

像Emacs和vim这样的基于文本的IDE可以随着时间的推移添加代码完成和重构等功能,因此从长远来看,它们的主要限制是基于文本的显示模型。

#21

I also almost exclusively use Vim (almost because I'm trying to learn emacs now) for all my development stuff. I think sheer intuitiveness (from the GUI of course) is the primary reason why people like to use IDEs. By being intuitive, little to no learning overhead of the tool is required. The lesser the learning overhead, the more they can get work done.

对于我所有的开发工作,我也几乎完全使用Vim(几乎因为我现在正在尝试学习emacs)。我认为纯粹的直观性(当然来自GUI)是人们喜欢使用IDE的主要原因。通过直观,几乎不需要工具的学习开销。学习开销越小,他们完成工作的次数就越多。

#22

Saves time to develop
Makes life easier by providing features like Integrated debugging, intellisense.

节省开发时间通过提供集成调试,智能感知等功能,使生活更轻松。

There are lot many, but will recommend to use one, they are more than obvious.

有很多,但会建议使用一个,它们是显而易见的。

#23

I'm not sure there's a clear dividing line between a text editor and an IDE. You have the likes of Notepad at one end of the scale, and the best modern IDEs at the other, but there are a lot of thing in between. Most text editors have syntax highlighting; editors aimed at programmers often have various other features such as easy code navigation and auto complete. Emacs even lets you integrate a debugger. The IDEs of even ten years ago had far less features to help programmers than you'd expect of a serious text editor these days.

我不确定文本编辑器和IDE之间有明确的分界线。你在规模的一端有类似记事本,而在另一端有最好的现代IDE,但中间有很多东西。大多数文本编辑器都有语法高亮显示;针对程序员的编辑器通常具有各种其他功能,例如简单的代码导航和自动完成。 Emacs甚至可以让您集成调试器。甚至十年前的IDE所拥有的功能远远少于帮助程序员的功能,而不是现在对于一个严肃的文本编辑器的期望。

#24

My main reason to use one is when the code goes beyond 100 files.

我使用的主要原因是当代码超过100个文件时。

Although ctags can do the work, some IDEs have a pretty good way to navigate the files easily an super fast.

虽然ctags可以完成这项工作,但是有些IDE可以非常快速地轻松导航文件。

It saves time when you have a lot of work to do.

当你有很多工作要做时,它可以节省时间。

#25

To me it's just the the GUI version of everything we did in the good old days of the terminal. I will always agree that IDE are not very superior because they hide a lot of stuff, especially concerning the linking stuff, but they have a notable advantage in some cases, for example with certain development platforms like Qt.

对我来说,它只是我们在终端过去的好时光所做的一切的GUI版本。我总是同意IDE并不是非常优越,因为它们隐藏了很多东西,特别是关于链接的东西,但它们在某些情况下具有显着的优势,例如对于像Qt这样的某些开发平台。

Some IDE like visual of others even seem to parse your code as you type it, and detect errors before you even compile: it seems logics that only an IDE can work closely with a compiler to immediately detect problem in the typed source.

某些类似IDE的视觉效果甚至似乎在您键入时解析您的代码,并在您编译之前检测错误:似乎逻辑只有IDE可以与编译器紧密合作以立即检测键入源中的问题。

My wild answer that the IDE/Command-line flame war exists is just because the C/C++ executable building is not very well handled from a standardized point of view, unlike with the D language; every platform handles compiling/linking/etc its own way, so to make it less messy they make an IDE.

我认为存在IDE /命令行火焰战的疯狂回答仅仅是因为从标准化的观点来看,C / C ++可执行构建的处理不是很好,与D语言不同;每个平台都以自己的方式处理编译/链接/等等,因此为了减少它们制作IDE的麻烦。

From your viewpoint it might be more simple to use the command-line, if there would have been only one compiler with standard options, it would have been easy, but the truth is C/C++ is flexible, so in the end, all platform do it their own way, hence the IDE to not waste explaining how to do it.

从您的角度来看,使用命令行可能会更简单,如果只有一个带有标准选项的编译器,那本来就很容易,但事实是C / C ++很灵活,所以最后,所有平台按照自己的方式去做,因此IDE不会浪费解释如何做到这一点。

If you can learn how an executable talks to the kernel or if you know anything about compiler design, maybe there is a way to work with a proper command-line, but I doubt you have.

如果您可以了解可执行文件如何与内核进行通信,或者您对编译器设计有所了解,可能有一种方法可以使用正确的命令行,但我怀疑您有。

Microsoft or Apple, all evil they would be, have to propose a straight-forward way to build application without entering in the details, and since building an application depends directly on the architecture of the OS, it will hardly be "standard" as the command-line is.

微软或苹果,他们将是邪恶的,必须提出一种直接的方式来构建应用程序而不需要输入细节,并且由于构建应用程序直接取决于操作系统的体系结构,因此它几乎不会像“标准”那样命令行是。

To put it simple, big and complex applications where you don't want to dig too deep into what it does -> IDE, little pieces of software or simple system software-design -> command-line. Except of course those nifty libraries that embed a Makefile, but that's another story.

简单,大而复杂的应用程序,你不想深入研究它的作用 - > IDE,小软件或简单的系统软件设计 - >命令行。当然除了那些嵌入Makefile的漂亮的库,但这是另一个故事。

Also I think IDE are used when the application delivered has something to do with, ironically, a GUI or something that has an interface or is directly bound to an OS, so again, it's also for people who will use a UI/GUI without knowing how it works, while people who will program systems won't need it all.

此外,我认为IDE是在交付的应用程序与某些事情有关时使用的,具有讽刺意味的是,GUI或具有接口或直接绑定到操作系统的东西,所以同样,它也适用于将使用UI / GUI而不知道的人它是如何工作的,而编程系统的人将不再需要它。

IDE is just modern shit, but I think in 100 years the command-line will still exist.

IDE只是现代的*,但我认为100年后命令行仍然存在。

#26

An IDE allows one to work faster and more easily... I noticed I spent a lot of time navigating in the code in a simple text editor...

IDE允许一个人更快,更轻松地工作...我注意到我花了很多时间在一个简单的文本编辑器中导航代码...

In a good IDE, that time goes down if the IDE supports jumping to functions, to previous editing position,to variables... Also, a good IDE reduces the time to experiment with different language features and projects, as the start-up time can be small.

在一个好的IDE中,如果IDE支持跳转到函数,到先前的编辑位置,转换到变量,那时间就会缩短......另外,一个好的IDE会缩短尝试不同语言功能和项目的时间,作为启动时间可以很小。

#27

I like an IDE because it puts a lot of functionality at my fingertips. Editing/Compilation/visibility of files in the project are all things I value in an IDE. I use Visual Studio now but in a former life I used SlickEdit and found that it made my development process more streamlined than when I wasn't using it.

我喜欢IDE,因为它在我的指尖提供了很多功能。编辑/编译/项目中文件的可见性是我在IDE中所重视的一切。我现在使用Visual Studio,但在以前的生活中我使用SlickEdit,发现它使我的开发过程比我不使用它时更加简化。

#28

There's only one thing to consider when deciding whether to use an IDE or not, and that's whether it makes you more productive or not.

在决定是否使用IDE时,只需要考虑一件事,那就是它是否会提高您的工作效率。

Short question so short answer :)

简短的问题这么短的答案:)

#29

It depends highly on what you're doing and what language you're doing it in. Personally, I tend to not use an IDE (or "my IDE consists of 3 xterms running vim, one running a database client, and one with a bash prompt or tailing logs", depending on how broadly you define "IDE") for most of my work, but, if I were to find myself developing a platform-native GUI, then I'd reach for a language-appropriate IDE in an instant - IMO, IDEs and graphical form editing are clearly made for each other.

这在很大程度上取决于你正在做什么以及你正在做什么语言。就个人而言,我倾向于不使用IDE(或者“我的IDE包含3个运行vim的xterms,一个运行数据库客户端,一个运行数据库客户端bash提示或拖尾日志“,取决于你为我的大部分工作定义”IDE“的广泛程度,但是,如果我发现自己正在开发一个平台本地GUI,那么我将找到一个适合语言的IDE即时 - IMO,IDE和图形表单编辑显然是相互制作的。

#30

An IDE handles grunt work that saves you time.

IDE处理繁重的工作,节省您的时间。

It keeps all associated project files together which makes it easy to collaborate.

它将所有相关的项目文件保存在一起,这使得协作变得容易。

You can usually integrate your source control into your IDE saving more grunt work and further enhancing collaboration.

您通常可以将源代码控制集成到IDE中,从而节省更多繁重的工作并进一步增强协作。

If it has auto complete features, it can help you explore your language of choice and also save some typing.

如果它具有自动完成功能,它可以帮助您探索您选择的语言,并节省一些打字。

Basically, an IDE reduces non-programming work for the programmer.

基本上,IDE减少了程序员的非编程工作。