长期持有的、不正确的编程假设

这种编程是不可能的。

不是开玩笑的，我一直认为编程是一种不可能学会的东西，我总是远离它。当我接近代码的时候，我永远也无法理解它。

然后有一天，我坐下来阅读了一些基本的初学者教程，并从那里开始学习。现在我是一名程序员，我热爱工作的每一分钟。

另外，我认为编程并不容易，它是一个挑战，我更喜欢学习，没有什么比解决一些编程问题更有趣的了。

编程很简单。

没有bug的软件是可能的。

让非程序员明白我在说什么。

私有成员变量是实例私有的，而不是类私有的。

在正式发布之前，没有缺陷是可能的。

这绝对不是真的，即使P2缺陷有时也会被打开。

该条件检查如下:

if (condition1 && condition2 && condition3)

以不确定的顺序执行…

除了插入/冒泡排序之外，任何事情都是非常简单的黑魔法。

我曾经认为编写Win32应用程序就足够了。

而且每个程序都必须有一个GUI，因为命令行已经“过时”了。

所有的语言(大部分)都是平等的。

在很长一段时间里，我认为语言的选择对开发过程的难度和项目成功的潜力并没有太大的影响。这绝对不是真的。

为工作选择正确的语言与任何其他单个项目决策一样重要/关键。

人们知道他们想要什么。

在很长一段时间里，我以为我会和人们交谈，他们会描述一个问题或工作流程，我将其放入代码并自动化。结果每次发生这种情况，他们以为自己想要的并不是他们真正想要的。

编辑:我同意大部分评论。这不是一个专业的答案，也可能不是提问者想要的答案。它不仅适用于编程。我相信这也不是我长期持有的假设，但这是我在这短短的10年里学到的最引人注目的事情。我确信这纯粹是我的天真，但我的大脑连接的方式，以及我进入商界之前的教学和经验，让我相信我会做我回答的事情;我将能够使用代码和计算机来解决人们的问题。

我想这个答案类似于Robin关于非程序员理解/关心我所谈论的内容的回答。这是关于将业务作为一个敏捷的、迭代的、交互的过程来学习。它是关于学习编程猴子和软件开发人员之间的区别。这是关于意识到两者之间的区别，并且在该领域真正优秀，不仅仅是语法和输入速度。

编辑:这个答案现在是社区-wiki，以安抚人们对这个答案感到不安，给我代表。

在编程的头几年，我没有意识到1kbyte在技术上是1024字节，而不是1000字节。我总是有点困惑，因为我的数据文件的大小似乎与我预期的稍有出入。

XML名称空间(或者更糟，格式良好)在某种程度上比没有它们要困难得多。

一个非常常见的错误，甚至在W3C!

我相信创建程序就像在课堂上教的一样……你和一群人坐在一起，讨论一个问题，想出一个解决方案，等等。相反，现实世界是“这是我的问题，我需要解决它，开始”，十分钟后你又遇到了另一个问题，让你没有真正的时间来有效地计划解决方案。

. net结构体(c#和VB.NET)是引用类型，就像类一样。

我是在。net 1.0出现之前或之后的某个时刻“收到”这条智慧的(我不知道从哪里来的，它可能完全从我的脑海中冒出来，就像雅典娜从宙斯的额头上冒出来一样)，并一直保存着它，直到大约4个月前Jon Skeet对这个概念进行了消除。

感谢乔恩。

附注:与编程无关，但我也相信(直到5分钟前)“阿波罗从宙斯的额头上长成了一个完整的阿波罗”。

c++在本质上比所有其他语言都要好。

这是我在大学前几年从一个朋友那里收到的。我带着它很长一段时间(我现在脸红了)。只有在与它一起工作了2年左右之后，我才能看到它们的裂缝是什么。

没有人，也没有什么事是完美的，总有改进的空间。

软件工程师总是诚实地告诉你他们现在在做什么，或者过去对你的软件做了什么。

“On Error Resume Next”是某种错误处理

我很早就开始学习编程了。那时我14岁左右。我有各种疯狂的想法，但不要问我准确的时间，因为那是很久以前的事了。

• 我曾经相信，如果你在Java中使用术语同步，那么Java会帮你解决同步的问题

• 我相信，在至少半年(可能更久)的时间里，静态类型将提高性能。

• 我相信释放一些东西会把内存归还给操作系统。

• 我认为malloc调用可以归结为检查操作系统上是否有足够的空闲空间，因此malloc的开销并不大。

• 我想了很长一段时间，Java在构建时考虑了其他语言的所有优点和缺点，并将其“完美融合”，将其他语言的最佳属性和错误拒之门外。

• 我大大高估了linkedlist优于arraylist的情况的数量。

• 我认为np -硬度是一个证明没有实例可以有效地解决，这是微不足道的错误，在一段时间。

• 我以为在旅行社网站上找到最好的飞行计划需要很长时间，因为“旅行推销员问题”，我自豪地笑着对我的亲戚说(当我还小的时候，对吧?!)

还能想出更多。不知道我坚持了多久。对不起。

用汇编语言进行优化=重写。

当我第一次真正理解汇编(来自BASIC)时，让代码运行得更快的唯一方法似乎是用汇编重写它。我花了好几年的时间才意识到编译器可以很好地进行优化，特别是在cpu和分支预测等方面，它们可能会在合理的时间内比人类做得更好。此外，花时间优化算法可能比花时间从高级语言转换到低级语言更好。而且过早的优化是万恶之源……

当然，你可以看看FindBugs和PMD，但这些是我最喜欢的陷阱和技巧(所有Java):

字段没有被覆盖，而是被遮蔽。

没有显式的super。超级访问。

未定义构造函数的类具有隐式零参数构造函数。今年我犯了一个与此相关的实际错误。

要获得对内部类的父类的引用，可以使用“Outer”语法。这“消除方法调用或同步的歧义”。

在c++术语中，类是“它们自己的朋友”，该类的任何实例的私有方法和字段都可以从同一类的任何方法引用，甚至是静态方法。这将使我早期的一些clone()和copy构造函数简单得多。

在扩展类的静态上下文中可以访问受保护的方法和字段，但前提是该类在同一个包中。我很高兴flex.messaging.io.amf不是一个密封的包。

软件的质量会带来更大的销量。有时确实如此，但并非总是如此。

这很尴尬，但很长一段时间我都没有真正理解引用类型和值类型之间的区别。我以为你必须使用ref关键字来改变一个对象在不同的方法。

这是我应该知道的c#最基本的概念之一。

640K应该足够任何人(DOS)。多年来，很多人都相信这一点。

当我第一次拥有8MB内存的系统时，我认为这远远超过了我的需求。它可以运行操作系统(Mac)以及我使用的所有应用程序(Word、Email、Firefox等)。

不用分析我就能知道性能问题出在哪里

我认为我应该尽可能地进行抽象。我的脑袋被这个撞了，因为太多交织在一起的小功能。

现在我试着让事情尽可能的简单和分离。重构使事物抽象比预测需要如何抽象要容易得多。

因此，我从开发规则它们的框架转移到完成工作的功能片段。从来没有回头，除了当我想起那段时间，我天真地认为我会是那个开发下一个大东西的人。

所有面向对象语言都有相同的面向对象概念。

• 一个Java interface !=方法的接口。
• Java接口是针对需要具有多重继承的特定于语言的解决方案。Ruby的mixin尝试解决同样的问题。
• Javascript中提供的开箱即用的继承与Java实现继承的方式非常不同。

我的编程如果由我一个人来执行会更快更好。

我以为静态输入就是你一动不动地坐在键盘前。

我认为主流设计模式很棒，当它们在CS课上被介绍时。在此之前，我有8年的编程经验，对于如何创建好的抽象概念，我真的没有扎实的理解。

设计模式就像魔法一样;你可以做一些很棒的事情。后来我发现了函数式编程(通过Mozart/Oz、OCaml、后来的Scala、Haskell和Clojure)，然后我明白了许多模式只是样板，或者额外的复杂性，因为语言表达能力不够。

当然，几乎总是有某种模式，但它们在表达性语言中处于更高的层次。现在我一直在用Java进行一些专业编码，当我不得不使用访问者或命令模式等惯例而不是模式匹配和更高阶函数时，我真的感到很痛苦。

我应该一直优化我的代码。这并不是说我在写之前不应该仔细考虑，而是说我应该努力思考如何从每个语句中挤出每一点性能，甚至牺牲可读性。

一个函数/方法应该只有一个出口点。

如果你看不懂我的代码，那你就是不懂这门语言。我有一些代码审查，我试图反击。

我又花了几年的时间才明白，有一个时间和地点可以让你的代码变得神奇，那就是在库中，而不是在应用程序中。该应用程序是为了清晰和可读性。Magic最好隐藏在扩展方法和框架后面。

• 编程语言==编译器/解释器
• 编程语言== IDE
• 编程语言==标准库

• 公司高管关心代码的质量。
• 行数越少越好。

在c++中，很长一段时间我都在想编译器在为纯虚方法提供定义时拒绝你的。

当我意识到我错了时，我很吃惊。

很多次，当我告诉别人为其抽象类提供其纯虚析构函数的默认实现时，他/她都用大大的眼睛看着我。我知道接下来会有一场长时间的讨论……这似乎在c++初学者中是一个普遍的信念(我认为我自己也是如此)。我目前还在学习!)

c++的纯虚拟方法的维基百科链接

我可能花了几天时间试图减少业务层使用的内存，后来才意识到项目的WinForms (GUI)使用的内存是应用程序其他部分的4倍多。

这个:

SomeClass object(initialValue);

这:

SomeClass object = initialValue;

保证在c++中是等价的。我认为第二种形式肯定会被解释成第一种形式。并非如此:请参见c++初始化语法。

我认为要提高数据库性能，我所需要做的就是将数据库转换为第三范式。

如果每一行都计算条件，如果你写这样的代码:

Dim a as Boolean = True
If a Then
Console.WriteLine("1")
a = False
Console.WriteLine("2")
Else
Console.WriteLine("3")
End If

那么输出将是:

1
3

在很长一段时间里，我认为糟糕的编程是发生在边缘的事情。正确做事是标准。我现在没那么天真了。

我想说的是，将日期的year元素存储为2位数字是一种困扰整个一代开发人员的假设。在Y2K上被炸毁的钱是相当可怕的。

我曾经认为应用程序的大部分工作实际上是编程。我相信这在某些情况下是正确的，但根据我的经验，我花了更多的时间来研究、记录、讨论和分析，而不是实际编码。(我从事的是操作基于激光的传感器的软件，确定如何最好地控制硬件比编写代码更具挑战性。)

我也曾经认为，程序员可以回头问旁边的人问题的开放环境是程序员团队敲定解决方案的最佳环境。事实证明，不管有没有团队，一个黑暗孤独的房间效率更高。

当我毕业时，我认为专业编程就像在大学编程一样，这意味着我将得到输入和预期输出，并被要求填写进行转换的黑框。在现实中，我必须弄清楚输入，输出和黑盒。

我过去并不认为市场和销售人员是人类的祸害，太天真了。

我喜欢编程。通过研究SICP的书，我发现我一无所知。至少现在我更深入地研究编程了。

假设我要使程序100%完成，没有错误，并报告它为“完成”。有时，公司想要在程序存在很多漏洞时发布该程序，以抢占市场份额。

在我完成计算机学校后，我可以开始一份工作，并将我在学校学到的知识应用到现实世界中。 (我真的希望我不要浪费我生命中的4年时间学习操作系统和prolog)

假设我把代码写得很好，尽可能没有错误，这就是我能做的最好的事情。事实证明，有时候经理们更喜欢那些努力成为他们最喜欢的人，而不是把工作做好的人。

之前从未遇到过整数提升… 并认为'z'在这段代码中可以容纳255:

unsigned char x = 1;
unsigned char y = 2;
unsigned char z = abs(x - y);

z的正确值是1

一些我仍然有麻烦的事情是以下误解-我仍然试图坚持他们，即使我知道更好:

• 所有涉众将客观地对软件设计做出决策。那些没有参与编写代码的人完全基于情感做出各种决定，而这些决定对我们开发人员来说并不总是有意义的。
• 项目预算总是有意义的 -我看到一些公司很乐意在几年里每月花费5万美元，而不是花25万美元在6个月内完成一个项目。对于一个人来说，如果他们不花掉他们的年度预算，那么他们就会花掉它，无论遇到什么困难。让我震惊的是，有多少项目资金被浪费在这样的事情上。
• 你应该为正确的工作使用正确的工具 -有时这个决定不在你的手中。有时它从高层下来，“你应该在这个项目中使用X技术”，让你想“WTF!谁想出了那这个荒谬的主意?给你发工资的人，就是他，现在把它搞定。
• 在现实中，为了得到你的薪水，你需要完成最后期限和商业目标。有时候你会做出最糟糕的决定，因为你只是没有时间去做正确的方式…就像有时候那个词就在你的舌尖上，但在你回想起来的那一刻，你会选择一个不同的、不那么理想的词。并不总是有时间把事情做好，有时只有时间去做——无论如何。因此，我们经常看到所谓有经验的开发人员使用反模式，他们必须在明天交付给最佳客户的软件演示截止日期前10分钟想出一个问题的解决方案。

事实证明，在Linux下，你是否检查内存分配是否返回一个引用并不重要，因为它实际上会谎言给你，并且要么在未来的某个时候实际分配内存，要么在没有你需要的内存时完全中止你的程序。

与自动化相结合的编程优雅是老式测试的充分替代品。

我曾经认为我永远不会像微软开发人员那样编程，但现在我认为我可以写同样干净的代码，甚至更好。

面向对象不一定比非面向对象好。

我认为OO总是更好的。然后我发现了其他技术，比如函数式编程，并意识到OO并不总是更好。

Windows中的线程很便宜。

事实证明，这只是部分正确。线程有一定的开销，需要自己的地址空间，在那里它可以生存和快乐。因此，如果我发现自己在一个应用程序中处理数十个线程，我会问自己如何将所有内容简化并整合到更少的线程中。

在开始开发之前，您可以完全理解问题。

我写的所有东西在可预见的未来都会失败。

并不是说一切最终都不会崩溃，而是在我的编程教育早期，当我发现try. catch块…我把所有的东西都包在里面....有些事情，如果失败了，将代表比我的程序处理的更大的问题(例如，北极和南极互换了位置)。

作为一名老的过程式程序员，当我第一次开始为一个业余项目用Java编程时，我并不真正理解OO。编写了大量的代码，却没有真正理解接口的意义，试图通过将所有东西都强制放到继承层次结构中来最大化代码重用——当一个层次结构无法容纳清理时，希望Java具有多重继承。我的代码成功了，但我现在对早期的东西感到畏缩。

当我开始阅读动态语言并试图找出一种好的语言来学习时，读到Python中重要的空白使我失去了兴趣——我确信我会讨厌它。但当我最终学会了Python，它变成了我真正喜欢的东西。我们通常在任何语言中都努力获得一致的缩进级别，但没有得到任何回报(除了视觉可读性)。在Python中，我发现我并没有比以前在缩进级别方面做更多的努力，并且Python处理了我在其他语言中不得不使用大括号或其他东西的事情。这让我觉得Python现在更干净了。

当我在TI-83上编程时，我认为你不能给变量赋值。因此(忽略这是C代码，不是TI-BASIC)而不是编写

c = c + 1;

我会写

d = c + 1;
c = d;

当我了解到+=和++时，我震惊了。

后藤是有害的。

现在我们决定是继续还是中断。

这种编程软件需要扎实的高等数学基础。

在我开始编程之前，我总是被告知要成为一名优秀的程序员，你必须精通高级代数、几何、微积分、三角函数等。

十年后，我只做过一次八年级学生做不到的事。

Unix和Linux操作系统设计得很好……我可能应该限定这个(!)

首先，这一观点被一些反真理的观点所强化，例如:

• 每个后续开发的操作系统最终都以对Unix的拙劣重新设计而告终(Lisp也是如此，在那里它更正确)。
• 构成“Unix哲学”的一系列规则。这并不是说他们错了，而是暗示Unix本身紧跟他们的步伐。

更确切地说，他们是设计得好/做得好，当然他们的一部分是，但即使这只是一个相对的判断，相对于一些糟糕的Windows版本。下面是一些做得不好的事情的例子:

• 配置一团糟，特别平面文件配置不好
• C编程语言应该在很久以前就被替换掉了(被D之类的东西取代)
• Shell脚本是精神分裂。它不利于开发，因为它是为快速输入而设计的速记。
• 目录结构命名不当
• GNU工具链是不必要的神秘
• 一般目的总是胜过特殊目的的信念

总的来说，它们需要不必要的专业知识来操作。或者更确切地说，有大量的知识，而只有适度的理解。

也不全是坏事。Linux在政治上更好，不会被业务需求所破坏，但遗憾的是，在很大程度上，很多技术高地已经失去了。

XML将是一种真正可互操作的、人类可读的数据格式。

就查询性能而言，SQL WHERE子句中整数的位比较实际上是免费的。

碰巧，对于前50万行左右来说，这在某种程度上是正确的。在那之后，它被证明是完全无联合国的。

在很长一段时间里，我认为其他人对所有编程概念(设计模式、最新的新语言、计算复杂性、lambda表达式，只要你能想到的)都了如指掌。

阅读博客、Stack Overflow和编程书籍似乎总是让我觉得自己在所有程序员必须凭直觉知道的事情上落后于潮流。

随着时间的推移，我意识到我实际上是在将我的知识与许多人的集体知识进行比较，而不是单个人，这对任何人来说都是一个相当高的标准。现实世界中的大多数程序员都有完成工作所需的知识缓存，并且有不少领域是他们薄弱或完全不了解的。

学习一门全新的语言真的很难。

销售人员实际地管理顾客的期望。(接受过承诺不足和超额交付的培训)

软件需求通常来自市场调查。

在很长一段时间里(大约5年)，我认为PHP很棒。

我以为我懂算法。然后我加入了Topcoder.com

我想我需要它。

运行时性能很重要。总解决时间通常是最重要的。

自从学习python之后，我已经摆脱了对静态类型的依赖。

我最近才发现在Hello World中执行了超过一百万条指令!我写的c++程序。我从来没有对像一条cout语句这样简单的东西有过如此高的期望

从大学时代起，我就认为自己是编程大师。因为我能写代码，而别人不会。但当我加入一家公司时，我发现自己对基本知识一无所知。我对自己的所有假设都是错的!现在我知道我需要知道什么和不知道什么了!

上大学的时候(90年代中期)，他们的计算机实验室只有Windows 3.11的机器(我知道，很奇怪的大学)。

有一段时间，我认为作为一个专业程序员，只有Windows平台与我相关和所有其他平台只是从历史学术的角度来看有趣。

从学校毕业并学习了现代unix和linux环境后，我不禁对我的蹩脚的学校感到愤怒和失望。

我现在还不敢相信，我在计算机工程学位毕业时从未见过bash shell，甚至没有听说过emacs或vim。

在不浪费字节和CPU周期的情况下编写高效的程序是非常重要的。

但随着经验的积累，它与字节或CPU周期无关，它与你的思想流有关，连续的，不间断的，就像一首诗。

本质上，不要太努力。

我不知道在Javascript中除以0是无穷大(IEEE 754算术)。最近经历了惨痛的教训。

代码审查是浪费时间。

从一家完全可选的公司搬到一家强制性的公司(甚至是被审计的)，我逐渐明白了它们的用处。对代码有另一双眼睛，即使是最琐碎的部分，也可以:

一个)在你搞砸一些琐碎的事情时拯救你的尴尬(例如，在我之前的工作中，一个琐碎的代码审查可以防止我们向客户发送数百封垃圾邮件)

B)可以教你一些你一开始不知道的东西(我在目前的工作中学习了新的库-不可避免地在一家大公司，有人已经偶然发现了你的问题，并做了更好的解决工作-这只是知道在哪里寻找的问题)

至少要确保除了你自己之外还有其他人知道事情是如何运作的。

最后，我对我在这里提交的代码比我以前的工作更满意，尽管那时我认为我什么都知道:)

聪明人总是比我聪明。

当我犯错误的时候，我真的可以痛打自己，经常因为自嘲而被责备。我曾经敬畏地看着很多开发人员，并且经常假设他们在X上知道的比我多，所以他们知道的比我多。

随着我不断积累经验，认识更多的人，我开始意识到，虽然他们在某一特定领域比我知道得多，但他们并不一定比我/你知道得多。

这个故事的寓意:永远不要低估你的能力。

他说他懂编程，这肯定是真的!

女人觉得计算机程序员性感……

我的错误假设:虽然总是有一些改进的空间，但就我而言，我已经是一个尽可能好的程序员了。

当我刚从大学毕业的时候，我已经用C语言编程6年了，知道所有关于“结构化编程”的知识，认为“OO”只是一种时尚，并认为“天哪，我很好!!”

十年后，我在想“好吧，那时候我远没有我想象的那么好……我得到了多态性的想法和如何写干净的OO程序…现在我真的很好”。

因此，不知何故，我总是真的很好，但也总是得到道路比我以前更好。

在那之后不久，我终于有了“一些”谦卑。总是有更多的东西要学(还没有用像Haskell这样的纯函数式语言写一个合适的程序)。

与UNIX相比，NT操作系统的设计有缺陷。事实证明，NT内核和设计决策与任何现代的UNIX类系统非常相似，内核中的大多数问题都是由有漏洞的公司编写的第三方漏洞驱动程序造成的。

以某种方式，一个运营大量相当高调/高流量网站的公司实际上知道他们在做什么。结果他们在很大程度上毫无头绪，而且非常幸运地处于他们所处的位置。所以我想寓意是，

扎实的软件工程& & & & &;最佳实践=商业成功

还是……

大多数关键的软件系统==垃圾

分析和性能分析是一回事。

然后我发现，虽然分析器总比没有强，但它包含错误的假设，比如:

• 只有总量才重要，细节无关紧要
• 统计精度是定位性能问题的必要条件
• 测量时间和定位不必要的耗时操作是一回事

像Python或Ruby这样的动态类型语言不太适合用于大型项目。

“这个项目将在两周内完成”

而且

“这需要2个小时才能实现”

我曾经认为我是一个很好的程序员。在那个职位上干了两年。

当你在真空中工作时，很容易把房间填满:-D

现在流行的$符号作为java/javascript标识符的一部分是非法的。

这很尴尬，但很长一段时间以来，我一直认为嵌套方法调用或进行多个方法调用比在c#中创建一个变量来存储每个方法调用的值更节省内存。

不是持有时间最长的，但在某一时刻，有几年的时间，我:

• 以为微软Windows是世界上唯一的操作系统(那是1992年)
• 了解DOS对于拥有“高级”操作系统知识已经足够了。

这就是为什么我在高中没有选择“计算机课程”。我以为我对计算机已经了解得够多了。

后来在大学里，出于我的错误:

• 我认为UNIX操作系统/程序是完美的，DOS/Windows永远不会接近它(那时候看起来很真实，我猜Linus也是这么想的，这就是为什么Linux和UNIX如此相似，而不是。其他操作系统)

最后，在很长一段时间里，我想:

• 只有我的软件很糟糕，而商业软件是完美无缺的，因为……它是“商业”软件
• 美国的软件/工程师/产品是优秀的同义词，其他的都只是糟糕的尝试。

标识列不能包含重复值: Sql server中的identity列 < / p >

认为自己对编程中的某种语言/主题了如指掌。根本不可能。

ASCII以不同于二进制的方式存储

这是因为我在我的“标准”环境中构建了软件，它可以在每个人的机器/服务器上工作。只是发现我安装了一些实际上正在使用的不知名的库和服务。然后发现我利用了一个漏洞，这个漏洞后来被修补了。

您无法诊断生产中的“间歇性错误”。重新启动服务器是解决这个问题的唯一方法。

也许在我早期的ASP编码中更真实。但是有很多很好的分析工具可以发现内存泄漏和其他奇怪的问题。Perfmon还提供了许多良好的诊断数据。另外，您应该在应用程序中编写诊断日志。

因为性能问题，像Java和。net这样的虚拟机架构对于除了玩具项目之外的任何东西都毫无价值。

(好吧，公平地说，也许在某些时候这是真的。)

在早期，大多数个人电脑都有一个卡式磁带接口来加载和存储程序。那时候我还没有电脑，但我能找到的任何与电脑有关的东西(主要是杂志)我都读(那是70年代末，我还没有互联网)。由于某种原因，我给人的印象是程序是直接从磁带中执行的，计算机有RAM的唯一原因是在程序运行时存储变量。我认为当代码必须执行跳转指令时，它会以某种方式倒带或将磁带推进到正确的位置，并从那里继续。

我以为Windows 3.1只是一个玩纸牌的平台。而DOS是BASICA的一个平台。

我知道要编写一个合适的web应用程序，当我必须设计在所有浏览器上都能运行的东西时，我很清楚这一点。

当你已经彻底测试了你的代码时，错误处理是不必要的。

我一直认为，任何为任何语言编写任何代码的人都会使用编辑程序。

我和我的一个客户一起工作，他让我主要作为支持，并为他写一些更复杂的东西。有一天他搞砸了一份文件，很严重。他不小心节省了超过3个小时的工作时间，当我问他为什么不经常存钱时，他回答说:“因为我还没做完。”当然，这不是一个可以接受的答案，于是我又捅了捅，又捅了捅。我最终发现，他从来没有使用任何编辑程序，从来没有!notepad.exe都不行!他一直在使用在线CPanel文件编辑器!它甚至没有“查找”功能。他无法保存直到他完成，因为他正在编辑网站上的实时文件!

不用说，我很惊讶，他至今仍在使用CPanel编辑器……

其他人都在使用最新最好的技术，而我的团队是唯一一个使用劣质过时工具的人。(除了神秘的cobol恐龙)

理解指针和递归是非常困难的。

VB6中的Integers与。net大小不同。

VB6可以进行位级操作。

专业程序员制作没有bug的软件。

每个人都想为一个问题写出最好的、最合适的代码……

OOP已经过时了:(直到今天我仍然后悔这么想。

学习正则表达式可以节省时间

字节和字符实际上是一回事——“ASCII”只是将字节值映射到屏幕上的符号的一种方式。

阅读Unicode真的让我大开眼界(尽管我仍然没有完全理解它)。

那是朝九晚五的工作

c++是最酷的语言!

大的注释/代码比率是一件好事。

我花了一段时间才意识到代码应该是自文档化的。当然，如果代码不能更清晰，或者有重要的原因，这里或那里的注释是有帮助的。但是，一般来说，最好还是把注释时间花在重命名变量上。它更清晰，注释不会与代码“不同步”。

当它们相等时，这个维n就是维(n+1)的实例。

我持有时间最长(因此也是代价最大)的错误假设是:“业务需求是理智和合理的，我只是还没有理解它们。”

100个绿色假设坐在墙上，
如果一个绿色假设不小心掉了，
墙上有99个绿色的假设

交替:

矮胖子摔了一跤 所有国王的马和所有国王的人，
艾菲姆说，他只是个技术人员

总是没有足够的时间在最后期限前完成。

不要使用高级的特定于实现的特性，因为你可能“有时”想要切换实现。我这样做了一次又一次，几乎无一例外地，这种转换从未发生过。

一个WTF总是一个糟糕专业的证据。

事实上，我已经意识到最近有多少WTF的我承诺自己在我的职业生涯，但我是安慰当StackOverflow显示给我它们只是另一种软件度量。

通过学习精确的科学，我不需要提高我有限的社交技能。

ide会变得更快。

变量实际上只是内存中特定区域的名称。

成为我所写代码的所有者，我是唯一一个应该理解或触摸它的人。

以为我是唯一一个会写代码的人……然后当我需要这个例程时，我不记得我做了什么，只是复制/粘贴我自己的代码。

我知道每个人都这么做。

如果我有一个像ML或Haskell中那样强大的静态类型系统，我应该使用它来编码尽可能多的不变量。只有有了经验，我才知道有时最好让不变量是动态的。

在初中学习算法的时候，我认为NPC只是一个非多项式问题，这意味着这个问题的复杂性并不比多项式简单。直到我在大学里学了计算理论，我才意识到我错了

Java很慢。这么多perl粉丝在slashdot上反刍(sp??)这很可悲。

订阅许多RSS订阅，阅读许多博客并参与开源项目是很重要的。

我意识到，真正重要的是我花了更多的时间来写代码。我有阅读和关注许多博客的习惯，虽然它们是丰富的信息来源，但真的不可能吸收所有的东西。平衡阅读是很重要的，要多强调练习。

Reg。开源的话，我怕我不会受欢迎。我尝试过参与开源项目，大部分都是。net。看到许多开源项目甚至没有遵循适当的体系结构，我感到震惊。我看到。net中的一个系统没有使用分层架构，数据库连接代码到处都是，包括后面的代码，我放弃了。

这真的很尴尬，但当我开始学习如何编程时，没有什么能让我满意。我想写电子游戏。而不是这些书里让我写的那些琐碎的小程序。所以我决定跳过10章，忽略基础知识。

所以我基本上忽略了变量!

问题是我没有从惯例中识别关键字:

Car car = new Car(); //good
Car test = new Car(); //wrong must be lowercase car!


for (int i = 0; i < 10; i++) //good
for (int test = 0; test < 10; test++)//wrong must be i

创建一个成功的应用程序只需要程序员就可以轻松完成。软件也要易于使用，美观，文档和适当的营销。软件开发是多学科的，如果一门学科不及格，应用程序也可能会失败。

总有一天，我会有一个现实的想法，那就是构建一些重要的代码/系统/什么的需要多长时间。

我是一名初出茅庐的年轻开发者，希望从事专业的开发工作，因为这是我所热爱的，以下是我曾经持有的一些观点，这些观点都是我在短暂的经验中学到的，但都是错误的

当你根本不把用户界面和逻辑分开时，你最终会遇到的可怕的混乱是可以接受的，这也是每个人写软件的方式

不存在太多复杂或抽象的东西

一类责任——我从未真正有过这个概念，它对我来说是非常正式的

测试是我在卧室里编写代码时不需要做的事情

我不需要源代码控制，因为它对我所做的项目来说是多余的

开发人员什么都做，我们应该知道如何设计图标和做出漂亮的布局

Dispose并不总是需要结束符

任何类型的错误发生时都应该抛出异常

异常是针对错误情况的，很多时候只返回一个指示失败的值就可以了。我最近才明白这一点，我一直在说这一点，并且在很长一段时间内仍然抛出异常

我可以编写一个完全没有错误的应用程序

作为一个新手，我有一个假设，在这个领域工作多年的人自然是更好的开发人员。

适合系统编程的语言必须支持[可变]变量。

我是一个优秀的程序员!

对Unicode的全面支持是成功将软件部署到亚洲地区的先决条件。

经理们知道他们在说什么。

我认为编写足够好的软件是一项简单的任务

代码质量可以是一个非常宽泛的概念。我已经彻底地讨论过了。

代码行数越多，软件就越好。

选择和使用我们的开发方法是因为它们是最好的。

后来我发现，我们使用的工具对我们做什么、什么时候做、怎么做的影响比我想象的要大得多。

你可以在它的构造函数中memset(this, 0, sizeof(TheObject))一个c++对象而没有负面的结果

面向对象始终是设计源代码的最佳方式，而且永远都是。

人们实际上关心所使用的技术(开源/闭源)。

在80年代早期，当我开始玩电脑(ZX81, 1K内存)时，我花了几个小时为杂志上的游戏输入大量的机器代码(字节，而不是人类可读的汇编语言)，基本上是使用BASIC Poke指令。

我相信，如果我输入了一条错误的指令，那么我就必须从头开始，从头开始输入机器代码。

我以前以为我会永远用VB编程，现在我用的是c#。

C/ c++中if语句的求值顺序是特定于编译器的。所以写作:

if(指针!= NULL) &&(指针->doSomething())

是不安全的，因为可以交换求值顺序。我最近发现(在多年的谎言之后)，它是ANSI-C规范的一部分，您可以保证订单和它的完全安全。

詹姆斯

我希望自己能成为有钱人，为别人编程

营销人员关心你做什么。

你需要一个客户规范来完成一个项目。很多时候，你从一个销售会议和一个记事本开始。当然，在会议结束时，他们想要一个最后期限，“只是大概的时间”。

我们作为软件工程师能够理解用户真正想要的是什么。

评论越多越好。我总是试图让我的代码尽可能具有可读性——主要是因为我几乎肯定是那个会修复我漏过的bug的人。所以在过去的几年里，我经常会收到一段又一段的评论。

最终，我明白了，有一个点，更多的评论——无论结构多么整齐——没有增加价值，实际上成为一个麻烦的维护。这些天，我采取了目录+脚注的方法，每个人都为此感到高兴。

当我刚从大学毕业开始工作时，我希望更多的高级开发人员知道他们在做什么。男孩，我错了....

喂!,

我只是在设计和写代码。

没有需求收集、文档或支持。

欢呼,

我从没想过我会成为一名专业程序员，我以为我会从事电子工作。但最终，编程更容易，薪水也更高，所以最初的副业变成了我的主要工作。

在学校里，你被教导编程是“读取输入，处理数据，写输出”。实际上，很少有处理步骤——大多数编码只是“读取输入，输出”。

一般来说，它要么是“从用户读取，写入数据库”，要么是“从数据库读取，显示在屏幕上”。这两种情况涵盖了大约95%的工作。

通过实现客户想要的东西来满足客户——不幸的是，这意味着客户知道他想要什么。

我最大的先入之见是，我将被允许以我想要的方式编程。当然，后来我离开了大学，被一家有荒谬框架、规则和程序的公司雇用，这不仅意味着我没有以我想要的方式编程，而且意味着我在编程严重。

人们会关心最佳实践，甚至一致性。

代码越少越好。现在我知道，有时候如果代码行数更多，就更容易阅读/理解，这是值得的

我以为这将是一场过山车之旅，里面有飞驰的汽车、放荡的女人、私人飞机和大胆的冒险。等着瞧吧，直到我得到那个职业顾问....

• 我以为我要连续写8个小时的代码。实际上，我每天花4个小时写代码，1个小时吃午饭，1个小时喝咖啡，2个小时闲逛/闲聊/堆积。

• 在工作之前，我认为所有的客户都是白痴，对电脑一窍不通。天哪，我错了。有时候，我们得到的项目是那些比我们做得更好的人做的，他们只是没有时间去做。

• 我认为小隔间很糟糕，现在我喜欢它们:D我实际上从一间没有门的办公室搬到了小隔间。我喜欢这种开放性。

• 并不是所有的程序员都是运动健将。我以为我是唯一一个去健身房的人。在我工作的地方，每天早上5点我们至少有10个人去健身房。

• 我以为不会有女程序员。我们的几个主角是女性。

• 我的同事正在/正在编写被认为是糟糕的代码，因为他们太差劲了。我花了一段时间才明白，我应该先核实到底发生了什么。大多数情况下，糟糕的代码是由于缺乏管理，客户不想检查他们真正想要的是什么，并且开始改变主意，就像没有明天一样，或者是其他任何人都无法控制的情况，比如经济危机。
• 客户需要“昨天”的功能，因为他们很愚蠢:并非如此。这是关于沟通。如果有人告诉他们，所有事情都可以在一周内完成，你猜怎么着?他们一周内就会想要。
• “永远不要改变正常工作的代码”。在我看来，这不是一件好事。显然，你不需要改变真正有效的方法。然而，如果你因为一段代码可能正常工作而不去修改它，那么你最终可能会发现这段代码并没有真正完成它应该做的事情。我曾见过一个销售佣金计算软件连续两年计算错误，因为没有人愿意维护这个软件。销售部没有人知道这件事。公式太复杂了，他们真的不知道如何检查数字。

我可以理解我自己的代码没有注释!!

规格是完整和充分的

Java将对象的副本传递给函数，而不是引用。

换句话说，我认为如果你将一个对象传递给一个方法，然后以某种方式改变对象，它不会改变调用范围内的对象。我总是将对象传递给方法，操作它们，然后返回它们!

我记得我10岁的时候，有人让我相信，将来会有一种计算机能够在3秒内运行一个无限循环。

Python是一种不切实际的、令人讨厌的语言(我仍然可以读到一些关于我早期代码的注释，抱怨它)，而c++是唯一真正的面向对象语言。

我错得太离谱了，到现在还觉得羞愧。

一个程序最终可以解决所有的问题。

alt text http://images.despair.com/products/demotivators/teamwork.jpg

我需要定义所有的变量，我将使用在我的函数在其开始(Pascal风格)。

我曾经相信我需要考虑我的函数使用的所有资源，并在我开始编码之前定义它们，这可能是因为我的第一门语言是Pascal，这是要求。然后当我转移到C语言时，我会定义只在这些循环之外的循环中使用的临时变量，忽略循环内作用域，只是为了“一切都将在开始时定义”。

我花了几年时间才明白，提前定义所有资源并不是一件容易的事，而且范围本身对代码可读性非常重要。

其他人会像我一样被已知的错误所困扰，并且会把修复它们作为项目工作的优先级。

我所受的教育将为我在野外工作做好准备。

OOP的好处是你可以重用对象，而实际上它是通过创建一个具有相同接口的新对象来重用代码的休息。

实际上，对象可能占代码的2%，因此重用只会给您带来2%的好处。真正的好处是通过创建一个新对象来重用其他98%的代码，从而允许所有其他代码完全不同。现在您重用了98%的代码。把一个东西写为一个对象所花费的时间延长3倍是值得的。

例如，如果你有一个绘图程序，突然有一个你想要绘制的新形状，你只需要改变ShapeObject(同时保持界面相同)。项目中的其他内容都不需要改变。

我不需要快速重构我的面向对象的代码。马丁·福勒终于睁开了我的眼睛。

我永远不会在编程中找到一个实际的使用卡诺图的地图我在我的计算机科学课程中教过。

考试只是拖延的另一种方法。

学习语言就是学习语法，以及标准库中最常见的部分。

当我第一次听说“鸭子打字”时，我以为它实际上是“管道打字”，类似于人们经常说的鸭子胶带。“Duck typing”听起来是错误的，而“pipe typing”则有一种奇怪的意义(拼凑的类型)。

编程是给后辈的，最好的项目经理是不会编程的人。

html元素id和name属性是可以互换的。

事实证明，带有'name'属性的元素是相关的/被使用的。引用post等和'id'属性用于DOM引用。

至少6年来，我一直坚信，每个问题都只有一个解。

完全不知道不同复杂性的多种算法、空间/时间的权衡、面向对象、功能和命令式、抽象级别和无法确定的问题。当那种幸福的天真被打破时，它打开了一个充满可能性的世界，关上了坐下来建造东西的大门。我花了很长时间才弄清楚怎么选一个然后用它来运行。

我可以说服传统的过程程序员，为什么OOP经常提供更好的解决方案。

也就是说，一种描述世界的语言需要有描述复杂对象及其关系的能力。

争论通常包括关于抽象类的废话，我的回答是“不是所有的OOP程序员都刚从Uni毕业，还沉迷于抽象”。或者经典的，“在面向对象编程中，没有什么是我在严格的过程式编程中做不到的”，我通常会回答，“不是你可以，而是如果你有一个更广泛的工具集，你是否将”。

我已经学会接受他们和我看世界的角度不同这一事实。

没开始做的事，永远做不完。

看起来真的很愚蠢，但我推迟了这么多项目，因为规模太大了。我刚刚完成了一个巨大的项目，我意识到如果我意识到它的范围，我就不会开始了。在现实中，即使是最复杂的系统，当被分解成离散的和明确的部分时，也是相当简单的。然而，从宏观层面来看，它很快就被压倒了。

PHP的mysql_fetch_row是从执行的SQL查询中检索数据的唯一方法。

老实说，我编写了一个完整的web应用程序，而没有使用mysql_fetch_array，并且每次我想要更改函数以添加额外的列时都必须更改一堆数字。

我曾经认为Internet Explorer 6盒式模型是MS想出的一个邪恶的愚蠢的想法，只是为了打破与其他浏览器的兼容性。

大量的csing使我相信它更符合逻辑，并且可以使页面设计维护(更改块填充/边框/页边距)更容易。

想想现实世界:改变A4页面的边框宽度并不会改变页面宽度，只会减少内容的空间。

我可以阅读，可以完成任何工作。

这种简单性几乎总能战胜复杂性。愚蠢的规则。

编辑:正如葛格所说，我把这个颠倒了。我的思绪一定是在回复中迷失了。如果使用得当，简单性几乎总是能让代码变得更好。

字节码解释的语言(如c#或f#)比那些直接编译成机器代码的重置按钮慢。

好吧，当我开始有这样的信念时(在80年代)，这是真的。然而，即使是在c#中，我有时也会想“把这个内循环放到一个。cpp -文件中是否会让我的应用程序运行得更快”)。

幸运的是,没有。

可悲的是，我几年前才意识到这一点。

不熟悉SQL和关系数据库的过程开发人员/程序员不需要任何正式的培训，也不需要了解如何使用SQL，并且快速阅读像傻瓜级SQL这样的内容就足以使用像甲骨文这样的关系数据库;SQL Server。

在处理存储在关系数据库(如Oracle和SQL Server)中的数据的应用程序中，许多错误往往是由于缺乏对关系数据库语言的理解或如何使用造成的;SQL < em > < / em >。

我曾经为一家软件供应商工作，他们的心态是，开发人员只需要一本SQL for Dummies书或类似的东西，他们就可以完全准备好处理任何关系数据库问题。现在，该供应商的客户端拥有数百gb的数据库，这种SQL知识的缺乏又以一种消极的方式回来了。这不仅仅是糟糕的查找和更新和插入是一个问题，而是数据库本身的实际设计才是真正的障碍。

如果当时开发主管能够像对待他们构建应用程序所用的语言那样对待SQL和关系数据库，那么所有这些都是可以避免的，而且成本也会低得多。

不要认为SQL不重要，因为它最终会回来困扰你。你可能可以在一段时间内摆脱它，甚至几年，但你最终会达到一个断点，在没有完全重新设计数据库的情况下，你无法继续前进，那是成本最高的时候。

那当断点有效时，谁还需要JUnit测试?(在调试模式下测试应用程序时)。后来我意识到为什么....

临时解决方案不是永久解决方案
或者换句话说:工作区不是永远的:)).

线程=进程

我通过阅读K&R自学了C。不幸的是，我没有逐字逐句地读，肯定漏掉了一些东西。我编写了我自己的malloc和calloc版本，我在不同的工作中都随身携带，因为我不知道你可以只链接现有的库。我这样做了好几年，直到最后有人问我为什么要带着这些东西到处走，“嗯……你知道你可以直接链接现有的库，对吧?”

:

for (int i = 0; i < myObj.variable; i = i + 1)

优化为:

int j = myObj.variable;
for (int i = 0; i < j; i = i + 1)

哇，当我意识到它们每次都在运行时，我停止在j的地方放入函数调用!

原因:

for (int i = 0; i < myObj.variable; i = i + 1){
if (function_argument == NULL){
myObj.variable++;
} else {
printf("%d", myObj.variable);
}
}

并不等同于:

int j = myObj.variable;
for (int i = 0; i < j; i = i + 1){
if (function_argument == NULL){
myObj.variable++;
} else {
printf("%d", myObj.variable);
}
}

任意的例子，但是您可以看到优化将如何改变执行。

@Kyralessa:值得注意的是，在大多数处理器上，在汇编/机器语言中，函数有可能在保持堆栈良好状态的情况下返回调用者以外的其他地方。事实上，这在很多情况下都是有用的。我在6502上首次看到的一个变化是打印消息例程，要打印的文本立即遵循调用指令，尽管它在Z80上工作得更好;执行将在零结束符之后恢复(或者，作为使用Z80时的一个轻微优化，在零结束符处恢复，因为让零字节作为NOP执行比试图避免它更便宜)。

有趣的是，在许多现代语言中，函数都有一个正常的退出点(将在调用之后恢复执行)，但也可以通过抛出异常退出。即使在C语言中，也可以使用setjmp/longjmp来模拟这种行为。

唯一的本地化/国际化问题是翻译消息。

我曾经认为所有其他语言(我没有语言环境的概念)在各个方面都像英语，除了单词和语法。因此，要本地化/国际化一个软件，您只需要让翻译器翻译显示给用户的字符串。然后我开始意识到:

• 有些语言是从右向左书写的。
• 一些脚本使用上下文塑造。
• 日期、时间、数字等的格式有很大的变化。
• 程序图标和图形可能对某些人群毫无意义或具有冒犯性。
• 有些语言有不止一个“复数形式”。
• .．.

即使在今天，我有时也会读到令我惊讶的国际化问题。

做事总有一种“正确”的方式。大学毕业后很长一段时间，我一直抱着这个想法。

当然，我意识到完成一项任务总有很多种方法。每种方法都有优点和缺点。查看可用的信息，做出决定，然后确保你能向你的老板证明这一点。

“这次会成功的”

在我刚开始学习c++的时候(很多时候)，我周围都是Java学者。当被问及c++相对于Java的优势时(通常是一个我试图排除的人为问题，但你去了)，我会在我的回答中包括c++给你引用而且指针。Java的家伙会看起来难以置信，并建议引用是指针，并嘲笑我走出房间。我坚持在c++中引用和指针是不同的。

说句公道话，我是对的。引用和指针在语义和语法上是不同的。不幸的是，我用一个谬论来支持我的说法:底层实现是不同的。

我坚信，通过标准化，引用在语法中是名称的别名，就像typedef是没有存储空间的类型别名一样。

我确信引用不是对象，也没有存储空间，它们只是提供了从“名称”到“对象”的多个顶级映射。在这方面，我认为它们就像文件系统中的软链接:

Code: int a = 3; int& b = a;


Names          Objects           Memory


+-----+     +-------------+     +-------+
|  a  |---->|             |     |       |
+-----+     |             |     |       |
|     int     |---->|   3   |
+-----+     |             |     |       |
|  b  |---->|             |     |       |
+-----+     +-------------+     +-------+

当然，尽管优化可能会导致这种情况，但引用确实有存储空间。它们是不同的对象，即使语法尽力将其从程序员那里抽象出来。

可以这么说，我很失望地了解到，关闭优化的编译器可能会将引用作为指针实现，需要解引用操作:我实际上是在文件系统中创建与硬链接的类比:

Code: int a = 3; int& b = a;


Names          Objects           Memory


+-----+     +-------------+     +-------+
|  a  |---->|     int     |---->|       |
+-----+     +-------------+     |       |
|   3   |
+-----+     +-------------+     |       |
|  b  |---->|     int&    |---->|       |
+-----+     +-------------+     +-------+

标准c++实际上并没有指定引用应该如何实现，所以我的理论可能适用于一些工具链，但在任何主流编译器中都不适用……当然标准中也没有说明。