如何让失败的项目重回正轨?

发布于 2024-07-08 09:25:44 字数 1474 浏览 12 评论 0原文

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(20

北方的韩爷 2024-07-15 09:25:45

在艰难的情况下,您的客户信任度为零,并且在这种情况下基本上无法成功,无论如何。

出于所有意图和目的,该项目需要重新启动; 不幸的是,现有商店通常没有机会重新开始并重新评估现有的一切。

我不想这么说,但你需要停止开发并花一个月的时间找出问题所在......

结果需要是一个可行的 6 个月至 1 年交付计划,真正让他们专注于必须具备的内容,并且对第三方组件的真实贸易研究。 废弃代码库需要成为一种选择; 启动一个新的源代码控制项目,当您到达某个特定的模块端口时,它会有意义并留下垃圾。

敏捷是伟大的,一旦你制定了真正的计划,它就是一种有效的方法; 但这并不能修复与客户之间破裂的关系……或者已经存在的所有垃圾。

Tough situation, you have zero customer trust and basically can't be successful under that situation, no matter what.

For all intents and purposes the project needs a reboot; the unfortunate fact is that incumbant shops usually don't get this oppurtunity to start over and re-evaluate everything that is there.

I hate to say it, but you need to halt development and spend a month working out what went wrong...

The result needs to be a plan for a feasible 6month - 1year delivery really making them focus on what the must-haves are and real trade studies on your third party components. And trashing the code base needs to be an option; start a new source control project and when you get to a particular module port peices that make sense and leave the garbage behind.

Agile is great and all, and a valid approach once you get a real plan in place; but its not going to fix a broken relationship with your customer... or all the junk that's already there.

-小熊_ 2024-07-15 09:25:45

以下是阅读您的经验后的关键学习摘要:

Maxim
1:确保这不是“死亡行军”

Ellie
2:确保交付的内容有效
3:重构& Realgin 代码库到架构/最佳实践
4:看看真正的问题是什么:团队在技术上是否有能力交付?

肯德尔
5:确保技术领导力

Bill K
6:实施敏捷流程(如果不是 TDD,至少要进行自动化单元测试,短迭代可以使进度可见)
7:获得客户认可
8:准备好扔掉那些不起作用的东西(抛开一厢情愿的想法)

沃伦
9:确保留下的团队成员有机会重新开始

蒂姆
10:激励团队并随着明显的改进奖励他们

jsl4980
11:你需要你的团队(最重要的)按计划进行支持& 顾客
[这引发了更多问题。 如果您的客户询问团队是否有足够的能力遵守您的时间表怎么办? 如果您自己知道团队提出的时间表只是表明他们缺乏理解,该怎么办]

Ather
12:团队有承诺吗?
13:你们正式进行质量检查吗?

帕特里克
14:重新开始、重新设计并重新符合尚未开发的模块的架构/设计最佳实践。

Here's the summary of key learning after reading through your experiences:

Maxim
1: Make sure this is not a "Death March"

Ellie
2: Make sure what's delivered works
3: Refactor & Realgin codebase to Architecture / Best practices
4: Look at what are the real issues: Is the team technically competenet to deliver?

Kendall
5: Ensure availaibility of Technical Leadership

Bill K
6: Implement Agile Processes (At least automated unit tests if not TDD, short iterations that make progress visible)
7: Get customer buy-in
8: Be prepared to throw out what cannot work (wishful thinking aside)

Warren
9: Make sure the team memebers that remain given a chance to start over

Tim
10: Motivate team and as improvement becomes visible reward them

jsl4980
11: You need buy-in on schedule from your team (most imp.) & customer
[This raises more questions. What if your customer asks whether the team is competent enough to stick to your schedule? What if you yourself know that the timelines the team is proposing just shows their lack of understanding]

Ather
12: Is the team commited?
13: Do you formally QA?

Patrick
14: Start over, redesign and reconform to Architecture/Design best practices for modules yet to be developed.

音盲 2024-07-15 09:25:45

摘要共有 14 项。 你无法全部完成。 那么,第一步是什么?

这是你首先要做的——改进一件事

  • 你有根本性的质量问题。 (#2-5)
  • 您遇到了架构和组件问题。 (#6, 7)
  • 你遇到了日程安排问题。 (#1,8,9)

您可以解决质量问题。 正式的单元测试,走向 TDD 会有所帮助。 这可能很困难,因为架构问题会减慢测试速度。

你可以解决建筑问题。 这可能会更困难,因为它可能会涉及看起来无法交付的返工。 但它可能会解决质量问题。 或者,它可能因基本的测试问题而变得更加复杂。

您可以解决日程安排问题。 如果没有其他修正(即质量或架构),您可能无法解决时间表问题。

我认为,人们态度的整体改善来自于尽早开始一次成功(任何成功)。 最容易实现的目标是什么?

  • 一个长期存在的错误? 一个单元测试套件可以找到并修复该错误?
  • 一项主要的建筑特色? 每个人都可以在自己的多维数据集中发布的图表会有帮助吗? 一个演示如何澄清事情?
  • 一个新的用例? 一项真正有效的新功能?

The summary has 14 items. You can't do them all. So, what's the first step?

Here's what you have to do first -- get one thing improved.

  • You've got fundamental quality issues. (#2-5)
  • You've got architecture and component issues. (#6, 7)
  • You've got schedule problems. (#1, 8, 9)

You can tackle quality. Formal unit testing, heading toward TDD can help. This might be hard because architecture issues slow testing down.

You can tackle architecture. This might be harder because it will probably involve rework that will not appear deliverable. But it may fix quality issues. Or, it may be compounded by fundamental testing problems.

You can tackle schedule. Without other corrections (i.e., quality or architecture) you may not get any traction with fixing schedule issues.

I think that overall improvements in people's attitudes come from starting with one success -- any success -- as early as possible. What's the lowest-hanging fruit?

  • One long-standing bug? One unit test suite to find and fix that bug?
  • One major architectural feature? Would a diagram that everyone can post in their cube help? How about a presentation clarify things?
  • One new use case? One new feature that actually works?
断爱 2024-07-15 09:25:45

首先,要下定决心,你可能会失败——如果你不能接受这一点,就不要接受挑战。 这包括成为替罪羊(确实发生过)。 管理层不会用这些术语来看待它(即他们不是有意/有意识地“陷害你”)。 但这是企业环境的现实; 如果你承担了责任(通常比那些不承担责任的人工资更高),那么如果事情进展不顺利,你就会陷入困境。 你也必须准备好长期坚持下去。 我曾经被安排在一个客户网站工作 8 个月,以修复一个日渐衰退的项目。 正如您所看到的,这里的另一位博主花了 9 个月才准备好发布版本。

现在,假设您同意尽管您付出了努力,但事情可能会变成梨形,这就是我的建议:

  • 错误跟踪系统将成为您最好的朋友,它将使您能够重新获得表面上的控制。 你不能指望从整体上理解一个复杂的系统,所以“分块”它会有所帮助。 错误跟踪系统可以让您将问题统一起来,并将其分发给与您一起工作的其他人。错误跟踪系统

  • 您需要应对技术和政治挑战。 技术通常不会那么糟糕,因为你是一名编码员并且你知道如何做到这一点。 政治因素要棘手得多,你掌舵着一艘完全偏离航线的船,而且你身处百慕大三角。 最大的挑战往往是遏制客户之间的负面情绪(例如客户:“这些牛仔不知道他们在做什么”,“他们向我承诺了这一点但没有兑现”,“我没有信心”在这些人中更多”)。

  • 首先,向客户道歉,并具体告诉他们您正在做什么来重新调整他们的项目,例如您:“我对您的项目延迟感到抱歉,我陷入困境现在我已经查看了项目历史,就我个人而言,如果我为这个系统付出了很多钱,我要解决的第一件事是......”<-宾果,你。刚刚承担了该项目的责任,这意味着没有回头路 - 现在要么全有要么全无。

  • 其他一些人已经说过了,我同意; 停止添加新功能。 他们没有提到的是,您可能必须这样做才能让客户满意(请记住,挑战有技术和政治方面)。

  • 尽可能了解业务领域。 仔细阅读您可以获得的任何需求文档。 由于您不知道最初讨论的内容,因此迟到才开始该项目,您将处于巨大的劣势。 魔鬼在于细节。 这就是我在无法挽救的后期项目中陷入困境的原因,每个人都处于紧张状态,而我错过了一个小要求。 在当时来说,这没什么大不了的,可以很容易地纠正,但从政治上来说,这是压垮骆驼的最后一根稻草。 一种可能有帮助的策略是在客户网站上呆几个星期。

  • 了解时间就是金钱。 这不仅仅是一个技术问题。 客户支付了不正确或尚未交付的东西。 你的公司已经消耗了资源,可能已经用完了所有的项目预算——公司现在正在亏损。 这就是新功能问题再次出现的地方,是的 - 人们说不要添加它们,要稳定。 但添加新功能可能是一种政治上有用的策略,管理层会很高兴,因为新资金将用于不合格的工作。

  • 我建议您或您的编码人员不要长时间工作来交付。 如果您通常下午 5 点出发,请改为下午 6.30 或 7 点出发。 你和你的编码男孩可以连续多周坚持一两个小时的额外工作,周末可能额外工作 4-5 个小时。 每晚工作到晚上 9 点或 10 点会在大约 2 周内导致倦怠(有些可能会持续更长时间)。 在那之后,你在项目上的额外时间弊大于利。 万一你的老板对此提出异议,请做出选择; 做他们要求的事情(即增加工作时间),或者说“我已经投入了额外的时间来完成这个项目——我会在这里长期工作,如果我死了,我也会完成这个项目。但这是我愿意投入的时间的限制。我在工作之外还有其他承诺要保留”<- 但要做好应对后果的准备(请记住,政治局势同样重要)作为技术方面)。

  • 这里有人说“停下来写一个规范,停下来做这个......” - 对不起,伙计们,我只是不能同意你们的观点,这是不现实的。 项目已经停滞不前,管理层或客户最不想做的就是“我们必须停止一切……”。 我以前尝试过这种方法,我对客户和管理层说过“错误会不断出现,直到我们停下来,我写出一份详细的系统测试计划。这需要我两周的时间”——客户不希望为此,管理层不愿意承担这笔费用。 事实上,错误不断出现。

  • 学会“杂耍”——你必须提前制定任务,这样程序员就不会等着你了。 这通常意味着您自己编写的代码会减少。 通常,最好通过在编码开始之前制定项目时间表来实现这一点。 程序员在完成当前正在做的事情后应该知道他们下一步要做什么,并且他们不应该来问你“我下一步做什么?”,他们应该已经知道了。

  • 内置恢复实用程序,特别是当软件反复出现难以确定的问题时。 例如; 可能需要 12 小时才能找到错误并修复它,可能需要 2 小时才能投入实用程序(阅读“黑客”)来暂时解决问题。 时间和动力是关键,不幸的是可能需要创可贴修复。 内置

  • 要密切关注客户的情绪。 他们需要知道你“站在他们一边”(例如客户:“该产品是不可接受的”,你:“我同意,如果我处于你的位置,我会踢我们的屁股。我能告诉你的是我在这方面)并且在一切正常之前不会休息”)。 当客户回到您的网站时,他们实际上会开始为您提供帮助。 例如,他们可能会保护您免受管理层的压力。

  • 以身作则。 类似于“我要留下来处理这个项目,如果你也愿意留下来,我会很感激你的帮助”和“我知道这不是我们的烂摊子,但我们仍然会清理”无论如何,我希望客户得到一些高质量的软件”。 程序员通常不太关心让他们陷入这种情况的公司,但他们可能关心的是他们自己的公司还是客户(“可能”)。

我在这里看到的许多建议都假设了相当高的权力(例如“停止项目以正确重新启动它”或“对新功能说不”)-您正在启动已经受到阻碍的项目,并且作为一名程序员,传统上,与真正的管理者相比,你影响变革的权力要小。 这并不意味着“放弃/不尝试”——它只是意味着你必须发挥创造力,做你通常不做的事情(即使用“软”或人际交往能力)。

这里很多人都在说放弃这个项目,逃之夭夭。 迄今为止,我已经完成了 3 个无可救药的迟到项目。 我成功修复了 2 个,还有 1 个无法修复。 就我个人而言,承担一个迟到的项目并不困扰我。 毕竟,最糟糕的情况就是你被解雇了:)

First off, be resolved that you may fail -- if you can't accept that, don't take the challenge. And that includes being a scapegoat (it does happen). Management won't look at it in those terms (i.e. they're not intentionally/consciously 'setting you up'). But that is a reality of a corporate environment; if you take on the responsibility (often with more pay than those that don't), then your head is for the block if things don't work out. You have to be ready to stick with it for the long haul too. I was once placed on a client site for 8 months to fix a waning project. And as you saw, one of the other blog-posters here spent 9 months before a release version was ready.

Now, assuming you are okay with the possibility of it going all pear-shaped in spite of your efforts, this is what I suggest:

  • a bug tracking system is going to be your number one best friend, it will allow you to regain a semblance of control. you can't hope to understand a complex system as a whole, so 'chunking' it will help. and a bug tracking system allows you to unitize problems and distribute them to the other guys you are working with.

  • you have got both technical and political challenges to deal with. the technical generally aren't so bad because you're a coder and you know how to do this. the political ones are much trickier, you're at the helm of a ship thats gone hopelessly off-course, and you're in the Bermuda triangle. the biggest challenge is often stemming the tide of negative sentiment amongst the client (e.g. client: "these cow-boys don't know what they are doing", "they promised me this and didn't deliver", "i have no confidence in these guys to any more").

  • for starters, apologize to the customer and tell them in concrete terms what you are doing to do to re-right their project, e.g. you: "I'm sorry about the delay on your project, I'm getting stuck into it now. I've looked at the project history, and personally, I would be angry too if I was paying good money for this system. the first thing I'm going to tackle is..." <- bingo, you've just taken responsibility for the project which means there's no turning back - its all or nothing now.

  • a few other people have said it here, and I agree; stop adding new features. what they haven't mentioned is that you may have to do this to keep the client happy (remember, there's a technical and political side to the challenge).

  • understand the business domain as best you can. read through any requirements documents you can get your hands on. you are at a massive disadvantage by coming onto the project late since you don't know what was originally discussed. the devil is in the detail. this is what sunk me on a late projects I wasn't able to salvage, everyone was on edge, and i missed a minor requirement. at the time, it wasn't a big deal and could have been corrected easily, but politically speaking, it was the straw that broke the camels back. one tactic which may help is to go out on client site for a few weeks.

  • understand that time is money. its not just a technical issue. the client has paid for something which isn't right or has not been delivered. your company has expended resources, possible having already used up all the project budget - the business is now losing money. and this is where the issue of new features come in again, yes - people are saying don't add them, stablise. but adding new features can be a politically helpful tactic, management will be happy because new money is coming in for off-spec work.

  • I'd recommend against you or your coding crew working ridiculous hours to deliver. if you normally leave at 5pm, leave at 6.30pm or 7pm instead. you and your coding boys can consistently maintain an hour or two of extra work for many weeks on end and perhaps 4-5 hours over the weekend. working until 9pm or 10pm every night will result in burn-out in roughly 2 weeks (some can go longer). after that point, your extra time on the project is doing more harm then good. in the unlikely event your boss takes issue with this, make a choice; do what they ask (i.e. work more hours), or say "I've already committed extra hours to working on this project - I'm here for the long haul and im going to get this project done if its the death of me. but that is the limit of how much time I'm willing to put in. i have other commitments to keep outside of work" <- but be ready for the consequences (remember, political situation as much as a technical one).

  • there are people here that are saying "stop and write a spec, stop and do this..." - I'm sorry guys, i just cant agree with you here, its unrealistic. the project is already stagnating, the last thing management or the client wants to here is "we have to stop everything and...". I've tried this before, where I've said to the client and management "the bugs will keep coming until we stop and i write up a detailed system test plan. it will take me two weeks" - the client didn't want to pay for this, and management wasn't willing to wear the cost. as it happened, the bugs kept coming.

  • learn to 'juggle' - you have to map out tasks ahead of time so programmers aren't waiting on you. this will generally mean you do less coding yourself. generally this is best achieved by having a project schedule before coding starts. programmers should know what they are doing next after they finish what they are currently working on, and they shouldn't be coming to ask you "what do i work on next?", they should already know.

  • build-in recovery utilities, especially if the software has recurring problems which are hard to pin-down. for example; it may take 12 hours to track down a bug and fix it, it may take 2 hours to put in utility (read 'hack') to fix the problem for the time-being. time and momentum are of the essessen, and unfortunately bandaid fixes may be needed.

  • be very observant of the clients mood. they need to know you are 'on their side' (e.g. client: "the product is unacceptable", you: "i agree, i would kick our asses to if i was in your position. all i can tell you is im on it and wont rest until its all working"). when the client is back on your site, they will actually start helping you. for instance, they may shield you from pressure from your management.

  • lead your guys by example. something along the lines of "I'm staying back a bit to work on the project, I'd appreciate the help if your willing to stay back too" and "i know its not our mess, but we're still going to clean it up anyway. i want the client to get some good quality software". programmers could generally care less about the company that got them into this situation, but they may care if its about one of their own or the client ('may').

many of the suggestions I've seen here assume a fairly high degree of power (e.g. 'stopping the project to restart it properly' or 'say no to new features') - you are starting the project already hamstrung, and as a programmer, you will traditionally have less power to affect change then a true manager. this doesn't mean 'give up/don't try' - it just means you are going to have to be creative and do things you don't normally do (i.e. use 'soft' or people skills).

a lot of people here are saying bail on the project, run for the hills. I have been on 3 hopelessly late projects to date. i managed to fix 2, and 1 I couldn't fix. personally, it doesn't bother me to take on a late project. after all, the worst that can happen is you get fired :)

我不在是我 2024-07-15 09:25:45

如果你从一开始就参与了这个项目,我不想这么说,但公司应该取代你(以及整个团队)。

应该由具有实际项目管理流程的称职团队重新分析,并由具有这种情况经验的项目经理领导。

任何原始编码员都不应该致力于保存它的“新项目”。 他们可以转移到其他项目(他们不必被解雇),但为了重新审视该项目,每个人都应该被替换。

当然,管理层必须理解并接受该项目将比预期晚得多的事实。 如果管理层不同意这一点(更换团队、寻找经验丰富的领导层、后退一步并重新开始),那么 @Maxim 是对的 - 离开那里。

If you were involved in the project from the beginning, I hate to say it, but the company should replace you (and the entire team).

It should be reanalyzed with a competent team with real project management processes and lead by a project manager with experience in this situation.

None of the original coders should work on the 'new project' of saving it. They can move to other projects (they don't have to be fired) but to get a fresh look at the project, everybody should be replaced.

And of course, management has to understand and be on board with the fact that the project is going to be much later than expected. If management doesn't agree with this (replace team, find experienced leadership, take a step back and start again) then @Maxim is right - get out of there.

不忘初心 2024-07-15 09:25:45

1)我首先要评估的是团队中的人是否致力于该项目? 如果没有的话,做任何其他事情都是没有意义的。 除非我有一个专注且忠诚的团队,否则没有什么可以阻止灾难的发生。
2)我会确保团队中有质量保证人员。
3)向客户提出合理的迭代增量发布计划。 由于我们所处的混乱局面,客户不可能很快得到所有东西。 根据客户的优先级,我们将经常向他提供较小的功能增量。 这将使客户保持参与,因为他看到了正在发生的事情,所以不会那么急躁。

1) The first thing I will assess is whether the people on the team are committed to the project or not? If not, it is worthless to do any other thing. Nothing can prevent the disaster unless I get a dedicated and committed team.
2) I'll make sure that there is QA on the team.
3) Come up with a reasonable plan of iterative and incremental releases to the customer. With the mess we are in, there is no way customer can get everything soon. Based on the priorities of customer, we'll deliver smaller increments of functionality to him frequently. This will keep customer engaged, a bit less-edgy since he is seeing something happening.

琉璃梦幻 2024-07-15 09:25:45

做什么事情,都要一步一步来。

首先,这不是关于添加功能,而是关于修复应用程序。 不要添加任何新内容。 只需重构即可。 对有人要求你在系统中引入的任何新东西说不。

不要尝试改进整个应用程序。 让您的团队利用最佳实践,使其专注于某一方面,尤其是使用单元测试。

仅使用测试驱动开发。 在这种情况下,它会立即向您显示您不理解行为的哪一部分(如果您不知道要测试什么,则无法编写测试代码。

因此,这是路线图:

  1. 确定您需要的关键部分更改
  2. 隔离暗示此行为的代码
  3. 在代码的其余部分中查找此代码的任何出现
  4. 使用这些知识和大量 TDD
  5. 进行重构 集成、测试和修复,直到此特定部分正常工作
  6. 返回步骤

向您的老板明确情况:这需要时间、金钱,而且会很痛苦。解释一下为什么,你会做什么,并且你没有其他办法,否则它会再次失败。

首先,不要尝试第一次就将其清理干净。您可以,但不要指望第一次更改您正在处理的部分的整个架构。您将不得不在整个应用程序上迭代该过程,这

只是方法。和耐心。

What ever you do, do it step by step.

First, it's not about addind features, it's about fixing the app. Don't add anything new. Just refactor. Say no to any new stuff somebody ask you to introduce in the system.

Don't try to improve the whole app. Take your team, make it focus on one aspect at the time, with the best practices you can, especially using unit test.

Use test driven development only. In that case, it will immediately show you what part of the behavior you don't understand (you can't code a test if you don't know what to test.

So here are the road map :

  1. Identify the critical part you need to change
  2. Isolate the code that implies this behavior
  3. Find any occurence of this code in the rest of the code
  4. Refactor using this knowledge and massive TDD
  5. Integrate, test and fix until this particular part works
  6. Go back to step

Make the situation clear to your boss : it will take time, money and will be painfull. Explain why, what you will do, and that you have no other way or it will fail AGAIN.

A above all, don't try to make it clean the first time. Refactor what you can, but don't expect to change the entire architecture of the part you are working on the first time. You will have to iterate the process on the whole application several times.

No miracle. Just method and patience.

独享拥抱 2024-07-15 09:25:45

在那里,遵循以下步骤:

稳定

  • 收集真实的故事:代码库有多好/坏,开发人员有多好/坏,真正需要完成什么(最基本的),什么时候它需要通过
  • 减少加班来完成(疲倦的人,无论好坏,都不能很好地工作)
  • 删除坏的,输入新的/好的 - 错误地进行替换(许多人可能会精疲力尽,甚至欣赏被迫的改变)
  • 删除对不良/不需要的代码的访问(重点关注提供 80% 价值的 20% 代码库)
  • 将基本代码实践落实到位,确保只有好的代码才能进入(不再损坏基础代码)

控制

  • 实施团队专注于应用程序组件(尽可能解耦),
  • 代码管理、发布管理、风险管理、质量保证等落实到位(构建您的环境,以便您能够成功)
  • 将 客户/赞助商好的一面 - 交付胜利,即使它是一个相当稳定的非常小的版本 - 然后进行变更管理(控制所要求的内容)

继续

  • 制定计划(计划是必不可少的,根据艾克的说法,计划是无用的 -你需要计划找出缺失的东西并设定目标,但不要指望能告诉未来) - 需要持续计划
  • 积极管理你的员工 - 优秀的人创造出好的产品 - 确保你获得并保留最好的
  • 重构随着时间的推移 - 边走边清理代码 - 你可能没有能力立即修复所有内容,所以加班加点以提供更干净的代码库
  • 勇敢地前进 - 加班更积极地进行交付测试(但不要压力)团队

Been there, followed these steps:

Stabilize

  • gather the real story: how good/bad is the codebase, how good/bad are the developers, what really needs to get done (bare bone min.), when it needs to get done by
  • reduce overtime (tired people, good or bad, don't work well)
  • remove the bad, input new/good - err on the side of replacement (many could be burnt out and appreciate even a forced change)
  • remove access to bad/un-required code (focus on the 20% of the code base that provides the 80% of the value)
  • put base code practices in place ensuring only good code is getting in (don't damage the base anymore)

Control

  • implement teams focused on the app components (decouple as much as possible)
  • put code management, release management, risk management, QA, etc. in place (build your environment so you can succeed)
  • get on your clients/sponsors good side - delivery a win, even if it's a somewhat stable very very small release - and then put in change management (control what gets requested)

Move forward

  • develop a plan (planning is essential, plans are useless according to Ike - you need to plan to find what is missing and to set a target, but don't expect to tell the future) - continuous planning is required
  • aggressively manage your people - good people make good product - make sure you get and retain the best
  • refactor over time - clean up code as you go - you may not have the luxury to fix everything at once so do it overtime to provide for a cleaner code base
  • move forward bravely - overtime be more aggressive with your deliveries test (but not stress) your team
第几種人 2024-07-15 09:25:45

敏捷重构。 确定客户的需求并确定其优先级,然后在短时间内从现有代码中创建最重要的内容。 祝你好运,伙计:)

Agile refactoring. Identify and prioritize what customer wants and then create the most important stuff in short sprints out of existing code. Good luck man :)

背叛残局 2024-07-15 09:25:44

维亚斯,我觉得我可以写这个问题。 我之前的工作涉及复兴一个经过一年开发而失败的 KVM 项目。 规格采用用户手册和开发人员使用类似产品的经验的形式。 我最终向 3 名汇编程序员教授 C,并从头开始重新架构。 我们在 4 个月内将产品成功推向市场。 (然后我辞职了。想想吧。)

我会再次做的一些事情,特别是在一个缺乏经验的团队中:

1。 一群缺乏经验的程序员 24x7 工作
10。 没有技术领导/或牛仔编码员可以解决技术问题

  • 让他们从项目中休息一下以“充电”。 也许是一天,也许是一个下午,或者也许是一顿丰盛的午餐。 它将标志着“旧”项目的结束和成功的开始。
  • 让他们同意他们回来后会全力以赴,并保证你将成为他们的首选人物、拉拉队长和防弹衣。 你们是一个团队,你们的工作就是为他们开辟道路、消除干扰并领导他们。
  • 计划立即取得成功,无论多么小,并保持“我能做到”的态度。

8. 错过了一个又一个里程碑
9. 团队无法确定交付日期,因为没有人就实际需要完成的工作量达成一致
3. 客户尖叫着说他甚至不能做基本的事情(保存/查询)等。

  • 小口吃!尽可能分解每个部分,然后处理小组件。 您将尽早发现“陷阱”,并能够更好地确定整个项目的范围。
  • 定义你的接口。任何时候你可以隔离一个块,去做。这允许并行开发,因为你已经决定了参数、先决条件、假设、内部发生的情况,和返回值。 您可以将其存根,然后独立构建其他模块和测试。
  • 确定优先级。首先关注影响客户的缺陷和问题。 新功能排在最后。 如有必要,推迟功能而不是提供有错误的代码。
  • 分配职责。志愿者是首选,每个人都在他/她的专业领域,但每项任务必须有一个人负责。
  • 跟踪缺陷并记录有助于您重现、定位和修复缺陷的所有内容。 记录交付时剩余的所有内容,这样客户就不会感到惊讶。

4。 习惯于将规范下达的程序员很难即兴发挥
6。 纸面上看起来不错的架构文档在实践中并未得到遵循

  • 将在需要时随时创建规范详细信息,每个部分都在需要之前创建。 它不需要很漂亮、完整,甚至不需要写得很清楚,只要每个人都理解当前的任务并且你有全局观即可。
  • 当开发人员准备好编码时,一次一小部分地讨论实现。 如有必要,自己编写框架,然后让团队填写“内容”。 您想让他们专注于每项任务,而不是“即兴发挥”。
  • 随时回答出现的问题。 您的主要目标是保持团队的生产力。

2. 修复错误只是为了引入新错误
5. 没有自动化的单元测试会使情况变得更糟 尽快

  • 计划并开始单元测试。 如果可能,争取团队外部的资源。
  • 在小问题变得更大或被隐藏之前解决它们。 对每个小部分的信心可以建立对整体的信心。

7. 使用的第三方组件首先没有经过适应性测试就成为瓶颈

  • 当您不编码时集思广益解决方案。 如果可能的话,不要让他们阻止你的进步。 您可以封装它们或围绕它们编写代码吗? 替换他们?

一般建议:

  • 保持团队领先。在团队遇到问题之前预测并尝试解决问题。 在需要之前收集任何必要的信息。
  • 不断沟通。明确表示您不希望出现任何意外,并在每天中征求疑虑、问题、状态、障碍等。 鼓励整个团队协作并分享“发现”。
  • 庆祝每一次成功。称赞巧妙的解决方案、在问题解决时带上甜甜圈、展示新的工作功能……任何可以向团队表明您欣赏他们的事情。
  • 完成每项任务,然后继续前进。不要浪费时间调整、增强或返工任何不直接阻碍成功的事情。
  • 信守对团队、客户和管理层的承诺

祝你好运——请随时通知我们!

Vyas, I feel like I could have written this question. My previous job involved resurrecting a KVM project that had failed after a year's development. Specs were in the form of a user manual and developers' experience with similar products. I ended up teaching C to 3 assembly programmers and re-architecting from scratch. We brought the product successfully to market in 4 months. (Then I resigned. Go figure.)

Some of the things I'd do again, particularly with an inexperienced team:

1. A team of inexperienced programmers work 24x7
10. No technical leadership / or a Cowboy Coder that can take on the technical issues

  • Give them a (short!) break from the project to "recharge." Maybe a day, maybe an afternoon, or maybe a long lunch on you. It will mark the end of the "old" project and the beginning of success.
  • Get their agreement to work their butts off when they return, and promise that you will be their go-to guy, cheerleader, and flak jacket. You, collectively, are a team, and your job is to forge their path, eliminate distractions, and lead them.
  • Plan an immediate success, no matter how small, and maintain a "can-do" attitude.

8. Milestone after milestone missed
9. The team is not able to come up with a delivery date as nobody agrees as to the quantum of work actually needs to be done
3. Customer is screaming that he could not even do the basic stuff (Saving/Querying) etc.

  • Take small bites! Break each piece down as far as possible, then deal with the small components. You'll identify "gotchas" early and be better able to scope the whole project.
  • Define your interfaces. Anytime you can isolate a chunk, do it. This allows parallel development, because you've already decided on parameters, preconditions, assumptions, what happens inside, and return values. You can stub it out, and build other modules and tests independently.
  • Prioritize. Focus on the defects and issues that affect the customer first. New features come last. If necessary, defer features rather than delivering buggy code.
  • Assign responsibilities. Volunteers are preferred, each in his/her area of expertise, but one person must be accountable for each task.
  • Track defects, and record everything that will help you reproduce, locate, and fix them. Document any that remain at delivery time, so the customer won't be surprised.

4. Programmers used to having the spec handed down struggle to improvise
6. Architecture document that looked nice on paper was not followed in practice

  • You will create the spec details as you go, each piece just before it's needed. It needn't be pretty, complete, or even written, as long as everyone understands the current task and you've got the big picture.
  • Discuss the implementation, one piece at a time, when the developer is ready to code it. Write the skeleton yourself if necessary, and let the team fill in the "guts." You want to keep them focused on each task, without "improvising."
  • Be available to answer questions as they arise. Your primary goal is to keep the team productive.

2. Bugs are fixed only to introduce new bugs
5. No automated unit tests aggr[a]vate the situation

  • Plan and start unit testing ASAP. If possible, enlist resources outside the team.
  • Fix small problems before they grow larger--or get hidden. Confidence in each small piece builds confidence in the whole.

7. Third party components used become bottlenecks not having been tested for fitness in the first place

  • Brainstorm solutions when you're not coding. Don't let them stop your progress if at all possible. Can you encapsulate or code around them? Replace them?

General suggestions:

  • Stay ahead of the team. Anticipate and try to solve problems before your team hits them. Gather any necessary information before it's needed.
  • Communicate constantly. Make it clear that you want no surprises, and solicit concerns, questions, status, roadblocks, etc throughout each day. Encourage collaboration and share "discoveries" across the team.
  • Celebrate every success. Compliment a clever solution, bring donuts when a problem is solved, demonstrate a new working feature ... anything that shows the team you appreciate them.
  • Get each task done, then move ahead. Don't waste time tweaking, enhancing, or reworking anything that isn't a direct barrier to success.
  • Keep your promises to the team, the customer, and your management.

Good luck -- please keep us posted!

挽容 2024-07-15 09:25:44

逃跑或者找新工作。 这是一场死亡行军,他们需要一个替罪羊。

死亡行军通常会涉及
拼命尝试纠正路线
通过询问团队成员来了解该项目
工作时间特别辛苦,
周末,或者尝试“扔
(足够)机构解决问题”
结果不同,常常导致
倦怠。

Run away or find a new job. This is a death march and they need a scape goat.

Often, the death march will involve
desperate attempts to right the course
of the project by asking team members
to work especially grueling hours,
weekends, or by attempting to "throw
(enough) bodies at the problem" with
varying results, often causing
burnout.

如果没结果 2024-07-15 09:25:44

冻结版本,并开始修复程序问题......按优先级处理客户投诉(公司业务方可以优先考虑)并让程序运行。 一旦解决了最大的问题,就开始清理代码。 将任务分配给其他开发人员,并开始在所有新代码上实施编码实践。

如果你可以做任何你想做的事,那么看看真正的问题是什么并解决它们。 如果这意味着组建一个新团队从头开始开发软件,那就这样吧。 但您至少应该尝试修复主要错误。 不要费心引入新功能,它们只会使问题更加复杂,而一个不起作用且问题没有得到解决的程序会失去您的客户。

Freeze releases, and start fixing issues with the program.... deal with the customer complaints by priority (the business side of the company can prioritize) and get the program running. Once you get the biggest issues out of the way, start cleaning up the code. Assign tasks to other developers, and start enforcing coding practices on all new code.

If you can do whatever you want, then look at what the real issues are and deal with them. If that means putting together a new team to develop the software all over from scratch, so be it. But you should try to at least fix the major bugs. Don't bother introducing new features, they only compound the problem, and a program that doesn't work and the problems aren't dealt with lose you clients.

情仇皆在手 2024-07-15 09:25:44

第 10 个问题显然是最严重的问题,或者至少是所有其他问题的根源。 找到具有一定创造力和能力来交付项目的人,并让他们自由地做任何事情 - 包括重新开始。

Number 10 is obviously the worst problem, or at least the root of all others. Find someone with some creativity and ability to deliver a project, and give them free reign to do anything - including start over.

丑丑阿 2024-07-15 09:25:44

我希望你能得到很好的报酬。 无论如何,我的计划将类似于以下顺序的步骤:

0)停止在整个团队中添加特性或功能。 在执行以下步骤直至步骤 5 时允许解决错误,然后停止错误修复和修复。 恢复功能开发:

1)应用我所说的“逆向人员配置法”:较弱的团队成员会拖慢更好更快的团队成员的速度,并且通常后期的软件项目需要删除人员,而不是添加人员。 因此,您需要评估团队成员作为个人贡献者的质量。 从团队中剔除实力较弱的员工,因为可能有一些。 最好的方法是检查他们的代码并检查他们的错误修复,找出谁使代码变得更糟或更好,然后为团队砍掉它们。 现在不是指导的时候,你需要最好的人来改变,在最佳的时间内“解决”这种情况。 如果你无法解雇他们或重新分配他们,请让他们为剩下的其他人提供咖啡或其他东西。

2) 评估代码本身。 识别代码中构造得不好和/或抽象得不好的区域。 如果区域代码构建得不好和/或在其应做的事情上明显很脆弱,则将其作为重写的目标。 此时这感觉很痛苦,但从长远来看它会节省你的时间。 反复出现的错误和/或修复历史记录将有助于识别无法挽救的代码。 如果一个代码区域或模块从根本上构建得很好,但在接口级别上没有很好地抽象,那么它应该适合重构。 这将节省大量时间并且是有用的代码。 保留重写区域、重构区域和合适区域的列表。

3) 定义一个新的合理架构,您相信该架构将产生一个健壮且完整的解决方案,满足您最终想要的特性和功能。 该架构在开始时可能不是最佳的,但实际上将您所拥有的与您想要的相匹配。

4) 与利益相关者合作,决定什么是可接受的第一个版本,尝试为“以后”的版本提供尽可能多的功能。 也许你不能削减任何东西,但如果可以的话,现在就是这样做的时候了。

5) 停止后台错误修复工作,并将已定义的工作分配给(剩余的)团队,以估算出其余功能的合理的新实施计划。 他们需要掌握时间表。 滚动日程并相当保守。 现在您可以合理预测何时可以真正拥有可行且可靠的东西。

6) 实现剩余的功能,然后通过解决剩余的错误来强化版本。 我假设这里遵守了所有正常的良好软件开发实践,例如源代码控制、单元测试等。

7) 消除尽可能多的障碍,以使团队尽快开发出东西。

8) 监控问题,并尽可能亲自动手提供帮助。 在你能提供帮助的范围内主动承担更棘手的问题,同时仍然保持团队所有成员的工作效率。

祝你好运!

I hope you are getting paid really well. In any case, my plan would be something like these steps in the following order:

0) Stop adding features or functions across the team. Allow bugs to be addressed while the following steps are taken up to step 5, then stop bug fixing & resume feature development:

1) Apply what I call the Inverse Staffing Law: Weaker team members slow down the better and faster ones and generally a late software project needs people removed, not added. So, you need to assess the quality of the team members as individual contributors. Eliminate weaker staff from the team because presumably there are some. This is best done by reviewing their code and examining their bug fixes and figure out who is making the code worse vs. better and chop them for the team. This is not a time to mentor, you are going to need the best folks to have a change of "fixing" the situation in a optimal period of time. If you can't fire them or reassign them, have them getting coffee or something for everyone else left.

2) Assess the code itself. Identify areas of the code that are not constructed well and/or not well abstracted. If a area code is not constructed well and/or is obviously brittle at it what it is supposed to do, target it for a re-write. This feels painful at this point, but it will save you time in the long run. Recurring bugs and/or history of fixes will help identify the code that can't be salvaged. If a code area or module is fundamentally constructed well, but not abstracted well at the interface level, it should be suitable for re-factoring. This will save significant time and is useful code. Keep a list of the re-write areas, the re-factor areas, and the suitable areas.

3) Define a new reasonable architecture that you believe will result in a robust and complete solution to where you want to eventually be in features and functions. The architecture might not be optimal as starting clean, but in effect match up what you have with where you would like to be.

4) Work with the stake holders to decide what will make an acceptable first release attempting to table as many features as possible for "later" releases. Maybe you can't cut anything, but if you can, now is the time to do it.

5) Stop the background bug fixing efforts and assign the defined work out to the (remaining) team to estimate out a reasonable new implementation plan of the rest of the functionality. They need to own the schedule. Roll up the schedule and be fairly conservative. Now you have a reasonable prediction of when you could actually have something workable and robust.

6) Implement the remaining features and then harden up the release by tackling the remaining bugs. I am assuming all the normal good software development practices are observed here like source control, unit tests, etc.

7) Remove as many barriers as possible to keep the team cranking out stuff as fast possible.

8) Monitor for issues, and assist by getting your hands dirty where ever your can. Offer to take on the nastier issues to the extent you can help and still keep all members of the team as productive.

Good Luck!

万劫不复 2024-07-15 09:25:44

这不再是技术领导力的问题,而是项目管理的问题。

作为技术主管,您将只是在泰坦尼克号上移动躺椅。 如果我是事实上的项目经理,我会这样做。

1) 确定项目发起人和利益相关者——包括官方的和真实的。

2)去找他们并要求项目“关闭”一周。

3)如果他们不同意,就放弃这个项目。

4) 如果他们确实同意,则将项目暂停一周——一切都停止。

5) 花整整一周的时间与项目中的重要人员交谈,以确定项目的真实状态。

6) 在参与这些讨论的同时,开始制定项目恢复计划,强调范围、进度、预算和人员之间可能的权衡。

7) 在周末,决定哪些(如果有)可能的项目场景是可行的。

8) 将这些方案中的最佳方案反馈给项目发起人和利益相关者,并开始谈判。

9)当就前进的方向达成一致时,重新启动项目并祈祷 - 可能不是按这个顺序。

This isn't about technical leadership any more, it's now about project management.

You as the technical lead will just be shifting deckchairs on the Titanic. So here's what I would do if I was the de-facto project manager.

1) Identify the project sponsors and stakeholders - both the official ones and the real ones.

2) Go to them and request that the project "goes dark" for a week.

3) If they don't agree, walk away from this project.

4) If they do agree, call a project time-out for a week - everything stops.

5) Spend that whole week talking to the important people on the project to identify the real project state.

6) Whilst engaged in those discussions, start formulating a project recovery plan, emphasising possible trade-offs between scope, schedule, budget, and personnel.

7) At the end of the week, decide which (if any) of your possible project scenarios are feasible.

8) Take the best of these scenarios back to the project sponsors and stakeholders, and start negotiating.

9) When a way forward is agreed, reboot the project and pray - possibly not in that order.

打小就很酷 2024-07-15 09:25:44

常识已经被马克西姆(退出死亡行军)给你指出了。 但如果出于未知的原因你希望坚持下去,让我用我在类似情况下的经验来招待你——也许它可能会有用。

这是我在一个沉睡的老城区的第一份工作,那里很难找到好的计算机工作,大学毕业后我迫切需要一份工作。 我被录用是因为管理层认为我足够热情,可能聊胜于无(我提出带自己的补偿来节省他们给我一台电脑的费用,并提出只为体验而工作)

该项目已被放弃由于死亡行军的情况,它的创建者在删除代码中的所有注释并执行其他混淆后消失了。 也没有人了解 win32/MFC 的东西。

我只是开始在旧纸和铅笔上研究代码(大量的涂改和修改),直到在 20 天内我知道了整个代码,包括熟记在心的变量以及发生的事情和地点。

有了这些知识,我就能够做出一个以前每个人都未能完成的关键作品。 当然,这只不过是沧海一粟,但它使管理层能够赢得客户的信心“聪明的家伙 - 费了很大的劲才把他搞定 - 已经让 x 工作了 - 你将在 y 时间内让你的东西工作起来”。

一旦客户被说服并且我们能够争取到一些时间,一些压力就被消除了。 这给团队带来了一些希望,我们开始努力奋斗。 6 个月后,我晋升为项目负责人,9 个月后,我们完成了修复交付(大量进度演示,期间客户明显越来越满意)。

正如您所看到的,成功的要素是无法直接复制的。 但我总结一下,你需要首先给项目带来一些希望——展示一些进展并赢得同事、管理层和客户的信心。 一旦到位,技术问题也应该得到纠正——没有什么可以替代等式的这一部分。

如果这看起来不太可能,那么所有的艰苦工作(哦,是的 - 很多很多工作,就像你从未想象过的 - 为什么你认为它被称为死亡行军)将是一种浪费,你最好在开始之前就放弃。

我别无选择,我热血沸腾,迫切需要一份工作。 技术细节可以让我发挥魔法,一切都按部就班。 我确实通过这部作品赢得了很多善意和自尊,但从长远来看,这只是一个我可以沉着地讲述的故事,除了那些少数知情者之外,仅此而已。

事情对你来说可能会有所不同,但由你决定。

祝你好运

Common sense has already been pointed out to you by Maxim (Quit the death march). But if for reasons unknown you wish to persist, let me regale you with my experience in a similar situation - perhaps it might come useful.

It was my first job in a sleepy old town where good computer jobs where hard to come by and I despertely needed one immediately after college. I was hired coz the management thought i was enthusiastic enough and might be better than nothing (I offered to bring in my own comp to save them a cost of giving me a PC and offered to work for the experience alone)

The project had been abandoned by its creators due to the death march situation and had gone away after deleting all the comments in the code and performing other obfuscations. Nobody knew win32 / MFC stuff either.

I simply started studying the code on good old paper and pencil (lots of rubbing and corrections) until within 20 days time i knew the entire code including the variables by heart and what and where things where happening.

Armed with this knowledge i was able to make a critical piece working which had eluded everyone before. Of-course this was nothing but a drop in the ocean but it enabled the management to buy the clients confidence "smart fellow - got him with great difficulty - already got x working - u will have ur stuff working within y time".

Once the client was convinced and we where able to buy some time, some pressure was taken away. This got some hope back into the team and we started to hammer away for good. 6 months later i got promoted to project lead and 9 months later we had our fix shipment (lots of progress demos and a visibly more and more satisfied client in between).

As you can see, the elements of success are not directly duplicatable. But i would summarize that you need to breath some hope into the project first - show some progress and win confidence - that of your peers, management and the client. Once that is in place the technical stuff should be corrected too - there is nothing to replace this part of the equation.

If that does not seem likely, all that hard work (oh yes - lots and lots of work like you never imagined - why do you think its called a death march) would be a waste and you had better quit even before you start.

I had no choice and i was hot blooded and desperately need a job. The technical details where something icould work magic upon, and everthing just clicked into place. I really earned a lot of good will and self respect with that piece of work but in the long run its just a story i can narrate with great aplomb and nothing more except for those few in the know.

Things might be different for you but its for you to decide.

Good luck

我三岁 2024-07-15 09:25:44
  • 确保你不是替罪羊
  • 削减范围蔓延
  • 修剪功能“需求”
  • 实施更快的开发周期(也许是敏捷/Scrum/XP/其他)
  • Make sure you aren't the scapegoat
  • Cut scope creep
  • Trim functionality "requirements"
  • Implement a faster dev cycle (maybe Agile/Scrum/XP/whatever)
千纸鹤 2024-07-15 09:25:44

如果可以的话,就逃吧。

如果不是,您需要停止所有导致项目不稳定的活动 - 包括编码和修复缺陷。

评估你所处的位置 将

需求分解为更小的“里程碑”

阅读一些实用书籍(我想到了麦康奈尔的“软件项目生存指南”。

识别所有问题和风险。将所有这些问题和风险传达给所有相关人员。

在 你

庆祝进步和里程碑,祝

好运。它可能无法挽回 - 事情必须改变才能变得更好。

If you can, run away.

If not, you need to stop all activities that make the project unstable - including coding and fixing defects.

Assess where you are

Break up the requirements into much smaller "milestones"

Read some practical books (Mcconnell's "Software Project Survival Guide" comes to mind.

Identify all the problems and risks. Communicate all those to all involved.

Work on each piece one at a time.

Celebrate improvements and milestones as they are reached.

Good luck. Your scenario sounds pretty bad. It may not be salvageable - and things have to change to get better.

旧故 2024-07-15 09:25:44

如果你真的必须让它走上正轨(如果保释不是一个选择),

那么首先要接受这是管理上的失败。 然后,您可能想继续实施严格但轻松的流程。

我建议采用某种形式的敏捷,因为它是最容易在没有专家的情况下成功实施的,但你必须对此非常严格,包括配对、无情重构、评论、尖峰功能、可见性、TDD、一周周期、每天工作 8 小时(是的,超过 8 小时往往对生产力的损害大于帮助,正如您似乎已经注意到的那样)...

也不要删除任何内容。 敏捷的某些部分依赖于其他部分——如果没有配对、重构和测试,你就无法消除前期设计(最大的敏捷失败之一)。

不要忘记它的管理方面。 开始一周迭代(每周演示)。 不断适应。 每天都有很短的站立会议来解决问题。 (最多保持 15 分钟,列出更长的问题等)燃尽图,核心团队与客户。

你不能只是每周举行一次 15 分钟的会议和两周的迭代并称之为敏捷,但如果你做得正确,它可能会给你一个机会。 您可能会聘请一位优秀的敏捷顾问来培训您入门。

另外,不断评估什么有效,什么无效。 准备好修复不起作用的地方。 每周召开一次会议,分析当周的开发成功和失败。

总体而言,它可以发挥作用,并且可以使一个摇摇欲坠的团队恢复正常,但这并不是微不足道的。 最好的部分是您可以实现它,而无需在当前的开发中花费大量时间。 你只是不断发展,但你会做得更好。

If you really had to get it on track (if bailing isn't an option)

Start off by accepting that it's a failure in management. You might then want to go on to implementing a strict but light process.

I'd suggest some form of Agile, since it's the easiest to successfully implement without a GURU, but you have to be VERY strict about it, including Pairing, Ruthless Refactoring, Reviews, Spiking functionality, Visibility, TDD, one-week cycles, 8-hour workdays (Yes, longer than 8 tends to harm productivity more than help, as you seem to have noticed)...

Don't be cutting anything out either. Parts of Agile rely on other parts--without the pairing, refactoring and testing you cannot eliminate upfront design (one of the biggest agile failures).

Don't forget about the management side of it. One week iterations to start (demo EVERY week). Constant adaptation. Very short stand-ups every day to address issues. (Keep to 15 minutes max, table longer issues, etc) Burndown charts, core-team with a client on it.

You can't just have a 15 minute meeting every week and 2 week iterations and call it Agile, but if you do it right, it just MIGHT give you a chance. You might get a GOOD agile consultant in to train you on getting started.

Also, constantly evaluate what works and what doesn't. Be prepared to fix what doesn't work. Weekly meetings to analyze that weeks' development successes and failures.

Overall it CAN work, and can bring a flailing team into line, but it's not trivial. The nicest part is that you can implement it without taking huge chunks of time out of your current development. You just keep developing, but you do it better.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文