If your team does not have any other projects to work on, ask experienced programmers of your your team to come up with at prototype so that you can create a requirement doc according to the needs of the client.
Also programmers novice to the technologies being used in the team could utilize this time to familiarize themselves with the technologies on which your team is going to develop the project.
Chances are that all of your developers can help with the design; let them. Architects don't have to be "lone wolves" and do everything themselves. You lay out the guidelines and the principles and the scaffolding, rough in the wiring, and let your developers flesh out the details - whether it is drawing Visio diagrams or building prototypes to mitigate unknowns/risks.
Migrate towards Agile/XP and away from waterfall methods, and you'll find the team a lot more help.
When making the general design, it's very handy to have programmers create proof-of-concepts. Do that especially with parts of the system that could end up being show stoppers if they don't work in the way you plan to do them, so you can think of alternatives, and adjust the design.
That's going to help you to make the right design-decisions before moving entirely into a certain direction.
Just doing a design, and then moving on and start coding is a sure way to mess up a project. You won't realize that your design is not feasible (or just plain sucks) until you're half-way coding, and by then it's too late to make radical changes.
You'll waste time mitigating non-existing problems during the design, and you'll run into unforeseen problems during implementation.
Generally the various stages overlap, so there will be some coding during design etc. There are a lot of things to do besides that. They can be reviewing unfamiliar technology that is going to be used, setting up source control system, reviewing business requirements, reviewing your documents to make sure they make sense and are clear. There is a lot of other work to be done besides programming.
What a software team does while the lead does the design is very different from company to company. On my company we try to work on the design while the developers are finalizing other projects or solving bugs.
Another approach that I've taken when starting a whole new project is to get the developers to work on the design as well - people with a good understanding of the requirements can help you designing smaller parts of the system and writing the specs for them. Others can work on mockups, frameworks. This worked rather well for the small software team I led in a previous job (4 developers in total).
I also found it useful to have other team members research parts I'm unsure of (or even validating that things I think should work will indeed work), such as:
Investigating whether an external API provides the features we need
Writing a small proof of concept or technology demonstrator
Create an API mockup (header file, interface or REST endpoint) to investigate whether the API looks useful.
As other have said, you typically want a ramp-up period during the first part of the project, and through the first iteration. You're planning on building this iteratively, aren't you? Start with a core team (nor more than 3-4 people, since you're going to need to communicate heavily with each other) to help you explore the requirements, get a basic data model in place, identify and setup any frameworks, identify and setup build and test tools. Some coding activities typically take place in the design phase: for UI mockups, run-ahead prototypes of technically sensitive areas (whatever risks you have should be mitigated by explirative coding: be they new technologies, undocumented interfaces to integrated systems, or unstable requirements).
But coders in the design phase should help with the design, in order to get their buy-in, and to help train up the rest of the team during the first iterations. Your role during this is to ensure that the major nonfunctional requirements (e.g. are known, prioritized, are met by the design, and can be tested). You should also collaborate with the project lead or whoever else is responsible for staffing and financing in order to sketch out the iterations and the staffing levels needed. Ensure the solution can be built iteratively, and aim at implementing only a basic structure during the first iteration, both to build confidence, and to eliminate risks. (Sometimes, you can push major risks to the second iteration, and focus the first towards confidence and team building.)
And of course, be sure you are not designing every detail. You should be able to use every design artifact in the next iteration (and elaborate them later as needed). Since design decisions are expensive to change, try to postpone them. However, some influence the entire solution (for instance, the data model, or your approach to security) and absolutely must be at least outlined up front. This isn't waterfall. This is just not closing your eyes and hoping a viable architecture will emerge by magic.
But design proceeds throughout the iterations. It's just that you do less of it as you go along, and with lesser impact on the solution (unless you're unlucky... and then things get expensive).
If there is no overlap with another ongoing project, getting them involved as you're doing is great, maybe push it a little further by having them prototype and present the plus and minus of alternative technologies (APIs, frameworks, libraries, etc...) that your project could use.
As a new software architect, I can recommend some books that helped me understand the role of the architect (but of course not to master it):
Fundamentals of Software Architecture An Engineering Approach:
This book gives good modern overview of software architecture and its many aspects, good place to start if you are a beginner or broaden your knowlage.
Software Architecture in Practice:
Explains what software architecture is, why it's important, and how to design, instantiate, analyze, evolve, and manage it in disciplined and effective ways.
Software Architect's Handbook:
This book takes you through all the important concepts, right from design principles to different considerations at various stages of your career in software architecture. It begins by covering the fundamentals, benefits, and purpose of software architecture.
Clean Architecture: A Craftsman's Guide to Software Structure and Design:
Learn what software architects need to achieve and how to achieve it, master essential software design principles and see how designs and architectures go wrong.
Software Architecture: The Hard Parts:
An advanced architecture book, with this book, you'll learn how to think critically about the trade-offs involved with distributed architectures.
Usually there's another project they can work on, but...
I have my team review the project specs/requirements and put together a basic/preliminary structure to get them already thinking through the application and working out specific questions.
When we convene at the table to discuss the plan they already have an idea of what the project is and requires and in some cases, they present questions I may have missed or overlooked.
Although it's too late now, a good way to approach it is to move the architect over before his current project has ended. Start freeing him up at like 25% then work your way up to 75-100% on the new project a month or two before it starts (maybe more depending on how much analysis and customer interaction there is).
On a trivial project (let's say 2 man-years) it might not be necessary, but anything bigger than that can end up in chaos if somebody doesn't at least get the analysis right before everybody jumps aboard.
发布评论
评论（11）
如果您的团队没有任何其他项目可以进行，请让您团队中经验丰富的程序员提出原型，以便您可以根据客户的需求创建需求文档。
此外，对团队中使用的技术不熟悉的程序员也可以利用这段时间来熟悉团队将要开发项目的技术。
If your team does not have any other projects to work on, ask experienced programmers of your your team to come up with at prototype so that you can create a requirement doc according to the needs of the client.
Also programmers novice to the technologies being used in the team could utilize this time to familiarize themselves with the technologies on which your team is going to develop the project.
建筑师 != 设计师
很可能所有的开发人员都可以帮助设计； 让他们。 建筑师不必成为“独狼”，自己完成所有事情。 您列出指导方针、原则和脚手架，进行粗略的接线，然后让您的开发人员充实细节 - 无论是绘制 Visio 图表还是构建原型以减轻未知数/风险。
迁移到敏捷/XP 并远离瀑布方法，您会发现团队获得了更多帮助。
architect != designer
Chances are that all of your developers can help with the design; let them. Architects don't have to be "lone wolves" and do everything themselves. You lay out the guidelines and the principles and the scaffolding, rough in the wiring, and let your developers flesh out the details - whether it is drawing Visio diagrams or building prototypes to mitigate unknowns/risks.
Migrate towards Agile/XP and away from waterfall methods, and you'll find the team a lot more help.
在进行总体设计时，让程序员创建概念验证非常方便。 尤其是对于系统中的某些部分，如果它们不按照您计划的方式工作，最终可能会成为阻碍，那么您就可以考虑替代方案，并调整设计。
这将帮助您在完全进入某个方向之前做出正确的设计决策。
仅仅进行设计，然后继续并开始编码肯定会搞砸项目。 直到你编码到一半时，你才会意识到你的设计是不可行的（或者只是简单地糟糕），到那时再做出根本性的改变就太晚了。
在设计过程中，您会浪费时间来缓解不存在的问题，并且在实施过程中会遇到不可预见的问题。
When making the general design, it's very handy to have programmers create proof-of-concepts. Do that especially with parts of the system that could end up being show stoppers if they don't work in the way you plan to do them, so you can think of alternatives, and adjust the design.
That's going to help you to make the right design-decisions before moving entirely into a certain direction.
Just doing a design, and then moving on and start coding is a sure way to mess up a project. You won't realize that your design is not feasible (or just plain sucks) until you're half-way coding, and by then it's too late to make radical changes.
You'll waste time mitigating non-existing problems during the design, and you'll run into unforeseen problems during implementation.
一般来说各个阶段是重叠的，所以在设计等过程中会有一些编码。除此之外还有很多事情要做。 他们可以审查将要使用的不熟悉的技术、建立源代码控制系统、审查业务需求、审查您的文档以确保它们有意义且清晰。 除了编程之外还有很多其他的工作要做。
Generally the various stages overlap, so there will be some coding during design etc. There are a lot of things to do besides that. They can be reviewing unfamiliar technology that is going to be used, setting up source control system, reviewing business requirements, reviewing your documents to make sure they make sense and are clear. There is a lot of other work to be done besides programming.
当领导负责设计时，软件团队所做的事情因公司而异。 在我的公司，我们尝试在开发人员完成其他项目或解决错误的同时进行设计。
我在开始一个全新项目时采取的另一种方法是让开发人员也参与设计——对需求有深入了解的人可以帮助您设计系统的较小部分并为其编写规范。 其他人可以研究模型、框架。 这对于我在之前的工作中领导的小型软件团队（总共 4 名开发人员）来说效果相当好。
我还发现让其他团队成员研究我不确定的部分（甚至验证我认为应该有效的事情确实有效）很有用，例如：
What a software team does while the lead does the design is very different from company to company. On my company we try to work on the design while the developers are finalizing other projects or solving bugs.
Another approach that I've taken when starting a whole new project is to get the developers to work on the design as well - people with a good understanding of the requirements can help you designing smaller parts of the system and writing the specs for them. Others can work on mockups, frameworks. This worked rather well for the small software team I led in a previous job (4 developers in total).
I also found it useful to have other team members research parts I'm unsure of (or even validating that things I think should work will indeed work), such as:
正如其他人所说，您通常希望在项目的第一部分以及第一次迭代期间有一个加速期。 您打算迭代地构建这个，不是吗？从一个核心团队（不超过 3-4 人，因为你们需要彼此频繁沟通）开始帮助您探索需求、建立基本数据模型、识别和设置任何框架、识别和设置构建和测试工具。 一些编码活动通常发生在设计阶段：对于技术敏感领域的UI模型、提前运行原型（无论您面临什么风险都应该通过探索性编码来减轻：它们新技术、未记录的集成系统接口或不稳定的需求）。
但是设计阶段的程序员应该帮助设计，以获得他们的支持，并在第一次迭代期间帮助培训团队的其他成员。 在此期间，您的角色是确保主要非功能性需求（例如，已知、优先考虑、设计满足，并且可以测试）。 您还应该与项目负责人或负责人员配备和融资的其他人员合作，以便勾勒出所需的迭代和人员配备水平。 确保解决方案可以迭代构建，并旨在在第一次迭代期间仅实现基本结构，既可以建立信心，又可以消除风险。 （有时，您可以将主要风险推到第二次迭代，并将第一次迭代的重点放在信心和团队建设上。）
当然，请确保您没有设计每个细节。 您应该能够在下一次迭代中使用每个设计工件（并在以后根据需要详细说明它们）。 由于更改设计决策的成本很高，因此请尝试推迟它们。 然而，有些因素会影响整个解决方案（例如，数据模型或安全方法），并且绝对必须至少预先概述。 这不是瀑布。 这并不是闭上眼睛，希望一个可行的架构会神奇地出现。
但设计在整个迭代过程中不断进行。 只是随着你的进展，你做的事情越来越少，对解决方案的影响也越来越小（除非你不走运……然后事情就会变得昂贵）。
As other have said, you typically want a ramp-up period during the first part of the project, and through the first iteration. You're planning on building this iteratively, aren't you? Start with a core team (nor more than 3-4 people, since you're going to need to communicate heavily with each other) to help you explore the requirements, get a basic data model in place, identify and setup any frameworks, identify and setup build and test tools. Some coding activities typically take place in the design phase: for UI mockups, run-ahead prototypes of technically sensitive areas (whatever risks you have should be mitigated by explirative coding: be they new technologies, undocumented interfaces to integrated systems, or unstable requirements).
But coders in the design phase should help with the design, in order to get their buy-in, and to help train up the rest of the team during the first iterations. Your role during this is to ensure that the major nonfunctional requirements (e.g. are known, prioritized, are met by the design, and can be tested). You should also collaborate with the project lead or whoever else is responsible for staffing and financing in order to sketch out the iterations and the staffing levels needed. Ensure the solution can be built iteratively, and aim at implementing only a basic structure during the first iteration, both to build confidence, and to eliminate risks. (Sometimes, you can push major risks to the second iteration, and focus the first towards confidence and team building.)
And of course, be sure you are not designing every detail. You should be able to use every design artifact in the next iteration (and elaborate them later as needed). Since design decisions are expensive to change, try to postpone them. However, some influence the entire solution (for instance, the data model, or your approach to security) and absolutely must be at least outlined up front. This isn't waterfall. This is just not closing your eyes and hoping a viable architecture will emerge by magic.
But design proceeds throughout the iterations. It's just that you do less of it as you go along, and with lesser impact on the solution (unless you're unlucky... and then things get expensive).
停止做那些无用的事情，开始用它们编码吧！ ;)
Stop doing the useless things you do and just start coding with them! ;)
如果与另一个正在进行的项目没有重叠，让他们参与你正在做的事情是很好的，也许可以通过让他们制作原型并展示替代技术（API、框架、库等）的优缺点来进一步推动它。 .）您的项目可以使用。
If there is no overlap with another ongoing project, getting them involved as you're doing is great, maybe push it a little further by having them prototype and present the plus and minus of alternative technologies (APIs, frameworks, libraries, etc...) that your project could use.
作为一个新的软件架构师，我可以推荐一些帮助我理解架构师角色的书籍（但当然不是掌握它）：
软件架构基础知识和工程方法：
这本书对软件架构及其许多方面进行了很好的现代概述，如果您是初学者或拓宽知识面，这是一个很好的起点。
实践中的软件架构：
解释什么是软件架构，为什么它很重要，以及如何以规范且有效的方式设计、实例化、分析、发展和管理它。
软件架构师手册：
本书将带您了解所有重要概念，从设计原则到软件架构职业生涯各个阶段的不同考虑因素。 它首先介绍软件架构的基础知识、优点和目的。
清洁架构：软件结构和设计工匠指南：
了解软件架构师需要实现什么以及如何实现它，掌握基本的软件设计原则并了解设计和架构如何出错。
软件架构：困难部分：
一本高级架构书籍，通过本书，您将学习如何批判性地思考分布式架构所涉及的权衡。
As a new software architect, I can recommend some books that helped me understand the role of the architect (but of course not to master it):
Fundamentals of Software Architecture An Engineering Approach:
This book gives good modern overview of software architecture and its many aspects, good place to start if you are a beginner or broaden your knowlage.
Software Architecture in Practice:
Explains what software architecture is, why it's important, and how to design, instantiate, analyze, evolve, and manage it in disciplined and effective ways.
Software Architect's Handbook:
This book takes you through all the important concepts, right from design principles to different considerations at various stages of your career in software architecture. It begins by covering the fundamentals, benefits, and purpose of software architecture.
Clean Architecture: A Craftsman's Guide to Software Structure and Design:
Learn what software architects need to achieve and how to achieve it, master essential software design principles and see how designs and architectures go wrong.
Software Architecture: The Hard Parts:
An advanced architecture book, with this book, you'll learn how to think critically about the trade-offs involved with distributed architectures.
通常他们可以从事另一个项目，但是......
我让我的团队审查项目规格/要求，并整理出一个基本/初步结构，让他们已经思考应用程序并解决具体问题。
当我们聚在一起讨论计划时，他们已经了解了项目是什么和需要什么，在某些情况下，他们提出了我可能错过或忽视的问题。
Usually there's another project they can work on, but...
I have my team review the project specs/requirements and put together a basic/preliminary structure to get them already thinking through the application and working out specific questions.
When we convene at the table to discuss the plan they already have an idea of what the project is and requires and in some cases, they present questions I may have missed or overlooked.
虽然现在已经太晚了，但解决这个问题的一个好方法是在架构师当前的项目结束之前将其调走。 开始让他腾出 25% 左右的时间，然后在新项目开始前一两个月将他的精力提高到 75-100%（也许更多，具体取决于有多少分析和客户互动）。
对于一个微不足道的项目（假设是 2 人年），这可能没有必要，但如果有人在每个人都开始之前没有至少得到正确的分析，任何比这个更大的项目都可能会陷入混乱。
Although it's too late now, a good way to approach it is to move the architect over before his current project has ended. Start freeing him up at like 25% then work your way up to 75-100% on the new project a month or two before it starts (maybe more depending on how much analysis and customer interaction there is).
On a trivial project (let's say 2 man-years) it might not be necessary, but anything bigger than that can end up in chaos if somebody doesn't at least get the analysis right before everybody jumps aboard.