blocks|key|1156350|text|在考虑过度设计的事情时，要避免使用雅格尼、干的和接吻。如果有许多部分似乎已经完成，而代码的许多部分似乎有一个，“如果发生这种情况怎么办?如果发生这种情况怎么办？”感受一下，这将是另一个问题。忽略良好的面向对象设计原则或固体原理将是另一个值得注意的问题。如果您认为您已经编写了完美的代码，那么这将是另一个麻烦的迹象，因为对于任何人来说，编写无法以这样或那样的方式改进的东西是非常罕见的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1156351|海事组织，请注意，有些人可能对你的工作过于挑剔，因为它是任何代码库的一部分，可能涉及到人们喜欢某种方式的东西，例如方法、测试和变量的命名约定。事情就是这样。现在，您可能需要弄清楚的是，如何处理诸如冲突或说服/影响这样的siutations中的人，其中有一些工具可以提供帮助。|1156352|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/You_ain%2527t_gonna_need_it|1|http://en.wikipedia.org/wiki/Don%2527t_repeat_yourself|2|http://en.wikipedia.org/wiki/KISS_principle|3|http://www.coderanch.com/t/98329/OO-Patterns-UML-Refactoring/principles-good-OO-design-preferably|4|http://www.lostechies.com/blogs/chad_myers/archive/2008/03/07/pablo-s-topic-of-the-month-march-solid-principles.aspx|5|http://www.kilmann.com/conflict.html|6|http://en.wikipedia.org/wiki/How_to_Win_Friends_and_Influence_People^0|H|3|0|L|2|1|O|2|2|2P|B|3|31|4|4|0|2Q|2|5|2T|5|6|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]|$A|13|B|14|1|15]|$A|16|B|17|1|18]|$A|19|B|1A|1|1B]|$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|E|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]|$A|1J|B|1K|1|1L]]|C|$]]|$1|F|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]|R|$5|I|J|K|C|$L|S]]|T|$5|I|J|K|C|$L|U]]|V|$5|I|J|K|C|$L|W]]|X|$5|I|J|K|C|$L|Y]]]]

Avoiding any use of <a href="http://en.wikipedia.org/wiki/You_ain%27t_gonna_need_it" rel="noreferrer">YAGNI</a>, <a href="http://en.wikipedia.org/wiki/Don%27t_repeat_yourself" rel="noreferrer">DRY</a>, and <a href="http://en.wikipedia.org/wiki/KISS_principle" rel="noreferrer">KISS</a> come to mind in looking at things that are over-engineered. If there are many parts that seem to be partially completed and many parts of code that seem to have a, "What if this happens? What if that happens?" feel to it, that would be another point. Ignoring <a href="http://www.coderanch.com/t/98329/OO-Patterns-UML-Refactoring/principles-good-OO-design-preferably" rel="noreferrer">good principles of OO design</a> or <a href="http://www.lostechies.com/blogs/chad_myers/archive/2008/03/07/pablo-s-topic-of-the-month-march-solid-principles.aspx" rel="noreferrer">SOLID principles</a> would be another to note. If you think you have written the perfect code, that would be another sign of trouble as it is extremely rare for anyone to write something that can't be improved in one way or another.

IMO, beware that some people may be overly critical of your work as part of any code base can involve people liking things a certain way, e.g. naming conventions on methods, tests and variables. That's just the way it is. Now, what you may have to figure out is how to handle people in siutations such as <a href="http://www.kilmann.com/conflict.html" rel="noreferrer">conflict</a> or <a href="http://en.wikipedia.org/wiki/How_to_Win_Friends_and_Influence_People" rel="noreferrer">persuasion/influence</a>, where there are tools that can help.

blocks|key|2776960|text|至于你是否是一名建筑宇航员的问题:如果你意识到让你领先于很多人的危险。你也不想像你的养牛者那样，听起来他们中的一些人已经变成了刻薄的老抱怨者。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2776961|过度工程是排序问题的结果，导致系统的某些部分受到过多的关注。因此，过度工程最明显的症状是，你可以看到系统的其他部分都因为缺乏注意而受到伤害。|2776962|(过度工程也有一种趋势，就是让系统面临更大的不良设计风险，因为复杂程度的增加，以及在决定过度工程师的哪些方面时容易出错的猜测，但正如一份评论所指出的，这并不会自动发生。)|2776963|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As for the question about if you an architecture astronaut: If you are aware of the danger that puts you ahead of a lot of people. You don't want to go the way of your cow-orkers either, it sounds like some of them have become crusty old whiners.

Over-engineering is the result of a problem with prioritization that resulted in some part of the system getting too much attention. So the most apparent symptom of over-engineering would be that you can see all around other parts of the system that are hurting for lack of attention.

(There is also a tendency for over-engineering to expose the system to increased risks of bad design, because of increased complication and the amount of error-prone speculation involved in deciding what aspects to over-engineer, but as a comment points out, that doesn't automatically follow.)

blocks|key|1156371|text|过度工程的常见症状是什么？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1156372|解决你没有的问题的代码。|unstyled|1156373|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|H|8|@]|9|@]|A|$]]|$1|E|3|-4|5|D|7|I|8|@]|9|@]|A|$]]]|F|$]]

<blockquote>
 What are common symptoms of
 over-engineering?
</blockquote>

Code that solves problems you don't have.

blocks|key|2777009|text|你是否在合理的时间范围内实施了你的项目？现在起作用了吗？如果是这样的话，你可能可以放松一下，因为过度工程最糟糕的问题之一就是永远不会真正做任何有用的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2777010|你所说的人也可能有一些好的建议，但这并不意味着你需要接受他们所说的一切作为福音。例如，在一个新的项目上使用最新版本的.NET并不会让我感到担心。他们真的在抱怨这个吗？|2777011|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Did you implement your project within a reasonable time frame? Is it working right now? If so, you can probably relax a little bit, as one of the worst problems with over engineering is never actually getting anything useful done.

The guys you talked too may have some good suggestions, but it doesn't mean you need to take everything they say as gospel. For example, using a recent version of .NET on a fresh project does not strike me as anything to worry about. Are they really complaining about that?

blocks|key|1156403|text|对于大多数内部业务应用程序，大多数代码应该关注实现业务关注点，而不是与业务无关的技术问题(比如“断开连接的变更跟踪体系结构”)。目前可用的框架相当成熟，并且支持大多数常见的用例。如果您正在发明新技术，或者(在业务应用程序开发的上下文中)只是为了包装而包装其他现有的框架或库，那么您可能做错了。理想情况下，您构建的每一块体系结构都应该可以追溯到某些业务需求。保持简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1156404|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

For most in-house business applications, most of your code should be concerned with implementing business concerns, and not technical concerns unrelated to the business (like your "disconnected change tracking architecture"). The currently available frameworks are pretty mature and support most common use cases. If you're inventing new technology or (in the context of business-application development) just wrapping some other existing framework or library just for the sake of wrapping, you're probably doing it wrong. Ideally every piece of architecture you build should be traceable back to some business requirement. Keep it simple.

blocks|key|1254722|text|IMHO大多数关于你的应用程序的评论都不是关于过度工程的，因为过度工程不是关于技术的。是关于建筑的。新技术可以在合理的时间内学习和理解。理解过度设计的应用程序通常要困难得多，有时甚至不可能。这使得第2、4和5点无效。第一点是不成立的，因为很明显，您是因为按原样编写应用程序而获得报酬的，而且如果它有效，您在这里没有问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1254723|这是我的“快速测试”，以确定应用程序是否倾向于过度设计：|offset|length|style|BOLD|1254724|包装器用于“一切”：包装器很有用，但它很容易过度使用。检查是否只包装真正需要包装的东西。(我基本上把自己的包装纸包了一次。我知道我在说什么;-)|unordered-list-item|1254725|重塑车轮：经典。这很常见，你已经提过了。您是否实现了某些功能，因为您需要满足您的需要？您的框架做了其他可用库所不做的事情？|1254726|“感觉”过度：--这是最重要的一点，也是最难看到的一点。看看您的代码，看看哪些部分感到过于复杂。那么，问问你自己，是否有一种更简单的方法来实现它，以及为什么你没有选择这种方式。如果你没有很好的答案，这部分可能是过度设计的。|1254727|这些只是我在应用程序中使用的快速提示。他们不能保证是“过度工程检测”的全部和最终。|1254728|entityMap^0|0|I|9|0|0|A|0|0|5|0|0|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|K|3|L|5|J|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|M|3|N|5|J|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|15|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$]]

IMHO most of the comments you got about your application aren't really about over-engineering because over-engineering is not about technology. It's about architecture. New technologies can be learned and understood in a reasonable amount of time. Understanding an over-engineered application is usually much more difficult and sometimes even impossible. This makes the points 2, 4 and 5 invalid. The first point is not really valid because you obviously got paid for writing the application as it is and if it works you got no problem here.

This is my "quick test" to find out if an application tends to be over-engineered:

<ul>
<li>Wrappers for "everything": Wrappers are useful but it's easy overdoing it. Check if you only wrap things that really need to be wrapped. (I basically wrapped my own wrapper once. I know what I'm talking about ;-) .)</li>
<li>Reinventing the wheel: A classic. This is very common and you already mentioned it. Did you implement some functionality because you needed to your wanted to? What does your framework do what other available libraries don't?</li>
<li>"Feels" over-engineered: This is the most important point but also the hardest point to see. Take a look at your code and look which parts feel overly complicated. Ask your self then if there is a easier way to implement it and why you didn't choose this way. If you got no good answer this part is probably over-engineered.</li>
</ul>

These are just quick tips which I use for my applications. They are not guaranteed to be the be-all and end-all of "over-engineering detection".

blocks|key|2777225|text|无聊|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2777226|无聊是过度设计代码的好前兆。我承认，当我找到第一份工作的时候，我觉得自己被利用得太少了。我只是很无聊。当我无聊的时候，我写了代码。不仅仅是任何代码--代码的大教堂。|2777227|不，说真的，我脑海里有一幅我的代码和抽象的画面，比如有金色凸起的尖顶的大塔，玻璃红玛瑙的飞扬的支撑，一个由拱形穹顶支撑的奇妙的拱顶，上面有漂亮的几何花边等等。|2777228|看到这些模式为我自己工作真的很吸引人，但回想起来，我对我留下的不敬的混乱感到非常羞愧。|2777229|如果您正在编写自己的框架和DSL代码来打发工作中不那么刺激的时间，请停止。最好把时间花在阅读Wards+Wiki或写一本开源书上，或者你可能只想要求管理层做更多的工作。|2777230|entityMap|0|LINK|mutability|MUTABLE|url|http://www.c2.com/cgi/wiki?WelcomeVisitors|1|http://en.wikibooks.org/wiki/Main_Page^0|0|2|0|0|0|0|1A|A|0|1M|5|1|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]|$9|17|A|18|1|19]]|E|$]]|$1|N|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

Boredom

Boredom is good precursor to over-engineered code. I'll admit, when I got my first job, I felt so underutilized. I was just bored. And when I got bored, I wrote code. Not just any code -- CATHEDRALS OF CODE.

No seriously, I had a mental picture of my code and abstractions as large towers with golden jutting spires, flying buttresses of glassy onyx, a wonderful vault supporting by arched domes topped with beautiful geometrical tracery, etc etc etc.

It was really fascinating to see the patterns working together for myself, but in retrospect, I am completely ashamed of the ungodly mess I left behind.

If you're writing your own frameworks and DSLs code to while away the less stimulating hours at work, just stop. Time is better spent reading <a href="http://www.c2.com/cgi/wiki?WelcomeVisitors" rel="noreferrer">Wards Wiki</a>, or writing <a href="http://en.wikibooks.org/wiki/Main_Page" rel="noreferrer">an open source book</a>, or you may just want to ask management for more work.

blocks|key|2777246|text|你不是建筑宇航员。LINQ非常简单、基本和有用，其中之一就是。.NET+3.5也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2777247|同时，你是团队中的新手，即使他们喜欢你所做的，你也会受到一些嘲弄。|2777248|带点盐把它全拿走。接受他们的批评，点头，然后和他们一起喝杯啤酒。|2777249|如果他们要求你改变它，那么你的评论是“天.我知道我做错了，但它有效，这将是太多麻烦，以改变”。|2777250|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

You're not an architecture astronaut. LINQ is pretty simple and basic and useful, for one. Same goes for .NET 3.5.

At the same time, you're the newbie on the team and going to get some kind of ribbing, even if they like what you did.

Take it all with a grain of salt. Just accept their criticism, nod, and have a beer with them afterwards.

If they ask you to change it, then your comment is "jeez .. I know i did it wrong, but it works and it's going to be too much trouble to change".

blocks|key|1157479|text|编写您自己的框架|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1157480|很有可能有人已经做过了。不仅如此，他们已经比你做得好了1000倍。更重要的是，他们所做的一切可能已经是一个行业标准，所以学习这项技术将使你在其他工作中更具竞争力。|1157481|在我工作的最后一家公司，一位程序员在他任期的大部分时间里都是独自完成他的项目。他写了公司最受欢迎的应用程序之一，并被广泛认为是团队中最好的--但在我看来，他有一个讨厌的习惯，就是从头开始写他所需要的一切。|1157482|他编写了自己的依赖注入框架，他自己的ORM，一个单元测试框架(令人费解地，它看起来和NUnit非常相似--为什么他不使用NUnit?)，一个创建工厂对象的框架(我称之为"工厂工厂“)。|1157483|请注意，代码其实很了不起，但有什么意义呢？|1157484|编写一个更好的核心库|1157485|在我目前的公司，似乎程序员编写了大量无用的代码来复制.NET框架中已经存在的特性。|1157486|除其他外，他们写道：|1157487|一个在ASP.NET+webforms中用于表单身份验证的活动目录框架--这是令人费解的，因为ASP.NET有这个内置的函数。|unordered-list-item|1157488|网站的热交换主题和皮肤--也是令人费解的，因为代码的功能不如内置的ASP.NET主题--并且需要1000%25的膨胀。|1157489|他们莫名其妙地编写了自己的类型化数据集和数据适配器。这些对象提供的功能少于VS将为您自动生成的类型化数据集，同时需要比NHibernate域对象更多的样板代码。|1157490|要么他们对这个框架不太了解，要么他们认为这个框架是众所周知的不足。|1157491|只有很少几个例子可以让我想到重新实现的库比原始库更好(参见简街核心图书馆、C5泛型.NET集合、真正的货币类)，但很有可能，您不会编写一个更好的标准库。|1157492|entityMap|0|LINK|mutability|MUTABLE|url|http://discuss.joelonsoftware.com/default.asp?joel.3.219431.12|1|http://ocaml.janestreet.com/?q=node/13|2|http://www.itu.dk/research/c5/|3|http://thinkarchitecture.blogspot.com/2008/07/making-money-with-c.html^0|0|8|0|0|0|2D|4|0|0|0|0|A|0|0|0|0|0|0|0|T|7|1|11|A|2|1C|6|3|0^^$0|@$1|2|3|4|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1L|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1M|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1N|8|@]|D|@$9|1O|A|1P|1|1Q]]|E|$]]|$1|L|3|M|5|6|7|1R|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1V|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1W|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1X|8|@]|D|@]|E|$]]|$1|W|3|X|5|V|7|1Y|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|V|7|1Z|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|20|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|21|8|@]|D|@$9|22|A|23|1|24]|$9|25|A|26|1|27]|$9|28|A|29|1|2A]]|E|$]]|$1|14|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]|1C|$5|17|18|19|E|$1A|1D]]|1E|$5|17|18|19|E|$1A|1F]]|1G|$5|17|18|19|E|$1A|1H]]]]

Writing your own Framework

Odds are, someone's already done it. More than that, they've already done it 1000x better than you ever could. More than that, whatever they've done is probably already an industry standard, so that learning the technology will make you more competitive at other jobs.

At the last company where I worked, a programmer had worked solo on his projects for most of his tenure. He wrote one of the company's more popular apps and was widely regarded as the best on the team -- but in my opinion, he had a nasty habit of writing everything he needed from scratch.

He'd written his own dependency injection framework, his own ORM, a unit testing framework (which, inexplicably, looked and acted very similar to NUnit -- why didn't he used NUnit?), a framework for creating factory objects (a "<a href="http://discuss.joelonsoftware.com/default.asp?joel.3.219431.12" rel="noreferrer">factory factory</a>" I'd call it).

Mind you, the code was actually remarkable, but what was the point?

Writing a better Core Library

At my current company, it always seemed like programmers writing useless amounts of code to replicate features already present in the .NET framework.

Among other things, they wrote:

<ul>
<li>An active-directory framework for forms authentication in ASP.NET webforms -- inexplicable because ASP.NET has this function built-in.</li>
<li>Hot-swappable themes and skins for websites -- also inexplicable, since the code was less functional than built-in ASP.NET themes and required 1000% more bloat.</li>
<li>They inexplicably wrote their own typed data sets and data adapters. These objects provided less functionality than typed datasets which VS will autogenerate for you, while simultaneously requiring more boilerplate code than NHibernate domain objects.</li>
</ul>

Either they don't know the framework very well, or they think its notoriously inadequate.

There are only preciously few examples I can think of where the re-implemented library is better than the original (see <a href="http://ocaml.janestreet.com/?q=node/13" rel="noreferrer">Jane Street Core Library</a>, <a href="http://www.itu.dk/research/c5/" rel="noreferrer">C5 Generic Collections for .NET</a>, <a href="http://thinkarchitecture.blogspot.com/2008/07/making-money-with-c.html" rel="noreferrer">a real currency class</a>), but odds are, you won't write a better standard library.

blocks|key|1156553|text|其中一半是老头子(我在他们的圈子里)，坚持他们所知道的试探性和真实的蒸汽机。另一半是真的，但没有告诉你任何新的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1156554|除此之外，杰夫·斯隆的回答是很出色的。|1156555|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

half of it is old men (i'm in their league) sticking to the tried and true steam engine they've known. the other half is true, but not really telling you anything new.

other than that, Jeff Sternal's answer is stellar.

blocks|key|1254917|text|过度工程的一个非常强烈的警告信号是，当一切都经历了如此多的间接过程时，很难找到真正实现某些具体的、域级功能的代码。如果您发现您的大部分函数只做很少的具体工作而只调用其他虚拟函数，您可能会遇到问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1254918|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One very strong warning sign of overengineering is when everything goes through so much indirection that it's hard to find the piece of code that actually implements some concrete, domain-level piece of functionality. If you find that most of your functions do very little concrete work and just call other virtual functions, you may have a problem.

blocks|key|2777421|text|插件，它为应用程序提供了内在功能|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2777422|让我们面对现实吧，可插拔的架构只是他妈的性感和有趣的写作。然而，这是另一个你需要问自己的地方，“我真的需要这样做吗？”|2777423|如果您不需要对应用程序进行临时添加，不要期望任何人编写第三方扩展，并且您的应用程序的范围定义得相当好，您不需要一个可插拔的体系结构。|2777424|你不应该写插件来支持你的应用程序的内在功能。假设您正在编写一个画图程序；您可能会支持插件以多种格式保存文件，但是您不需要一个可插拔的撤消管理器或文件浏览对话框。|2777425|entityMap^0|0|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|M|$]]

Plugins which provide intrinsic functionality to your app

Let's face it, pluggable architectures are just damn sexy and fun to write. However, this is another one of those areas where you need to ask yourself, "do I really need to do it this way?".

If you don't have a need for ad-hoc additions to your application, don't expect anyone to write third-party extensions, and the scope of your application fairly well-defined, you don't need a pluggable architecture.

You shouldn't write plugins to support intrinsic functionality in your app. Let's say you were writing a Paint program; you'd probably support plugins to save files in multiple formats, but you wouldn't need a pluggable undo manager or file browse dialog.

blocks|key|1157524|text|当一个同事的电脑从你的头上飞过，因为他们在过去的6个小时里试图用你荒谬的框架显示一个令人毛骨悚然的对话框时，这是一个非常具体的症状。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1157525|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

When a co-worker’s computer comes flying past your head because they’ve spent the last 6 hours trying and failing to make a freaking dialog box appear using your ridiculous framework, that’s a pretty concrete symptom right there.

blocks|key|1157532|text|试着评估您是否做了一些事情，以便在代码的预期寿命内最小化工作。这包括维护和开发。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1157533|在代码生命周期中，请记住，代码的生命周期与应用程序的生命周期不同。也许最好先写一个快速的原型，然后再重新设计/重构之后，更好地理解领域。在这种情况下，生命周期非常短，所以保持简单。|1157534|此外，不同的应用需要不同的工程技术。如果这个应用程序失败了，它会造成生命损失吗？也就是说，它是机械心脏的控制器，还是航天飞机导航火箭的控制器？或者是一份无聊青少年的联系人名单？|1157535|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Try to evaluate if you have done things to minimize work over the expected life of the code. This includes maintenance as well as development.

In the code lifecycle, remember that the life of the code is not the same as the life of the application. It maybe better to write a quick prototype first, then re-engineer/refactor after better understanding of the domain. In this situation, the lifecycle is very short, so keep it simple.

In addition, different applications require different amouhts of engineering. Is this application going to cost lives if it fails? I.e. is it a controller for a mechanical heart, or for the space shuttle navigation rockets? Or is it a contact list for bored teens?

blocks|key|1156664|text|在一种更通用和更高层次的方法上，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1156665|I+feel+that+when+there's+a+gap+between+the+complexity+of+the+problem+and
the+complexity+of+the+solution,+then+you+have+a+clear+case+of+overengineering.+|code-block|syntax|javascript|1156666|实现这一目标的途径有哪些？解决你没有的问题，把问题看得更复杂，试图预测未来太多，建立过于通用的东西等等。|1156667|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

On a more generic and high level approach, 

<pre><code>I feel that when there's a gap between the complexity of the problem and
the complexity of the solution, then you have a clear case of overengineering. 
</code></pre>

What are the ways to achieve that? 
Solve problems that you don't have, seeing the problem more complex that it really is, trying to forecast too much in the future, building too generic stuff, among others.

blocks|key|1255090|text|作为一个从事软件专业开发24年的人，我所能说的就是这个问题--对特定问题所需的抽象级别的呼吁--是我日常设计和编程工作中最困难的部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1255091|在“旧”时代，缺乏工程的现象很普遍，这导致了所有结构化的方法和实践。现在看来我们走的是另外一条路。没有简单的答案，有时你只会知道你是否落后或过度设计在事后;)|1255092|我有过多次事后回想的经历，当时我对自己说：“我希望我不要把这件事弄得这么复杂”，而且“如果我能听到后脑勺那个小小的声音，让它在这里变得更通用就好了”。|1255093|我还没有找到打电话的绝对规则.|1255094|我怀疑我有过度设计的倾向，所以我把这张照片做成了我个人电脑的壁纸|1255095|📷|atomic|offset|length|1255096|​|1255097|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/a67723f0cc869bf301eae6f1b8e6cb06.png|imageAlt^0|0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X|Y|-4]]]]

As someone who has been developing software professionally for 24 years, all I can say is that this issue - making the call on the level of abstraction required for a particular problem - is the hardest part of my daily design &amp; programming work.

In the "old" days, under-engineering was rife, which led to all the structured methodologies and practices. Now, it seems we've gone the other way. There is no easy answer, and sometimes you will only know if you under or over engineered in hindsight ;)

I've had multiple hindsight experiences where I said to myself: "I wish I didn't complicate this so much", but also "If only I listened to the little voice in the back of my head, and made it a bit more generic here".

I've yet to distill absolute rules for making the call...

I suspect I'm prone to over-engineering, so I've made this picture my PC's wallpaper <img src="https://i.stack.imgur.com/zM8eR.png" alt="">

blocks|key|2777674|text|我想提供一个不同的视角，但我认为这个词应该被删除，代之以更恰当的描述。它给“工程”打上了烙印，这应该是关于简单、可维护性和实用性的，最重要的是，当许多被称为“过度工程”的东西具有精确相反的品质时(好像工程太多了，或者过于重视它，应该产生最复杂的解决方案)。例如，看到过度工程和糟糕的测试过程之间的关联是很常见的(至少我经常看到这两者并驾齐驱)，而在工程中，什么样的过度执行了最少数量的正式测试？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2777675|我说，从这样的角度来看，我经常听到软件经理和偶尔出现的恐龙，他们不太了解这个术语，去抨击任何试图降低系统维护成本或提出更完善的测试程序和安全标准的人。对于门外汉来说，任何一种认真关注声音工程、测试，而不是在他们想要的快速应变速度下产生代码的做法，都是“过度工程”。|2777676|有很多人真正认识到“过度工程”的真正气味，但这个词至少可以说是误导人的。|2777677|至于症状，除了已经提供的优秀症状，对我来说，这是一个盲点，能够正确地评估和重新评估你面前的工作。程序员可以在他们的想象中建立世界，沉迷于和专注于高耸的概念。虽然这是一个枯燥而笼统的答案，但这可能会导致我们无法再看到实际的问题和优先事项。概念化得太深往往会使我们对眼前的问题产生盲点，使问题变得过于复杂，与现实和实际的用户需求失去联系。对我来说，最需要注意的症状是心理学。|2777678|围绕着生产的各种职业都很容易受到这种基本趋势的影响，在这种趋势下，人们忽视了由于过于沉迷于概念而需要解决的实际和紧迫的问题(例如:电影导演)。对于一般的编程，对抗它的一种方法是在概念化到第n级之前，更早地支持简单、实用、编码(在我们深深地爱上任何想法之前，请给我们更多的时间重新评估)。拥抱这些理想不会走得太远，但对我来说，关键是要避免开发这个盲点，因为它阻碍了我们正确评价自己的工作。一个过度设计的代码库不是一夜之间就会出现的--它需要在错误的方向上付出大量的努力才能产生它，对我来说，最大的可以预防的问题与远见无关，但往往发展得太晚了。|2777679|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Kind of want to offer a different perspective, but I think this term should be struck out and replaced with a more appropriate description. It places a stigma on "engineering" which should be about simplicity and maintainability and practicality above all, when a lot of what is described as "over-engineering" has the precise opposite qualities (as though engineering too much, or taking it too seriously, is supposed to yield the most convoluted solutions). It is common, for example, to see a correlation between over-engineering and poor testing procedure (at least I have often seen these two go hand-in-hand), and what kind of excess in engineering performs the minimal amount of formal testing?

I say that coming from a standpoint where I often heard software managers and occasional dinosaurs who weren't so SE-savvy to throw this term around at anyone attempting to, say, reduce the maintenance costs in a system or propose more sound testing procedures and safety standards. It's too easy for the layman to think that any kind of serious focus on sound engineering, testing, and not producing code at the sprint-like snap-snap-snap pace they want is "over-engineering".

There are plenty who genuinely recognize the true smells of "over-engineering" but the term is at least arguably misleading.

As for the symptoms, besides the excellent ones already provided, to me it's a blindspot in being able to properly evaluate and reevaluate the work in front of you. Programmers can build worlds in their imagination, get obsessed and absorbed with towering concepts. While it's kind of a boring and generic answer, that can lead to a danger of no longer seeing the actual problems and priorities right under our nose. To conceptualize too deep is to often develop a blindspot as to what is right in front of us, to overcomplicate problems, to lose touch with reality and the actual user-end needs. To me the biggest symptoms to watch out for revolve around psychology.

All kinds of professions revolving around production are vulnerable to this basic trend where one loses sight of the actual and immediate problems to solve as result of getting too obsessed about concepts (ex: a film director). With programming in general, a way to combat it is to favor plainness, simplicity, practicality, coding sooner before conceptualizing something to the nth degree (buying us more time to reevaluate before we fall too deeply in love with any ideas). One can't go too far wrong embracing these ideals, but the key to me is to avoid developing that blindspot which prevents us from being able to properly evaluate our own work. An overengineered codebase doesn't come about overnight -- it takes a long amount of dedicated work in the wrong direction to yield it, and to me the biggest preventable issue with that is not foresight-related but often developing the proper hindsight too late.

I have recently found myself in the position of explaining an (In-House) application I have written to two candidates my company likes to hire in order to assist in maintenance and adding minor features.

It is the first "production" application I have written, it has 45k LOCs and I spent almost two years of "solo" development on it. I am fairly young (18) and wrote the application from scratch while being contracted as stand-in for a former developer who left the company. Unexperienced in designing applications of this size, I tried to use common architecture- and design-patterns. 

Today I know I have done some serious over-engineering, e.g. using a disconnected change tracking architecture instead of the Unit Of Work pattern, which the chosen ORM has already implemented. I will probably never have to go "real" three tiers.

Both candidates have 10 years+ background in In-House Application Development with the relevant platform. Being half their age and having little experience I do respect their opinion. When I was explaining the application architecture to them, comments were along the lines of:

<ul>
<li>Jeez, no one would pay me to do stuff like that, I have to get things done</li>
<li>Stick with what the framework does, don't use fancy libraries/technologies</li>
<li>Don't wrap framework code. On a team, everyone will write his own wrapper code anyway.</li>
<li>You're using .NET 3.5? Well, we are using 2.0.</li>
<li>What does that LINQ stuff buy me? All this query composition and projection seems too complicated.</li>
</ul>

Now I am asking myself: 
Am I an <a href="http://www.joelonsoftware.com/articles/fog0000000018.html" rel="noreferrer">architecture astronaut</a>? How do I know I am going too far with architecture? What are common symptoms of over-engineering?

Concrete symptoms of over-engineering

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我最近发现自己的立场是解释一个(内部)申请，我已经写信给两个候选人，我的公司喜欢雇用，以协助维护和添加次要功能。这是我写的第一个“制作”应用程序，它有45k个LOCs，我在上面花了将近两年的“独奏”开发。我现在还很年轻(18岁)，我从零开始写了这个应用程序，同时还为一位离开公司的前开发人员签订了合同。在设计这种规模的应...

问过度工程的具体症状
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问过度工程的具体症状EN