你最有争议的编程意见是什么？

时间：2009-01-02 13:14:27

标签： language-agnostic

这绝对是主观的，但我想尽量避免它变得有争议。我认为，如果人们适当地对待它，这可能是一个有趣的问题。

这个问题的想法来自my answer到"What are five things you hate about your favorite language?" question的评论主题。我争辩说C＃中的类应该默认密封 - 我不会把我的推理放在这个问题上，但我可以写一个更全面的解释作为这个问题的答案。我对评论中讨论的热度感到惊讶（目前有25条评论）。

那么，你持有什么有争议的意见？我宁愿避免那种以相对较少的基础（例如括号放置）而变得非常宗教的东西，但是例子可能包括诸如“单元测试实际上并不十分有用”或“公共领域真的很好”之类的东西。重要的是（对我来说，无论如何）是你有理由支持你的意见。

请提出您的意见和推理 - 我鼓励人们投票支持有争议和有趣的意见，无论您是否恰好同意这些意见。

407 个答案:

答案 0 :(得分：876)

那些在闲暇时间没有为了好玩而编码的程序员永远不会那么好。

我认为即使是最聪明，最有才华的人也永远不会成为真正优秀的程序员，除非他们把它当作一项工作。这意味着他们在一边做了很少的项目，或者在业余时间搞乱了很多不同的语言和想法。

（注意：我并不是说优秀的程序员除了编程之外什么也不做，但是他们做的不仅仅是编程从9到5）

答案 1 :(得分：770)

您应该一直使用的唯一“最佳做法”是“使用你的大脑”。

太多人跳过太多的乐队，试图将方法，模式，框架等强加给那些不能保证的东西。只是因为某些东西是新的，或者因为受尊重的人有意见，并不意味着它适合所有人：）

编辑： 只是为了澄清 - 我不认为人们应该忽视最佳实践，有价值的意见等等。只是人们不应该盲目地跳过某些东西而不考虑为什么这个“事物”是如此伟大，它是否适用于我所做的事情做什么，它带来了什么好处/缺点？

答案 2 :(得分：711)

代码中的大多数注释实际上都是代码重复的有害形式。

我们花费大部分时间来维护其他人（或我们自己）编写的代码，而且糟糕，不正确，过时，误导性的评论必须接近代码中最令人讨厌的工件列表的顶部。

我认为最终很多人都会把它们弄掉，特别是那些花箱怪物。

更好地专注于使代码可读，根据需要进行重构，并最大限度地减少习语和怪癖。

另一方面，许多课程教导评论几乎比代码本身更重要，导致下一行添加一个到invoiceTotal 评论风格。

答案 3 :(得分：711)

“谷歌搜索”没关系！

是的，我知道在那里冒犯了一些人，他们多年的紧张记忆和/或光荣的编程书籍开始落入任何人都可以在几秒钟内访问的资源，但你不应该持有反对使用它的人。

我经常听到谷歌搜索批评问题的答案，而且实在没有意义。首先，必须承认每个人都需要参考材料。你不知道所有事情，你需要重新审视。承认这一点，您获取信息的地方真的很重要吗？如果你在一本书中查找它，在谷歌上查找它，或者从一只说话的青蛙那里听到它你是否幻觉，这是否重要？不是。正确的答案是正确的答案。

重要的是，您了解材料，将其用作成功编程解决方案的终结手段，并且客户/您的雇主对结果感到满意。

（虽然如果你从幻觉说话的青蛙那里得到答案，你应该得到一些帮助）

答案 4 :(得分：694)

XML被高估了

我认为在使用他们的大脑之前，有太多人跳上了XML的潮流...... 用于Web的XML非常棒，因为它是专门为它设计的。否则，我认为一些问题定义和设计的想法应该优先于任何使用它的决定。

我的5美分

答案 5 :(得分：679)

并非所有程序员都是平等的

经理们常常认为DeveloperA == DeveloperB只是因为他们有相同的经验水平等等。实际上，一个开发人员的性能可能是另一个开发人员的10倍甚至100倍。

谈论它具有政治风险，但有时候我想指出，即使有几个团队成员出现技能相同，但情况并非总是如此。我甚至已经看到了主要开发人员“超出希望”并且初级开发人员完成了所有实际工作的情况 - 但我确保他们获得了信誉。 ：）

答案 6 :(得分：614)

我不明白为什么人们认为Java绝对是大学里最好的“第一”编程语言。

首先，我认为第一种编程语言应该强调学习控制流和变量的必要性，而不是对象和语法

另一方面，我认为那些没有调试C / C ++中的内存泄漏经验的人不能完全理解Java带来的内容。

自然进展也应该是从“我怎么做”到“如何才能找到那样做的图书馆”，而不是相反。

答案 7 :(得分：541)

如果你只懂一种语言，无论你怎么认识它，你都不是一个优秀的程序员。

似乎有一种态度说，一旦你真的擅长C＃或Java或其他任何你开始学习的语言，那就是你所需要的。我不相信 - 我所学过的每一种语言都教会了我一些关于编程的新知识，我能够将其与其他所有人一起带回到我的工作中。我认为任何限制自己使用一种语言的人都不会像现在这样好。

这也向我表明，某些缺乏审查能力和实验意愿并不一定符合我期望在一个非常优秀的程序员中找到的品质。

答案 8 :(得分：536)

效果确实重要。

答案 9 :(得分：488)

打印语句是调试代码的有效方法

我认为通过使用System.out.println（或任何适用于您的语言的print语句）乱丢代码来调试代码是完全可以的。通常，这可能比调试更快，您可以将打印输出与应用程序的其他运行进行比较。

只需确保在开始制作时删除print语句（或者更好，将它们转换为日志记录语句）

答案 10 :(得分：467)

你的工作就是让自己失业。

当您为您的雇主编写软件时，您创建的任何软件都应以任何开发人员可以接收并以最少的努力理解的方式编写。它设计良好，清晰一致地编写，格式清晰，记录在需要的位置，按预期每天构建，检入存储库，并进行适当的版本控制。

如果你受到公共汽车，下岗，解雇或离职的打击，你的雇主应该能够立刻取代你，下一个人可以介入你的角色，拿起你的代码和在一周内完成并运行。如果他或她不能那样做，那你就失败了。

有趣的是，我发现实现这一目标使我对雇主更有价值。我越努力成为一次性用品，我就越有价值。

答案 11 :(得分：466)

1）商业应用闹剧：

我认为整个“企业”框架的事情是烟雾缭绕。 J2EE，.NET，大多数Apache框架和管理此类事物的大多数抽象都会产生比它们解决的复杂性更高的复杂性。

采用任何常规的Java或.NET ORM，或任何所谓的现代MVC框架，这些框架可以“魔术”来解决繁琐，简单的任务。您最终编写了大量难以验证和快速编写的丑陋XML样板。您拥有大量的API，其中一半只是为了集成其他API的工作，无法回收的接口，以及仅为克服Java和C＃的不灵活性所需的抽象类。我们根本不需要大部分内容。

所有不同的应用程序服务器如何使用自己的darned描述符语法，过于复杂的数据库和组件产品呢？

关键不在于复杂性==糟糕，而是不必要的复杂性==糟糕。我曾经在大规模的企业安装中工作，其中一些是必要的，但即使在大多数情况下，也只需要一些本土脚本和一个简单的Web前端来解决大多数用例。

我尝试用简单的Web框架，开源数据库和简单的编程结构替换所有这些企业应用程序。

2）n年经验要求：

除非您需要顾问或技术人员来处理与应用程序，API或框架相关的特定问题，否则您实际上并不需要具有该应用程序5年经验的人员。您需要的是一位开发人员/管理员，他们可以阅读文档，拥有您正在做的任何领域的知识，以及谁可以快速学习。如果你需要用某种语言开发，一个体面的开发人员会在不到两个月的时间内完成它。如果您需要X Web服务器的管理员，他应该在两天内阅读手册页和新闻组并加快速度。少一点，那个人不值得他付钱。

3）常见的“计算机科学”学位课程：

大多数计算机科学和软件工程学位都是公牛。如果你的第一个编程语言是Java或C＃，那么你做错了。如果你没有完成代数和数学的几门课程，那就错了。如果你没有深入研究函数式编程，那就不完整了。如果你不能将循环不变量应用于一个简单的for循环，你就不值得你作为一个假定的计算机科学家。如果你有x和y语言以及面向对象的经验，那就充满了s ***。一个真正的计算机科学家根据它使用的概念和语法来看待一种语言，并将编程方法看作是众多语言中的一种，并且对于选择新语言，设计方法或规范语言两者的基本理念有很好的理解。是微不足道的。

答案 12 :(得分：440)

吸毒者和二传手严重过度使用

我见过数百万人声称公共领域是邪恶的，所以他们把它们变成私人的，并为所有人提供吸气剂和制定者。我认为这几乎与使字段公开相同，如果您使用线程（但通常不是这种情况）或者您的访问者具有业务/表示逻辑（至少是“奇怪的”），可能会有所不同。

我不赞成公共领域，而是反对为每个人制作一个getter / setter（或Property），然后声称这样做是封装或信息隐藏 ......哈！

<强>更新

这个答案在它的评论中引起了一些争议，所以我会试着澄清一点（我会保留原文，因为那是很多人投票的。）

首先：任何使用公共字段的人都应该获得监禁时间

现在，创建私有字段，然后使用IDE 自动为每个字段生成getter和setter 几乎与使用公共字段一样糟糕。

很多人都认为：

private fields + public accessors == encapsulation

我说（自动或不自动）为你的字段生成getter / setter对有效地违背了你想要实现的所谓封装。

最后，让我引用本主题中的Uncle Bob（摘自“清洁代码”第6章）：

  

我们有理由保留我们的   变量私有。我们不想要   其他人依赖他们。我们想要   改变他们的类型的自由   突发奇想或实施   冲动。那么，为什么这么做呢   程序员自动添加getter   暴露于他们的对象和设置者   他们的私人领域就像他们一样   公共吗

答案 13 :(得分：383)

UML图被高估了

当然有一些有用的图表，例如class diagram for the Composite Pattern，但许多UML图绝对没有价值。

答案 14 :(得分：381)

意见：SQL是代码。这样对待

也就是说，就像您的C＃，Java或其他喜欢的对象/过程语言一样，开发一种可读且可维护的格式化样式。

我讨厌看到草率的自由格式的SQL代码。如果你在页面上看到两种花括号样式时尖叫，当你看到隐藏或混淆JOIN条件的自由格式化的SQL或SQL时，为什么或为什么不尖叫呢？

答案 15 :(得分：354)

可读性是代码中最重要的方面。

甚至比正确性更重要。如果它是可读的，那么很容易修复。它易于优化，易于更改，易于理解。希望其他开发人员也能从中学到一些东西。

答案 16 :(得分：342)

如果您是开发人员，则应该能够编写代码

去年我做了很多面试，在接受采访时，我应该测试人们的思维方式，以及他们如何在白板上实现简单到中等的算法。我最初开始时遇到的问题是：

  

鉴于Pi可以使用函数4 *（1 - 1/3 + 1/5 - 1/7 + ...）进行估算，更多项可以提供更高的精度，编写一个函数来计算Pi的精度5位小数。

这是一个应该让你思考的问题，但不应该让经验丰富的开发人员无法接触（可以在大约10行C＃中回答）。然而，我们的许多人（据称是由该机构预先筛选过的）候选人甚至无法开始回答它，甚至解释他们如何回答它。所以过了一会儿，我开始问更简单的问题，如：

  

假设圆的面积是Pi乘以半径的平方，则写一个函数来计算圆的面积。

令人惊讶的是，超过一半的候选人无法用任何语言编写此功能（我可以阅读大多数流行语言，所以我让他们使用他们选择的任何语言，包括伪代码）。我们有“C＃开发人员”无法在C＃中编写此函数。

我对此感到惊讶。我一直认为开发人员应该能够编写代码。现在看来，这似乎是一个有争议的观点。当然这是面试候选人之一！

修改

在评论中有很多关于第一个问题是好还是坏的讨论，以及你是否应该在面试中提出这样复杂的问题。我不打算在这里深入研究（这是一个全新的问题），除了说你在很大程度上忽略了帖子。

是的，我说人们无法取得任何进展，但第二个问题是琐碎的，很多人也无法取得任何进展！自称为开发人员的任何人应该能够在几秒钟内将答案写入第二个，甚至不用思考。许多人不能。

答案 17 :(得分：331)

匈牙利记谱法的使用应该受到死刑的惩罚。

这应该是有争议的;）

答案 18 :(得分：288)

设计模式对设计的影响大于对设计的帮助。

IMO软件设计，特别是良好的软件设计太多样化，无法在模式中有意义地捕获，特别是在人们实际可以记住的少量模式中 - 而且它们太抽象了，人们不能真正记住多于一小部分。所以他们没有多大帮助。

另一方面，有太多人迷恋这个概念并试图在各处应用模式 - 通常，在生成的代码中，你无法找到所有（完全没有意义的）单身人士和抽象工厂之间的实际设计

答案 19 :(得分：274)

代码越少越好！

如果用户说“就是这样吗？”，并且您的工作仍然不可见，那就完成了。荣耀可以在其他地方找到。

答案 20 :(得分：267)

PHP很糟糕; - ）

证据在布丁中。

答案 21 :(得分：262)

单元测试无法帮助您编写好的代码

进行单元测试的唯一原因是确保已经运行的代码不会中断。首先编写测试，或者将代码编写到测试中是荒谬的。如果您在代码之前写入测试，您甚至不知道边缘情况是什么。您可以拥有通过测试的代码，但在不可预见的情况下仍会失败。

此外，优秀的开发人员会保持较低的凝聚力，这将使新代码的添加不太可能导致现有内容出现问题。

事实上，我会进一步概括，

软件工程中的大多数“最佳实践”都是为了防止糟糕的程序员造成太大的伤害。

他们在那里亲自抓住糟糕的开发者并防止他们犯下愚蠢的错误。当然，由于大多数开发人员都很糟糕，这是一件好事，但优秀的开发人员应该获得通过。

答案 22 :(得分：256)

编写小方法。程序员似乎喜欢在他们做多个不同的事情时编写loooong方法。

我认为应该在任何可以命名的方法中创建一个方法。

答案 23 :(得分：235)

可以暂时编写垃圾代码

有时，只需要快速而肮脏的垃圾代码即可完成特定任务。模式，ORM，SRP，无论如何......抛出一个控制台或Web应用程序，编写一些内联sql（感觉很好），并提出要求。

答案 24 :(得分：196)

代码==设计

我不喜欢复杂的UML图和无尽的代码文档。在高级语言中，您的代码应该是可读的并且可以理解。复杂的文档和图表实际上不再是用户友好的。

这是一篇关于Code as Design主题的文章。

答案 25 :(得分：186)

软件开发只是一项工作

别误会我的意思，我很喜欢软件开发。我在过去的几年里写了一篇关于这个主题的博客。我在这里花了足够的时间来获得> 5000的声望点。我在一家初创公司工作的时间通常为60小时，而且比我作为承包商的工资要少得​​多，因为团队很棒而且工作很有意思。

但在宏伟的计划中，这只是一份工作。

它在诸如家庭，我的女朋友，朋友，幸福等许多事物中排名很重要，而且如果我有无限量的现金，例如骑摩托车，帆船游艇，或者其他我想做的事情。滑雪。

我认为有时许多开发人员忘记了开发只是让我们能够拥有生活中更重要的东西（并通过做我们喜欢的事情来拥有它们），而不是成为最终目标。

答案 26 :(得分：184)

我还认为在源代码管理中使用二进制文件没有错误 ..如果有充分理由的话。如果我有一个程序集，我没有源，并且可能不一定在每个开发机器上的相同位置，那么我通常会将它粘贴在“二进制”目录中并使用相对路径在项目中引用它。

很多人似乎认为我应该被焚烧，甚至在同一句话中提到“源控制”和“二元”。我甚至知道那些有严格规定的地方，说你无法添加它们。

答案 27 :(得分：180)

每个开发人员都应该熟悉现代计算机的基本架构。这也适用于以虚拟机为目标的开发人员（可能更是如此，因为他们一次又一次地被告知他们不需要担心内存管理等问题。）

答案 28 :(得分：164)

软件架构师/设计师被高估

作为开发人员，我讨厌软件架构师的想法。他们基本上是不再编写全职代码的人，阅读杂志和文章，然后告诉你如何设计软件。只有那些实际上全职写软件的人才应该这样做。 5年前，在你成为建筑师之前，我不在乎你是否是世界上最好的程序员，你的意见对我来说毫无用处。

如何引起争议？

编辑（澄清）：我认为大多数软件架构师都会成为优秀的业务分析师（与客户交谈，编写需求，测试等），我只是认为他们没有设计软件，高级别或其他方面。

答案 29 :(得分：152)

没有“一刀切”的发展方法

我很惊讶这是一个有争议的意见，因为在我看来，这似乎是常识。然而，在热门博客上有许多条目宣传“一刀切”的发展方式，所以我想我可能实际上是少数。

我所看到的事情被吹捧为任何项目的 正确方法 - 在了解任何信息之前 - 就像使用测试驱动开发一样TDD），域驱动设计（DDD），对象关系映射（ORM），敏捷（资本A），面向对象（OO）等，包括从方法到架构到组件的所有内容。当然，所有这些都有很好的市场缩略词。

人们甚至似乎将徽章放在他们的博客上，例如“我是测试驱动”或类似的，好像他们严格遵守单一方法无论项目项目的细节实际上是什么好东西。

不是。

选择正确的方法，体系结构和组件等，应该在 per-project 的基础上完成，并且不仅取决于您正在处理的项目类型和它的独特要求，以及您正在与之合作的团队的规模和能力。

答案 30 :(得分：148)

大多数专业程序员都很讨厌

我遇到过太多人为了他们的生活而做这项工作，他们对自己所做的一切都很蹩脚。蹩脚的代码，糟糕的沟通技巧，对新技术毫无兴趣。太多，太多......

答案 31 :(得分：115)

计算机科学学位不是 - 而且不应该 - 教你成为一名程序员。

编程是一种交易，计算机科学是一门研究领域。你可以成为一名优秀的程序员，一名可怜的计算机科学家，一名伟大的计算机科学家和一名可怕的程序员。了解差异非常重要。

如果您想成为程序员，请学习Java。如果你想成为一名计算机科学家，至少要学习三种几乎完全不同的语言。例如（汇编程序，c，lisp，ruby，smalltalk）

答案 32 :(得分：101)

SESE（单次入境单一退出）不是法律

示例：

public int foo() {
   if( someCondition ) {
      return 0;
   }

   return -1;
}

VS 

public int foo() {
   int returnValue = -1;

   if( someCondition ) {
      returnValue = 0;
   }

   return returnValue;
}

我的团队和我发现，在许多情况下，始终遵守这一点实际上会适得其反。

答案 33 :(得分：101)

C ++是最糟糕的编程语言之一 - 永远。

它具有委员会设计的所有标志 - 它没有做任何给定的工作，并且做了一些工作（如OO）非常糟糕。它有一个“厨房水槽”的绝望，它不会消失。

学习编程是一种可怕的“第一语言”。没有优雅，没有帮助（来自语言）。相反，你有熊陷阱和矿场（内存管理，模板等）。

尝试学习OO概念并不是一门好的语言。它表现为“带有类包装器的C”而不是适当的OO语言。

我可以继续，但现在就把它留在那里。我从来没有喜欢用C ++编程，尽管我在FORTRAN上“切了我的牙齿”，但我完全喜欢用C语言编程。我仍然认为C是伟大的“经典”语言之一。在我看来，C ++肯定不是。

干杯，

-R

编辑：回应有关C ++教学的评论。您可以通过两种方式教授C ++ - 在类固醇上教授C“（从变量，条件，循环等开始），或者将其教授为纯粹的”OO“语言（从类，方法等开始）。您可以找到使用这些方法中的一种或另一种的教学文本。我更喜欢后一种方法（首先是OO），因为它强调了C ++作为OO语言的能力（这是C ++的原始设计重点）。如果你想教C ++“作为C”，那么我认为你应该教C，而不是C ++。

但是根据我的经验，C ++作为第一语言的问题在于，这个语言在一个学期内教学效果太差，而且大多数“简介”文本试图覆盖所有内容。根本不可能涵盖“第一语言”课程中的所有主题。你必须至少把它分成两个学期，然后它不再是“第一语言”，IMO。

我教C ++，但只是作为一种“新语言” - 也就是说，在注册课程之前，你必须精通一些先前的“纯”语言（不是脚本或宏）。 C ++是一种非常精细的“第二语言”，IMO。

-R

'Nother Edit :(对Konrad）

我完全不同意C ++“在各方面都优于C”。我花了数年时间编写C程序用于微控制器和其他嵌入式应用程序。这些器件的C编译器经过高度优化，通常可以生成与手动编码汇编器一样好的代码。当您转向C ++时，您将获得编译器强加的巨大开销，以便管理您可能不使用的语言功能。在嵌入式应用程序中，通过添加类等IMO可以获得很少的收益。你需要的是严密，干净的代码。你可以用C ++编写它，但是你真的只是编写C语言，而C编译器在这些应用程序中更加优化。

我首先在C中编写了一个MIDI引擎，稍后在C ++中（根据供应商的要求）编写了一个嵌入式控制器（声卡）。最后，为了满足性能要求（MIDI时序等），我们不得不为所有核心代码恢复为纯C。我们能够将C ++用于高级代码，并且使用类非常好 - 但是我们需要C来获得较低级别的性能。 C代码比C ++代码快一个数量级，但手动编码汇编程序只比编译的C代码略快。这可以追溯到20世纪90年代初期，只是为了恰当地安排事件。

-R

答案 34 :(得分：95)

您必须知道如何打字成为程序员。

在那些不知道如何打字的人之间存在争议，但他们坚持认为他们可以像任何打字员那样快速地双手狩猎，或者他们并不需要花那么多时间打字，或Intellisense减轻了输入...的需要。

我从未见过 知道如何打字的人，但坚持认为它没有什么区别。

另请参阅：Programming's Dirtiest Little Secret

答案 35 :(得分：89)

计算机科学或其他IT领域的学位使您成为更全面的程序员

我不在乎你有多少年的经验，你读了多少博客，你参与了多少个开源项目。一个资格（我建议超过3年）让你暴露一种不同的思维方式，给你一个很好的基础。

仅仅因为你写了一些比计算机科学学士学位更好的代码，并不意味着你比他好。你有什么他可以在瞬间获得，而不是相反的情况。

获得资格证明了您的承诺，事实上您将超越经验，使您成为更好的开发人员。擅长他们所做并且具有资格的开发人员可能会非常恐怖。

如果这个答案被否决，我不会感到惊讶。

此外，一旦你获得资格，你就会慢慢地将自己与那些有资格的人（我的经历）进行比较。你意识到，只要你能在一起工作，这一切都无关紧要。

无论资格如何，始终对其他开发者诚实行事。

答案 36 :(得分：89)

懒惰的程序员是最好的程序员

懒惰的程序员通常会找到减少编写代码所花费的时间的方法（特别是很多相似或重复的代码）。这通常转化为公司/团队中的其他开发人员可以从中受益的工具和工作流程。

当开发人员遇到类似项目时，他可能会创建工具来引导开发过程（例如，创建一个与公司数据库设计范例一起使用的DRM层）。

此外，像这样的开发人员经常使用某种形式的代码生成。这意味着所有相同类型的错误（例如，代码生成器未检查所有方法上的空参数）通常可以通过修复生成器来修复，而不是修复该错误的50多个实例。

一个懒惰的程序员可能需要花费几个小时才能将第一个产品推出门外，但是可以节省数月的时间。

答案 37 :(得分：87)

除非您能解释为什么需要，否则不要使用继承。

答案 38 :(得分：86)

世界需要更多GOTO

除了“我的教授告诉我GOTO很糟糕”以外，没有任何理由经常避免使用GOTO。它们有一个目的，可以在很多地方大大简化生产代码。

也就是说，在99％的代码编写中，它们并不是必需的。

答案 39 :(得分：80)

我以前曾在公开场合广播过这些意见，但这里有：

动态类型语言中编写良好的代码遵循静态类型约定

使用过Python，PHP，Perl和其他一些动态类型语言，我发现这些语言中编写良好的代码遵循静态类型约定，例如：

  • 重新使用具有不同类型的变量（例如，它的错误样式以获取列表变量并分配int，然后在同一方法中为变量分配bool），它被认为是错误的样式。动态类型语言中编写良好的代码不会混合类型。

  • 静态类型语言中的类型错误仍然是动态类型语言中的类型错误。

  • 函数通常设计为一次对单个数据类型进行操作，因此接受T类型参数的函数只能合理地用于T类型的对象或T的子类。

  • 以多种不同数据类型为操作符设计的函数以将参数约束到定义良好的接口的方式编写。一般而言，如果类型A和B的两个对象执行类似的功能，但不是彼此的子类，那么它们几乎肯定会实现相同的接口。

虽然动态类型语言肯定提供了多种方法来破解，但这些语言中大多数编写良好的惯用代码都非常关注类型，就像使用静态类型语言编写的代码一样严格。

动态类型不会减少程序员需要编写的代码量

当我指出如此多的静态类型约定跨越到动态类型世界时，我通常会添加“为什么要使用动态类型语言开始？”。 即时响应是能够编写更简洁，更具表现力的代码，因为动态类型允许程序员省略类型注释和明确定义的接口。但是，我认为最流行的静态类型语言，如C＃，Java和Delphi，在设计上很笨重，而不是因为它们的类型系统。

我喜欢使用带有真实类型系统的语言，如OCaml，它不仅是静态类型的，而且它的类型推断和结构类型允许程序员省略大多数类型的注释和接口定义。

ML系列语言的存在证明了我们可以享受静态类型的好处，并且可以用动态类型语言编写所有简洁的内容。实际上，我使用OCaml的REPL作为临时的，一次性脚本，其他人都使用Perl或Python作为脚本语言。

答案 40 :(得分：76)

花费一整天在Stackoverflow上回答问题的程序员可能没有做他们付出的工作。

答案 41 :(得分：72)

代码布局很重要

也许支撑位置的细节应该仍然是纯粹的宗教观点 - 但这并不意味着所有的布局风格都是平等的，或者根本没有客观因素！

问题在于布局的超级规则，即：“保持一致”，听起来如此，被许多人用作拐杖，从不试图看看他们的默认风格是否可以改进 - 而且，此外，甚至不重要。

几年前，我正在学习速读技术，我学到的关于眼睛如何在“注视”中获取信息的一些事情，可以最优化地扫描页面，以及下意识地拾取背景的角色，让我考虑如何将其应用于代码 - 并特别考虑编写代码。

它使我成为一种倾向于柱状的风格，标识符在逻辑上被分组并尽可能对齐（特别是我对每个方法参数都在自己的行上变得严格）。然而，不是长柱不变的结构，改变块中的结构实际上是有益的，这样你最终会得到一个矩形岛，眼睛可以在一个装置中进入 - 即使你没有有意识地阅读每一个角色。

最终结果是，一旦你习惯了它（通常需要1-3天），它会变得赏心悦目，更容易理解，并且对眼睛和大脑的负担更少，因为它已经布局了以一种更容易接纳的方式。

几乎无一例外，我要求尝试这种风格的每个人（包括我自己）最初都说，“我讨厌它！”但是一两天后说，“我喜欢它 - 我发现它很难回去用这种方式重写我所有的旧东西！“。

我一直希望能有时间做更多的对照实验来收集足够的证据来写论文，但一如既往地忙于其他事情。然而，对于那些对有争议的技术感兴趣的人来说，这似乎是一个很好的机会： - ）

[编辑]

我终于开始写博客（经过多年停留在“意义”阶段）：Part one，Part two，Part three。

答案 42 :(得分：71)

意见：显式变量声明是一件好事。

我永远不会理解让开发人员浪费昂贵的时间来追踪由变量名称拼写引起的运行时错误而不是简单地让编译器/解释器捕获它们的“智慧”。

没有人给我一个更好的解释，“因为我不必写'int i'，所以节省时间。”嗯......是的，当然，但是需要多少时间来追踪运行时错误？

答案 43 :(得分：68)

意见：“调试”和“发布”构建之间永远不会有不同的代码

主要原因是发布代码几乎从未经过测试。最好让相同的代码在测试中运行，就像在野外一样。

答案 44 :(得分：64)

意见：开发人员应该测试自己的代码

我看到太多的废话交给测试只是为了让它没有真正修复有问题的bug，招致沟通开销和培养不负责任的做法。

答案 45 :(得分：63)

尊重单一责任原则

乍一看你可能认为这不会引起争议，但根据我的经验，当我向另一位开发人员提及他们不应该在页面加载方法中做任何事情时，他们经常会推迟...所以对于孩子们请退出建立我们经常看到的“尽力而为”的方法。

答案 46 :(得分：63)

分页永远不是用户想要的

如果您开始讨论在哪里进行分页，在数据库中，在业务逻辑中，在客户端上等等，那么您就会问错误的问题。如果您的应用程序回馈的数据超出了用户的需求，请找出一种方法让用户根据实际标准缩小他们的需求，而不是任意大小的块。如果用户真的想要所有这些结果，那么会给他们所有结果。你帮助的人一次回馈20个？服务器？这比你的用户更重要吗？

[编辑：澄清，基于评论]

作为一个真实世界的例子，让我们来看看这个 Stack Overflow问题。假设我有一个有争议的编程观点。在我发布之前，我想看看是否已经有一个解决相同意见的答案，所以我可以对它进行投票。我唯一的选择就是点击每一页的答案。

我更喜欢以下选项之一：

  1. 请允许我搜索答案（根据实际标准缩小我需要的方法）。

  2. 请允许我查看所有答案，以便我可以使用浏览器的“查找”选项（给我所有结果）。

    3. 如果我只是想找到我之前读过的答案，但同样找不到，这同样适用。我不知道它什么时候发布或者它有多少票，所以排序选项没有帮助。即使我这样做，我仍然需要玩一个猜谜游戏才能找到合适的结果页面。答案是分页的，我可以直接点击十几页之一。

    。

    -
    BMB

答案 47 :(得分：60)

<强> Source Control: Anything But SourceSafe

另外：独家锁定是邪恶的。

我曾经在某个地方工作，他们认为独家锁定意味着你保证人们在你办理登机手续时不会覆盖别人的变化。问题是，为了完成任何工作，如果文件被锁定，开发人员会只需将其本地文件更改为可写，并在有机会时将源控件与其版本合并（或覆盖）。

答案 48 :(得分：60)

不编码的架构师是无用的。

这听起来有点刺耳，但这并非不合理。如果您是系统的“架构师”，但没有一定程度的实际参与所使用的技术，那么您如何获得开发团队的尊重？你如何影响方向？

建筑师需要做更多事情（与利益相关者会面，与其他团队协商，评估供应商，编写文档，进行演示等）但是，如果您从未看到建筑师签入的代码......请警惕！

答案 49 :(得分：60)

对象永远不会处于无效状态

不幸的是，如此多的ORM框架为所有实体类强制使用零arg构造函数，使用setter来填充成员变量。在这些情况下，很难知道必须调用哪些setter才能构造有效的对象。

MyClass c = new MyClass(); // Object in invalid state. Doesn't have an ID.
c.setId(12345); // Now object is valid.

在我看来，一个对象发现自己处于无效状态应该不可能，并且类的API应该在每次方法调用之后主动强制执行它的类不变量。

构造函数和mutator方法应该将对象从一个有效状态原子转换为另一个有效状态。这要好得多：

MyClass c = new MyClass(12345); // Object starts out valid. Stays valid.

作为某个图书馆的消费者，在尝试使用某个对象之前跟踪是否已经调用了所有正确的设置者是一种痛苦的痛苦，因为文档通常没有提供关于该类合同的线索。

答案 50 :(得分：58)

意见：单元测试不需要预先编写，有时根本不需要。

推理：开发人员很难测试自己的代码。我们的确是。这就是我们通常有测试团队或QA小组的原因。

我们编写的代码大部分时间是与其他代码交织在一起进行单独测试，因此我们最终会跳过图形化的箍来提供可测试性。并不是说这些模式很糟糕，但它们有时会增加不必要的复杂性，所有这些都是为了进行单元测试......

......无论如何往往都行不通。要编写全面的单元测试需要很多时间。通常比我们愿意付出更多的时间。而且测试越全面，如果它测试的东西的界面发生变化就会变得越脆，迫使重写不再编译的测试。

答案 51 :(得分：58)

默认情况下，所有变量/属性都应为readonly / final。

推理有点类似于Jon提出的类的sealed参数。程序中的一个实体应该只有一个工作，而只有一个工作。特别是，对于大多数变量和属性来说，改变价值绝对没有意义。基本上有两个例外。

  1. 循环变量。但是，我认为变量实际上并没有改变价值。相反，它在循环结束时超出范围，并在下一轮重新实例化。因此，不变性对循环变量很有效，每个试图手动改变循环变量值的人都应该直接下地狱。

  2. 蓄电池。例如，想象一下对数组中的值进行求和的情况，或者甚至是积累一些其他信息的列表/字符串。

    今天，有更好的方法来实现同一目标。函数式语言具有高阶函数，Python具有列表理解能力，.NET具有LINQ。在所有这些情况下，不需要可变累加器/结果持有者。

    考虑字符串连接的特殊情况。在许多环境（.NET，Java）中，字符串实际上是不可变的。为什么然后允许赋值给一个字符串变量呢？更好地使用构建器类（即StringBuilder）。

    3. 我意识到今天的大多数语言都不是为了默许我的愿望。在我看来，由于这个原因，所有这些语言都存在根本缺陷。如果将它们更改为默认情况下将所有变量视为只读，并且在初始化后不允许对它们进行任何赋值，它们将不会失去它们的表现力，功能和易用性。

答案 52 :(得分：52)

实现有时足够好就足够了，作为程序员，你的价值会大幅提升。

请注意，当我说“足够好”时，我的意思是“足够好”，而不是一些恰好有效的废话。但话说回来，当你处于紧张状态时，“一些恰好有效的废话”可能会被认为是“足够好”。

答案 53 :(得分：48)

如果我有争议，我必须建议Jon Skeet不是无所不能的..

答案 54 :(得分：46)

好的，我说我会详细介绍一下我的“密封课”意见。我想有一种方法可以表明我感兴趣的答案就是给自己一个答案：）

意见：默认情况下，C＃

中应隐藏类

<强>推理：

毫无疑问，继承是强大的。但是，它必须在某种程度上受到指导。如果有人以完全出乎意料的方式从基类派生，这可能会打破基本实现中的假设。考虑基类中的两个方法，其中一个方法调用另一个方法 - 如果这些方法都是虚方法，那么必须记录该实现细节，否则有人可以合理地覆盖第二个方法并期望调用第一个方法。当然，一旦记录了实施，就无法改变......所以你就失去了灵活性。

通过默认密封方法，C＃向正确的方向迈出了一步（相对于Java）。但是，我相信进一步的步骤 - 默认密封类 - 会更好。特别是，很容易覆盖方法（或者没有明确地密封您不会覆盖的现有虚拟方法），这样您最终会出现意外行为。这实际上并不会阻止您做任何您当前可以做的事情 - 它只是更改默认，而不是更改可用选项。这将是一个“更安全”的默认设置，就像C＃中的默认访问始终是“此时可用的最私密的可见性。”

通过让人们明确表明他们希望人们能够从他们的课程中获得，我们会鼓励他们多考虑一下。它也可以帮助我解决我的懒惰问题 - 虽然我知道我应该密封几乎所有课程，但我很少记得这样做：（

<强>反的参数：

我可以看到一个论点，说明没有虚拟方法的类可以相对安全地派生而不需要额外的不灵活性和文档。我不知道如何反击这一个，除了说我相信意外开启的课程的伤害大于意外密封课程的伤害。

答案 55 :(得分：46)

“Java糟透了” - 是的，我知道所有人都不会持有这种观点：）

我有这种看法，因为我见过的大多数Java应用程序都是内存耗尽，运行缓慢，用户界面太糟糕等等。

G-曼

答案 56 :(得分：43)

糟糕的程序员是语言不可知的

一个非常糟糕的程序员几乎可以用任何语言编写错误的代码。

答案 57 :(得分：42)

聪明的程序员是危险的

我花了更多时间来修复“聪明”程序员编写的代码。我宁愿有一个优秀的程序员而不是一个非常聪明的程序员，他想通过编写只有他（或她）可以解释的代码来证明他是多么聪明。

答案 58 :(得分：40)

如果您有任何想法如何编程，则不适合在表单上放置按钮

这有争议了吗？ ;）

无论我们如何努力，几乎不可能对53岁的Doris有必要使用我们的订单输入软件。我们根本无法掌握她想象的在计算机内部的心理模型，因为我们不需要想象：我们知道正在发生什么，或者有一个非常好的主意。

Interaction Design应由非程序员完成。当然，这实际上永远不会发生。相反，我很高兴;我喜欢UI设计，即使内心深处，我知道我不适合它。

有关详细信息，请阅读书籍The Inmates Are Running the Asylum。请注意，我发现这本书令人不安和侮辱;如果您是一位关心用户体验的开发人员，这将是一个难以理解的内容。

答案 59 :(得分：40)

避免缩进。

使用提前退货，继续或休息。

而不是：

if (passed != NULL)
{
   for(x in list)
   {
      if (peter)
      {
          print "peter";
          more code.
          ..
          ..
      }
      else
      {
          print "no peter?!"
      }
   }
}

做的：

if (pPassed==NULL)
    return false;

for(x in list)
{
   if (!peter)
   {
       print "no peter?!"
       continue;
   }

   print "peter";
   more code.
   ..
   ..
}

答案 60 :(得分：38)

在1970年1月1日之前，真假是另一种方式......

答案 61 :(得分：38)

我可能会因此而被烤，但是：

在python中使隐形字符在语法上显着是一个坏主意

这会分散注意力，给初学者带来许多微妙的错误，在我看来，并不是真的需要。关于我见过的唯一没有自愿遵循某种体面格式指南的代码来自一年级的CS学生。即使代码不遵循“好”标准，也有很多工具可以将其强制转换为更令人愉悦的形状。

答案 62 :(得分：37)

您无需编制所有内容

我对所有事情感到厌倦，但随后一切都需要塞进一个程序中，就像那样总是更快。一切都需要基于网络，需要通过计算机完成。请用你的笔和纸。它更快，维护更少。

答案 63 :(得分：37)

应从OO语言中删除空引用

来自Java和C＃背景，其中从一个方法返回null以指示失败，我得出结论，null会导致许多可避免的问题。语言设计者可以删除与NullRefernceExceptions相关的整类错误，如果它们只是从代码中消除了空引用。

此外，当我调用一个方法时，我无法知道该方法是否可以返回空引用，除非我真正深入了解实现。我希望看到更多的语言遵循F＃的模型来处理空值：F＃不允许程序员返回空引用（至少对于用F＃编译的类），而是要求程序员使用option类型来表示空对象。关于这种设计的好处是，有用的信息（例如函数是否可以返回空引用）是如何通过类型系统传播的：返回类型'a的函数与返回{{1}的函数具有不同的返回类型。 }}

答案 64 :(得分：35)

单身人士不邪恶

在现实世界中有一个单身人士的地方，绕过它们的方法（即单一模式）只是伪装的单身人士。例如，Logger是单身人士的完美候选人。另外，消息泵也是如此。我当前的应用程序使用分布式计算，不同的对象需要能够发送适当的消息。应该只有一个消息泵，每个人都应该能够访问它。另一种方法是将一个对象传递到我可能需要的任何地方的消息泵，并希望新的开发人员不会在没有思考的情况下新建一个，并想知道为什么他的消息无处可去。单身人士的独特性是最重要的部分，而不是其可用性。单身人士在世界上占有一席之地。

答案 65 :(得分：35)

如果您不知道，那很好。但如果你甚至不能谷歌，你就会被解雇。

互联网是一种工具。如果你从中学习，那不会让你感到愚蠢。

答案 66 :(得分：34)

一张图片不价值千言万语。

有些照片可能胜过千言万语。他们中的大多数不是。对于许多懒惰的经理来说，这种陈旧的格言大多是不真实的，这是一个可怜的借口，他不想仔细阅读创建的报告和文档来说“我需要你在图表中向我展示。”

我的妻子攻读语言学专业，并在图片和徽标上看到了几个有关传统智慧的有趣证明：他们没有突破语言和文化障碍，他们通常不会在正确文本附近的任何地方进行交流，他们只是无法替代真正的沟通。

特别是，如果线条未标记且无法解释，和/或每条线条具有不同的含义而不是表示相同的关系（除非以某种方式彼此区分），否则与线条相连的带标签的气泡是无用的。如果你的线条有时表示关系，有时表示行动，有时表示时间的流逝，那么你真的是在冲洗。

每个优秀的程序员都知道你使用适合手头工作的工具，对吧？并非所有系统都在图片中得到最佳指定和记录。图形规范语言可以自动转换为可证明正确的可执行代码或任何壮观的想法，如果存在的话。在适当的时候使用它们，而不是在阳光下使用。实体 - 关系图非常棒。但并非所有事情都能在图片中总结出来。

注意：表可能与黄金相当。但表格与图片不同。而且，精心设计的短篇散文段落可能更适合手头的工作。

答案 67 :(得分：33)

你需要注意对象痴迷程序员。

e.g。如果你编写一个模拟内置类型（如整数或浮点数）的类，你可能是一个痴迷于对象的程序员。

答案 68 :(得分：33)

那里有很多糟糕的教学。

我们的开发人员喜欢在乔尔说大脑中有一部分用于理解某些人刚出生的指针时感到自鸣得意。我们很多人在这里讨论并且热衷于的主题是深奥的，但有时这只是因为我们这样做。

答案 69 :(得分：33)

不要编写代码，删除代码！

一位聪明的老师曾经告诉我：“不要编写代码，编写代码很糟糕，删除代码很好。如果你必须编写代码 - 编写小代码......”

答案 70 :(得分：32)

在开发代码时要牢记优化是个好主意。

每当我这样说时，人们总会回答：“过早优化是一切罪恶的根源。”

但是在调试之前我不是说优化。我甚至都没有说优化，但是当你设计代码时，请记住这可能成为瓶颈的可能性，并写下它以便可以重新调整它以提高速度，而不会撕裂API。

雨果

答案 71 :(得分：31)

如果开发人员无法撰写清晰，简明且语法正确的评论，那么他们应该返回并使用英语101。

我们有开发人员和（恐怖）建筑师，他们不能连贯地写作。当他们的文件被审查时，他们会说“哦，不要担心语法错误或拼写 - 这并不重要”。然后他们想知道为什么他们的错综复杂的垃圾文件变成了错综复杂的错误代码。

我告诉实习生我指导如果你不能口头或书面地传达你的好主意，你也可以不拥有它们。

答案 72 :(得分：31)

C ++是一门优秀的语言

我几乎一两个星期在另一个问题中被私刑，因为他说C ++不是一个非常好的语言。所以现在我会尝试反过来说。 ;）

不，说真的，我试图提出的观点，现在又要再试一次，是C ++有很多缺陷。很难否认这一点。这是非常复杂的，学习它实际上是你可以献出一生的东西。它使许多常见的任务变得非常困难，允许用户首先陷入未定义行为的海洋和不可移植的代码，而编译器没有给出警告。

但这并不是许多人试图做到的无用，破旧，过时，讨厌的语言。它不应该被扫地并被忽视。没有它，世界将不会是一个更好的地方。它有一些独特的优势，遗憾的是，这些优势隐藏在古怪的语法，遗留问题，尤其是糟糕的C ++教师背后。但他们在那里。

C ++有许多功能，我在使用C＃或其他“现代”语言编程时非常想念这些功能。 C＃和其他现代语言可以从中学到很多东西。

它不是盲目专注于OOP，而是探索并开创了泛型编程。它允许令人惊讶的表达式编译时元编程，从而生成极其高效，强大的和清洁代码。在C＃获得LINQ或lambda表达式之前差不多十年，它接受了函数式编程的教训。

它允许您通过静态断言和其他元编程技巧在编译时捕获惊人数量的错误，这样可以大大简化调试，甚至可以在某些方面击败单元测试。 （我更喜欢在编译时捕获错误而不是之后，当我运行我的测试时）。

变量的确定性破坏允许RAII，这是一个非常强大的小技巧，它使得try / finally块和C＃的using块变得多余。

虽然有些人指责它是“委员会设计”，但我会说是的，确实如此，在这种情况下，这实际上并不是坏事。看看Java的类库。有多少课程已被弃用？不应该使用多少？彼此的功能有多少重复？有多少设计糟糕？

C ++的标准库要小得多，但总的来说，它设计得非常好，除了一两个小疣（例如vector<bool>）之外，它的设计仍然很好。当某个功能被添加到C ++或其标准库时，它会受到严格的审查。 Java不能从中受益吗？ .NET也是如此，虽然它更年轻，并且设计起来稍微好一点，但仍然积累了一些与现实不同步的好的类，或者设计起来很糟糕。

C ++有很多其他语言无法比拟的优势。这是一个很好的语言

答案 73 :(得分：31)

源文件 SO 20世纪。

在函数/方法的主体内，将过程逻辑表示为线性文本是有意义的。即使逻辑不是严格线性的，我们也有很好的编程结构（循环，if语句等），它们允许我们使用线性文本干净地表示非线性操作。

但是我没有理由要求我在不同的文件中划分我的类，或者在这些文件中按特定顺序对我的函数/方法/字段/属性/等进行排序。为什么我们不能将所有这些东西都放在一个大的数据库文件中，让IDE负责动态地对所有内容进行排序？如果我想按名称对我的成员进行排序，那么我将单击成员表上的成员标题。如果我想通过辅助功能对它们进行排序，那么我将单击辅助功能标题。如果我想将我的类视为继承树，那么我将单击按钮来执行此操作。

也许可以在空间上查看类和成员，就好像它们是虚拟世界中的某种实体一样。如果程序员需要，IDE可以自动定位类和互相使用附近的成员，以便他们很容易找到。成像能够放大和缩小这个虚拟世界。完全放大，你可以用星球中的小类行星命名星系。放大命名空间，您可以看到具有方法大陆和岛屿的类行星以及作为轨道卫星的内部类。放大方法，您会看到......该方法的源代码。

基本上，我的观点是，在现代语言中，您放入课程的文件或您定义课程成员的顺序并不重要，那么为什么我们仍然被迫使用这些古老的实践呢？还记得Gmail何时问世，谷歌说“搜索，不排序”？那么，为什么不能将相同的哲学应用于编程语言呢？

答案 74 :(得分：30)

我一直在折腾一下：

数据是系统。

流程和软件是为数据而构建的，而不是相反的。

没有数据，流程/软件几乎没有价值。数据仍然具有价值，没有围绕它的过程或软件。

一旦我们理解了数据，它的作用，它如何交互，它在不同阶段存在的不同形式，只有这样才能构建一个解决方案来支持数据系统。

成功的软件/系统/流程似乎具有敏锐的意识，即使不是在任何特定时刻“数据所在”的狂热正念。

答案 75 :(得分：30)

设计模式是石器时代编程语言设计的症状

他们有自己的目的。很多好的软件都是用它们构建的。但事实上，需要将这些“食谱”编纂成关于代码如何工作/应该如何工作的心理抽象，这说明缺乏足够表达的编程语言来处理这种抽象。

我认为，补救措施在于允许您将越来越多的设计嵌入到代码中的语言，通过定义可能不存在或可能不具有普遍适用性但真正真正在你的代码不断处理的情况下有意义。计划人们多年来已经知道这一点，并且有可能使用Scheme宏来使大多数猴子雇用他们的裤子。

答案 76 :(得分：28)

通过对狂热者的热情和错误的假设认为他们是铁定的规则，将伟大的人物脱离背景来反思众所周知的说法真的得到了我的山羊。例如，this thread所涵盖的“过早优化是所有邪恶的根源”。

国际海事组织，许多技术问题和解决方案对环境非常敏感，全球最佳实践的概念也是一种谬论。

答案 77 :(得分：26)

当我声称代码仅仅是我的设计的表达时，我经常会大喊大叫。我非常不喜欢看到这么多开发人员在编写代码时“动态”设计系统的方式。

当这些牛仔中的一个从他的马上掉下来时所浪费的时间和精力是惊人的 - 并且只有一点前期的设计工作就可以发现他们击中的问题中的9次。

我觉得现代方法论并没有强调设计在整个软件开发过程中的重要性。例如，当您甚至没有审查过您的设计时，重视代码审查！这很疯狂。

答案 78 :(得分：25)

牛仔编码员完成了更多工作。

我在创业氛围中度过了一生。如果没有牛仔编码器，我们会浪费无休止的周期，确保事情“正确”完成。

正如我们所知，基本上不可能预见所有问题。牛仔编码器直接面对这些问题，并且被迫比那些试图预测它们的人更快地解决它们。

但是，如果你是牛仔编码，那么在其他人不得不维护它之前你最好重构意大利面。 ;）我所知道的最好的是使用连续重构。他们完成了大量的工作，不要浪费时间去预测未来，通过重构，它就变成了可维护的代码。

无论敏捷程度如何，过程总会妨碍一个好牛仔。

答案 79 :(得分：25)

用户不是白痴 - 你是。

我听过很多次开发人员说“某某是白痴”，我的反应通常是“他可能是个白痴，但你允许他成为一个白痴。”

答案 80 :(得分：25)

Emacs更好

答案 81 :(得分：25)

应始终使用基于1的数组而不是基于0的数组。基于0的数组不自然，不必要且容易出错。

当我算上苹果或员工或小工具时，我从一开始，而不是零。我教给孩子们同样的东西。没有第0个苹果或第0个员工或第0个小部件。使用1作为数组的基础更直观，更不容易出错。忘记加一 - 减 - 一 - 地狱（就像我们以前称之为）。基于0的阵列是由计算机科学发明的非自然构造 - 它们不能反映现实，计算机程序应该尽可能地反映现实。

答案 82 :(得分：24)

您编程的过程越多，代码越差

我在8年左右的编程中注意到了一些东西，看起来很荒谬。这是获得质量的唯一途径，就是聘请优质的开发人员，尽可能多地从他们那里删除流程和形式。单元测试，编码标准，代码/同行评审等只会降低质量，而不会增加质量。这听起来很疯狂，因为相反的情况应该是正确的（更多的单元测试应该会带来更好的代码，优秀的编码标准应该会带来更易读的代码，代码审查应该会提高代码的质量）但事实并非如此。

我认为这可以归结为我们称之为“软件工程”的事实，当它真的是设计而不是工程设计时。

有些数字证实了这一说法：

  

来自编辑

     

IEEE软件，2001年11月/ 12月

     

Quantifying Soft Factors

      Steve McConnell

     

...

     

流程成熟度的重要性有限

     

...   在比较中型项目时   （100,000行代码），一个用   最糟糕的过程需要1.43   与那个人一样多的努力   最好的过程，所有其他的事情   平等。换句话说，   过程成熟度的最大影响   关于项目的生产力是1.43 。 ...

     

......克拉克没有强调的是那个   对于10万行的程序   代码，几个人为因素   影响生产力超过   过程呢。 ...

     

......仅凭资历导向的因素   （AEXP，LTEX，PEXP）发挥影响力   3.02。 七   以人为本的因素   集体（ACAP，AEXP，LTEX，   PCAP，PCON，PEXP和SITE §）发挥作用   惊人的影响范围为25.8！   这个简单的事实占了很多   非流程导向的原因   微软等组织，   亚马逊和其他创业者   强者可以体验   行业领先的生产力   看似昙花一现的过程。 ...

     

底线

     

......事实证明，交易过程   工作人员连续性的复杂性，   商业领域的经验，私人   办公室，以及其他以人为本   因素是良好的经济权衡。   当然，最好的组织   实现高度的动力和过程   同时精致，和   对任何人来说，这都是关键挑战   领先的软件组织。

§阅读文章，了解这些缩略语的解释。

答案 83 :(得分：23)

意见：框架和第三方组件应仅作为最后手段使用。

我经常看到程序员立即选择一个框架来完成一项任务，而不需要学习工作所需的基础方法。某些东西将不可避免地破裂，或者我们会找到一个我们没有考虑到的限制，我们将立即陷入困境，不得不重新考虑系统的主要部分。只要仔细考虑，框架就可以使用。

答案 84 :(得分：23)

生成的文档几乎总是毫无价值。

或者，作为推论：您的API需要维护者和用户的单独文档集。

实际上有两类人需要了解您的API：维护人员，他们必须了解您的实施细节以便在工作中有效，以及需要高级概述，示例和详细信息的用户关于他们可以访问的每种方法的效果。

我从未遇到过在任何一个领域都取得成功的生成文档。通常，当程序员为工具编写注释以提取和制作文档时，他们的目标是在中间的某个地方 - 只是足够的实现细节来填充和混淆用户但还不足以显着地帮助维护者，并且没有足够的概述对用户的真正帮助。

作为维护者，我总是而不是干净，清晰的评论，不受你的自动文档工具所需的任何奇怪标记的影响，告诉我为什么你用你的方式编写那个奇怪的开关语句做了，或者这个看似冗余的参数检查修复了什么错误，或者我需要知道的任何其他事情，以便在我处理它时实际保持代码干净和无错误。我希望这些信息就在代码中，与代码相邻，所以我不必搜索你的网站，以便在一个有助于阅读的状态下找到它。

作为一个用户，我总是而是拥有一个完整，组织良好的文档（一组网页将是理想的，但我会选择一个结构良好的文本文件，也告诉我你的API是如何架构的，什么方法做什么，以及如何实现我想用你的API做的事情。我不想在内部看到你写的哪些类允许我做什么工作，或者他们为此而写的文件。我当然不想下载你的资源，所以我可以弄明白幕后发生了什么。如果您的文档足够好，我就不必这样做。

无论如何，这就是我的看法。

答案 85 :(得分：23)

要制作出色的软件，您需要领域专家和优秀的开发人员。

答案 86 :(得分：22)

如果您的文本编辑器没有完成良好的代码完成，那么就会浪费每个人的时间。

快速记住成千上万的参数列表，拼写和返回值（更不用说类结构和类似的复杂组织模式）是计算机擅长的任务，而人（相对）则不是。我全心全意地购买，放慢了自己的速度，避免小工具/功能崇拜是提高效率和避免错误的好方法，但是当你花费零时花费30秒不必要地通过源代码或文档进行搜索没有任何好处。特别是如果你只需要一个拼写（这比我们愿意承认的更多）。

当然，如果没有一个编辑器为您的语言提供此功能，或者任务很简单，可以在加载较重的编辑器时敲除，那么没有人会告诉您Eclipse和90个插件是正确的工具。但是请不要告诉我HJKL能够像1999年那样绕过你的方式，这样每次你需要一个方法签名时，你可以节省更多的时间......即使你觉得自己不那么“黑客”这样做了。

思想？

答案 87 :(得分：22)

客户并不总是正确的。

在我处理的大多数情况下，客户是产品所有者，也就是“业务”。开发人员通常只是编码并且不会尝试提供产品的既得利益。有一种误解，认为IT部门是“公司内部的公司”，这是一堆垃圾。

我觉得我的角色是帮助企业表达他们的想法 - 我相互理解，我有兴趣了解业务，以便我可以提供最好的体验。而这条路线意味着产品所有者有时会要求他/她认为是计算机的下一次革命，让某人同意这个事实，或解释为什么没有人做某事某事的更可能的原因办法。这是互利的，因为产品所有者理解产品的思想，开发团队理解他们所做的不仅仅是吊索代码。

这实际上已经开始引领我们走上<强>增加生产力的道路。怎么样？由于表格双方的分歧导致沟通有所改善，因此我们更有可能在流程的早期阶段走到一起，为产品定义找到一个互利的解决方案。

答案 88 :(得分：22)

我最有争议的编程意见是 发现性能问题不是测量，而是捕获 。

如果你在一个房间里寻找大象（而不是老鼠），你需要知道它们有多大吗？没有！你所要做的就是看。 它们的巨大之处在于它们很容易找到！ 没有必要先测量它们。

至少自从关于 gprof 的论文以来，测量的概念至少是常识 （Susan L. Graham, et al 1982）*，一直在我们的鼻子底下，一直是very simple and direct way to find code worth optimizing。

作为一个小例子，这是它的工作原理。假设您采用调用堆栈的5个随机时间样本，并且您碰巧在5个样本中的3个上看到特定指令。这告诉你什么？

.............   .............   .............   .............   .............
.............   .............   .............   .............   .............
Foo: call Bar   .............   .............   Foo: call Bar   .............
.............   Foo: call Bar   .............   .............   .............
.............   .............   .............   Foo: call Bar   .............
.............   .............   .............   .............   .............
                .............                                   .............

它告诉你程序花费60％的时间执行该指令所要求的工作 。删除它会删除60％：

...\...../...   ...\...../...   .............   ...\...../...   .............
....\.../....   ....\.../....   .............   ....\.../....   .............
Foo: \a/l Bar   .....\./.....   .............   Foo: \a/l Bar   .............
......X......   Foo: cXll Bar   .............   ......X......   .............
...../.\.....   ...../.\.....   .............   Foo: /a\l Bar   .............
..../...\....   ..../...\....   .............   ..../...\....   .............
   /     \      .../.....\...                      /     \      .............

大致。

如果你可以删除指令（或者更少地调用它），那就是大约2.5倍的加速。 （注意 - 递归是无关紧要的 - 如果大象怀孕了，它不会更小。） 然后你可以重复这个过程，直到你真正接近最佳状态。

  • 这不需要测量精度，功能计时，呼叫计数，图表，数百个样本，任何典型的分析内容。

有些人在遇到性能问题时会使用它，并且不明白什么是重要的。

大多数人从未听说过它，当他们听到它时，认为这只是一种低劣的抽样模式。但它是非常不同的，因为它通过提供呼叫站点（以及终端指令）的成本来确定问题，作为挂钟时间的百分比。大多数剖析器（不是全部），无论是使用采样还是仪器，都不会这样做。相反，他们提供各种汇总测量，这些测量充其量只是问题可能位置的线索。 Here is a more extensive summary of the differences.

*事实上，该论文声称 gprof 的目的是“帮助用户评估抽象的替代实现”。它没有声称帮助用户找到需要替代实现的代码，然后在更好的级别上运行。

我的第二个最有争议的意见是this，或者可能是因为它不是那么难以理解。

答案 89 :(得分：22)

如果您不知道，那很好。但如果你甚至不能谷歌，你就会被解雇。

互联网是一种工具。如果你从中学习，那不会让你感到愚蠢。

答案 90 :(得分：21)

可以成为Mort

并非所有人都是“摇滚明星”程序员;我们中的一些人这样做是因为它是一种美好的生活，我们并不关心所有最新潮流和潮流;我们只是想做我们的工作。

答案 91 :(得分：21)

不要评论您的代码

注释不是代码，因此当事情发生变化时，很容易不更改解释代码的注释。相反，我更喜欢将代码中的废话重构为没有理由进行评论的点。一个例子：

if(data == null)  // First time on the page

为：

bool firstTimeOnPage = data == null;
if(firstTimeOnPage)

我真正评论的唯一一次是当它是TODO或解释原因

时 
Widget.GetData(); // only way to grab data, TODO: extract interface or wrapper

答案 92 :(得分：21)

优秀程序员讨厌编码

类似于“一个优秀的程序员是一个懒惰的程序员”和“少代码更好”。但是通过遵循这一理念，我已经设法编写了可能会使用数倍代码的应用程序（并且需要花费数倍的开发时间）。简而言之：在编码之前先思考。我自己的程序的大多数部分最后导致问题的部分是我实际上喜欢编码的部分，因此代码太多，因此写得很差。就像这一段。

优秀程序员是设计师

我发现编程使用与设计相同的概念（如同在艺术中使用的相同设计概念）。我不确定大多数其他程序员会发现同样的事情是真的;也许它是右脑/左脑的东西。从他们的代码到命令行用户界面到他们的图形用户界面，有太多的程序是丑陋的，很明显这些程序的设计者实际上并不是设计师。

虽然相关性可能不是，在这种情况下，意味着因果关系，但我注意到，随着我在设计方面变得更好，我在编码方面变得更好。使事情适合和感觉正确的相同过程可以而且应该在两个地方使用。如果代码感觉不对，则会导致问题，因为a）它不对，或者b）你会假设它以一种“感觉正确”的方式工作，它会然后再次是对的。

艺术和代码不在频谱的两端;代码可以用于艺术，也可以是一种艺术形式。

免责声明：不幸的是，并非所有代码都很漂亮或“正确”。

答案 93 :(得分：20)

我在ASP.NET / VB.NET中工作很多，并且发现ViewState绝对是一场噩梦。它默认在大多数字段上启用，并在每个网页的开头导致大量编码数据。页面上的控件越大，ViewState数据就越大。大多数人并不关注它，但它会创建大量数据，这通常与页面上执行的任务无关。如果不使用这些选项，则必须在所有ASP控件上手动禁用此选项。它可以是或者拥有自定义控件。

在我使用的某些页面上，页面的一半由ViewState组成，这真是一种耻辱，因为可能有更好的方法。

这只是我在语言/技术观点方面可以想到的一个小例子。这可能是有争议的。

顺便说一下，你可能想在这个帖子上编辑投票，它可能会受到一些人的欢迎;）

答案 94 :(得分：20)

我有争议的观点：面向对象编程绝对是软件工程领域最糟糕的事情。

OOP的主要问题是完全没有严格的定义，每个人都可以达成一致。这很容易导致其中存在逻辑漏洞的实现，或像Java这样的语言，遵循这个关于OOP意味着什么的奇怪的宗教教条，同时迫使程序员做所有这些扭曲和“设计模式”只是为了解决特别是OOP系统。

因此，OOP欺骗程序员认为他们正在实现这些巨大的生产力提升，OOP在某种程度上是一种“自然”的思考方式，同时迫使程序员输入大量不必要的样板。

然后，由于没有人知道OOP究竟意味着什么，我们会浪费大量的时间浪费在关于语言X或Y是否是“真正的OOP”的小论证上，奇怪的货物文化语言特征绝对是“必不可少”的语言被认为是“真正的OOP”。

我们不应该要求这种语言或那种语言是“真正的oop”，而应该通过实验来查看显示的语言功能，实际上提高生产力，而不是试图强制它是一种想象的理想语言，或者确实迫使我们的程序符合“真正面向对象程序”的一些柏拉图理想。

我们不是坚持我们的程序符合“真正面向对象”的柏拉图理想，而是注重坚持良好的工程原理，使我们的代码易于阅读和理解，以及使用某种语言的功能。无论他们是否足够“OOP”，都能提高工作效率。

答案 95 :(得分：20)

布尔变量只能用于布尔逻辑。在所有其他情况下，请使用枚举。

布尔变量用于存储只能采用两个可能值的数据。使用它们时出现的问题经常被忽视：

  • 程序员通常无法正确识别某些数据何时应该只有两个可能的值
  • 指导程序员做什么的人，例如程序经理或任何人编写程序员遵循的规范，通常都无法正确识别这一点
  • 即使正确地将一条数据识别为仅具有两种可能的状态，该保证可能在将来也不会成立。

在这些情况下，使用布尔变量会导致混淆代码，这通常可以通过使用枚举来防止。

示例

假设程序员正在为仅销售汽车和卡车的汽车经销商编写软件。程序员为他的软件开发了一个完整的业务需求模型。知道所售车辆的唯一类型是汽车和卡车，他正确地确定他可以在车辆类中使用布尔变量来指示车辆是汽车还是卡车。 

class Vehicle {
 bool isTruck;
 ...
}

编写软件时，如果isTruck为真，则车辆为卡车，当isTruck为假时，车辆为车辆。这是在整个代码中多次执行的简单检查。

一切都顺利运行，直到有一天汽车经销商购买另一家销售摩托车的经销商。程序员必须更新软件，以便在经销商业务发生变化的情况下正常运行。现在需要确定车辆是汽车，卡车还是摩托车，这三种可能状态。

程序员应该如何实现？ isTruck是一个布尔变量，因此它只能保存两个状态。他可以将它从布尔值更改为允许许多状态的其他类型，但这会破坏现有逻辑，并且可能不会向后兼容。从程序员的角度来看，最简单的解决方案是添加一个新变量来表示车辆是否是摩托车。 

class Vehicle {
 bool isTruck;
 bool isMotorcycle;
 ...
}

代码被更改，以便当isTruck为真时，车辆是卡车，当isMotorcycle为真时，车辆是摩托车，当它们都是假的时，车辆就是汽车。

问题

此解决方案存在两个大问题：

  • 程序员想要表达车辆的类型，这是一个想法，但解决方案使用两个变量来实现。如果程序员只使用一个完全指定类型的变量，那么不熟悉代码的人将更难理解这些变量的语义。
  • 通过添加新的布尔值来解决这个摩托车问题并不会让程序员更容易处理将来发生的这种情况。如果经销商开始销售总线，程序员将不得不通过添加另一个布尔值重复所有这些步骤。

开发人员的错误是他的软件的业务需求发生了变化，要求他修改现有的代码。但是首先使用布尔变量使得他的代码不够灵活，难以修改以满足未知的未来需求（更少“面向未来”）。当他以最快的方式实现更改时，代码变得更难以阅读。使用布尔变量最终是一个不成熟的优化。

解决方案

首先使用枚举可以防止出现这些问题。 

enum EVehicleType { Truck, Car }

class Vehicle {
 EVehicleType type;
 ...
}

在这种情况下，为了容纳摩托车，程序员必须做的就是将Motorcycle添加到EVehicleType，并添加新逻辑来处理摩托车案例。不需要添加新变量。不应该破坏现有的逻辑。并且不熟悉代码的人可以很容易地理解车辆的类型是如何存储的。

悬崖笔记

不要使用只能存储两种不同状态的类型，除非你绝对确定两种状态总是足够的。如果在将来需要两个以上状态的任何可能条件下使用枚举，即使布尔值满足现有要求。

答案 96 :(得分：19)

C（或C ++）应该是第一种编程语言

第一种语言不应该是简单的语言，应该是建立学生思维并为严肃的计算机科学做好准备的语言。
C是完美的，它迫使学生思考记忆和所有低级别的东西，同时他们可以学习如何构造他们的代码（它有功能！）

C ++具有额外的优势，它真的很糟糕:)因此学生将理解为什么人们不得不想出Java和C＃

答案 97 :(得分：19)

您总是需要数据库。

如果您需要存储少于几千个“东西”并且您不需要锁定，那么平面文件可以工作并且在很多方面都更好。它们更便携，您可以手动编辑它们。如果您在数据和业务逻辑之间进行了适当的分离，则可以轻松地将平面文件替换为数据库（如果您的应用程序需要它）。如果您考虑到这一点进行设计，它会提醒您在数据和业务逻辑之间进行适当的分离。

-
BMB

答案 98 :(得分：17)

这是多年来对我来说显而易见的一个但是对其他人来说都是诅咒：在'release'版本中用NDEBUG关闭C（或C ++）断言几乎总是错误的（唯一的例外是时间或空间处罚是不可接受的）。

理由：如果断言失败，您的程序已进入

状态
  • 从未经过测试
  • 开发人员无法为
    • 编写恢复策略
  • 开发人员已经有效地记录为不可思议。

然而，某种程度上“行业最佳实践”是，当涉及到客户数据的实时运行时，事情应该只是糊涂并希望最好。

答案 99 :(得分：17)

所有源代码和评论都应该用英文写成

使用英语以外的语言编写源代码和/或注释，如果您不理解它们所使用的语言，则会减少可重用性并且更难以调试。

SQL表，视图和列也是如此，尤其是在使用缩写时。如果它们没有缩写，我可能能够在线翻译表/列名称，但如果它们是缩写的，我可以做的就是选择并尝试解密结果。

答案 100 :(得分：16)

如果要在以后节省3倍的时间，只写一个抽象。

我看到人们有时会写下所有这些疯狂的抽象，我想自己，“为什么？”

除非抽象真的会节省你的时间，或者它会节省维护代码时间的人，但似乎人们只是越来越多地编写意大利面条代码。

答案 101 :(得分：16)

单词'evil'是Stackoverflow和simular论坛上滥用和过度使用的单词。

使用它的人想象力太少。

答案 102 :(得分：16)

较新的语言和托管代码不会让糟糕的程序员变得更好。

答案 103 :(得分：15)

当人们告诉我使用getter和setter而不是让变量公开时，我应该能够同时获取和设置类变量时，我真的不喜欢。

如果要改变对象中对象的变量，我完全同意，所以你不会得到这样的东西：a.b.c.d.e = something;但我宁愿使用：a.x = something;然后是a.setX（某事）;我认为a.x =某事;实际上更容易阅读，更漂亮然后设置/得到相同的例子。

我没有看到原因：

void setX（T x） {     this-＆gt; x = x; }

T getX（） {     返回x; }

这是更多的代码，一次又一次地执行它的更多时间，并且只是使代码更难阅读。

答案 104 :(得分：15)

课程应该适合屏幕。

如果您必须使用滚动条查看所有课程，那么您的课程太大了。

代码折叠和微缩字体是作弊。

答案 105 :(得分：15)

最好的代码通常是你不写的代码。作为程序员，我们希望通过编写一些很酷的方法来解决每个问题。任何时候我们都可以解决问题并仍然向用户提供他们想要的80％而不需要引入更多代码来维护和测试我们已经提供了更多的价值。

答案 106 :(得分：15)

我通常持有相当有争议，强烈和响亮的意见，所以这里只有几个：

“因为我们是微软服装/合作伙伴/专家”永远不是一个有效的论据。

我现在工作的公司现在首先认定自己是微软的专家。所以前面提到的论点会被抛出很多，我还没有看到它有效的背景。

我不明白为什么在每个适用的角落推广微软的技术和产品，压倒客户和员工的满意度以及普遍的语用学原因。

这只是我对软件业政治的深刻仇恨的基石。

MOSS（Microsoft Office Sharepoint Server）是一块糟糕的东西。

Kinda回应了第一个观点，但老实说，我认为MOSS应该被淘汰出市场。许可和设置需要花费大量资金，对网络标准采取措施并使开发人员普遍非常不满意。我还没有看到一个总体上有积极成果的MOSS项目。

然而，一次又一次，客户接近我们并要求提供MOSS解决方案。

答案 107 :(得分：14)

开发者不应该测试自己的软件

开发和测试是两个截然相反的学科。发展就是建筑，测试就是拆迁。有效的测试需要一种特定的思维方式和方法，在这种思维方式和方法中，您试图发现开发人员的错误，发现他们的假设漏洞以及逻辑缺陷。包括我自己在内的大多数人根本无法将自己和自己的代码放在这样的审查之下，仍然是客观的。

答案 108 :(得分：13)

远离Celko !!!!

http://www.dbdebunk.com/page/page/857309.htm

我认为使用代理主键然后使用“自然”主键会更有意义。

@ocdecio：Fabian Pascal给出了（在你所链接的页面的第3点引用的他的书Practical issues in database management的第3章）作为选择稳定性关键的标准之一（它始终存在和不改变）。当一个自然键没有这样的属性时，必须使用代理键，这显然是你在评论中暗示的。

你不知道他写了什么，你没有费心去检查，否则你会发现你真的同意他的意思。那里没有任何争议：他说“不要教条，适应环境的一般指导方针，最重要的是，思考，用你的大脑而不是教条/食谱/古茹语的方法”。

答案 109 :(得分：13)

新的Web项目应考虑不使用Java。

我已经使用Java进行Web开发已超过10年了。起初，与可用的替代方案相比，这是朝着正确方向迈出的一步。现在，有比Java更好的选择。

这实际上只是解决问题的魔锤方法的一个特例，但它真的很痛苦。

答案 110 :(得分：13)

开发人员都不同，应该这样对待。

开发人员不适合盒子，不应该这样对待。解决问题的最佳语言或工具与开发人员一样，与解决问题的细节一样多。

答案 111 :(得分：13)

我有一些......所有东西都有例外，所以这些并不是很难和快，但它们确实适用于大多数情况

没有人关心您的网站是否经过验证，XHTML严格，符合标准，还是拥有W3C徽章。

它可能会从网络开发人员那里获得一些高五，但其他人看着你的网站可能会给你一个废话，无论你是否验证了你的代码。绝大多数网络冲浪者都在使用IE或Firefox，并且由于这两种浏览器都是宽容的非标准，非严格，无效的HTML，所以你真的不需要担心它。如果您为汽车经销商，机械师，广播电台，教堂或当地小型企业建立了一个站点，那么您认为这些企业的目标受众特征中有多少人关注有效的HTML？我猜测它非常接近于0.

大多数开源软件都是无用的，过于复杂的废话。

让我安装一下我发现的这个很好的OSS。它看起来应该完全符合我的要求！哦等等，首先我必须安装其他窗口管理器。好。然后我需要获取此命令行工具并将其添加到我的路径。现在我需要X，Y和Z的最新运行时。现在我需要确保运行这些进程。好的，很棒......全部配置完毕。现在让我学习一组全新的命令来使用它。哦，很酷，有人为它构建了一个GUI。我想我不需要学习这些命令。等等，我需要这个库来使GUI工作。现在要下载了。好吧，现在它正在工作...废话，我无法弄清楚这个可怕的用户界面。

听起来很熟悉吗？ OSS充满了复杂功能的复杂性，需要成为专家才能执行的棘手安装，以及大多数人不知道该怎么做的工具。这么多项目都被淘汰，其他项目很少，很少有人会使用它们，而一些体面的项目（FlowPlayer，OSCommerce等）有如此荒谬的过于复杂和臃肿的源代码，它无法达到目的。编辑源。您可以编辑源...如果您可以找出400个文件中的哪个包含需要修改的代码。当你得知它的全部400个时，你真的遇到了麻烦。

答案 112 :(得分：13)

编程尚处于起步阶段。

尽管编程语言和方法已经很快发展了很多年，但我们还有很长的路要走。迹象很明显：

  1. 语言文档在互联网上随意传播（stackoverflow在这里帮助）。

  2. 如果不破坏以前的版本，语言就无法在语法上发展。

  3. 调试仍然经常使用printf进行。

  4. 语言库或其他形式的大规模代码重用仍然非常罕见。

    5. 显然所有这些都在改善，但如果我们都同意这是开始而不是结束那么会很好。

答案 113 :(得分：13)

如果您想编写好的软件，请离开您的计算机

与最终用户以及想要和需要该软件的人一起去聊天。只有他们才能了解您的软件需要完成什么以及它需要如何实现。

  • 问他们爱与爱是什么讨厌现有的流程。
  • 向他们询问他们流程的未来发展方向。
  • 闲逛，看看他们现在使用的是什么，并找出他们的使用模式。您需要满足并匹配他们的使用期望。看看他们经常使用什么，特别是如果他们喜欢它并且可以有效地使用它。匹配。

最终用户并没有给老鼠一个优雅的代码或它的语言。如果它适用于他们并且他们喜欢使用它，那么你就赢了。如果它不能让他们的生活更轻松，更好 - 他们讨厌它，你输了。

走一英里 - 然后去写你的代码。

答案 114 :(得分：13)

过度使用面向对象编程

有时最好的答案就是答案。

答案 115 :(得分：12)

SQL本可以而且应该做得更好。由于其原始规格有限，各种供应商多年来一直在不同方向扩展语言。为MS-SQL编写的SQL与用于Oracle，IBM，MySQL，Sybase等的SQL不同。其他严肃的语言（例如以C ++为例）是经过精心标准化的，因此在一个编译器下编写的C ++通常在未经修改的情况下编译。为什么SQL不能更好地设计和标准化？

HTML作为浏览器显示语言是一个严重破坏的选择。我们花了数年时间通过CSS，XHTML，Javascript，Ajax，Flash等来扩展它，以便创建一个可用的UI，结果仍然不如您的基本胖客户端Windows应用程序。此外，一个称职的网络程序员现在需要知道三种或四种语言才能形成一个像样的用户界面。

噢，是的。匈牙利的符号是令人厌恶的。

答案 116 :(得分：12)

每个开发人员都应花费数周甚至数月的时间来开发基于纸张的系统，然后再开始构建电子系统。然后他们也应该被迫使用他们的系统。

开发一个良好的纸质系统努力工作。它迫使你考虑到人性（繁琐的过程被忽略，过于复杂的过程往往会崩溃），并教你欣赏简单的价值（新工作在这个托盘， QA的工作在这个托盘中进行，归档在这个框中。）

一旦你弄清楚如何在纸上构建系统，建立一个有效的计算机系统往往要容易得多 - 人们实际上想要（并且能够）使用

我们开发的系统并非由训练有素的自动机系统组成;真实的人使用它们，真正的人是由经理训练的，他们也是真正的人，并且没有多少时间浪费训练他们如何跳过你的篮球。

事实上，对于我的第二点：

每个开发人员都应该被要求运行一个互动培训课程，向用户展示如何使用他们的软件。

答案 117 :(得分：12)

大多数咨询程序员都很难，不应该被允许编写生产代码。

恕我直言 - 可能约为60％或更多

答案 118 :(得分：12)

不应允许非开发人员管理开发人员。

更正：不应允许零开发经验的员工管理开发人员。

答案 119 :(得分：12)

大多数程序员在编程时都没用

（你确实说'有争议'）

我坐在家里的办公室里思考一些编程问题，最后我在书架上查看了我的“完整光谱ROM反汇编”副本并思考：

“今天有多少程序员可以编写Spectrum ROM中使用的代码？”

对于那些不熟悉它的人来说，Spectrum有一种基本的编程语言可以做简单的2D图形（线条，曲线），排序的文件IO和浮点计算，包括所有16K的Z80代码中的transendental函数（a＆lt; ;没有FPU或整数乘法的5Mhz 8位处理器。如今，大多数毕业生都难以编写一个“小世界”的“Hello World”计划。

我认为问题在于可以做到这一点的程序员的绝对数量几乎没有变化，但是百分比很快就会接近零。这意味着随着更多低于标准的程序员进入该领域，正在编写的代码质量正在下降。

我目前在工作的地方，有七位程序员，包括我自己。其中，我是唯一一个通过阅读博客，书籍，这个网站等来保持最新状态并在家里进行“有趣”编程的人（我的妻子一直对此感到惊讶）。还有一个程序员热衷于编写结构良好的代码（有趣的是，他使用Delphi做了很多工作）并重构了糟糕的代码。其余的都不是很好。关于它，您可以将它们描述为“强力”程序员 - 将强制使用不合适的解决方案，直到它们以一种方式工作（例如，使用带有重复array.Resize的C＃数组来动态添加项而不是使用List）。

现在，我不知道我现在所处的位置是否典型，尽管从我以前的位置我会说是。事后看来，我可以看到一些常见的模式肯定对任何项目没有帮助（缺乏对一个代码的同行评审）。

因此，7名程序员中有5名是垃圾。

Skizz

答案 120 :(得分：12)

编程任务只是有趣而且不可能，直到你确信自己能够成功解决它。

我想，这就是为什么我的很多项目都在一个名为“_ _继续”的文件夹中完成的原因。

答案 121 :(得分：12)

应弃用大于运营商（＆gt;，＆gt; =）

我尝试编码的偏好超过一段时间而不是超过一段时间而且卡住了！我不想回去，事实上我觉得每个人都应该按照我的方式去做。

考虑常见的数学“范围”符号：0＆lt; = i＆lt; 10

现在很容易在代码中进行近似，你习惯于看到变量在中间重复的惯用语，加上＆amp;＆amp;：

if (0 <= i && i < 10)
    return true;
else
    return false;

一旦你习惯了这种模式，你永远不会看到愚蠢的感觉

if ( ! (i < 0 || i >= 9))
    return true;
再次以同样的方式。

长关系序列变得更容易使用，因为操作数倾向于非递减顺序。

此外，对operator<的偏好在C ++标准中得到了体现。在某些情况下，operator=是根据它来定义的！ （作为!(a<b || b<a)）

答案 122 :(得分：12)

软件就像卫生纸。你花在它上的钱越少，它就越痛苦。

也就是说，外包很少是一个好主意。

我一直认为这是真的，但直到最近我才真正知道它的程度。我最近一直在“维护”（读取：“修复”）一些离线代码，这是一个巨大的混乱。如果我们公司内部开发的差异很大，这很容易使我们公司付出代价。

您公司以外的人员本质上对您的业务模式知之甚少，因此无法为您的业务中的任何系统编程。而且，他们知道他们不需要支持它，所以没有动力做任何事情而不是半屁股。

答案 123 :(得分：11)

应该指派初级程序员进行对象/模块设计和设计维护几个月，然后才允许他们实际编写或修改代码。

太多程序员/开发人员在没有理解优秀设计元素的情况下达到了5年和10年的标记。当他们想要超越仅仅编写和维护代码时，它可能会瘫痪。

答案 124 :(得分：11)

请勿在数据库中使用存储过程。

它们原本很好的原因 - 安全性，抽象性，单一连接 - 都可以在中间层完成，ORM集成了许多其他优点。

这个肯定是有争议的。每次我提起它，人们都会把我撕裂。

答案 125 :(得分：11)

随机收集库克的格言......

  • 最难学的语言是你的第二个。

  • 最难学习的操作系统是你的第二个 - 特别是如果你的第一个是IBM大型机。

  • 一旦你学会了几种看似不同的语言， 你终于意识到所有的编程 语言是相同的 - 只是语法上的细微差别。

  • 虽然在没有学会装配的情况下，一个人可以很有生产力和适销性， 没有它，没有人会对计算有一种内心的理解。

  • 调试器是不太懂的程序员的最后避难所 他们最初在做什么。

  • 如果不使用硬件内存管理，任何操作系统都不会稳定。

  • 低级系统编程比应用程序编程容易得多。

  • 拥有最喜欢的语言的程序员正在玩。

  • 首先编写用户指南！

  • 政策和程序适用于那些缺乏主动执行的人。

  • （承包商信条）： 告诉他们他们需要什么。 Give'em他们想要什么。 确保检查清除。

  • 如果你没有找到编程的乐趣，那就放弃它或者接受它，尽管你可以做一个 住在它，你永远不会超过平均水平。

  • 正如旧屁必须学习.NET方法名称一样， 你将不得不学习图书馆的电话。但那里没有什么新东西 程序员的生活是不断适应不同环境的， 而且你的皮带上挂的工具越多，你的用途就越多，越来越有市场。

  • 你可能会在一开始就用一些代码块来尝试一些想法， 但是，一般来说，在你知道整个程序或者程序如何之前，你不会认真地开始编码 应用程序将被布局，你知道整个事情将完全正常工作 标榜。对于大多数具有至少一定程度复杂性的项目， 我通常最终花费60％到70％的时间来预测这些想法。

  • 了解编程与语言无关，与算法有关。 所有这些漂亮的geegaws与人们多年来提出的令人难忘的缩略词 只是不同的方式皮肤实现cat。当你剥去所有的 OOPiness，RADology，Development Methodology 37和Best Practice 42，你仍需要处理 与基本构建块：

    • 分配
    • 条件
    • 迭代
    • 控制流程
    • I / O

一旦你真正能够把自己包裹起来，你最终会达到你的目的 看（从编程的角度来看）编写库存应用程序之间的差别很小 汽车零部件公司，图形实时TCP性能分析器，数学模型 一个恒星核心，或约会日历。

  • 初级程序员使用小块代码。随着他们获得经验， 他们使用越来越大的代码块。
    随着他们获得更多经验，他们使用小块代码。

答案 126 :(得分：11)

关于递归的最糟糕的事情是递归。

答案 127 :(得分：11)

这个主要与网络有关，但是......

使用表格进行网页布局

如果我正在开发一个需要挤压性能的巨型网站，我可能会考虑它，但没有什么能让我更方便地在浏览器上看到一致而不是表格。我开发的大多数应用程序大约有100-1000个用户，最多可能有100个用户。表格的额外膨胀并没有以任何方式杀死我的服务器。

答案 128 :(得分：11)

编码未输入

编写代码需要时间。大多数情况下，在编辑器窗口中，您只是查看代码，而不是实际输入。不经常，但经常，你删除你写的东西。或者从一个地方搬到另一个地方。或重命名。

如果你长时间敲击键盘，你做错了什么。

推论：每天编写的代码行数不是程序员工作效率的线性度量，因为程序员一天写入100行很可能是一个更好的程序员，然后是编写20行的程序员，但是编写5000行代码的程序员肯定是坏程序员

答案 129 :(得分：11)

90％的程序员都是非常糟糕的程序员，几乎我们所有人都没有工具来评估我们当前的能力水平（尽管我们通常可以回顾并意识到我们用来吮吸的程度有多糟糕）

我不会发布这个，因为它会让所有人失望，而我并没有真正尝试得分，但是：

A）不是问题的重点，而且

B）这个帖子中的大多数“答案”证明了这一点

前几天我听到了一个很好的比喻：编程能力与运动能力的差异至少有所不同。我们中有多少人可以跳进专业团队并真正提高他们的机会？

答案 130 :(得分：11)

估计适合我，不适合你

作为开发部门经理，估算对我来说是一个有用的工具，可以规划我的团队正在进行的工作。

它们并不是特定日期的功能交付的承诺，它们不是推动团队更努力工作的坚持。

恕我直言，如果你强迫开发者承诺估计你得到最安全的数字。

例如 -

  

我认为一个功能可能需要大约5天。问题很可能会花费30天。

     

如果估算仅用于计划，那么我们将全部工作到5天，并说明出现问题的可能性很小。

     

但是 - 如果需要满足该估算作为交付承诺，您认为会给出什么估计？

如果开发人员的奖金或工作保障取决于是否达到预期，您认为他们会给出最准确的猜测，还是他们最肯定会猜到的？

我的这种观点与其他管理层存在争议，并且被解释为我试图摆脱正确的目标，或者我试图掩盖糟糕的表现。每次都很难卖，但我已经习惯了。

答案 131 :(得分：11)

我不知道它是否真的有争议，但是如何：方法和函数名称是您的代码可以拥有的最好的评论;如果您发现自己正在撰写评论，请将您正在评论的部分代码转换为函数/方法。

这样做会产生令人愉快的副作用，迫使你很好地分解你的程序，避免发现很快就会与现实不同步的评论，为你提供一些可以为代码库提供帮助的东西，并让你的代码保持新鲜柠檬味。

答案 132 :(得分：11)

复制/粘贴 IS 万恶之源。

答案 133 :(得分：10)

使用存储过程

除非您正在编写由不可重用的SQL查询组成的大型过程函数，否则请移动数据库的存储过程并进入版本控制。

答案 134 :(得分：10)

创建类似于带有疯牛病的椒盐卷饼的UML图表的能力实际上并不是一项有用的软件开发技能。

图表代码的重点是可视化连接，以查看设计的形状。但是，一旦你通过了相当低的复杂程度，可视化对于精神上的处理来说太过分了。如果你坚持使用直线，那么以图形方式进行连接只会很简单，这通常会使图表比连接被巧妙地分组并沿基本方向布线更难阅读。

仅将图表用于广泛的交流目的，并且只有当它们被理解为谎言时才使用。

答案 135 :(得分：10)

这个怎么样：

垃圾收集器实际上损害了程序员的工作效率，并且难以找到并修复资源泄漏

请注意，我说的是一般的资源，而不仅仅是记忆。

答案 136 :(得分：10)

Python的方法声明中的显式self是糟糕的设计选择。

方法调用得到了语法糖，但声明没有。这是一个漏洞抽象（按设计！）导致恼人的错误，包括运行时错误，报告的参数数量中有明显的一个错误。

答案 137 :(得分：10)

我有争议的意见？ Java并不吸引Java API。为什么java库坚持要做简单的任务呢？为什么他们不是修复API，而是创建框架来帮助管理样板代码？此意见适用于需要10行或更多行代码才能从文件中读取一行的任何语言。

答案 138 :(得分：10)

正在开发的绝大多数软件在收集需求时并不涉及最终用户。

通常只是一些提供“要求”的经理。

答案 139 :(得分：10)

任何具有足够功能的库都太复杂而无法使用，任何简单易用的库都缺乏成为良好通用解决方案所需的功能。

我经常跑到这里。使用起来非常复杂的详尽库我撕掉了我的头发和简单易用的库，这些库并不能完全满足我的需要。

答案 140 :(得分：10)

大多数开发人员都没有线索

是的，你去了。我说过了。我发现我个人都知道的所有开发人员......实际上只有少数人真的很好。只有少数人明白代码应该被测试......面向对象的开发方法实际上可以帮助你。令我感到沮丧的是，有些人获得了开发人员的称号，而实际上他们只能复制并粘贴一些源代码然后执行它。

无论如何......我很高兴像stackoverflow这样的计划正在启动。对开发人员来说，这很好奇。有没有更好的办法？我做得对吗？也许我可以用这种技术来加快速度等等......

但是没有......大多数开发人员只是学习他们的工作所需的语言，并坚持使用它，直到他们自己变老，脾气暴躁的开发人员不知道发生了什么。他们所得到的只是一大笔薪水，因为他们只比你年长。

嗯嗯...... IT社区的生活是不公正的，我将在未来采取措施忽视这些人。万岁！

答案 141 :(得分：10)

编码是一种艺术

有些人认为编码是一门艺术，有些人认为编码是一门科学。

“科学”派认为，目标是获得情境的最优代码，然后编码是研究如何获得这种最优的科学。

“艺术”派系认为，有很多方法可以获得最佳的情境代码，这个过程充满了主观性，而根据自己的技能和经验明智地选择是一门艺术。

答案 142 :(得分：10)

递归很有趣。

是的，我知道它可能是无效的堆栈空间使用，以及所有爵士乐。但有时候，与迭代对应物相比，递归算法更加干净整洁。当我可以在某个地方潜行递归函数时，我总是有点高兴。

答案 143 :(得分：10)

MIcrosoft没有许多人说的那么糟糕。

答案 144 :(得分：10)

使软件可配置是一个坏主意。

可配置软件允许最终用户（或管理员等）选择太多选项，这些选项可能并非全部已经一起测试（或者更确切地说，如果数量非常少，我可以保证不会测试）。

所以我认为将其配置硬编码（但不一定是回避常量等）的软件只是一个好主意。使用合理的默认值运行，并且不要允许它们被更改。

一个很好的例子是Google Chrome上的配置选项数量 - 但是，这可能仍然太多了：）

答案 145 :(得分：10)

微软应该停止支持任何处理Visual Basic的事情。

答案 146 :(得分：10)

Intranet像SharePoint这样的框架让我觉得整个企业界都是一头巨大的鸵鸟，其头脑浑浊

我不仅在这里谈论MOSS，我还与其他一些企业INTRANET产品合作，绝对不是其中一个很好，但SharePoint（MOSS）是迄今为止最糟糕的。

  • 这些系统中的大多数都不能轻易弥合Intranet和Internet之间的差距。因此，作为远程​​工作人员，您不得不进行VPN接入。外部客户无法直接掌握您的内部信息。当然这可以固定在一个价格$$$。
  • 搜索功能总是可悲的。其他部门根本不知道有关信息的时间很多。
  • 信息片段，人们开始抵制工作流程或恢复电子邮件
  • SharePoint开发是地球上最痛苦的开发形式。没有像SharePoint那样糟透了。我见过一些开发人员在与MOSS合作超过一年后考虑退出IT。
  • 无论开发人员如何讨厌MOSS，无论最基本的项目需要花多长时间，无论结果看起来多么新手，无论内容如何无法检测和分散：

每个人仍然继续使用和购买SHAREPOINT，并且管理者仍然非常难以预测它不是SATANS SPAWN。

<强>微格式

使用最初为可视化布局设计的CSS类 - 现在为视觉和上下文数据分配的是一个黑客，充满了歧义。不是说功能不应该存在，而是修复该死的基本语言。 HTML并没有被黑客攻击来生成XML - 而是出现了XML语言。现在我们有这些急切的脚本小子黑客攻击HTML和CSS来做一些它不打算做的事情，那仍然很好，但我希望他们能把这些东西留给自己，而不是制定标准。只是为了一些 - 屠杀！

答案 147 :(得分：9)

大多数语言支持者都会发出很多声音。

答案 148 :(得分：9)

我的：

长切换语句是你的朋友。真。至少在C＃中。

人们倾向于避免和阻止他人使用长切换语句，因为他们“无法管理”和“具有糟糕的性能特征”。

嗯，问题是在C＃中，switch语句总是自动编译为哈希跳转表，因此如果你需要简单的分支，实际使用它们就性能而言就是 Best Thing To Do™多个分支。此外，如果案例陈述是按智能组织和分组的（例如按字母顺序排列），则它们根本无法管理。

答案 149 :(得分：9)

Rob Pike写道：“数据占主导地位。如果你选择了正确的数据结构并组织好了，算法几乎总是不言而喻。数据结构，而不是算法，是编程的核心。”

从那时起，任何严肃的数据都存在于数百万条记录中，我认为良好的数据建模是最重要的编程技巧（无论是使用rdbms还是使用sqlite或amazon simpleDB或google appengine数据存储。）

当数据（所有数据）都存储在这样的数据存储系统中时，不再需要花哨的搜索和排序算法。

答案 150 :(得分：9)

Web应用程序很糟糕

我的互联网连接很慢。我对几乎所有非Google网站的体验至少令人沮丧。为什么没有人再写桌面应用程序了？原来如此。没有人想要了解操作系统的工作原理。至少，不是Windows。你最后一次处理WM_PAINT，你的头部爆炸了。创建一个工作线程来执行一项长任务（我的意思是，以Windows方式执行）完全超出了你。到底是什么回调？哦，天啊！

垃圾收集糟透了

不，它实际上没有。但这让程序员们别无选择。在大学里，他们教给我们的第一语言是Visual Basic（原始语言）。在那之后，还有另一个课程，教师假装他们教我们C ++。但损坏已经完成。实际上没有人知道如何使用这个深奥的关键字delete。在测试我们的程序之后，我们得到了无效的地址异常或内存泄漏。有时候，我们都得到了。在我能够实际编程的1％的教师中，只有一个能够自己管理自己的记忆（至少，他假装）并且他正在写这个咆哮。其余的用VB.NET编写程序，根据定义，这是一种糟糕的语言。

动态打字糟透了

除非你正在使用汇编程序，否则（那种动态类型实际上值得称赞）。我的意思是动态的，解释性的语言所带来的开销使它们吮吸。并且不要带着那些愚蠢的论点，即不同的工具对不同的工作有益。 C是几乎所有东西的正确语言（它快速，强大和便携），而当它不是（它不够快）时，总会有内联汇编。

我可能会提出更多的咆哮，但那会更晚，而不是现在。

答案 151 :(得分：9)

方法/函数参数的前提条件应该是语言的一部分，而不是程序员总是检查它。

答案 152 :(得分：9)

需求分析，规范，设计和文档几乎不会适用于“模板”。通过从空白文档开始并开始输入，您可以100％获得更好的时间。 “我会以这样的方式解释这个问题，如果我死了，其他人阅读这份文件，他们就会知道我所知道的所有事情，现在就看到并理解”，然后从那里组织，让章节标题自然而然地发展适合您指定的任务，而不是受限于某些企业或学校对您的文档应该是什么样子的想法。如果你必须做一个图表，而不是使用某人的正式和不可理解的系统，你通常最好只绘制一个有意义的图表，带有一个清晰的图例，它实际上指定了你试图指定的系统并传达信息另一方面的开发人员（通常是你，几年后）需要接收。

[如果你必须，一旦你写完了真实的文件，你就可以经常将它塞进你的组织强加给你的任何模板套装中。但是，您可能会发现自己必须添加章节标题和复制材料。]

这类文档的模板唯一有效的时间就是当你拥有大量非常相似的任务时，这些任务的细节不同。 “编写程序以允许通过此调制解调器组进行一次性远程登录访问，使用C-Kermit驱动终端连接nexus，”“生成容量使用的历史趋势和预测报告”，“使用此库为所有报告提供能够传真，“”修复2000年问题的此代码，“和”在此表中添加数据库触发器以填充由第三方供应商为我们提供的软件产品“可以不所有无论人们怎么想，都可以用同一个模板来描述。为了记录，我的大学课程试图教我和我的同学的要求和设计图表技术不能用来指定一个简单的计算器程序（每个人都知道它）。

答案 153 :(得分：9)

对于优秀的程序员来说，语言不是问题。

这可能不是很有争议，但我听到很多其他程序员抱怨说“为什么他们都不使用delphi？”，“C＃糟透了”，“如果他们强迫我使用java，我会改变公司”等等。
我认为一个优秀的程序员是灵活的，能够用他生命中可能需要学习的任何编程语言编写好的程序

答案 154 :(得分：9)

有时跳上行列是好的

我厌倦了那些展示“爷爷综合症”的人（“你们孩子和你们新奇的测试驱动开发。过去十年中出现的每一项大技术都已经糟透了。回到我的日子，我们写了真正的代码！“......你明白了。”

有时候受欢迎的东西很受欢迎。

答案 155 :(得分：9)

VB 6可以用于善恶。在编码过于复杂的时候，它是一个快速应用程序开发环境。

我过去一直非常讨厌VB，并且由于我不喜欢经典的VB，仍然嘲笑VB.NET（可能是开玩笑）作为Fisher Price语言，但在当时，没有什么比完成工作更能击败它

答案 156 :(得分：9)

代码生成不好

我讨厌那些需要你使用代码生成（或复制和粘贴）来处理简单事情的语言，比如带有所有Getter和Setter的JavaBeans。

C＃的AutoProperties是朝着正确方向迈出的一步，但对于包含Fields，Properties和Constructor参数的精美DTO，您仍然需要大量的冗余。

答案 157 :(得分：9)

如果您需要阅读本手册，则该软件不够好。

简单明了： - ）

答案 158 :(得分：9)

编程不是艺术，也不是科学。这是一门工程学科。

这不是艺术：编程需要创造力。这不是艺术。代码的设计和编写是为了正常工作，而不是在情感上移动。除了空格外，为了美观原因而更改代码会破坏您的代码。虽然代码可以很漂亮，但艺术不是主要目的。

这不是科学：科学和技术是不可分割的，但编程属于技术范畴。编程不是系统的研究和观察;它是设计和实施。

这是一门工程学科：程序员设计和构建东西。优秀的程序员设计功能。他们了解不同实施方案的权衡，并选择适合他们正在解决的问题。

我确信有些人愿意解析词汇，将艺术和科学的定义扩展到包括编程或仅限于机械设备或硬件的工程。检查字典。此外，“计算机程序设计的艺术”是艺术的不同用法，意思是技巧或工艺，如“谈话的艺术”。编程的产物不是艺术。

答案 159 :(得分：8)

关系数据库对于Web应用程序来说非常糟糕。

例如：

  • 线索评论
  • 标签云
  • 用户搜索
  • 保持记录查看次数
  • 提供撤消/修订跟踪
  • 多步向导

答案 160 :(得分：8)

我们使用我们构建的模型 - 视图 - 控制器框架在这里进行了大量的开发。我经常告诉我的开发人员我们需要违反MVC设计模式的规则，以使网站运行得更快。对于开发人员来说，这是一个很难卖的东西，他们通常不愿意为任何事情牺牲精心设计的代码。但是，性能是构建Web应用程序的首要任务，因此有时我们必须在框架中做出让步。

例如，视图层不应该直接与数据库对话，对吧？但是，如果要生成大型报告，应用程序将使用大量内存将数据传递到模型和控制器层。如果您有一个支持游标的数据库，它可以使应用程序更快地从视图层直接访问数据库。

性能胜过开发标准，这是我有争议的观点。

答案 161 :(得分：8)

我认为使用try / catch异常处理比使用简单的返回代码和相关的常见消息传递结构来传递有用的错误消息更糟糕。

使用try / catch块的乱码代码不是解决方案。

只是将异常传递到堆栈上希望上面的内容会做正确的事情或者 产生信息性错误不是解决方案。

认为您有可能系统地验证正确的异常处理程序是否可以解决透明或异常对象中可能出错的任何问题是不现实的。 （还可以考虑后期绑定/外部库以及系统发展时调用堆栈中不相关函数之间的不必要依赖性）

返回代码的使用很简单，可以轻松地系统地验证覆盖率，如果处理得当，则迫使开发人员生成有用的错误消息，而不是过于常见的堆栈转储和模糊的I / O异常，这些异常“异常”无意义甚至是最有感染力的最终用户。

-

我最后的反对意见是使用垃圾收集语言。不要误会我的意思..我喜欢他们在某些情况下，但一般来说，对于服务器/ MC系统，他们在我看来没有位置。

GC不可吸收 - 即使是设计得非常好的GC算法也可能会根据其依赖图中非显而易见的循环引用而长时间甚至永久地挂起对象。

遵循一些简单模式和使用内存记帐工具的非GC系统没有此问题，但在设计和测试方面需要比GC环境更多的工作。这里的权衡是在非GC中测试期间很容易发现内存泄漏，而发现GC相关问题的条件则要困难得多。

内存很便宜但是当您泄漏昂贵的对象（例如事务句柄，同步对象，套接字连接等）时会发生什么。在我的环境中，如果没有软件描述中的重大变化，您可以只是坐下来让语言为您担心这一点是不可想象的。

答案 162 :(得分：8)

最好的程序员在调试器中跟踪所有代码并测试所有路径。

嗯...... OP说有争议！

答案 163 :(得分：8)

在发现缺陷时纠正它们。不只是“严重性1”缺陷; 所有缺陷。

建立一种部署机制，使用户可以立即使用应用程序更新，但允许他们选择何时接受这些更新。与用户建立直接沟通机制，使他们能够报告缺陷，将他们的经验与更新联系起来，并提出改进建议。

通过积极的测试，可以在创建它们的迭代过程中发现许多缺陷;立即纠正它们可以减少开发人员中断，这是创建缺陷的重要因素。立即纠正用户报告的缺陷，形成建设性的社区，以产品改进取代产品质量作为主要话题。实施与您的愿景和战略一致的用户建议的改进产生了热情的福音传播者社区。

答案 164 :(得分：8)

Web服务绝对是糟透了，而不是未来的方式。它们效率低得离谱，并不保证有序交付。永远不要在写入客户端和服务器的系统中使用Web服务。它们主要用于micky mouse mash-up类型的应用程序。它们绝对不能用于任何类型的面向连接的通信。

这种立场让我和同事们进行了一些非常热烈的讨论，因为网络服务是一个如此蠢糊的话题。任何要求使用Web服务的项目都注定要失败，因为它显然已经从管理层那里得到了荒谬的要求。

答案 165 :(得分：8)

持续测试

你必须编写测试，你必须先编写它们。编写测试会改变编写代码的方式。它可以让你思考你想要它实际做什么之后，你只需要跳进去写一些除了你想做的事情之外的事情。

它还为您提供了目标。看着你的测试变成绿色，你可以获得更多信心，让你获得成功。

它还为您编写边缘案例的测试提供了基础。由于您在开始时编写了针对测试的代码，因此您可能需要在代码中使用一些钩子进行测试。

没有理由不测试您的代码。如果你不这样做，你只是懒惰。我还认为你应该先测试，因为好处超过了以这种方式编码所需的额外时间。

答案 166 :(得分：8)

代码 设计

答案 167 :(得分：8)

汇编是最好的第一种编程语言。

答案 168 :(得分：8)

优秀的开发人员需要了解的不仅仅是如何编码

答案 169 :(得分：8)

过早优化 不是万恶之源！缺乏适当的计划是万恶之源。

记住旧的海军看见

  

正确的计划可防止P * s差   性能！

答案 170 :(得分：8)

开发人员过度使用数据库

开发人员经常将数据存储在应该在代码或文件中的DBMS中。我已经看到一个存储“系统密码”的单列一行表（与用户表分开。）我已经看到存储在数据库中的常量。我见过数据库会让成年人变得更加困惑。

有一些神秘的敬畏，违规编码员拥有DBMS - 数据库可以做任何事情，但他们不知道它是如何工作的。 DBA实践黑人艺术。它还允许责任转移：“数据库太慢了”， “数据库做到了”，其他借口很常见。

如果不加以控制，这些程序员继续开发数据库，​​系统内系统。 （这个反模式有一个名字，但我忘了它是什么。）

答案 171 :(得分：8)

有时您必须对数据库进行非规范化。

对于大多数程序员而言，这种观点并不顺利，但有时候你必须牺牲noramlization等性能。

答案 172 :(得分：8)

编程：这是一个有趣的工作。

我似乎看到了两个广泛的开发人员群体。那些不喜欢它，但他们是有能力的，钱是好的。另一群喜欢它的人有点令人毛骨悚然。这似乎是他们的生活。

我认为这项工作通常很有趣且很有趣。每天都有各种各样的空间来学习新的东西。我想不出我想要的另一份工作。但它仍然是一份工作。会产生妥协，你生产的东西并不总是那么好。

鉴于我的仆人会在海滩上喝啤酒或和我的孩子一起玩。

答案 173 :(得分：8)

汇编程序没有死

在我的工作中（复制保护系统）汇编程序编程是必不可少的，我正在使用许多hll复制保护系统，只有汇编程序才能让你真正有能力利用代码中隐藏的所有可能性（比如代码变异，低级别的东西） ）。

许多代码优化只有通过汇编程序编程才能实现，查看任何视频编解码器的来源，使用汇编程序编写源代码并优化使用MMX / SSE / SSE2操作码，许多游戏引擎使用汇编程序优化的例程，甚至Windows内核具有SSE优化例程：

NTDLL.RtlMoveMemory

.text:7C902CD8                 push    ebp
.text:7C902CD9                 mov     ebp, esp
.text:7C902CDB                 push    esi
.text:7C902CDC                 push    edi
.text:7C902CDD                 push    ebx
.text:7C902CDE                 mov     esi, [ebp+0Ch]
.text:7C902CE1                 mov     edi, [ebp+8]
.text:7C902CE4                 mov     ecx, [ebp+10h]
.text:7C902CE7                 mov     eax, [esi]
.text:7C902CE9                 cld
.text:7C902CEA                 mov     edx, ecx
.text:7C902CEC                 and     ecx, 3Fh
.text:7C902CEF                 shr     edx, 6
.text:7C902CF2                 jz      loc_7C902EF2
.text:7C902CF8                 dec     edx
.text:7C902CF9                 jz      loc_7C902E77
.text:7C902CFF                 prefetchnta byte ptr [esi-80h]
.text:7C902D03                 dec     edx
.text:7C902D04                 jz      loc_7C902E03
.text:7C902D0A                 prefetchnta byte ptr [esi-40h]
.text:7C902D0E                 dec     edx
.text:7C902D0F                 jz      short loc_7C902D8F
.text:7C902D11
.text:7C902D11 loc_7C902D11:                           ; CODE XREF: .text:7C902D8Dj
.text:7C902D11                 prefetchnta byte ptr [esi+100h]
.text:7C902D18                 mov     eax, [esi]
.text:7C902D1A                 mov     ebx, [esi+4]
.text:7C902D1D                 movnti  [edi], eax
.text:7C902D20                 movnti  [edi+4], ebx
.text:7C902D24                 mov     eax, [esi+8]
.text:7C902D27                 mov     ebx, [esi+0Ch]
.text:7C902D2A                 movnti  [edi+8], eax
.text:7C902D2E                 movnti  [edi+0Ch], ebx
.text:7C902D32                 mov     eax, [esi+10h]
.text:7C902D35                 mov     ebx, [esi+14h]
.text:7C902D38                 movnti  [edi+10h], eax

因此，如果您下次听到汇编程序已经死亡，请考虑您观看过的最后一部电影或您玩过的游戏（及其复制保护版本）。

答案 174 :(得分：8)

自己编写可能是一个有效的选项。

根据我的经验，在使用第三方代码解决问题时似乎有太多的热情。自己解决问题的选择通常不会跨越人们的思想。虽然不要误会我的意思，但我并没有宣传永远不会使用库。我所说的是：在您考虑使用的可能框架和模块中，添加自己实施解决方案的选项。

但为什么要编写自己的版本？

  • 不要重新发明轮子。但是，如果你只需要一块木头，你真的需要整个车轮吗？换句话说，你真的需要openCV来沿轴转动图像吗？
  • 妥协。您通常必须妥协您的设计，以便能够使用特定的库。您必须包含的更改量是否值得您将获得的功能？
  • 学习。您必须学习使用这些新的框架和模块。你需要多长时间？你值得吗？是否需要更长的学习时间而不是实施？
  • 成本。不是一切都是免费的。虽然，这包括你的时间。考虑一下你要使用这个软件需要花多少时间来节省你，以及它是否物有所值？ （还记得你必须花时间去学习它）
  • 你是一个程序员，而不是......一个只是点击一起的人（对不起，想不出任何诙谐的事）。

最后一点值得商榷。

答案 175 :(得分：8)

自切片面包以来，关系数据库系统 将是最好的事情......

...当我们（希望）得到它们时，就是这样。 SQL数据库很难吸收它并不好笑。

我觉得有趣（如果难过）是认证的DBA 谁认为SQL数据库系统是关系型的。说出所述认证质量的数量。

困惑？阅读C. J. Date的书。

修改

为什么称它为 Relational ，这个词是什么意思？

现在，具有强大（heck，任何）数学背景的程序员（或经过认证的DBA， wink ）是一个例外，而不是常见的情况（I也是常见案例的一个例子。带有表，列和行的SQL，以及名为Entity / Relationship Modeling的笑话只会增加对伤害的侮辱。难怪由于实体（表）之间的某些 Relationships （外键？）而被称为 Relational 数据库系统的误解是如此普遍。

事实上， Relational 源自数学关系概念，因此与集合论和函数密切相关（在数学中，而不是任何编程，意义上） ）。

[http://en.wikipedia.org/wiki/Finitary_relation][2]：

  

在数学中（更具体地说，在集理论和逻辑中），关系是一个属性，它将真值分配给的组合（ k -tuples） k 个人。通常，该属性描述 k -tuple的组件之间的可能连接。对于给定的一组 k - 元组，根据属性是否存在，为每个 k -tuple分配一个真值。

     

三元关系的一个例子（即三个人之间）是：“ X 被 Z 引入 Y ” ，其中（X，Y，Z）是3元组的人;例如，“Beatrice Wood被Marcel Duchamp介绍给Henri-PierreRoché”是真的，而“Karl Marx被维多利亚女王介绍给Friedrich Engels”是错误的。

Wikipedia非常清楚：在SQL DBMS中，这样的三元关系将是“ table ”，而不是“外键”（我正在服用）重命名关系的“列”的自由：X = who，Y = to，Z = by）：

CREATE TABLE introduction (
  who INDIVIDUAL NOT NULL
, to INDIVIDUAL NOT NULL
, by INDIVIDUAL NOT NULL
, PRIMARY KEY (who, to, by)
);

此外，它还包含（其中可能包含）此“行”：

INSERT INTO introduction (
  who
, to
, by
) VALUES (
  'Beatrice Wood'
, 'Henri-Pierre Roché'
, 'Marcel Duchamp'
);

但不是这一个：

INSERT INTO introduction (
  who
, to
, by
) VALUES (
  'Karl Marx'
, 'Friedrich Engels'
, 'Queen Victoria'
);

关系数据库字典：

  

关系（数学）给定集合 s1 ， s2 ，...， sn ，不一定是明显的， r 是这些集合上的一个关系，当且仅当它是一组 n - 元组中的每一个都有来自 s1 的第一个元素时，它是 s2 的第二个元素，依此类推。 （等效地， r 是笛卡尔积 s1 x s2 x ... x sn 的子集。）

     

设置 si 是 r 的 i 域（ i = 1，...，< EM>名词的）。 注意：数学关系和关系模型对应关系之间存在几个重要的逻辑差异。以下是其中一些：

     
      
  • 数学关系对其属性有从左到右的排序。
    •   
  • 实际上，无论如何，数学关系充其量只是一个非常基本的属性概念。当然，他们的属性没有被命名，除了他们的序数位置。
    •   
  • 因此，数学关系在关系模型意义上并没有真正的标题或类型。
    •   
  • 数学关系通常是二元的，偶尔也是一元的。相比之下，关系模型中的关系是 n ，其中 n 可以是任何非负整数。
    •   
  • 首先在关系模型的上下文中明确定义JOIN，EXTEND等关系运算符;关系的数学理论包括很少这样的算子。
    •   
     

依此类推（以上并不是一份详尽的清单）。

答案 176 :(得分：7)

<强> There is no such thing as Object-Oriented programming.

答案 177 :(得分：7)

完成编码后编写规范。 （如果有的话）

在我参与的许多项目中，我们在一开始就花了很多精力在Microsoft Word中编写“规范”。当这个大型镜头买进项目时，这个过程最终达成了一个“签署”会议，在那次会议之后，没有人再次看过这个文件。这些文档完全是浪费时间，并不反映软件的实际设计方式。这并不是说应用程序设计没有其他有价值的工件。它们通常包含在索引卡，白板快照，鸡尾酒餐巾纸和其他类似媒体上，为应用程序设计提供了一种时间表。这些通常是应用程序的真实规格。如果你要写一个Word文档，（我并不是特别说你应该）在项目结束时这样做。至少它会准确地代表代码中已完成的工作，并可能像QA团队或下一版本开发人员那样帮助其他人。

答案 178 :(得分：7)

最佳做法是危险因素，因为它们要求我们用口号代替思考。

答案 179 :(得分：7)

社交技能比技术技能更重要

具有良好社交技能的普通程序员可以比那些不喜欢的优秀程序员更加成功。

答案 180 :(得分：7)

我有争议的意见： OO编程被大大高估[并且像银弹一样对待]，当它真的只是工具箱中的另一个工具时，仅此而已！

答案 181 :(得分：7)

大多数编程求职面试问题毫无意义。尤其是程序员所想出的那些。

这是一种常见的情况，至少根据我的＆amp;我的朋友经历，在哪里膨胀 程序员，问你一些棘手的wtf他花了几周谷歌搜索。有趣的是，你回家并在一分钟内谷歌。这就像他们经常试图用他们的精密武器来打败你，而不是检查你是否是一个全面，务实的团队合作者。

类似的愚蠢IMO是当你被要求提供高度可访问的基础知识时，例如：“等等，让我看看你是否可以在一张纸上伪编码insert_name_here - 算法（原文如此！） ”。在申请高级编程工作时，我真的需要记住它吗？我应该有效地解决问题或难题吗？

答案 182 :(得分：7)

工具，方法，模式，框架等不能替代经过适当培训的程序员

我厌倦了与人（主要是经理）打交道，他们认为最新的工具，方法，模式或框架是一个银弹，可以消除雇用有经验的开发人员编写软件的需要。虽然，作为一名拯救风险项目的顾问，我不应该抱怨。

答案 183 :(得分：7)

最简单的方法是最好的方法

程序员喜欢解决假定或推断的需求，这些需求会增加解决方案的复杂程度。

“我认为这段代码将成为性能瓶颈，因此我将添加所有这些额外的代码来缓解这个问题。”

“我假设用户想要做X，因此我会添加这个非常酷的附加功能。”

“如果我让我的代码解决这个不必要的场景，那将是一个很好的机会来使用我一直有兴趣尝试的这项新技术。”

实际上，满足要求的最简单的解决方案是最好的。如果出现新的要求或问题，这也为您提供了最灵活的解决方案。

答案 184 :(得分：7)

例外情况只能用于真正例外情况

似乎异常的使用在我最近工作的项目中猖獗。

以下是一个例子：

我们有拦截网络请求的过滤器。过滤器调用筛选器，筛选器的工作是检查请求是否具有某些输入参数并验证参数。设置要检查的字段，抽象类确保参数不为空，然后调用特定类实现的screen（）方法进行更多的扩展验证：

public boolean processScreener(HttpServletRequest req, HttpServletResponse resp, FilterConfig filterConfig) throws Exception{           
            // 
            if (!checkFieldExistence(req)){
                    return false;
            }
            return screen(req,resp,filterConfig);
    }

checkFieldExistance（req）方法从不返回false。如果没有缺少任何字段，则返回true;如果缺少字段，则返回异常。

我知道这是糟糕的设计，但问题的一部分是这里的一些建筑师认为每次遇到意外事件时都需要抛出异常。

另外，我知道checkFieldExistance（req）的签名会抛出异常，它就像我们几乎所有的方法一样 - 所以我没想到该方法可能抛出异常而不是返回false。直到我挖出代码才发现它。

答案 185 :(得分：7)

有争议的呃？我认为C ++流使用＆lt;＆lt;和＆gt;＆gt;。我讨厌它。他们是轮班经营者。以这种方式重载它们是非常糟糕的做法。这让我想要杀死那些提出这个想法的人，并认为这是一个好主意。哎呀。

答案 186 :(得分：7)

“评论是谎言”

评论不会运行，很容易被忽略。最好用单元测试说明的清晰的重构代码来表达意图。 （单元测试TDD当然......）

我们不会写评论，因为它们冗长而且模糊了代码中真正发生的事情。如果您觉得需要发表评论 - 找出代码中不清楚的内容并重构/编写更清晰的测试，直到不需要评论......

......我从极限编程中学到的东西（当然假设你已经建立了清理代码的团队规范......）

答案 187 :(得分：7)

现代C ++是一种优美的语言。

在那里，我说了。很多人真的很讨厌C ++，但老实说，我发现使用STL / Boost风格编程的现代C ++在大多数时候都是一种非常富有表现力，优雅且极其富有成效的语言。

我认为大多数讨厌C ++的人都是基于OO的糟糕体验。 C ++不能很好地执行OO，因为多态通常依赖于堆分配的对象，而C ++没有自动垃圾回收。

但是，当涉及通用库和函数编程技术时，C ++确实很有用，这使得构建非常大，高度可维护的系统成为可能。很多人都说C ++会尝试做所有事情，但最终却什么都不做。我可能会同意它不像其他语言那样做OO，但它比任何其他主流的基于C语言的通用编程和函数式编程 更好 。 （C ++ 0x只会进一步强调这一事实。）

我也很欣赏C ++如何让我在必要时获得低级别，并提供对操作系统的完全访问权。

加RAII。认真。当我使用其他基于C语言编程时，我真的很想念析构函数。 （不，垃圾收集不会使析构函数变得无用。）

答案 188 :(得分：7)

JavaScript是一种“混乱”的语言，但上帝帮助我，我喜欢它。

答案 189 :(得分：7)

使用单元测试作为验证代码的最后手段。

如果我想验证代码是否正确，我更喜欢以下技术而不是单元测试：

  1. 类型检查
  2. 断言
  3. 简单可验证的代码

    4. 对于其他一切，都有单元测试。

答案 190 :(得分：7)

不是真的编程，但我不能仅仅为了它而忍受css布局。它反效果，令人沮丧，并使维护成为浮动和边缘的噩梦，改变单个元素的位置可能会使整个页面失控。

这绝对不是一个流行的观点，但我在20分钟内完成了我的桌面布局，而css大师花了几个小时调整行高，边距，填充和浮动只是为了做一些基本的事情，垂直居中一个段落。

答案 191 :(得分：6)

我坚信非托管代码不值得麻烦。与追踪内存泄漏相关的额外可维护性开支，即使是最好的程序员偶尔引入也远远超过从C ++这样的语言中获得的性能。如果Java，C＃等无法获得所需的性能，请购买更多的机器。

答案 192 :(得分：6)

全球和/或单身人士本身并不是邪恶的

我来自更多的sysadmin，shell，Perl（和我的“真正的”编程），PHP类型的背景;去年我被扔进了Java开发工具。

单身人士是邪恶的。全球是如此邪恶，甚至不被允许。然而，Java有像AOP这样的东西，现在有各种“依赖注入”框架（我们使用的是Google Guice）。 AOP少了，但DI的东西肯定会给你什么？全局。呃，谢谢。

答案 193 :(得分：6)

我认为在VS中使用C＃中的区域完全可以在VS中折叠代码。太多人试图说它隐藏了你的代码并且很难找到东西。但是如果你正确使用它们，它们对识别代码段很有帮助。

答案 194 :(得分：6)

根据我得到的反馈量，我最有争议的意见显然是programmers don't always read the books they claim to have read。紧接着我的观点是a programmer with a formal education is better than the same programmer who is self-taught（但不一定比一个自学成才的不同程序员更好）。

答案 195 :(得分：6)

你不应该满足于找到“有效”代码的第一种方式。

我真的不认为这应该引起争议，但事实确实如此。人们在代码的其他地方看到了一个例子，来自在线，或者从1999年的一本旧的“自学高级SQL SQL #BeansServer在3.14159分钟”一书中看到的一个例子，他们认为他们知道一些东西并将它们复制到他们的代码中。他们没有通过示例来了解每条线的作用。他们没有考虑他们的程序的设计，看看是否可能有更有条理或更自然的方式来做同样的事情。他们没有试图保持他们的技能组合最新，以了解他们正在使用上一个千年的最后一年中弃用的想法和方法。他们似乎没有经验可以了解他们复制的东西多年来为程序员带来了特定的可怕维护负担，并且可以通过更多的思考来避免它们。

事实上，他们似乎甚至没有意识到可能有不止一种方法可以做某事。

我来自Perl世界，其中一个口号是“有多种方法可以做到”。 （TMTOWTDI）那些粗略看过Perl的人把它写成“只写”或“不可读”，很大程度上是因为他们看过上面描述的思维模式的人写的蹩脚代码。那些人没有考虑设计，可维护性，组织，减少代码重复，耦合，内聚，封装等等。他们写了废话。这些人存在各种语言的编程，易于学习的语言有很多方法可以为他们提供足够的绳索和枪支来自杀。同时进行。

但是，如果你在Perl世界中徘徊的时间超过粗略的外观，并观察社区中的长期人在做什么，你会看到一个了不起的事情：优秀的Perl程序员花一些时间寻找最好的做某事的方法。当他们命名一个新模块时，他们会四处询问建议并将他们的想法从人们身上反弹。他们将代码交给他们进行查看，批评和修改。如果他们必须做一些令人讨厌的事情，他们会以最小的方式将其封装在一个模块中，以便以更有条理的方式使用。同一个想法的几个实现可能会暂时搁置一段时间，但它们竞争思想共享和市场份额，并且他们通过努力做到最好来竞争，其中很大一部分是通过使自己易于维护。非常好的Perl程序员似乎认为 很难关于他们正在做的事情并寻找最好的做事方式，而不仅仅是抓住第一个通过大脑的想法。

今天我主要在Java世界中编程。我已经看到了一些非常好的Java代码，但是我也看到了很多垃圾，我看到了我在开头描述的更多心态：人们解决了第一个似乎有用的丑陋代码，而不了解它，不用考虑是否有更好的方法。

您将在每种语言中看到两种心态。我并不是要特意谴责Java。 （实际上我在某些方面非常喜欢它......也许这应该是我真正有争议的意见！）但我相信每个程序员都需要花费几年的时间来使用TMTOWTDI风格的语言，因为即使传统观念认为这导致混乱和蹩脚的代码，它实际上似乎产生了一些人，他们明白你需要考虑你正在做的事情的影响，而不是相信你的语言被设计成让你做正确的事情毫不费力。

我认为你可以在另一个方向上走得太远：即完美无视你的真正需求和目标的完美主义（通常是你企业的真正需求和目标，通常是盈利能力）。但是，如果没有学会投入一些超过平均水平的努力来考虑找到最佳（或至少一种最好的）方式来编写他们正在做的事情，我认为任何人都不可能成为真正优秀的程序员。

答案 196 :(得分：6)

意见：不应该有任何编译器警告，只有错误。或者，以不同的方式表达您应该始终使用-Werror 编译代码。

原因：编译器认为它应该被纠正，如果它应该是一个错误，或者没有必要修复，在这种情况下编译器应该关闭。

答案 197 :(得分：6)

VB糟透了
虽然一般来说并不是非常有争议，但当你在VB的房子里工作时，它就是

答案 198 :(得分：6)

关系型数据库是浪费时间。请改用对象数据库！

关系数据库供应商试图欺骗我们相信世界上唯一可扩展，持久和安全的存储是关系数据库。我是经过认证的DBA。您是否曾花费数小时尝试优化查询并且不知道出了什么问题？关系数据库不允许您在需要时创建自己的搜索路径。您将对应用程序速度的大部分控制权交给了您从未见过的人，而且他们并不像您想象的那么聪明。

当然，有时在维护良好的数据库中，他们会为复杂的查询提供快速答案。但是你付出的代价太高了！每次要读取数据条目时都必须选择编写原始SQL，这很危险。或者使用Object关系映射器，它会增加更多的复杂性和控制之外的东西。

更重要的是，您被主动禁止提出智能搜索算法，因为每次该数据库的往返都需要大约11毫秒。实在是太多了。想象一下，你知道这个超级图算法会在适当的时候回答一个特定的问题，这个问题在SQL中甚至可能无法表达。但即使你的算法是线性的，有趣的算法也不是线性的，忘记将它与关系数据库结合起来，因为枚举大表会花费你几个小时！

将它与SandstoneDb或Gemstone for Smalltalk进行比较！如果你是Java，请给db4o一个机会。

所以，我的建议是：使用object-DB。当然，它们并不完美，有些查询会变慢。但是你会惊讶地发现有多少会更快。因为加载对象不需要SQL和域数据之间的所有这些奇怪的转换。如果你确实需要某个查询的速度，那么对象数据库就有你应该信任的查询优化器：你的大脑。

答案 199 :(得分：6)

两个大脑比一个好看

我坚信，在提高代码质量和编程效率方面，结对编程是最重要的因素。不幸的是，对于那些认为“更多的手=＆gt;更多代码=＆gt; $$$！”的管理层来说，这也是一个极具争议性的问题。

答案 200 :(得分：6)

<强> 1。你不应该一直遵循网络标准。

<强> 2。您无需评论您的代码。

只要陌生人可以理解。

答案 201 :(得分：6)

由于有数百个答案可能最终未读，但不管怎么说，这是我的宠儿。

如果你是程序员，那么你很可能在网页设计/开发

对于程序员来说，这个网站是一个非凡的资源，但如果您正在寻找XHTML / CSS帮助，那么这个网站绝对是一个非常糟糕的地方。即使是优秀的Web开发人员也会发布90年代优秀资源的链接！

当然，XHTML和CSS很容易学习。但是，你不只是学习一门语言！您正在学习如何使用它，很少有设计人员和开发人员可以做到这一点，更不用说程序员了。我花了很长时间才成为一名有能力的设计师，甚至更长时间成为一名优秀的开发人我可以从10岁起编写HTML代码，但这并不意味着我很好。现在我是Photoshop和Illustrator等程序的有能力的设计师，我完全能够在记事本中编写一个好的网站，并且能够用多种语言编写基本脚本。不仅如此，我对搜索引擎优化技术有着良好的认识，并且很容易告诉你大多数人出错的地方（暗示：获得一些好的内容！）。

此外，这个地方是关于网络标准建议的可怕资源。您不应该只编写代码以在不同的浏览器中工作。您应始终遵循标准，以便将来验证您的代码。在下一次浏览器更新出现时，您在网站上使用的修补程序通常会中断。不仅如此，好的浏览器还是遵循标准。最后，IE被允许破坏互联网的原因是因为你允许它通过为IE编码你的网站！如果你要继续为Firefox做这个，那么我们将再次失败！

如果您认为基于表格的布局同样好，如果不比CSS布局好，那么您不应该被允许谈论这个主题，至少在没有我先击败你的情况下。此外，如果您认为W3Schools是送别人的最佳资源，那么您就是完全错误的。

如果您是Web Design / Development的新手，请不要理会这个地方（它充满了程序员，而不是Web开发人员）。转到一个好的网页设计/开发社区，如SitePoint。

答案 202 :(得分：6)

您无法通过计算代码行来衡量效率。

每个人都知道这一点，但由于某种原因，这种做法仍然存在！

答案 203 :(得分：6)

这不是工具，是你

每当开发人员尝试做一些新的事情，比如做UML图表，任何类型的图表，项目管理，他们首先寻找解决问题的完美工具。经过无休止的搜索，找不到合适的工具，他们的动机挨饿剩下的就是关于缺乏可用软件的抱怨。有鉴于此，有组织的计划在没有软件的情况下就会死亡。

嗯，只有你自己才能与组织打交道。如果您习惯于组织，您可以在有或没有软件的帮助下（大多数没有）进行组织。如果您不习惯组织，没有人可以帮助您。

所以“没有合适的软件”只是根本没有组织的最简单的借口。

答案 204 :(得分：6)

反映在生产代码中没有位置

反射破坏了静态分析，包括重构工具和静态类型检查。反思也打破了开发人员对代码的正常假设。例如：向类中添加一个方法（不会影响类中的其他方法）应该永远不会产生任何影响，但是当使用反射时，其他一些代码可能会“发现”新方法并决定叫它。实际上确定这样的代码是否存在是难以处理的。

我认为在代码生成器中使用反射和测试很好。

是的，这确实意味着我试图避免使用反射的框架。 （Java缺乏正确的编译时元编程支持太糟糕了）

答案 205 :(得分：6)

垃圾收集被高估

许多人认为在Java中引入垃圾收集是与C ++相比最大的改进之一。我认为介绍最好是非常小的，编写良好的C ++代码在适当的位置（使用RAII等技术）完成所有内存管理，因此不需要垃圾收集器。

答案 206 :(得分：6)

不要害羞，抛出异常。 异常是一种完全有效的信号失效方式，并且比任何返回代码系统都要清晰得多。 “Exceptional”与这种情况发生的频率无关，而且与该类认为正常执行条件的内容有关。当除数为零时抛出异常就好了，无论情况发生的频率如何。如果问题可能发生，请保护您的代码，以便不会使用不正确的参数调用该方法。

答案 207 :(得分：6)

在许多情况下，使用正则表达式解析HTML很好

每次有人在Stack Overflow上发布一个问题，询问如何使用正则表达式实现一些HTML操作，第一个答案是“正则表达式是一个不足以解析HTML的工具，所以不要这样做”。如果提问者试图建立一个网络浏览器，这将是一个有用的答案。然而，通常提问者想要做一些事情，比如在某个域的所有链接上添加一个rel标记，通常是在可以对传入标记的样式做出某些假设的情况下，这是一个非常合理的事情。一个正则表达式。

答案 208 :(得分：5)

编写广泛的规范是徒劳的。
编写正确的程序非常困难，但编译器，调试器，单元测试，测试器等可以检测并消除大多数错误。另一方面，当您编写具有与程序（即伪代码，UML）相当的详细程度的规范时，您大多数都是您自己的。如果你有一个可以帮助你正确理解语法的工具，那就认为自己很幸运。

广泛的规范很可能是错误的。
作者在第一次尝试时得到它的机会大致相同，就像一个类似的大型程序在没有经过测试的情况下无错误的机会。同行评论消除了一些错误，就像代码审查一样。

答案 209 :(得分：5)

程序员需要与客户交谈

一些程序员认为他们不需要与客户交谈。对于贵公司来说，这是一种肯定的方式，可以写出一些绝对精彩的东西，没有人可以解决它的用途或者如何使用它。

您不能指望产品经理和业务分析师做出所有决策。实际上，程序员应该在创建模块或功能的1000个（通常很小的）决策中做出990，否则产品将永远不会发货！因此，请确保您的决定得到通知。了解您的客户，与他们合作，观看他们使用您的软件。

如果你要编写最好的代码，你希望人们使用它。感兴趣的是你的用户群，并从那里的“愚蠢的白痴”中学习。不要害怕，他们真的会爱你。

答案 210 :(得分：5)

较低的camelCase是愚蠢和无意义的

使用较低的camelCase使名称/标识符（从这一点使用的“名称”）看起来像一个由两部分组成的东西。然而，Upper CamelCase清楚地表明所有单词都属于一起。

匈牙利表示法是不同的 ...因为名称的第一部分是类型指示符，因此它与名称的其余部分具有不同的含义。

有些人可能认为较低的camelCase应该用于函数/过程，特别是在类内部。这在Java和面向对象的PHP中很流行。但是，没有理由这样做来表明它们是类方法，因为通过它们可以访问的方式它们变得非常清楚，这些只是那个。

一些代码示例：

# Java
myobj.objMethod() 
# doesn't the dot and parens indicate that objMethod is a method of myobj?

# PHP
$myobj->objMethod() 
# doesn't the pointer and parens indicate that objMethod is a method of myobj?

Upper CamelCase对类名和其他静态名称很有用。所有非静态内容都应该通过访问它们的方式来识别，而不是通过它们的名称格式（！）

来识别

这是我的同源代码示例，其中名称行为由除名称之外的其他内容指示...（另外，我更喜欢使用下划线来分隔名称中的单词）。

# Java
my_obj = new MyObj() # Clearly a class, since it's upper CamelCase
my_obj.obj_method() # Clearly a method, since it's executed
my_obj.obj_var # Clearly an attribute, since it's referenced

# PHP
$my_obj = new MyObj()
$my_obj->obj_method()
$my_obj->obj_var
MyObj::MyStaticMethod()

# Python
MyObj = MyClass # copies the reference of the class to a new name
my_obj = MyObj() # Clearly a class, being instantiated
my_obj.obj_method() # Clearly a method, since it's executed
my_obj.obj_var # clearly an attribute, since it's referenced
my_obj.obj_method # Also, an attribute, but holding the instance method.
my_method = myobj.obj_method # Instance method
my_method() # Same as myobj.obj_method()
MyClassMethod = MyObj.obj_method # Attribute holding the class method
MyClassMethod(myobj) # Same as myobj.obj_method()
MyClassMethod(MyObj) # Same as calling MyObj.obj_method() as a static classmethod

所以，我对camelCase的完全 ob 主观意见。

答案 211 :(得分：5)

在我的工作场所，我一直在尝试引入更多敏捷/ XP开发习惯。连续设计是我迄今为止最感受到的阻力。也许我不应该把它称为“让所有的建筑团队围捕并射击他们”......;）

答案 212 :(得分：5)

手动停止程序是一种有效且经过验证的查找性能问题的方法。

可信？不是最重要的。真正？绝对

程序员的判断力远远超过必要。

在这些帖子中见证所有被认为是“邪恶”或“可怕”的事情。

程序员对数据结构感到满意。

见证所有关于类，继承，私有 - 公共，内存管理等的讨论，以及如何分析需求。

答案 213 :(得分：5)

默认情况下，数组应该是基于1而不是基于0。系统实现语言不一定是这种情况，但像Java这样的语言吞噬了比它们应有的更多的C奇怪。 “元素1”应该是第一个元素，而不是第二个元素，以避免混淆。

计算机科学不是软件开发。毕竟，你不会雇用一名只研究物理的工程师。

尽可能多地学习数学。你不会使用大部分内容，但你需要能够以这种方式擅长软件。

标准化的单一最佳编程语言是Common Lisp，即使它是冗长的并且具有从零开始的数组。这主要来自于设计方式 编写计算，而不是冯·诺依曼机器的抽象。

编程语言的所有比较批评中至少有90％可以简化为“语言A具有功能C，我不知道如何在语言B中执行C或类似的东西，因此语言A更好。”< / p>

“最佳实践”是我所见过的最令人印象深刻的拼写“平庸”的方法。

答案 214 :(得分：5)

转到可以！（足够有争议）
有时......所以给我们选择！例如，BASH没有goto。也许这有一些内在的原因但仍然存在。
此外，goto是汇编语言的构建块。不，如果你的声明！ ：）

答案 215 :(得分：5)

意见：数据驱动设计将推车置于马前。它应该从我们的思想中消除。

绝大多数软件不是关于数据，而是关于我们试图为客户解决的业务问题。它是关于问题域，它涉及对象，规则，流程，案例和关系。

当我们使用数据开始设计，并在数据和数据（表，外键和x-to-x关系）之间的关系之后对系统的其余部分进行建模，我们将整个应用程序约束为如何数据存储在数据库中并从数据库中检索。此外，我们将数据库体系结构公开给软件。

数据库架构是一个实现细节。我们应该可以自由地改变它，而不必显着改变我们软件的设计。业务层永远不必知道如何设置表，或者是从视图或表中提取表，还是从动态SQL或存储过程中获取表。这种类型的代码应该 从不 出现在表示层中。

软件是关于解决业务问题。我们处理用户，汽车，帐户，余额，平均值，摘要，转移，动物，消息，包裹，购物车，订单以及各种其他真实有形物品，以及我们可以对它们执行的操作。我们需要保存，加载，更新，查找，删除这些项目如所须。有时，我们必须以特殊方式做这些事情。

但是没有真正令人信服的理由我们应该在数据库中完成应该完成的工作并将其从数据中移除并将其放在源代码中，可能在单独的机器上（引入网络流量并降低性能） 。这样做意味着要背弃已经完成的数十年的工作，以提高内置于数据库中的存储过程和函数的性能。存储过程引入“另一个API”的论点是好奇的：当然它确实存在;该API是一个保护您免受数据库模式影响的外观，包括主键和外键，事务，游标等的复杂细节，它可以防止您必须在源代码中将SQL拼接在一起。

将马放回购物车前面。考虑问题域，并围绕它设计解决方案。然后，从问题域派生数据。

答案 216 :(得分：5)

不是很有争议的AFAIK但是...... 在创造这个词之前，AJAX已经出现了，每个人都需要“放手”。人们正在将它用于各种各样的事情。但是没有人真正关心它。

然后突然发生了战祸！有人创造了这个词，每个人都加入了AJAX的行列。突然之间，人们现在成为AJAX的专家，好像动态加载数据的“专家”之前并不存在。我认为这是导致互联网残酷破坏的最大因素之一。那和“Web 2.0”。

答案 217 :(得分：5)

原始数据类型是过早优化。

只有一种数据类型，即标量可以获得语言，它们就可以了。其他语言并不是那么幸运。开发人员只需要输入“int”和“double”，因为他们必须写一些东西。

重要的不是数据类型的大小，而是数据的用途。如果你有一个月中的某一天变量，如果它是有符号或无符号的，或者它是char，short，int，long，long long，float，double还是long double，则无关紧要。重要的是它是一个月中的某一天，而不是一个月，或一周中的某一天，或者其他什么。请参阅乔尔的专栏，了解错误的事情;最初建议的匈牙利符号是一个好主意。在实践中使用它，它几乎是无用的，因为它说错了。

答案 218 :(得分：5)

继承是邪恶的，应该弃用。

事实上，聚合在所有情况下都更好。静态类型的OOP语言无法避免继承，它是描述类型所需方法的唯一方法。但动态语言和鸭子打字可以没有它。 Ruby mixins比继承更强大，而且更可控。

答案 219 :(得分：5)

<强> Variable_Names_With_Bloody_Underscores

甚至更糟

<强> CAPITALIZED_VARIABLE_NAMES_WITH_BLOODY_UNDERSCORES

应该全球覆盖......带有偏见！ CamelCapsAreJustFine。 （Glolbal常数不能承受）

GOTO声明供11岁以下的开发人员使用

任何不支持指针的语言都不配名称

.Net = .Bloat 微软致力于网站开发的最好例子（Expressionless Web 2） 是写过的缓慢膨胀的最好的例子。 （尝试使用Web Studio）

响应： 好吧，让我稍微解决一下Underscore问题。从您提供的C链接：

- 全局常量应该全部带有'_'分隔符。 我实际上同意这一点，因为它是如此BLOODY_OBVIOUS

- 例如NetworkABCKey。注意来自ABC的C和来自键的K是如何混淆的。有些人不介意这个，有些人只是讨厌它，所以你会在不同的代码中找到不同的政策，所以你永远不知道该怎么称呼。

我属于前一类。我非常谨慎地选择名字，如果你不能一眼就知道K属于Key，那么英语可能不是你的第一语言。

  • C函数名称

    • 在C ++项目中，应该只有很少的C函数。
    • 对于C函数，使用带有'_'的所有小写字母的GNU约定作为单词分隔符。

理由

* It makes C functions very different from any C++ related names.

实施例

INT    some_bloody_function（）    {    }

这些“标准”和惯例只是随着时间推移而作出的任意决定。我认为，虽然它们具有一定的逻辑意义，但它们会使代码变得混乱，并使一些应该简短易读的东西，笨拙，冗长和混乱。

C已被采纳为事实上的标准，不是因为它很友好，而是因为它很普遍。我可以使用语法友好的高级语言在20中编写100行C代码。

这使程序流程易于阅读，众所周知，在一年或更长时间后重新访问代码意味着在整个地方跟踪面包屑。

我确实使用下划线，但对于全局变量只是因为它们很少而且很远，它们很明显。除此之外，一个经过深思熟虑的CamelCaps（）函数/变量名称还没让我失望！

答案 220 :(得分：5)

大多数'用户友好型'第四代语言（包括SQL）都是毫无价值的高估垃圾，这些垃圾本来就不应该被普遍使用。

4GL通常具有冗长而模糊的语法。尽管4GL应该允许“非技术人员”编写程序，但仍然需要“技术”人员来编写和维护它们。

一般来说，4GL程序更难编写，更难阅读，更难以优化。

应尽可能避免使用4GL。

答案 221 :(得分：5)

调试器是一个拐杖。

这是有争议的，即使我不像以前那么多地相信它。

Con：我花了更多的时间来快速了解其他人的大量代码，所以任何有助于“我是如何到达这里”和“正在发生的事情”的任何事情，无论是验尸还是验尸都会有所帮助。 / p>

亲：但是，我很高兴地认为，如果您不了解自己开发的代码或者您熟悉的代码的问题的答案，那么将所有时间花在调试器上并不是解决方案，这是问题的一部分。

在点击“发布你的答案”之前，我对这个确切的短语进行了快速Google检查，结果发现我不是唯一持有此观点或使用过这句话的人。我在Fog Creek软件论坛上找到了a long discussion of this very question，该论坛引用了包括Linus Torvalds在内的各种名人作为值得注意的支持者。

答案 222 :(得分：5)

有太多的程序员写了太多的代码。

答案 223 :(得分：5)

关注点分离是邪恶的：）

如果你有充分的理由，只能单独关注。否则，不要将它们分开。

我只是为了分离而遇到过多次分离。 Dijkstra的声明“最小耦合，最大凝聚力”的下半部分不应该被遗忘。 ：）

很高兴进一步讨论这个问题。

答案 224 :(得分：5)

我讨厌大学和研究所为新来的人提供编程教学的短期课程。对艺术 1 和编程科学来说，这是完全的耻辱和蔑视。

他们开始向人们教授C，Java，VB（恶心），而没有很好地掌握计算机的硬件和基本原理。 应首先通过Morris Mano的计算机系统架构等书籍来教授 MACHINE ，然后教导指导机器解决问题的概念而不是蚀刻语义和一种编程语言的语法。

此外，我不了解政府学校，大学教授儿童使用商业操作系统和软件的计算机基础知识。至少在我的国家（印度），没有多少学生购买操作系统，甚至折扣办公套装，更不用说开发软件的主宰（编译器，IDE等）。这会引发盗窃和盗版行为，并使其从学院图书馆复制和窃取软件的行为成为一种正当行为。

他们再次被教导使用一些产品而非基本思想。

如果你被教导的只是2x2是4而不是乘法的概念吗？

或者，如果你现在被教导要测量倾向于学校某些复合墙的杆的长度，而不是毕达哥拉斯定理

答案 225 :(得分：5)

设计模式在软件设计和开发方面浪费时间。

不要误解我的意思，设计模式很有用，但主要是作为通信载体。他们可以非常简洁地表达复杂的想法：工厂，单身，迭代器......

但它们不应该作为一种开发方法。开发人员经常使用一系列基于设计模式的类来构建他们的代码，在可读性和性能方面，更简洁的设计会更好。所有这些都表明个别类可以在其域外重用。 如果某个类不是为重用而设计的，或者不是该接口的一部分，那么它就是一个实现细节。

设计模式应该用于将名称放在组织特征上，而不是规定必须编写代码的方式。

（它应该是有争议的，还记得吗？）

答案 226 :(得分：5)

Microsoft Windows是软件开发的最佳平台。

<强>推理： 微软以优秀且廉价的开发工具破坏其开发人员，该平台及其API已有详细记录，该平台正以惊人的速度发展，为开发人员创造了大量机会。操作系统拥有庞大的用户群，这对于明显的商业化非常重要原因是，有一个很大的Windows开发者社区，我还没有因为选择微软而被解雇。

答案 227 :(得分：5)

我可以在没有封闭的情况下生活。

现在看起来每个人和他们的母亲都希望闭合语言存在于一种语言中，因为它是自切片面包以来最伟大的发明。而且我认为这只是另一种炒作。

答案 228 :(得分：5)

保持业务逻辑不受数据库限制。或者至少保持它非常精益。让DB做它想做的事情。让代码执行代码的目的。周期。

  

如果你是一个单人表演（基本上，傲慢和自负，不仅因为你在控制中而不是听别人的智慧），你可以按照自己的意愿行事。因为你要求开始，我不相信你是那样的。但是在谈到这个问题时我遇到了一些问题，并认为有必要指明。

     

如果您使用DBA但是自己的数据库工作，请在业务对象，它们与数据库之间的网关以及数据库本身之间保持明确定义的分区。

     

如果您与DBA一起工作并且不允许执行您的数据库工作（无论是通过政策还是因为他们都是premadonnas），您就非常接近于成为一个傻瓜，让您依赖它们来完成任何工作数据库实体中的代码相关业务逻辑（sprocs，函数等）。

     

如果您是DBA，请让开发人员保持他们的数据库实体清洁＆amp;稀。

答案 229 :(得分：5)

BAD IDE使编程语言变弱

良好的编程IDE确实更容易使用某些语言并且更好地监督。我的职业生涯中有点被宠坏了，我工作过的公司总是有最新的Visual Studio可供使用。

大约8个月，我在我的工作旁边做了很多Cocoa，Xcode编辑器使用这种语言太困难了。超载很难找到，处理打开文件的总体方式只会让你的屏幕变得非常麻烦，非常快。这真是一种耻辱，因为Cocoa是一种很酷且功能强大的语言。

当然顽固的Xcode粉丝现在会投票支持我的帖子，但有很多IDE真的好多了。

人们转向IT，谁不应该

这是我去年的博客文章的复制/粘贴。

我的经验主要是关于荷兰市场，但它们也可能适用于任何其他市场。

我们（因为我将所有软件工程师组合在一起）目前处于对我们来说非常好的市场中。无论价格如何，公司都在拼命地试图获得软件工程师（从现在开始的SE）。如果您现在切换工作，您可以要求几乎任何您想要的东西。在荷兰，现在有一种趋势，就是让2辆租赁汽车找到工作，只是为了让你为他们工作。这有多奇怪？我怎么能同时驾驶2辆车呢？

当然这对我们来说听起来非常好，但这也会造成一种非常不健康的情况。

例如： 如果您目前正在为一家快速发展的公司工作，而您正在努力吸引更多的同事，最终从地面开始进行一些认真的软件开发，那么在没有提供高薪的情况下就找不到任何人。试图找到优质的同事是非常困难的。由于工资很高，很多人都被我们的工作所吸引，但这也意味着很多没有正确激情的人正在进入我们的市场。

激情，是的，我认为这是正确的词。当你对工作充满热情时，你的工作不会在05:00 PM停止。您将整夜刷新所有开发RSS源。您将在互联网上搜索可能在工作中使用的最新技术。你将在一个月内开始大约十几个新的“有前途”的项目，看看你是否可以掌握几周前刚刚阅读的最新技术（并找到实际使用该技术的有用方法）。

没有这种激情，市场可能会看起来非常好（因为汽车，金钱，当然还有我们吸引的辣妹），但我认为它不会那么有趣，让我们说：消防员或者战斗机飞行员。

听起来我想在这里保护自己的工作，部分原因是这样。但我也试图保护自己免受我不想与之合作的人的伤害。我想就我读到的内容进行激烈的讨论。我希望能够和那些对我的工作具有同样“热情”的人保持激情。我希望有正确理由与我合作的同事。

我在找那些人!!

答案 230 :(得分：5)

评论不好

每当代码需要注释来解释它在做什么时，代码就太复杂了。我总是尝试编写足够自我解释的代码，以便不需要很多注释。

答案 231 :(得分：5)

HTML 5 + JavaScript将成为未来最常用的UI编程平台.Flash，Silverlight，Java Applets等等都将死于沉默的死亡

答案 232 :(得分：5)

没有人关心您的代码

如果您没有参与政府安全检查项目并且您没有融资，那么很可能没有人关心您在公司/客户群之外的工作。没有人嗅探包或试图入侵你的机器来阅读你的源代码。这并不意味着我们应该对安全性轻率，因为肯定会有许多人只是想要造成一般性破坏并破坏您的辛勤工作，或者访问贵公司可能拥有的存储信息，例如信用卡数据或身份数据。块。但是，我认为人们过分关注其他人访问您的源代码并采纳您的想法。

答案 233 :(得分：5)

记事本是一个完美的文本编辑器。 （有时用于非Windows换行的wordpad）

  • 编辑配置文件
  • 查看日志文件
  • 开发

我知道真正相信这一点的人！然而，他们将使用IDE进行开发，但继续使用记事本来完成其他任务！

答案 234 :(得分：5)

应要求所有项目经理都有编码任务

在我工作的团队中，项目经理实际上是一名程序员，他能够很好地理解代码的技术问题以完成编码任务，所做出的决策缺乏通信在项目经理团队中经常发生的情况。不参与代码。

答案 235 :(得分：5)

如果不值得测试，则不值得建设

答案 236 :(得分：5)

从长远来看，开源软件的成本更高

对于常规业务线公司，开源看起来是免费的，但隐藏成本。

当您考虑到质量不一致，可变可用性和UI / UX，互操作性和标准的困难，配置增加，相关的培训和支持需求增加时，开源的总体拥有成本远远高于商业产品

精通技术的程序员类型解放开源并运行它;他们“得到它”并且可以采用它并根据他们的目的进行定制。另一方面，主要是非技术性但需要软件来运行其办公室，网络和网站的企业面临着自身痛苦的世界风险以及在时间，生产力和（最终）支持方面的巨大成本费用和/或放弃体验的费用。

答案 237 :(得分：4)

应禁止调试器。这会迫使人们编写可通过单元测试测试的代码，最终会带来更好的代码质量。

删除副本＆amp;从所有编程IDE粘贴。复制＆amp;粘贴的代码非常糟糕，应该完全删除此选项。然后程序员可能会懒得重新输入所有代码，所以他创建了一个函数并重用了代码。

每当你使用Singleton时，自己拍打。单身几乎从来都不是必需的，而且大部分时间只是一个全局变量的奇特名称。

答案 238 :(得分：4)

每当你向外界公开一个可变类时，你应该提供事件来观察它的变异。额外的努力也可能说服你让它永远不变。

答案 239 :(得分：4)

实施IDisposable的类库指南错误。

我不经常分享这个，但我认为IDisposable的默认实施指南是完全错误的。

我的问题不在于Dispose的重载，而是从最终化中删除了项目，而是，我鄙视如何调用在终结器中释放托管资源。我个人认为应该抛出一个异常（是的，因为将它抛到终结器线程上而产生的所有肮脏）。

背后的原因是，如果您是IDisposable的客户端或服务器，则可以理解您不能简单地将对象放在最后。如果你这样做，这是一个设计/实现缺陷（取决于它是如何留在周围和/或它是如何暴露的），因为你不知道你应该注意的实例的生命周期。

我认为这种类型的错误/错误是在竞争条件/与资源同步的级别上。不幸的是，通过调用Dispose的重载，该错误​​永远不会实现。

编辑：如果有人有兴趣，我写了一篇关于这个主题的博客文章：

http://www.caspershouse.com/post/A-Better-Implementation-Pattern-for-IDisposable.aspx

答案 240 :(得分：4)

QA应该（间接地）比开发更好地了解代码。质量保证得到报酬，发现事情并不打算发生，他们经常这样做。 :)（顺便说一句，我是一个开发人员，他很重视那些优秀的QA人员 - 远远少于他们......很少见。）

答案 241 :(得分：4)

虽然我完全支持测试驱动开发（TDD），但我认为在开发人员开始整个开发周期的原型设计问题解决方案之前，这是至关重要的一步。

我们经常会陷入困境，试图按照我们的TDD惯例寻找可能导致错误解决的解决方案，因为我们对该域名不太了解。简单的原型通常可以解释这些问题。

原型非常棒，因为与第一次（有时）编写测试时相比，您可以快速完成并丢弃更多代码。然后，您可以使用空白的平板开始开发过程，但需要更好的理解。

答案 242 :(得分：4)

重用代码与其“可重用性”成反比。仅仅因为“可重用”代码更复杂，而快速破解很容易理解，因此它们可以重复使用。

软件故障应该取消系统，以便可以检查和修复它。试图处理故障情况的软件通常比崩溃更糟糕。也就是说，崩溃后系统重置是否更好，还是应该无限期挂起，因为失败处理程序有错误？

答案 243 :(得分：4)

Java并不是最好的东西。仅仅因为它带有“企业”贴纸并不能让它变好。它也不会让它变得快速。它也不是每个问题的答案。

此外，ROR并非完全被Blogsphere破解。

在我看来，OOP并不总是好的。事实上，我认为这通常很糟糕。

答案 244 :(得分：4)

意见：大多数代码都很糟糕，因为这是程序员想要的。

间接地，我们一直在培养极端创造力的文化。并不是说我不认为解决问题有创造性的元素 - 它确实 - 它甚至与绘画之类的东西都不一样（参见Paul Graham着名的“黑客与画家”杂文）。

如果我们向这个方法倾斜我们的行业，最终它意味着让每个程序员前进并打击他们想要的任何高度创造性，疯狂的东西。当然，对于任何规模较大的项目，尝试将数十个不相关的，非结构化的，未计划的位组合成一个最终的相干位将无法按定义工作。这不是猜测，也不是估计，而是我们今天所面临的行业状况。你有多少次在主要程序中看到与其余代码完全不一致的功能子位？它现在如此普遍，任何人都会使用任何这些混乱的奇迹。

令人困惑，复杂，丑陋的东西不断变得更糟，更不稳定。如果我们正在构建一些物理的东西，地球上的每个人都会打电话给我们看看这些东西是多么丑陋和搞砸了，但是因为它或多或少是虚拟的隐藏，我们能够摆脱一些最糟糕的制造过程我们的物种将永远看到。 （你能想象一辆四种不同的人以四种不同的方式设计四种不同车轮的车吗？）

但悲伤的部分，这一切的争议部分，是绝对没有理由这样做，除了历史上文化是朝着更多的自由和更少的组织，所以我们保持这种方式（可能变得更糟）。软件开发是一个笑话，但这是一个笑话，因为这是程序员所希望的（但是在一百万年内绝不会承认这是真的，“管理人员的情节”对大多数人来说是一个更好的理由）。

在我们醒来之前，我们会在脚下射击自己多久，并意识到那些持枪的人，指着它并扣动扳机？

保罗。

答案 245 :(得分：4)

未注释的代码是人类的祸根。

我认为评论是必要的。他们在视觉上将其划分为逻辑部分，并在阅读代码时提供替代表示。

文档注释是最基本的，但使用注释来拆分更长的函数有助于编写新代码并在返回现有代码时更快地进行分析。

答案 246 :(得分：4)

我们是软件开发人员，而不是C / C＃/ C ++ / PHP / Perl / Python / Java / ...开发人员。

在您接触了几种语言之后，选择一种新语言并提高效率是一项小任务。也就是说你不应该害怕新语言。当然，生产和掌握语言之间存在很大差异。但是，没有理由回避你从未见过的语言。当人们说“我是PHP开发人员”时，它会让我感到困惑。或者当工作机会说“Java开发人员”时。在成为开发人员几年后，新的语言和API确实不应该是令人生畏的，从没有看到语言变得富有成效，不应该花费很长时间。我知道这是有争议的，但这是我的观点。

答案 247 :(得分：4)

当有人认为整个编程语言“笨拙”时，通常会发现他不知道如何使用它。

答案 248 :(得分：4)

有时候吞下异常是合适的。

对于UI铃声和wistles，提示用户输入错误信息是一种冲突，而且无论如何他们根本没有任何东西可以做。在这种情况下，我只需记录它，并在它显示在日志中时处理它。

答案 249 :(得分：4)

“一切都应尽可能简单，但并不简单。” - 爱因斯坦。

答案 250 :(得分：4)

“程序员是天生的，而非制造的。”

答案 251 :(得分：4)

我相信Zen of Python

答案 252 :(得分：4)

可以保护您的申请。

每当有人问一个关于如何阻止用户盗用他们的应用程序或将其从黑客手中保护下来的问题时，答案就是这是不可能的。废话。如果你真的相信这一点，那么就把门打开（或者把它们从房子里取出来！）。也不要去看医生。你是凡人 - 试图治愈疾病只是推迟了不可避免的事情。

仅仅因为某人可能能够盗用您的应用或破解您的系统并不意味着您不应该尝试减少将会这样做的人数。你真正在做的是让它需要比入侵者/海盗愿意做更多的工作。

就像一个门闩和ADT在你的房子将保持窃贼，合理的反盗版和安全措施将使黑客和海盗不受你的影响。当然，他们闯入的诱惑力越大，你需要的安全性就越高。

答案 253 :(得分：4)

获得计划报酬通常是男人时间最糟糕的用途之一。

首先，你与Elbonians竞争，他们每天工作四分之一。你需要说服你的雇主你提供了Elbonians永远不能做的事情，并且你的东西值得一个宜居的薪水。随着Elbonians越来越多的海外业务，真正的优势消耗殆尽，管理层知道它。

另一方面，你花时间解决别人的问题。是时候你可以花时间来提升自己的兴趣，或者解决你真正感兴趣的问题。如果你认为你通过解决其他人的问题来拯救世界，那你为什么不让Elbonians为你做这件事呢？

最后，软件（visicalc，Napster，Pascal等）的重大创新并非由小隔间农场创建。它们是由一两个人创建的，没有预付款。你不能强行重新创建它。当一个称职的程序员有一个非常好的主意时，有时候会发生魔术。

有足够的软件。有足够的软件开发人员。你不必是一个雇用的人。节省你的才能，时间，头发，婚姻。让别人把他的灵魂卖给键盘。如果你想编程，那很好。但是不要为钱而这样做。

答案 254 :(得分：4)

Linq2Sql并不是那么糟糕

我遇到了很多垃圾Linq2Sql的帖子。我知道这不完美，但是什么呢？

就我个人而言，我认为它有它的缺点，但总的来说它可以用于原型设计或开发中小型应用程序。当我考虑花了多少时间来编写无聊的DAL代码时，我不能抱怨，特别是考虑到我们不久前的替代品。

答案 255 :(得分：4)

软件开发人员，编码人员，程序员，架构师之间没有区别......

我已经在这个行业中使用了超过10种酵母，并且仍然发现尝试区分这些“角色”绝对是愚蠢的。你写代码？你是开发人员。您花了一整天时间绘制精美的UML图表。你是......好吧......我不知道你是什么，你可能只是想给别人留下深刻的印象。 （是的，我知道UML）。

答案 256 :(得分：4)

“程序员必须在旁边进行编程，否则他们就不会像那些人一样好。”

正如kpollock所说，想象一下，对于医生或士兵来说......

主要的不是他们是否编码，而是他们是否考虑过。计算科学是一项智力练习，你不一定需要编写代码来思考让你作为程序员更好的问题。

当他离开他的研究时，爱因斯坦并不喜欢玩粒子和波浪。

答案 257 :(得分：4)

三元运营商绝对不好意思。它们是懒惰屁股编程的缩影。

user->isLoggedIn() ? user->update() : user->askLogin();

这很容易搞砸。修订版＃2略有改动：

user->isLoggedIn() && user->isNotNew(time()) ? user->update() : user->askLogin();

哦，是的，还有一个“小改变。”

user->isLoggedIn() && user->isNotNew(time()) ? user->update() 
    : user->noCredentials() ? user->askSignup
        : user->askLogin();

哦，废话，那个案件怎么样？

user->isLoggedIn() && user->isNotNew(time()) && !user->isBanned() ? user->update() 
    : user->noCredentials() || !user->isBanned() ? user->askSignup()
        : user->askLogin();

不，不，不。只需保存代码更改即可。别再懒得了：

if (user->isLoggedIn()) {
    user->update()
} else {
    user->askLogin();
}

因为第一次做正确的事情将使我们所有人不必再转换你的垃圾三元组并重新开始：

if (user->isLoggedIn() && user->isNotNew(time()) && !user->isBanned()) {
    user->update()
} else {
    if (user->noCredentials() || !user->isBanned()) {
        user->askSignup();
    } else {
        user->askLogin();
    }
}

答案 258 :(得分：4)

程序编程很有趣。 OOP很无聊。

答案 259 :(得分：4)

严格遵守标准阻碍了简单化。

MVC对网站的评分过高。它主要是VC，有时是M。

答案 260 :(得分：4)

小代码总是更好，但后来很复杂？：而不是if-else让我意识到有时大代码更具可读性。

答案 261 :(得分：3)

设计开发率为80％，编码开发率为20％

我相信开发人员应该花费80％的时间在精细的细节设计，他们将要构建的内容，并且只有20％实际编码他们设计的内容。这将产生几乎零错误的代码，并在测试 - 修复 - 重新测试周期中节省很多。

提前到达金属（或IDE）就像是过早优化，这被认为是万恶之源。周到的前期设计（我不一定会谈论巨大的设计文档，白板上的简单图纸也会起作用）将产生比编码和修复更好的结果。

答案 262 :(得分：3)

将XML存储在关系数据库中的CLOB中通常是一种可怕的伪造。它不仅在性能方面很可怕，还将正确管理数据结构的责任从数据库架构师转移到应用程序员。

答案 263 :(得分：3)

宏，预处理器说明和注释是邪恶的。

请为每个文件提供一种语法和语言！

//不适用于Make文件或插入实际代码的编辑器宏。

答案 264 :(得分：3)

Web的MVC应该比传统的MVC简单得多。

传统MVC涉及“侦听”“事件”的代码，以便可以不断更新视图以反映模型的当前状态。但是，在Web范例中，Web服务器已经进行了监听，请求就是事件。因此，Web的MVC只需要是中介模式的特定实例：控制器在视图和模型之间进行调解。如果正确地制作了Web框架，则可重用的核心应该不超过100行。该核心只需要实现“页面控制器”范例，但应该是可扩展的，以便能够支持“前端控制器”范例。

下面是一个方法，它是我自己的框架的关键，在财富100强网络硬件制造商为财富50强媒体公司制造的嵌入式消费设备中成功使用。我的方法被一位前Smalltalk程序员和一本关于最着名的Java Web框架的Oreilly书的作者比作Smalltalk;此外，我已将相同的框架移植到mod_python / psp。

static function sendResponse(IBareBonesController $controller) {
  $controller->setMto($controller->applyInputToModel());
  $controller->mto->applyModelToView();
}

答案 265 :(得分：3)

PHP文件中的HTML过多：有时是必要的

PHP文件中过多的Javascript：触发猛禽攻击

虽然我很难确定你在 echo 和？＆gt;＆lt;之间的所有转换？ ？php的ing html（毕竟，php只是html的处理器），添加的javascript行和行使它成为一个完全无法维护的混乱。

人们必须掌握这一点：它们是两种独立的编程语言。选择一个作为您的主要语言。然后继续寻找一种快速，干净且易于维护的方法，使您的主要语言包括第二语言。

你一直在PHP，Javascript和HTML之间跳跃的原因是因为你们三个都不好。

好吧，也许它并不是完全有争议的。我的印象是这是一个令人沮丧的令人沮丧的主题：）

答案 266 :(得分：3)

随时随地使用类型推断。

编辑：

以下是几个月前我写的关于我为何会这样做的博客文章的链接。

http://blogs.msdn.com/jaredpar/archive/2008/09/09/when-to-use-type-inference.aspx

答案 267 :(得分：3)

扩展方法是魔鬼的工作

每个人似乎都认为.Net中的扩展方法是自切片面包以来最好的方法。唱赞歌的开发商数量似乎在不断增加，但恐怕我不禁鄙视他们，除非有人能提出我尚未听过的精彩理由或榜样，否则我永远不会写一。我最近遇到了这个thread，我必须说阅读最高投票额度的例子让我觉得有点像呕吐（当然是比喻）。

其扩展优点的主要原因是提高了可读性，提高了OO-ness以及更好地链接方法调用的能力。

我担心我必须有所不同，我发现事实上他们明确地说，由于他们的核心是谎言这一事实​​而降低了可读性和OO-ness。如果你需要一个作用于对象的实用程序方法，那么编写一个对该对象起作用的实用程序方法不会骗我。当我看到aString.SortMeBackwardsUsingKlingonSortOrder然后字符串应该有该方法，因为这告诉我一些关于字符串对象的东西，而不是关于AnnoyingNerdReferences.StringUtilities类的东西。

LINQ的设计方式是链接方法调用是必要的，以避免奇怪和不舒服的表达式，LINQ引起的扩展方法是可以理解的，但通常链式方法调用会降低可读性并导致我们看到的类型的代码模糊的Perl竞赛。

因此，简而言之，扩展方法是邪恶的。抛弃撒旦的锁链并承诺免费扩展代码。

答案 268 :(得分：3)

开发团队应该更多地通过技术/架构层而不是业务功能进行隔离。

我来自一般文化，开发人员拥有“从网页到存储过程的所有内容”。因此，为了在系统/应用程序中实现一个功能，他们将准备数据库表模式，编写存储过程，匹配数据访问代码，实现业务逻辑和Web服务方法，以及网页界面。

猜猜是什么？每个人都有自己的做事方式！每个人都在努力学习ASP.NET AJAX和Telerik或Infragistic套件，企业库或其他生产力和数据层和持久性框架，面向Aspect的框架，日志和缓存应用程序块，DB2或Oracle percularities。你猜怎么着？每个人都花了很长时间来学习如何以正确的方式做事！意思是，同时存在很多错误以及由此产生的大量缺陷和性能瓶颈！还有更长的时间来解决它们！跨越每一层！每个人都参与每个Visual Studio项目。没有人专门处理和选择一个问题/技术领域。太多的厨师破坏了汤。所有厨师都会产生一些放射性粘液。

开发人员可能有跨层/域责任，但他们不应假装自己可以成为所有学科的主人，并且应该仅限于少数几个。根据我的经验，当一个项目不是一个小项目并且使用大量技术时，在单个层中覆盖更多业务功能比覆盖整个架构的更少业务功能更高效（以及鼓励更多测试代码测试该层） stack（激励开发人员仅通过他们的UI而不是测试代码进行测试）。

答案 269 :(得分：3)

XHTML是邪恶的。写HTML

无论如何，您必须将MIME类型设置为text / html，那么为什么要自欺欺人地相信您真的在编写XML？无论谁下载你的页面，都会相信它是HTML，所以把它变成HTML。

有了这个，请随意和高兴不关闭你的＆lt; li＆gt;，这是没有必要的。不要关闭html标签，无论如何文件都已结束。它是有效的HTML，可以完美地解析。

它将创建更易读，更少样板代码，您不会丢失任何东西。 HTML解析器工作得很好！

完成后，转到HTML5。这个比较好。

答案 270 :(得分：3)

Hibernate对开发人员的思想无用且有害。

答案 271 :(得分：3)

这个并不完全是编程，因为 html / css 不是编程语言。

表格适用于布局

css和divs不能做任何事情，为自己省去麻烦并使用简单的表格，然后在它上面使用css。

答案 272 :(得分：3)

最新的设计模式往往是蛇油。正如之前在这个问题中所说的那样，过度使用设计模式可能会损害设计，而不仅仅是帮助它。

如果我再听到一个人说“每个人都应该使用IOC”（或者一些类似的粪便），我想我会被迫追捕他们并告诉他们他们的方式错误。

答案 273 :(得分：3)

Upfront设计 - 不要只是开始编写代码，因为您很乐意编写代码

我见过很多设计很差的应用程序，因为开发人员非常兴奋地编写代码，他们只是打开了一个白页并开始编写代码。我知道在开发生命周期中事情会发生变化。但是，使用从表单到表单，方法到方法的几种不同布局和开发方法的应用程序很难处理。

如果您没有明确定义任务以及计划如何编写任务，那么很难达到应用程序要处理的目标。花一些时间（而不仅仅是5分钟）并确保在开始编码之前已经尽可能多地布置了它。这样你就可以避免替代品必须支持的意大利面条。

答案 274 :(得分：3)

女性比男性做出更好的程序员。

我与之合作的女性程序员并没有像男人那样坚持“他们的”代码。他们对批评和新想法更加开放。

答案 275 :(得分：3)

如果您只考虑一种方法，请不要这样做。

无论是界面布局，任务流程还是代码块，只需停止。做一些事情来收集更多的想法，比如询问其他人如何做，并且在你至少有三个完全不同的想法和至少一个信任危机之前不要再实施。

一般来说，当我认为某些事情只能以某种方式完成，或者认为只有一种方法有任何优点时，这是因为我没有仔细考虑应该对设计产生足够影响的因素。如果我有，他们中的一些人显然会发生冲突，导致混乱，从而导致实际的决定，而不是死记硬背。

成为一名优秀的程序员并不能使您成为一名可靠的界面设计师

遵循世界上所有的界面指南只会开始提供帮助。如果它甚至在人类的可能性......似乎有一种特殊的成瘾，让事情“可爱”和“聪明”。

答案 276 :(得分：3)

程序员将他们（自己极少有限的愚蠢）编程语言视为神圣的宗教信仰。

程序员几乎像宗教信徒那样进行这些讨论是如此有趣：没有批评者允许，（通常）没有客观的讨论，（经常）基于非常有限或缺乏的知识和信息进行辩论。要获得确认，请阅读以前的答案，尤其是评论。

同样有趣并且另一个确认：根据“给我一个有争议的意见”这个问题的定义，任何争议意见都不应该有资格获得负面投票 - 实际上相反：争议越多越好。但是我们的程序员如何反应：像巴甫洛夫的狗一样，对不喜欢的观点投反对票。

PS：为了公平，我赞成其他人。

答案 277 :(得分：3)

不应将成员变量声明为私有（在java中）

如果您声明某些私有内容，则会阻止任何未来的开发人员从您的类派生并扩展其功能。从本质上讲，通过编写“私有”，你暗示你现在比以往开发人员可能知道的更多地了解你的课程。每当你写“私人”时，你应该写“受保护”。

绝不应将类声明为final（在java中）

同样，如果你将一个类声明为final（这会阻止它被扩展 - 阻止它被用作继承的基类），那么你暗示你比任何未来的程序员都知道的更多，关于什么是你正确使用班级的正确方法。这从来都不是一个好主意。你什么都不知道。有人可能会想出一个非常合适的方法来扩展你没有想到的课程。

Java Bean是一个糟糕的主意。

java bean约定 - 将所有成员声明为private，然后为每个成员编写get（）和set（）方法 - 强制程序员编写样板文件，容易出错，繁琐且冗长的代码，其中没有代码需要。只需将公共成员变量公开！如果您需要更改实施，请相信您以后更改它的能力（提示：99％的时间，您永远不会）。

答案 278 :(得分：3)

控制反转不会消除依赖关系，但它确实可以很好地隐藏它们。

答案 279 :(得分：3)

良好的表现VS优雅的设计

它们并不是相互排斥的，但我无法忍受过度设计的类结构/框架，它们完全不了解性能。我不需要有一串新的This（new That（new Whatever（）））;创造一个物体，告诉我早上5点哦，顺便说一下，这是奥巴马生日前的217天，周末是2天。我只是想知道健身房是否开放。

在2之间取得平衡是至关重要的。当您需要抽出所有处理器执行密集的操作（例如读取数TB的数据）时，代码需要变得讨厌。为占用10％资源的地方保存优雅，这可能超过代码的90％。

答案 280 :(得分：3)

软件开发是计算机科学的一小部分。

人们有时似乎认为这两者是同义词，但实际上计算机科学有很多方面，普通开发人员很少（如果有的话）接触到这些方面。根据一个人的职业目标，我认为有很多CS毕业生可能会更好地接受某种软件工程教育。

我高度重视教育，拥有计算机科学学士学位，并且正在兼职攻读硕士学位，但我认为很多获得这些学位的人都把学位视为达到目的的手段，并且收益很少。我知道有很多人参加了我所学过的系统软件课程，写了我写的同一个汇编程序，直到今天看不出他们做了什么。

答案 281 :(得分：3)

那个，嗯，人们应该评论他们的代码？这周似乎很有争议......

代码只告诉我实际上它做了什么;不是应该做什么

我看到一个计算point value of an Australian Bond Future的函数的时间是我想看到一些注释，指出编码器认为计算应该是什么的时间！

答案 282 :(得分：3)

启用多个结帐 如果我们改进了开发人员的足够纪律，我们将通过自动合并源代码控制从这个设置中获得更高的效率。

答案 283 :(得分：3)

学校教育废墟创造力 *

*“废墟”的意思是“潜在的废墟”

当然，需要上学！每个人在使用它之前都需要学习东西 - 然而，如果我们不小心的话，你所拥有的关于如何针对特定业务领域做出某种策略的所有好主意很容易被抛入我们的深层脑中。

当你学习新事物并掌握新技能时，你也会对这些新事物和技能进行拳击，因为它们显然是“做事的方式”。作为人类，我们倾向于倾听当局 - 无论是教师，顾问，同事，还是您喜欢的网站/论坛。我们应该始终意识到我们的思维方式的“缺陷”。听听其他人说的话，但不要把他们说的理所当然。始终对您收到的每一条新信息保持批评的观点。

而不是想“哇，这很聪明。我将从现在开始使用它”，我们应该想“哇，这很聪明。现在，我怎样才能在我的个人技能和创意工具箱中使用它。”

答案 284 :(得分：3)

生成记录良好的代码所花费的时间少于记录不充分的代码

当我说记录良好的时，我的意思是评论会在每一步都清楚地表达您的意图。是的，输入注释需要一些时间。是的，你的同事应该都足够聪明，通过阅读你的描述性函数和变量名称，并通过所有可执行语句来理解你的意图。但是，如果你刚刚解释了你的意图，那么它需要花费更多的时间来完成它，当代码的逻辑证明是错误的时候，清晰的文档特别有用。不是你的代码会出错......

我坚信，如果你从开始项目到运送无缺陷产品的时间，那么编写记录良好的代码会花费更少的时间。首先，必须清楚地解释你正在做的事情会迫使你清楚地思考它，如果你不能写清楚，简洁的解释你的代码正在完成什么，那么它可能设计得不好。而另一个纯粹自私的原因是，记录良好且结构良好的代码更容易转移到其他人维护 - 从而释放原作者去创造下一个重要的东西。我很少有必要停止我正在做的事情来解释我的代码是如何工作的，因为对于任何能够阅读英语的人来说这显然是显而易见的（即使他们不能阅读C / C ++ / C＃等）。还有一个原因，坦率地说，我的记忆力并不是那么好！我不记得我昨天吃的早餐了，更不用说我在一个月或一年前编写代码时的想法了。也许你的记忆远远超过我的记忆，但是因为我记录了我的意图，我可以快速拿起我离开的地方并做出改变，而不必先弄清楚我写作时的想法。

这就是为什么我记录得很好 - 不是因为我觉得有一些高贵的要求可以产生适合显示的漂亮代码，而不是因为我是纯粹主义者，而只是因为端对端它让我能在更短的时间内发布优质软件

答案 285 :(得分：3)

永远不要让最好的做法或模式痴迷你。

这些应该是指导方针，而不是一成不变的法律。

而且我非常喜欢这些模式，GoF书或多或少都是这样说的，浏览的东西，提供了一个常用的术语。不是球和链的福音。

答案 286 :(得分：3)

有时可以使用正则表达式从HTML中提取内容。严重的是，使用钝语解析器进行争论，或使用像/<a href="([^"]+)">/这样的快速正则表达式？它并不完美，但是你的软件启动和运行得更快，你可以使用另一个正则表达式来验证提取的匹配实际上是一个URL。当然，这很糟糕，并且可能在几个边缘情况下失败，但它对于大多数用途来说已经足够了。

基于大量的“如何使用正则表达式获取HTML？”几乎每天都会在这里发布的问题以及每个答案都是“使用HTML解析器”的事实，这应该是有争议的。

答案 287 :(得分：3)

清理和重构在（团队）开发中非常重要

团队发展的很多工作都与管理有关。如果您使用的是错误跟踪器，那么只有当有人花时间关闭/构建事物并降低票证数量时，它才有用。如果您正在使用源代码管理，则需要在此处进行清理并经常重新构建存储库。如果你是编程，那么应该有人关心重构其他人的懒惰产品。这是软件开发过程中大部分方面的一部分。

每个人都同意这种管理的必要性。它总是第一件被跳过的东西！

答案 288 :(得分：3)

  1. 良好的架构是成长的，而非设计的。

  2. 管理人员应确保他们的团队成员始终低于他们的最新技术水平，无论那个级别如何。当人们在他们的舒适区工作时，他们会产生更高质量的代码。

答案 289 :(得分：3)

许多开发人员对于放置内容的地方缺乏了解，导致文件，类和方法级别的源代码组织混乱。此外，相当大比例的此类开发人员对代码组织问题基本上是聋哑人。试图教导，哄骗，威胁或羞辱他们以保持代码清洁是徒劳的。

在任何一个足够成功的项目中，通常都有一个开发人员，他们非常安静地使用扫帚到代码库来保持熵。

答案 290 :(得分：3)

我有争议的观点可能是John Carmack（ID Software，Quake等）并不是一个非常优秀的程序员。

不要误会我的意思，我认为他是一个非常聪明的程序员，但在我注意到地震源代码中的“#define private public”之后，我忍不住认为他是一个让工作完成的人没有什么，但在我的定义中不是一个优秀的程序员:) 这个意见让我进入了很多热烈的讨论;）

答案 291 :(得分：3)

软件不是工程学科。

我们永远不应该让计算机逃离数学系。

答案 292 :(得分：3)

使用存储过程易于维护且部署较少 vs 使用ORM是OO方式因此很好

我在很多项目中都听过很多这样的话，当这些陈述出现时，总是很难解决这个问题。

答案 293 :(得分：3)

如果编程语言的语法不直观，我并不关心编程语言是多么强大，我不能将它放在一边等待一段时间，并且不需要花太多精力刷新细节就可以回到它。我宁愿一种语言本身是直观的，而不是神秘而强大的创建DSL。计算机语言是ME的用户界面，我希望它的设计与任何其他用户界面一样，易于使用。

答案 294 :(得分：3)

理解“做什么”至少与了解“如何”做同样重要，而且几乎总是比知道解决问题的“最佳”方式重要得多。特定领域的知识对于编写优秀的软件通常至关重要。

答案 295 :(得分：3)

缺陷和增强请求相同

除非您使用固定价格合同开发软件，否则在优先处理“错误”和“增强功能”以及“新功能”请求之间的待办事项时应该没有区别。好吧 - 也许这没有争议，但我曾参与过企业IT项目，其中的规定是“所有未解决的漏洞必须在下一版本中得到修复”，即使这没有让开发人员有时间获得最理想的新功能。因此，1％的用户遇到的问题，1％的时间优先于新功能，可能对90％的用户立即有用。我喜欢把我的整个项目积压，对每个项目进行估算并将其带到用户社区进行优先排序 - 项目未归类为“缺陷”，“增强”等。

答案 296 :(得分：3)

软件开发是一门艺术。

答案 297 :(得分：3)

在所有案例中，评论都是邪恶的：http://gooddeveloper.wordpress.com/

答案 298 :(得分：3)

我永远是对的。

或者通过讨论称之为设计。但如果我提出一些建议，你最好能够证明我错的原因，并提出一个你可以辩护的替代方案。

当然，这只有在我合情合理的情况下才有效。幸运的是，我是。 ：）

答案 299 :(得分：3)

可用性问题绝不是用户的错误。

当一些用户做了团队中每个人都认为“只是一件蠢事”的事情时，我无法计算问题出现的频率。像“为什么有人这样做？”这样的短语或者“他为什么不做XYZ”通常会出现。

尽管许多人厌倦了听到我这样说：如果现实生活中的用户试图做一些不起作用，导致出错或导致意外行为的事情，那么这可能是任何人的错，但< em>不用户的！

请注意，我并不是指故意滥用该软件的人。我指的是该软件的可能目标群。

答案 300 :(得分：3)

德尔福很有趣

是的，我知道它已经过时了，但Delphi是一个非常有趣的开发工具。

答案 301 :(得分：3)

低级语言不适合大多数问题。

答案 302 :(得分：3)

程序员不应该触摸Word（或PowerPoint）

除非您正在开发单词或文档处理工具，否则不应触及仅发出二进制blob的Word处理器，并且就此而言：

生成的XML文件是二进制blob

程序员应该写纯文本文档。程序员编写的文档只需传达意图，而不是格式化。它必须可以使用编程工具链来生成：编辑器，版本控制，搜索实用程序，构建系统等。当您已经拥有并知道如何使用该工具链时，其他所有文档制作工具都会浪费时间和精力。

当需要为非程序员生成文档时，应使用轻量级标记语言，例如reStructuredText（如果您正在编写纯文本文件，那么您可能正在编写自己的轻量级标记），并从中生成HTML，PDF，S5等。

答案 303 :(得分：3)

详细的设计是浪费时间，如果工程师需要它们来做一份体面的工作，那么就不值得使用它们了！

好的，所以这里有几个想法：

1）waterfall开发的旧概念，你应该事先做好所有设计，产生一些美化极其详细的类图，序列图等等，这完全是浪费时间。正如我曾经对一位同事所说，一旦代码完成，我将完成设计。我认为敏捷部分地认识到 - 代码是设计，任何体面的开发人员都在不断重构。当然，这使得您的班级图表过时可笑 - 他们总是如此。

2）管理层经常认为你可以有用地聘请一个糟糕的工程师并将它们用作“代码猴” - 换句话说，他们并不是特别有才能，但是他们 - 你不能用它们来写一些代码。嗯..不！如果你必须花费这么多时间编写详细的规范，而你基本上是在指定代码，那么自己编写它会更快。你不是在节省任何时间。如果开发人员不够聪明，无法运用自己的想象力和判断力，那么他们就不值得使用。 （注意，我不是在谈论能够学习的初级工程师。很多'高级工程师'属于这一类。）

答案 304 :(得分：3)

为数据访问层创建单元测试时，应直接从数据库检索数据，而不是从模拟对象中检索。

请考虑以下事项：

void IList<Customer> GetCustomers()
{
  List<Customer> res = new List<Customer>();

  DbCommand cmd = // initialize command
  IDataReader r = cmd.ExecuteQuery();

  while(r.read())
  {
     Customer c = ReadFiledsIntoCustomer(r);
     res.Add(c);
  }

  return res;
}

在GetCustomers的单元测试中，是否应该调用cmd.ExecuteQuery（）实际访问数据库，还是应该模拟它的行为？

我认为如果以下情况属实，你不应该模拟对DB的实际调用：

  1. 存在测试服务器和架构。
  2. 架构稳定（意味着您不希望对其进行重大更改）
  3. DAL没有智能逻辑：查询是简单构建的（配置/存储过程） 而且绝望化逻辑很简单。

    4. 根据我的经验，这种方法的好处是你可以尽早与数据库进行交互，尝试“感觉”，而不仅仅是“外观”。它为您节省了许多麻烦，是熟悉模式的最佳方式。

    许多人可能会争辩说，只要执行流程越过流程边界，它就会陷入单元测试。我同意它有它的缺点，特别是当数据库不可用时，你就无法运行UT。

    但是，我认为在许多情况下这应该是有效的事情。

答案 305 :(得分：3)

程序员应该不惜一切代价避免通过继承隐藏方法。

根据我的经验，几乎我所见过的每一个地方继承的方法隐藏都会导致问题。通过基类型引用与派生类型引用访问时，方法隐藏导致对象的行为不同 - 这通常是一件坏事。虽然许多程序员没有正式意识到它，但大多数人直观地认为对象将遵循Liskov Substitution Principle。当对象违背了这种期望时，面向对象系统固有的许多假设都可能开始磨损。我见过的最令人震惊的案例是隐藏方法改变对象实例的状态。在这些情况下，对象的行为可能会以难以调试和诊断的微妙方式发生变化。

好的，所以可能会出现一些不常见的情况，即方法隐藏实际上是有用且有益的 - 就像在不支持它的语言中模拟方法的返回类型协方差一样。但绝大多数时候，当开发人员使用方法隐藏它时，要么是出于无知（或偶然），要么是为了解决一些可能需要更好的设计处理的问题。一般来说，我看到的方法隐藏的有益情况（并不是说没有其他方法）是一个返回某些信息的无副作用的方法被一个计算更适用于调用上下文的东西隐藏。 / p>

像C＃这样的语言通过在隐藏基类方法的方法上要求new关键字来改进一些东西 - 至少有助于避免非自愿地使用方法隐藏。但我发现许多人仍然将new的含义与override的含义混淆 - 特别是因为在简单的情况下，他们的行为可能看起来相同。如果像FxCop这样的工具实际上有用于识别方法隐藏的潜在错误用法的内置规则，那将是很好的。

顺便说一句，通过继承隐藏的方法不应该与其他类型的隐藏混淆 - 例如通过嵌套 - 我认为这是一个有效且有用的构造，并且潜在问题较少。

答案 306 :(得分：3)

匿名函数很糟糕。

我正在教自己jQuery，虽然它是一种优雅且非常有用的技术，但大多数人似乎都将它视为最大化匿名功能用户的某种竞争。

函数和过程命名（以及变量命名）是我们在编程中最大的表达能力。将函数作为数据传递是一种很好的技术，但是将它们设为匿名因此非自我记录是一个错误。这是表达代码含义的失败机会。

答案 307 :(得分：3)

永远不要改变未破坏的东西。

答案 308 :(得分：3)

如果您曾经让任何来自rentacoder.com的人触摸您的项目，那么它和您的业务都完全没有价值。

答案 309 :(得分：3)

我有两个：

设计模式有时是程序员编写错误代码的一种方式 - “当你有锤子时 - 全世界看起来像钉子”的心态。如果有一些我讨厌的东西是两个开发人员按模式创建设计：“我们应该使用带有外观的命令......”。

没有“过早优化”这样的事情。您应该在达到这一点之前对代码进行分析和优化，直到它变得太痛苦为止。

答案 310 :(得分：3)

只有一种设计模式：封装

例如：

  • 工厂方法：您已封装对象创建
  • 策略：您封装了不同的可变算法
  • 迭代器：你封装了顺序访问集合中元素的方法。

答案 311 :(得分：3)

大小很重要！修饰您的代码，使其看起来更大。

答案 312 :(得分：3)

Java是我们这一代的COBOL。

每个人都学会编码。它的代码在大公司中运行，试图让它运行数十年。与其他所有选择相比，每个人都鄙视它，但无论如何都被迫使用它，因为它支付账单。

答案 313 :(得分：2)

成为一名优秀的程序员确实需要在该领域的多个方面工作：应用程序开发，系统（内核）工作，用户界面设计，数据库等。有一些共同的方法，以及特定于工作的一个方面的某些方法。您需要学习如何像Java编码器一样编写Java编程，而不是像C ++编码器那样编程，反之亦然。用户界面设计非常困难，并且使用大脑的不同部分而不是编码，但在代码中实现该UI也是另一项技能。不只是没有“一种”编码方法，而是只有一种编码方式。

答案 314 :(得分：2)

如果你有合适的工具并且花时间正确编写它，该软件可以没有bug。

答案 315 :(得分：2)

意见：没有函数定义，返回类型可以生成灵活可读的代码。

这种观点可能更适用于解释语言而不是编译。需要一个返回类型和一个函数参数列表，对于像intellisense这样自动记录代码的东西很有用，但它们也是限制。

现在不要误解我的意思，我不是说抛弃返回类型或参数列表。他们有自己的位置。而且90％的时间他们更多的是受益而不是障碍。

有时候和地方有用。

答案 316 :(得分：2)

如果没有远程调试器，则无法编写Web应用程序

Web应用程序通常将客户端和服务器端的多种语言之间的交互联系在一起，需要来自用户的交互，并且通常包括第三方代码，可以是从简单API实现到拜占庭框架的任何内容。

当我进入并通过一个体面的远程调试器跟踪复杂的Web应用程序中的实际情况时，我已经失去了我让另一位开发人员和我坐在一起的次数，看到他们大吃一惊并惊讶于此存在这样的工具。即使在看到它们的实际操作之后，它们通常仍然不会麻烦地安装和设置这些类型的工具。

您无法使用print语句调试非平凡的Web应用程序。如果你没有修改你的应用程序中的所有代码，那么十次。

如果您的调试器可以浏览所有正在使用的语言，并向您显示发生的http事务，那就更好了。

如果没有Firebug，您无法开发Web应用程序

沿着类似的路线，一旦你使用了Firebug（或非常接近等价物），你会看到任何试图开发混乱的恐怖和恐怖的Web应用程序的人。特别是Firebug显示计算样式，如果你记得回到不使用它并花费数小时随机改变CSS的各个部分并在太多地方添加“！important”以便有趣，你将永远不会回去。

答案 317 :(得分：2)

信不信由你，我相信，在OO语言中，，大​​多数（业务逻辑）代码在类的数据上运行应该在类本身，这对我的团队来说是异端邪说。

答案 318 :(得分：2)

2个空格缩进。

没有讨论。它必须是这样的; - ）

答案 319 :(得分：2)

Code as Design: Three Essays by Jack W. Reeves

任何软件的源代码都是其最准确的设计文档。其他所有内容（规范，文档，有时还有评论）都是错误的，过时的或误导性的。

保证让你几乎无处不在。

答案 320 :(得分：2)

Tcl / Tk是有史以来最好的GUI语言/工具包组合

它可能缺少特定的小部件，并且不如块中的新孩子好看，但它的模型优雅且易于使用，可以通过交互式键入命令更快地构建工作GUI 而不是使用可视化界面构建器。它的表现力是无与伦比的：其他解决方案（Gtk，Java，.NET，MFC ......）通常需要10到100个LOC来获得与Tcl / Tk单线程相同的结果。所有这些都没有牺牲可读性或稳定性。

pack [label .l -text "Hello world!"] [button .b -text "Quit" -command exit]

答案 321 :(得分：2)

令我感到有趣的是，这个问题很有趣，我刚刚阅读了第一页的答案，到目前为止，我还没有找到一个有争议的意见。

也许这更多地说明了stackoverflow产生共识的方式比其他任何东西都要多。也许我应该从最底层开始。 ： - ）

答案 322 :(得分：2)

依赖管理软件会带来更多危害

我参与过包含一百多个不同库的Java项目。在大多数情况下，每个库都有自己的依赖项，这些依赖库也有自己的依赖项。

像Maven或Ivy这样的软件应该通过自动获取每个库的正确版本然后以递归方式获取其所有依赖项来“管理”这个问题。

问题解决了，对吧？

错误。

下载库是依赖关系管理的 easy 部分。困难的部分是创建软件的心理模型，以及它如何与所有这些库交互。

我不受欢迎的意见是：

如果你不能口头解释，除了头脑，项目中所有库之间的基本交互，你应该消除依赖，直到你可以。

同样，如果列出所有库（及其方法）直接或间接从您的某个函数调用所花费的时间超过10秒，那么您在管理依赖项方面做得很差。 / p>

您应该能够轻松回答“我的应用程序的哪些部分实际上依赖于XYZ库？”的问题。

当前的依赖管理工具弊大于利，因为它们可以轻松创建不可能复杂的依赖图，并且它们几乎不提供减少依赖性或识别问题的功能。

我见过开发人员包含10或20 MB的库，在项目中引入了数千个依赖类，只是为了消除几十行简单的自定义代码。

使用库和框架可能会很好。但总是有一个成本，并且模糊成本的工具本质上存在问题。

此外，有时（注意：当然不总是）通过编写一些实现完全所需内容的小类来重新发明轮子，而不是引入对大型通用库的依赖性

答案 323 :(得分：2)

goto有一些（很少）合法用途（特别是在C中，作为异常处理的替代品）。

答案 324 :(得分：2)

永远不要将任何内容实现为单身。

您可以决定不构建多个实例， 但始终确保您的实施可以处理更多。

我还没有找到使用单例的任何场景 实际上是正确的做法。

在过去的几年里，我对此进行了一些非常热烈的讨论， 但最后我总是对的。

答案 325 :(得分：2)

有用且干净的高级抽象明显比绩效更重要

一个例子：

我经常看到同行花费数小时写复杂的Sprocs，或者为了“性能”而返回非直观的匿名类型的大量LINQ查询。

它们可以实现几乎相同的性能，但具有相当清晰，直观的代码。

答案 326 :(得分：2)

自动更新会导致安全性较差的质量较差的软件

理念

使用最新的错误修复程序和安全补丁来保持用户软件最新的系统。

现实

产品必须按固定期限发货，通常以质量保证为代价。然后发布包含许多错误和安全漏洞的软件，以便在知道“自动更新”可用于解决以后所有问题的过程中满足截止日期。

现在，让我想到这个的软件就是VS2K5。起初，它很棒，但随着更新的安装，软件正在慢慢恶化。最大的攻击是丢失了宏 - 我花了很长时间创建了一组有用的VBA宏来自动化我编写的一些代码 - 但显然有一个安全漏洞而不是修复它，宏系统被禁用了。 Bang是一个非常有用的功能：录制击键并重复播放。

现在，如果我真的很偏执，我可以看到自动更新是一种让人们通过慢慢安装更频繁地破坏系统的代码来升级软件的方法。随着系统变得越来越不可靠，用户很想为下一个版本付费，并承诺更好的可靠性等等。

Skizz

答案 327 :(得分：2)

MS Access *是一个真正的开发工具，专业程序员可以毫不羞耻地使用

仅仅因为一个特定的平台是黑客和秘书的磁铁，他们认为他们是程序员不应该玷污平台本身。每个平台都有其优点和缺点。

悼念某些平台或工具或贬低他们作为“玩具”的程序员，他们对自己的手艺的了解程度远远低于他们自我说服的程度。对于我来说，听到一个程序员猛烈抨击他们没有亲自使用的任何环境，这是一个明显的迹象。

*在这里插入任何恶意工具（VB，PHP等）。

答案 328 :(得分：2)

......“理念的澄清”不应该是开发者的唯一责任......是的，xkcd让我使用了那个特定的短语......

如果您想要将其称为psuedo-meta-sorta-kinda特定的“代码”，我们常常交给项目。通常有产品经理负责制定项目的初始要求，然后执行0％的基本逻辑验证。

我并不是说技术方法不应该由架构师制定，或者说实施不应该由开发人员负责，而应该是产品经理要求确保他们的要求在逻辑上是可行的。

就我个人而言，我参与了太多“简单”项目，这些项目在这里和那里遇到一点范围蔓延，然后遇到一个“小”变化或特征添加，这与先前的要求相矛盾 - 无论是暗示还是明确。在这些情况下，对于那些要求不可能发生边界变化的人来说，让开发人员无法实现他们的梦想就会变得非常容易。

答案 329 :(得分：2)

switch-case不是面向对象的编程

我经常看到很多switch-case或者糟糕的if-else结构。这只是一个标志，表示不将状态置于其所属的位置，并且不使用已经存在的真实有效的switch-case结构：method lookup / vtable

答案 330 :(得分：2)

真的有争议：

你什么都不知道！

或换句话说：

我知道我一无所知。

（这可以在很多种情况下解释，但我认为你明白了。）

从计算机/开发开始，恕我直言，每个人都有三个阶段需要完成：

新手： 什么都不知道（这是事实）

中级： 认为他非常了解（/全部）（这是自负）

专业人士： 知道他什么都不知道（因为作为一名程序员，你大部分时间都要做你从未做过的事情）。 这不是坏事：我喜欢让自己熟悉新事物。

我认为作为一名程序员，你必须知道如何学习 - 或者更好：学习学习（因为记住：你什么都不知道！）。）

答案 331 :(得分：2)

设计模式不好。

实际上，design patterns aren't。

您可以编写错误代码，并将其隐藏在一堆模式下。使用单例作为全局变量，并将其表示为goto。不管。

设计模式是针对特定问题的标准解决方案，但需要您首先了解问题。如果不这样做，设计模式将成为下一个开发人员的问题的一部分。

答案 332 :(得分：2)

<强> Software-Reuse is the most important way to optimize software-development

不知何故，软件重用已经流行了一段时间，但已经失去了它的魅力，当许多公司发现只用重用口号写powerpoint演示文稿实际上没有帮助。他们认为软件重用不是“足够好”而且无法实现他们的梦想。所以它不再流行 - 它被大量的项目管理新人所取代（例如敏捷）。

事实是，任何真正优秀的开发人员都会自己执行某种软件重用。我会说任何开发人员，不做软件重用都是一个糟糕的开发人员！

我自己经历过多少软件重用可以在开发中产生性能和稳定性。但是，当然，一系列PowerPoints和半心半意的管理层并不足以充分发挥公司的潜力。

我链接了一篇关于软件重用的非常古老的文章（参见标题）。它最初用德语写成，然后翻译 - 请原谅，当它不是那么好的写作时。

答案 333 :(得分：2)

可以使用短变量名称

但不适用于嵌套循环中的索引。

答案 334 :(得分：2)

与命令式编程相比，函数式编程不是更直观或更容易学习。

函数式编程有许多好处，但我经常听到函数式程序员说，对于没有编程经验的人来说，理解函数式编程要比命令式编程更容易。从我所看到的相反，人们发现很难解决琐碎的问题，因为当你最终进入一个没有国家的世界时，他们无法管理和重复使用他们的临时结果。

答案 335 :(得分：2)

在.NET上开发不是编程。它只是将其他人的代码拼凑在一起。

来自编码背景，您需要了解硬件，以及这仍然是我所在行业的重要要求，我认为高级语言只是简单地组装其他人的工作。这没有什么本质上的错误，但是它是“编程”吗？

MS通过努力工作并向'开发人员'展示了符号指令语法，从而做了很多工作。我现在似乎已经知道越来越多的开发人员似乎受到类的存在或不存在的约束而无法完成工作。

我的观点来自于这样一种观念，即要成为一名程序员，您应该能够在平台允许的最低级别进行编程。因此，如果您正在编程.NET，那么您需要能够深入了解并制定解决方案，而不是依靠别人为您创建课程。这简直是​​懒惰，在我的书中不符合“发展”的要求。

答案 336 :(得分：2)

我宁愿真正熟练/经验丰富的老技术让我能够有效地解决现实世界的问题，而不是新的“时尚”技术仍然会经历青春期。

答案 337 :(得分：2)

开发项目必然会失败，除非整个程序员团队获得完全授权以做出与所使用技术相关的所有决策。

答案 338 :(得分：2)

我会说我对编程最有争议的观点是我真的相信你不应该担心抛弃代码和重写代码。很多时候人们会觉得如果你写下一些东西，那么改变就意味着你做错了什么。但是我的大脑工作方式是让一些非常简单的工作，并缓慢地更新代码，同时确保代码和测试继续一起工作。它最终可能会创建类，方法，附加参数等，我完全知道会在几个小时内消失。但我这样做是因为我只想朝我的目标迈出一小步。最后，我认为我不再花时间使用这种技术，而不是那些盯着屏幕试图在编写一行代码之前先找出最佳设计的程序员。

我得到的好处是，我不必经常处理不再有效的软件，因为我碰巧以某种方式打破它，并试图找出停止工作的原因和原因。

答案 339 :(得分：2)

如果您还没有阅读过手册页，那么您就不是真正的程序员。

答案 340 :(得分：2)

在设计阶段引入了80％的错误。
其他80％是在编码阶段引入的。

（这个观点的灵感来自阅读Dima Malenko的答案。“开发是关于设计的80％，关于编码的20％”，是的。“这将产生几乎零错误的代码”，不。）

答案 341 :(得分：2)

最佳做法不是。

答案 342 :(得分：2)

每个文件一个类

谁在乎？我更喜欢一个文件中包含的整个程序，而不是一百万个不同的文件。

答案 343 :(得分：1)

C ++是未来的杀手级语言......

......动态语言。

没有人拥有它，拥有越来越多的功能，如编译时（元）编程或类型推断，没有函数调用开销的回调，不强制执行单一方法（多范式）。 POSIX和ECMAScript regular expressions。 multiple return values。你可以拥有named arguments。等等。

在编程中，事情的进展非常缓慢。它花了10年的时间才开始（主要是因为性能），大多数编程的人仍然没有得到它（JS中的类？来吧！）。我会说C ++将在15 - 20年后真正开始发光。在我看来，对于C ++（语言和编译器供应商）的适当时间以及今天用动态语言进行聚合的程序员的大量时间来说，这就好了。

C ++需要变得更加程序员友好（模板生成的编译器错误或编译时出现的编译错误），程序员需要意识到静态类型是一种恩惠（它已经在进行中，请参阅其他答案，其中断言用动态类型语言编写的好代码就像语言是静态类型一样编写。

答案 344 :(得分：1)

简单性与最优性

我认为编写既简单又优化的代码非常困难。

答案 345 :(得分：1)

关联数组/哈希映射/哈希表（+用你最喜欢的语言调用的东西）是自切片面包以来最好的东西！

当然，它们提供从键到值的快速查找。但它们也使得即时构建结构化数据变得容易。在脚本语言中，它通常是表示结构化数据的唯一（或至少是最常用的）方式。

恕我直言，他们是许多脚本语言成功的一个非常重要的因素。

即使在C ++中，std :: map和std :: tr1 :: unordered_map帮助我更快地编写代码。

答案 346 :(得分：1)

Python完成其他编程语言在开发时间的一半时所做的一切 ...... Google也是如此！如果您不同意，请查看Unladen Swallow。

等等，这是事实。它仍然有资格作为这个问题的答案吗？

答案 347 :(得分：1)

那（至少在初始设计期间），每个数据库表（好吧，几乎每一个）都应该被明确定义为包含一些明显不可忽视的业务实体或系统级域抽象，并且无论你是否将其用作aa在主要密钥和其他从属表中的外键中，应明确定义表属性的某些列（属性）或子集，以表示该表的唯一键（实体/抽象）。这是确保整个表结构表示完整系统数据结构的逻辑一致表示的唯一方法，没有重叠或误解扁平化。我坚信Pks和Fks使用无意义的代理键并加入功能（性能，易用性和其他原因），但我相信这个方向的趋势已经使数据库社区离得太远了原始的Cobb原则，我们失去了自然键提供的许多（数据库一致性）的好处。

那么为什么不同时使用它们呢？

答案 348 :(得分：1)

（未命名）元组是邪恶的

  • 如果您使用元组作为具有独特含义的多个对象的容器，请改用类。
  • 如果您使用它们来保存应该可通过索引访问的多个对象，请使用列表。

  • 如果您使用它们从方法返回多个值，请改用Out参数（这确实需要您的语言支持pass-by-reference）

  • 如果它是代码混淆策略的一部分，请继续使用它们！

我看到人们使用元组只是因为他们太懒而无法为他们的对象提供NAMES。然后，API的用户将被强制基于无意义的索引而不是有用的名称来访问元组中的项目。

答案 349 :(得分：1)

例外情况被视为有害。

答案 350 :(得分：1)

在彻底考虑上述问题之前，永远不要在一个问题上下定决心。没有编程标准EVER证明以不良方式处理问题是正确的。如果标准要求编写一个类，但经过仔细考虑后，您认为静态方法更合适，总是采用静态方法。你自己的判断总是比编写标准的人的最佳前瞻思路更好。如果你在一个团队中工作，标准是很好的，但是规则应该被打破（当然是很好的品味）。

答案 351 :(得分：1)

  • Xah Lee：如果您可以过滤掉所有的攻击性和合理评估语句而不同意（或不同意）完全基于语句背后的个性，那么实际上有一些非常值得注意和合法的观点。很多我的“争议性”观点得到了他和其他臭名昭着的“巨魔”的回应，他们批评了我经常使用的语言或工具。（/ p>

  • [文档生成器]（http://en.wikipedia.or / wiki / Comparison_of_documentation_generators）：...创建者发明了一些特别针对文档源代码的自定义语法（包括，但不限于JavaDoc）完全是多余的，浪费时间，因为：

    • 1）他们未充分利用应该使用最多的人;和
    • 2）所有这些迷你文档语言所有都可以轻松替换为YAML

答案 352 :(得分：1)

我觉得使用goto语句很好，如果你以一种理智的方式使用它们（以及一种理智的编程语言）。它们通常可以使您的代码更容易阅读，并且不会强迫您使用一些扭曲的逻辑来完成一件简单的事情。

答案 353 :(得分：1)

硬编码很好！

在很多情况下，确实更有效，更容易维护！

我看到常量放入参数文件的次数确实是多久 你改变了水的冰点或光速吗？

对于C程序，只需将这些类型的值硬编码到头文件中，将java编译成静态类等。

当这些参数对您的程序行为产生极大影响时，您确实希望对每个更改进行一次regresion测试，这对于硬编码值来说似乎更自然。当事物存储在参数/属性文件中时，诱惑是认为“这不是一个程序，所以我不需要测试它。”

另一个优点是它可以阻止人们在参数/属性文件中弄乱重要值，因为没有任何！

答案 354 :(得分：1)

在合并到主线之前有一个涉及代码被批准的过程是一个糟糕的主意。它会给开发人员带来不安全感和懒惰，如果他们知道他们可能会搞砸几十个人会对他们所做的改变非常谨慎，不必考虑他们所有可能的代码客户端可能会影响。审阅代码的人不太可能像编写代码一样考虑它，因此它实际上可能导致更差的质量代码被签入...但是，是的，它可能会遵循所有的样式指南和得到好评：）

答案 355 :(得分：1)

正如大多数其他人一样，我努力坚持像DRY这样的原则而不是人类编译器。

我想推动的另一个策略是“告诉，不要问”。我不想用吸气剂/固定器弄乱所有物体，而是用它们来筛选它们。我想告诉他们做些什么。

这似乎直接反对良好的企业实践与哑实体对象和更厚的服务层（这有很多要求）。嗯，想法？

答案 356 :(得分：1)

意见：开发领域的持续时间并不总是与经验相同。

许多行业都用一种语言来看待“多年的经验”。是的，5年的C＃是有道理的，因为你可能学习新的技巧，什么不是。但是，如果您与公司合作并且维护相同的代码库已经存在多年，我觉得好像您没有获得作为处理不同情况和客户需求的人在不同情况下的曝光量。

我曾经采访过一位为自己拥有10年编程经验并且在VB5,6和VB.Net工作的人而感到自豪的人......在那段时间里他们都在同一家公司工作。经过更多的探索，我发现当他使用所有这些版本的VB时，他只是升级并不断维护他原来的VB5应用程序。从未修改过架构，让升级向导完成他们的工作。我采访了那些只有2年的人才，但他们参与了多个项目，这些项目比他有更多的“经验”。

答案 357 :(得分：1)

软件工程师不应该与计算机科学人员合作

他们的不同之处： SE关心代码可重用性，而CS只关注代码 SE关心性能，而CS只是想现在就把事情做好 SE关心整个结构，而CS不关心 ...

答案 358 :(得分：1)

经理们知道一切

根据我的经验，管理人员通常不会通过了解代码来实现目标。无论你告诉他们什么，它太长，不对或太贵。

从第一个开始的另一个：

从来没有时间做正确的事，但总有时间再做一次

一位优秀的工程师朋友曾表示愤怒地描述管理层将他的估计减半的情况，从他那里得到一个半版本然后给了他两倍的时间来重做它，因为它失败了。在商业软件领域，这是一个相当规律的事情。

今天在尝试配置仅具有Web界面的路由器时想到的一个：

Web界面适用于吸盘

以前版本的固件上的CLI非常好哦。这个版本有一个Web界面，它试图从无法使用的IT机器人中隐藏所有网络的复杂性，甚至无法使VLAN正确。

答案 359 :(得分：1)

尚未对其进行测试尚未发现争议，但可能存在潜力：

最好的代码行是你从未写过的代码。

答案 360 :(得分：1)

编程很容易，五岁的孩子可以做到。

编程本身并不难，这是常识。你只是告诉计算机该做什么。你不是天才，请自己克服。

答案 361 :(得分：1)

我不相信任何与优化相关的问题应该充斥着错误引用的“过早优化是万恶之源”的颂歌，因为优化为混淆的代码是编码乐趣的原因

答案 362 :(得分：1)

这是我的：

“您不需要（文本）语法来表达对象及其行为。”

我赞同Jonathan Edwards及其Subtext项目的想法 - http://alarmingdevelopment.org/

答案 363 :(得分：1)

人们抱怨从语言中删除'goto'。我碰巧认为任何类型的条件跳转都被高估了，而'if''而''switch'和一般用途'for'循环被高估了，应该非常谨慎使用。

每次进行比较和条件跳转时，都会增加一点复杂性，一旦调用堆栈深达几百个项目，这种复杂性就会迅速增加。

我的第一选择是避免条件，但如果不实际，我的下一个偏好是保持构造函数或工厂方法中的条件复杂性。

显然，这对许多项目和算法（如控制流循环）都不实用，但我喜欢这样做。

-Rick

答案 364 :(得分：1)

程序员和开发人员之间存在差异。例如：程序员编写分页逻辑，开发人员在页面上集成分页。

答案 365 :(得分：1)

只有两种人使用C（/ C ++）：那些不懂任何其他语言的人，以及那些懒得学习新语言的人。

答案 366 :(得分：1)

“其他”是有害的。

答案 367 :(得分：1)

在聚合和组合的背景下考虑的Law of Demeter是一种反模式。

答案 368 :(得分：1)

我认为有太多人做出编程决策而不应该担心实现。

答案 369 :(得分：1)

你永远不会使用足够的语言，因为每种语言最适合一小类问题，而且混合语言太难了。

宠物示例：只有在经过深思熟虑的规范（因为许多相互依赖意味着重构地狱）和使用具体概念时才应使用Java。 Perl只应用于文本处理。 C只应在速度胜过一切时使用，包括灵活性和安全性。键值对应用于一维数据，CSV用于二维数据，XML用于分层数据，DB用于任何更复杂的数据。

答案 370 :(得分：1)

我相信“让我们重写过去并尝试修复那些假装无用的错误”是一个在绝望情况下的宝贵调试口号：

https://stackoverflow.com/questions/978904/do-you-use-the-orwellian-past-rewriting-debugging-philosophy-closed

答案 371 :(得分：1)

删除课程。 .NET Framework中的类（类方法）的数量隐式处理异常。与愚蠢的人合作很困难。

答案 372 :(得分：1)

如果语言具有暴露的实际类型，请勿对基本类型使用关键字。在C＃中，这将引用bool（Boolean），int（Int32），float（Single），long（Int64）。 'int'，'bool'等不是语言的实际部分，而只是实际类型的'快捷方式'或'别名'。不要使用不存在的东西！在我看来，Int16，Int32，Int64，布尔等等比“短”，“长”，“整数”更有意义。

答案 373 :(得分：1)

当许多新技术出现在现场时，我只能了解它们以确定我现在是否需要它们。

如果没有，我把它们放在一边，直到“早期采用者”敲掉粗糙的边缘，然后每隔几个月/年再次检查一次。

答案 374 :(得分：1)

敏捷糟透了。

答案 375 :(得分：1)

Jon Bentley的“编程珍珠”不再是一本有用的书。

http://tinyurl.com/nom56r

答案 376 :(得分：1)

我认为Java应该通过瘦本机库包装器支持特定于系统的功能。

另一方面，我认为Sun决定要求Java仅支持便携式功能，这几乎是每个人的角度都是一个很大的错误。

数十年后，SWT出现并解决了编写可移植本机窗口小部件UI的基本问题，但到那时微软被迫将Java分解为C＃，并且编写了大量C ++，否则可能已经完成了文明的Java。现在世界上运行着C＃，VB，Java，C ++，Ruby，Python和Perl。除了SWT之外，所有Java程序看起来都很奇怪。

如果Java出现了本机库周围的薄包装，那么人们可能已经完全用Java 编写了与SWT等效的，而且随着事情的发展，我们可以将可移植的显然本机应用程序编写成Java的。我完全用于便携式应用程序，但如果在中间件UI（和其他功能）库的开放市场中实现可移植性，并且不是通过简单地将用户的菜单简化为垃圾或使用Swing伪造UI，那会更好。

我认为Sun认为ISV会受到Java限制的影响，然后世界上所有新的PC应用程序都会神奇地运行在太阳队身上。不错的尝试。他们最终没有得到应用程序而且没有语言起飞，直到我们可以将它用于仅逻辑服务器后端代码。

如果事情做得不同，那么本地申请就不会死了。

答案 377 :(得分：1)

从长远来看，质量保证可以做得很好，而无需进行各种形式的测试

很多地方似乎都有“做法”，“我们这样做”。这似乎隐含地排除了其他方法。

从长远来看，这是一个严重的问题，因为质量保证的主要功能是提交错误 - 并将其修复。

如果您没有找到尽可能多的错误，那么您无法做到这一点。当您排除方法时，例如，过于依赖黑盒，您就会开始忽略整个可发现的编码错误类。这意味着，通过暗示，您将使整个编码错误类别无法修复，除非其他人偶然发现它。

潜在的问题通常似乎是管理层+员工。有这个问题的经理似乎对计算机科学和/或团队的价值主张有着狭隘的思考。他们倾向于创建反映他们的方法的团队，以及测试方法的白名单。

我不是说你可以或应该一直做所有事情。让我们面对现实，一些测试方法对于给定的产品来说只是浪费时间。某些方法在某些产品成熟度水平上更有用。但我认为缺少的是测试组织挑战自己学习新事物的能力，并将其应用于整体表现。

这是一个假设性的对话，可以总结出来：

  

我：你测试了 10 年的启动脚本，你设法学习了关于shell脚本及其工作原理的任何内容吗？！

     

测试员：是的。

     

我：权限？

     

Tester：安装程序执行此操作

     

Me：平台，特定于发行版的依赖项？

     

测试人员：我们提交了

的错误      

我：错误处理？

     

测试人员：当客户支持发生错误时，会向我们发送一些信息。

     

我：好的......（开始考虑在stackoverflow中编写帖子......）

答案 378 :(得分：1)

  • 很快我们将在一个没有的世界中进行编程 数据库

  • AOP和依赖注入是GOTO 21世纪。

  • 构建软件是一种社交 活动，而不是技术性的。

  • Joel有一个博客。

答案 379 :(得分：1)

您只需要3到5种语言即可完成所有操作。 C是明确的。也许汇编，但你应该知道它并能够使用它。如果你为网络编码，也许是javascript和/或Java。像bash这样的shell语言和一个像Lisp一样的HLL，可能很有用。任何其他事情都会分散注意力。

答案 380 :(得分：1)

IDE's should check显然，在浪费时间编制之前，是否可以链接他们创建的代码是有争议的

但是我认为我不应该编译大量的代码只是为了意识到Windows锁定了我正在尝试创建的文件，因为另一个程序员有一些奇怪的线程问题需要他延迟卸载DLL后3分钟不应该使用它们。

答案 381 :(得分：1)

“XML和HTML是网络的”汇编语言“。为什么还要破解它？

很明显，现在很少有开发人员在汇编语言中学习/编码，原因在于它是原始的并且让你远离你必须在高级别解决的问题。因此，我们发明了高级语言来封装那些级别实体，以通过我们可以在更高级别上更多地联系的语言元素来提高我们的生产力。就像我们可以用计算机做的更多，而不仅仅是它的组成主板或CPU。

通过Web，在我看来，开发人员仍在阅读/编写和黑客攻击HTML，CSS，XMl，模式等。

我认为这些相当于Web或其基板的“汇编语言”。 我们应该完成吗？当然，我们需要在出现问题时进行破解。 但当然，这是一个例外。 我断言我们正在用机器级别的低级汇编语言替换它在Web级别上的等价语言。

答案 382 :(得分：1)

Visual Basic或C＃都胜过另一个。它们几乎相同，保存了一些语法和格式。

答案 383 :(得分：1)

我认为我们应该远离'C'。它太老了！但是，老狗还在大声喊叫!!

答案 384 :(得分：0)

有一次我从同事那里看到以下内容：

equal = a.CompareTo（b）== 0;

我说他不能假设在一般情况下，但他只是笑了。

答案 385 :(得分：0)

System.Data.DataSet Rocks！

在我看来，强类型的DataSet比大多数业务应用程序的自定义DDD对象更好。

推理：我们正在向后弯腰以找出自定义对象的工作单元，LINQ to SQL，实体框架以及它增加了复杂性。使用来自某处的漂亮代码生成器来生成数据层，而工作单元位于对象集合（DataTable和DataSet）上 - 毫无疑问。

答案 386 :(得分：0)

并非所有内容都需要封装到自己的方法中。有时候，方法可以做多件事。

答案 387 :(得分：0)

不要过分担心要学习什么语言，使用像c＃或python这样的行业重量级人物。像Ruby这样的语言在卧室里很有趣，但是在工作场景中不要蹲下。像c＃和Java这样的语言可以处理很小的软件项目。如果有人不这样说，那么你谈论脚本语言。期！

在开始项目之前，请考虑网上有多少支持和代码示例。同样，选择像Ruby这样的语言，例如与Java相比，网上的代码示例非常少，只会让你在遇到问题时更加悲痛。

您不能在论坛上发布消息，并希望在您的老板询问您的编码方式时回复。你有什么要说的？ “我正在等待有人在这个论坛上帮助我”

学习一种语言并学习它。学习多种语言可能会带来技能和实践，但你甚至都可以做到。擅长一个。有完整的书籍专门用于Java中的线程，当你想到它时，只有一个命名空间超过100个。

掌握一个或者在很多地方做得很好。

答案 388 :(得分：0)

使用设计模式和文档

在网络开发中，使用这些东西从来没有感觉到它的使用

答案 389 :(得分：0)

对自己有争议，因为有些事情最好不要说，所以你不会被其他人描绘为太自我主义。但是，这是：

如果是，请从我开始

答案 390 :(得分：0)

“不要从构造函数中调用虚方法”。这有时只是一个PITA，但只是因为在C＃中我无法决定在构造函数中哪一点调用我的基类的构造函数。为什么不？ .NET框架允许它，那么有什么理由让C＃不允许它？

该死！

答案 391 :(得分：0)

记录器配置是浪费时间。如果它意味着学习一种新的语法，尤其是那些无声地失败的语法，为什别误会我的意思，我喜欢好日志。我喜欢logger继承并向处理程序添加格式化程序给记录器。但是为什么要在配置文件中呢？

是否要在不重新编译的情况下更改日志记录代码？为什么？如果你将日志记录代码放在一个单独的类，文件中，那么它会有什么区别？

您是否希望将可配置的日志与您的产品一起分发给客户？这不仅仅是提供太多信息吗？

最令人沮丧的是，用流行语言编写的流行实用程序倾向于以语言指定的格式编写好的API。写一个Java日志实用程序，我知道你已经生成了javadocs，我知道如何导航。为您的记录器配置编写特定于域的语言，我们有什么？也许有文档，但它到底在哪里？你决定组织它的方式，我只是不想跟随你的思路。

答案 392 :(得分：0)

显然我的是Haskell has variables。这既“微不足道”（根据至少8名SO用户）（虽然似乎没有人能够就哪个琐碎的答案是正确的）达成一致，而且甚至要提出一个不好的问题（据至少有五位选民和四位投票结束的人）它）。哦，我（和计算科学家和数学家）错了，虽然没人能给我详细解释原因。

答案 393 :(得分：0)

您必须知道C才能称自己为程序员！

答案 394 :(得分：0)

C必须死。

当有其他语言（例如D）可用时，在C语言中进行自愿编程应该受到忽视。

答案 395 :(得分：0)

C ++ STL库非常通用，对任何人来说都是最佳选择。

答案 396 :(得分：0)

人脑是所有锁的主键。

这个世界上没有任何东西可以让你的大脑更快地移动。相信我，这不是哲学而是实际的。就意见而言，它们就在

之下

1）永远不要超出编程语言中指定的边界，一个简单的例子就是C和C ++中的指针。不要滥用它们，因为你可能会得到 DAMN SEGMENTATION FAULT。

2）始终遵循编码标准，是的，你正在阅读的是正确的，编码标准对你的程序有很多，毕竟你的程序是由机器执行但是被其他大脑理解< / em>：）

答案 397 :(得分：-1)

那WordPress是CMS（技术上确实如此）。

https://stackoverflow.com/questions/105648/wordpress-is-it-a-cms

答案 398 :(得分：-1)

引用已故的E. W. Dijsktra：

编程是应用数学中最困难的分支之一;较贫穷的数学家最好保持纯粹的数学家。

计算机科学不再是计算机，而是天文学与望远镜有关。

我不明白如果不能解决像this one那样简单的数学问题，人们如何能够声称自己是一名合适的程序员。一个CRUD猴子 - 也许，但不是程序员。

答案 399 :(得分：-1)

复制/粘贴不是反模式，事实上它有助于避免犯更多错误

我的经验法则 - 只键入无法复制/粘贴的内容。如果创建类似的方法，类或文件 - 复制现有的方法，更改所需的内容。 （我不是在讨论复制应该放在单个方法中的代码）。

我通常从不输入变量名称 - 复制粘贴它们或使用IDE自动完成。如果需要一些DAO方法 - 复制类似的方法并更改所需的内容（即使90％将被更改）。对于某些人来说，可能看起来像极端懒惰或缺乏知识，但我几乎从不必处理导致我拼错的问题，而且他们通常难以捕捉（如果没有在编译级别检测到）。

每当我离开我的复制粘贴规则并开始输入内容时，我总是拼错一些东西（这只是一个统计数据，没有人可以写出完美的文字），然后花更多时间试图弄清楚在哪里。

答案 400 :(得分：-2)

“好的Coders Code和伟大的Coders重用它”现在正在发生但是“Good Coder”是唯一喜欢该代码的 ONE 。  而“伟大的编码器”只是为了找出错误，因为他们没有时间思考和编码。但他们有时间在该代码中找到错误。

所以不要批评!!!!!!!!

创建自己的代码您想要的代码。

答案 401 :(得分：-2)

真正的程序员喜欢像灵魂伴侣这样的开源软件，并喜欢微软作为一个肮脏但令人满意的妓女

答案 402 :(得分：-4)

开发人员应该能够在未获得任何人许可的情况下修改生产代码，只要他们记录更改并通知相关方。

答案 403 :(得分：-4)

由于缺乏多样性，软件很糟糕。任何种族都没有冒犯，但是当一个职业由不同的种族和两种性别组成时，事情都很有效。只要看看过度使用不可再生能源。这很好，因为每个人都在贡献，而不仅仅是“刻板的家伙”

答案 404 :(得分：-8)

我有争议的观点是应该从所有编程语言中删除“While”结构。

你可以轻松复制使用“重复”和布尔标志，我只是不相信它有两个结构是有用的。事实上，我认为在一种语言中同时使用“Repeat ... Until”和“While..EndWhile”会让新程序员感到困惑。

更新 - 额外备注

新程序员使用的一个常见错误虽然他们认为一旦测试条件标记为false，代码就会中断。所以 - 如果While测试在代码中间标记为false，则它们会假设While循环中断。重复这个错误并没有那么多。

只要只有一种循环类型，我实际上并没有为两种循环类型中的哪一种留下困扰。我选择Repeat over While的另一个原因是“While”功能使用“repeat”比使用其他方式更有意义。

第二次更新： 我猜这个事实我是目前唯一一个负得分的人，这意味着这实际上是一个有争议的观点。 （不像你们其他人。哈！）

答案 405 :(得分：-10)

如果它不是原生的，那就不是真正的编程

根据定义，程序是由计算机运行的实体。它直接与CPU和操作系统对话。代码不直接与CPU和操作系统对话，而是由直接与CPU和操作系统对话的其他程序运行，不是程序;这是一个剧本。

在Java问世之前，这只是一个简单的常识，完全没有争议。突然间，有一种脚本语言具有足够大的功能集来完成以前完全属于程序领域的任务。作为回应，微软开发了.NET框架和一些脚本语言，并通过在开发工具中慢慢减少对真正编程的支持来支持.NET脚本，从而进一步搞砸了水域。

尽管它可以完成许多以前必须编写程序的东西，但是任何类型的托管代码仍然是脚本编写，而不是编程，并且编写的“程序”总是会共享脚本的性能特征：它们运行速度更慢，占用的内存远远超过真实（本机）程序完成相同任务所需的内存。

人们称之为编程正在通过降低定义来减轻每个人的伤害。它导致整体质量下降。如果你尝试让编程变得如此简单以至于任何白痴都可以做到，那么你最终会得到很多白痴，他们认为他们可以编程。

答案 406 :(得分：-12)

两行代码太多了。

如果方法有第二行代码，那就是代码气味。重构。

相关问题
最新问题