软件开发的两种态度
来源:互联网 发布:广西广电网络套餐介绍 编辑:程序博客网 时间:2024/05/19 14:00
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
Martin Fowler说,软件开发(准确说,软件团队的领导者)有两种态度:“指导者”和“激发者”。所谓“指导者”,是认为大多数开发者不具备足够的能力,因此要给他们足够的限制;所谓“激发者”,是认为开发者具有足够的潜力,因此要给他们相当的自由(和足够的监护),让他们充分发挥自己的才华。 相比之下,我更喜欢扮演“激发者”的角色——不解内情的人常常把一个激发者带领的团队称为“精英团队”之类的,这对于团队成员本身就是一种足够的荣誉,足以激励他们去钻研自己的技艺了。 | design | 8 March 2004 |
Many debates in software development are underpinned by whether the speaker has a DirectingAttitude or an EnablingAttitude. These different attitudes affect choices over languages, designs, tools, processes, and lots more. Here's some examples of this dichotomy:
These aren't hard-wired attitudes. Often people are directing in some cases and enabling in others. But I think there is a deep strain running through here, often a personality issue, that runs underneath much discussion on how we do software. (I'm very much in the enabling category, as if you can't tell.) You might think that all restrictions on what a developer does imply a directing attitude, but it's not that simple. As an example, consider memory management. You can think of this as a directing feature: programmers can't be trusted to manage memory correctly so take away their ability to allocate memory. But I look at memory management as an enabling technology - it takes away something I don't want to worry about, so I can concentrate better on those things I do care about. |
------------------------
DirectingAttitude | design | |
One of two SoftwareDevelopmentAttitudes. The directing attitude says that since most developers aren't that good (it's rumored that almost 50% are below average) we need to direct the way they do things. This direction is to prevent them from causing harm to the system they are working on. Typically this attitude manifests itself in designs and tools that prevent developers from doing certain things, limiting what they can do to keep them away from complex areas. People with an EnablingAttitude criticize this whips-and-chains attitude by saying you can't foolproof anything, because fools are ingenious and will figure out how to abuse any system. |
EnablingAttitude | design | |
One of two SoftwareDevelopmentAttitudes.The enabling attitude takes the view that developers are responsible professionals and so should be given the freedom to do whatever they need to do. Designs that follow this attitude should make things easy to use well but should assume that developers know what they are doing and thus not try hard to prevent something being used badly. As such these tools can be misused, but take the attitude that users should know better, and if they don't they deserve all they get. People with a DirectingAttitude criticize this elitist attitude by saying it can only be used by the upper quartile of software developers. As such they just aren't practical for the general bell curve of software developers. |
- 软件开发的两种态度
- 软件开发态度
- 软件开发态度
- 孔夫子的两种就业态度
- 软件开发的两种架构
- 一件事情两种态度
- 产品开发的工作态度
- 提高软件开发效率的两种工作模式
- 戴尔让APP软件开发"有态度"的云计算服务
- (分享)我们对软件的态度
- 人生的两种态度 - 事找你?还是你找事?
- 我对敏捷开发的态度[转]
- 良好的工作态度---两年工作的深切体会
- 交接两位同事的工作,体会不一样的态度
- IT高管对企业SaaS软件的三种态度
- 工作的三种态度
- 学习C语言要具备两种态度
- 对做软件和从事IT行业的态度
- ASP.NET To HTML
- [SIP]SIP之穿越NAT
- IT职业教育(2)IT培训教材的优劣
- Bea user group的BPM主题会后随笔
- "SymbianOS Error -3606"问题解决了
- 软件开发的两种态度
- 最长公共子序列
- [JavaME]手机申请移动分配的动态IP?(2)
- [WiX]我的第一个WiX安装脚本
- 瞎想CSDN之未来
- 新一轮FUD:停止相信自由软件?
- 我对BPM认识之路(8):区分Workflow与BPM
- 在CSDN写blog应该具备的精神
- [JavaME]手机是否能够申请到动态IP?