Make the Invisible More Visible - Revision history

JonJagger at 09:41, 8 August 2009

JonJagger — Sat, 08 Aug 2009 09:41:08 GMT

←Older revision		Revision as of 09:41, 8 August 2009
Line 13:		Line 13:
	* Writing unit tests provides evidence about how easy the code unit is to unit test. It helps reveal the presence (or absence) of developmental qualities you'd like the code to exhibit; qualities such as low coupling and high cohesion.		* Writing unit tests provides evidence about how easy the code unit is to unit test. It helps reveal the presence (or absence) of developmental qualities you'd like the code to exhibit; qualities such as low coupling and high cohesion.

-	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.	+	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) of runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

	* Using bulletin boards and cards makes progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.		* Using bulletin boards and cards makes progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.

JonJagger at 04:57, 19 July 2009

JonJagger — Sun, 19 Jul 2009 04:57:13 GMT

←Older revision		Revision as of 04:57, 19 July 2009
Line 9:		Line 9:
	* If your project is apparently on track and one week later it's six months late you have problems, the biggest of which is probably ''not'' that it's six months late, but the invisibility force fields powerful enough to hide six months of lateness! Lack of visible progress is synonymous with lack of progress.		* If your project is apparently on track and one week later it's six months late you have problems, the biggest of which is probably ''not'' that it's six months late, but the invisibility force fields powerful enough to hide six months of lateness! Lack of visible progress is synonymous with lack of progress.

-	Invisibility can be dangerous. You manage things better when you can see them and see them constantly changing~~. Your thoughts are clearer when you have something concrete to tie your thinking to~~:	+	Invisibility can be dangerous. You think more clearly when you have something concrete to tie your thinking to. You manage things better when you can see them and see them constantly changing:

	* Writing unit tests provides evidence about how easy the code unit is to unit test. It helps reveal the presence (or absence) of developmental qualities you'd like the code to exhibit; qualities such as low coupling and high cohesion.		* Writing unit tests provides evidence about how easy the code unit is to unit test. It helps reveal the presence (or absence) of developmental qualities you'd like the code to exhibit; qualities such as low coupling and high cohesion.
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* Using bulletin boards and cards makes ~~abstract ideas like~~ progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.	+	* Using bulletin boards and cards makes progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.

	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.		* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.

JonJagger at 04:45, 19 July 2009

JonJagger — Sun, 19 Jul 2009 04:45:51 GMT

←Older revision		Revision as of 04:45, 19 July 2009
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* ~~Bulletin~~ boards and cards ~~make~~ abstract ideas like progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.	+	* Using bulletin boards and cards makes abstract ideas like progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.

	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.		* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.

Kevlin at 03:29, 19 July 2009

Kevlin — Sun, 19 Jul 2009 03:29:50 GMT

←Older revision		Revision as of 03:29, 19 July 2009
Line 14:		Line 14:

	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.
		+
		+	* Bulletin boards and cards make abstract ideas like progress visible and concrete. Tasks can be seen as ''Not Started'', ''In Progress'', or ''Done'' without reference to a hidden project management tool and without having to chase programmers for fictional status reports.

	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.		* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.

JonJagger at 10:47, 10 July 2009

JonJagger — Fri, 10 Jul 2009 10:47:35 GMT

←Older revision		Revision as of 10:47, 10 July 2009
Line 3:		Line 3:
	* Source code has no innate presence, no innate behavior, and doesn't obey the laws of physics. It's visible when you load it into an editor, but close the editor and it's gone. Think about it too long and, like the tree falling down with no one to hear it, you start to wonder if it exists at all.		* Source code has no innate presence, no innate behavior, and doesn't obey the laws of physics. It's visible when you load it into an editor, but close the editor and it's gone. Think about it too long and, like the tree falling down with no one to hear it, you start to wonder if it exists at all.

-	* A running application has presence and behavior, but reveals nothing of the source code it was built from. ~~The number of pixels~~ Google's home page ~~lights up~~ is pleasingly minimal; the goings on behind ~~the pixels~~ are surely substantial.	+	* A running application has presence and behavior, but reveals nothing of the source code it was built from. Google's home page is pleasingly minimal; the goings on behind it are surely substantial.

	* If you're 90% done and endlessly stuck trying to debug your way through the last 10% then you're not 90% done, are you? Fixing bugs is not making progress. You aren't paid to debug. Debugging is waste. It's good to make waste more visible so you can see it for what it is and start thinking about trying not to create it in the first place.		* If you're 90% done and endlessly stuck trying to debug your way through the last 10% then you're not 90% done, are you? Fixing bugs is not making progress. You aren't paid to debug. Debugging is waste. It's good to make waste more visible so you can see it for what it is and start thinking about trying not to create it in the first place.

JonJagger at 08:44, 10 July 2009

JonJagger — Fri, 10 Jul 2009 08:44:52 GMT

←Older revision		Revision as of 08:44, 10 July 2009
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software ~~reveal the~~ reality; estimates do not.	+	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveals reality; estimates do not.

	It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.		It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.

JonJagger at 08:43, 10 July 2009

JonJagger — Fri, 10 Jul 2009 08:43:08 GMT

←Older revision		Revision as of 08:43, 10 July 2009
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence ~~such as demos and~~ releasable software.	+	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence. Completion of releasable software reveal the reality; estimates do not.

	It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.		It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.

JonJagger at 22:01, 9 July 2009

JonJagger — Thu, 09 Jul 2009 22:01:41 GMT

←Older revision		Revision as of 22:01, 9 July 2009
Line 5:		Line 5:
	* A running application has presence and behavior, but reveals nothing of the source code it was built from. The number of pixels Google's home page lights up is pleasingly minimal; the goings on behind the pixels are surely substantial.		* A running application has presence and behavior, but reveals nothing of the source code it was built from. The number of pixels Google's home page lights up is pleasingly minimal; the goings on behind the pixels are surely substantial.

-	* ~~Lack of visible management is synonymous with lack of management.~~ If ~~your project is apparently on track and one week later it~~'~~s six months late~~ you ~~have problems~~, ~~the biggest of which~~ is ~~probably ''~~not'~~' that it~~'s ~~six months late, but the invisibility force fields powerful enough~~ to ~~hide six months of lateness!~~	+	* If you're 90% done and endlessly stuck trying to debug your way through the last 10% then you're not 90% done, are you? Fixing bugs is not making progress. You aren't paid to debug. Debugging is waste. It's good to make waste more visible so you can see it for what it is and start thinking about trying not to create it in the first place.

-	* ~~Lack of visible progress~~ is ~~synonymous with lack of progress. If you~~'~~re 90% done and endlessly stuck trying to debug your way through the last 10% then~~ you~~'re not 90% done~~, ~~are you? Fixing bugs~~ is not ~~making progress. You aren~~'~~t paid to debug. Debugging is waste. It~~'s ~~good~~ to ~~make waste more~~ visible ~~so you can see it for what it~~ is ~~and start thinking about trying not to create it in the first place~~.	+	* If your project is apparently on track and one week later it's six months late you have problems, the biggest of which is probably ''not'' that it's six months late, but the invisibility force fields powerful enough to hide six months of lateness! Lack of visible progress is synonymous with lack of progress.

	Invisibility can be dangerous. You manage things better when you can see them and see them constantly changing. Your thoughts are clearer when you have something concrete to tie your thinking to:		Invisibility can be dangerous. You manage things better when you can see them and see them constantly changing. Your thoughts are clearer when you have something concrete to tie your thinking to:

JonJagger at 21:03, 9 July 2009

JonJagger — Thu, 09 Jul 2009 21:03:22 GMT

←Older revision		Revision as of 21:03, 9 July 2009
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* Doing ~~iterative and~~ incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development ~~progress~~ evidence such as demos and releasable software.	+	* Doing incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development evidence such as demos and releasable software.

	It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.		It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.

JonJagger at 19:46, 9 July 2009

JonJagger — Thu, 09 Jul 2009 19:46:47 GMT

←Older revision		Revision as of 19:46, 9 July 2009
Line 15:		Line 15:
	* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.		* Running unit tests provides evidence about the code's behavior. It helps reveal the presence (or absence) runtime of qualities you'd like the application to exhibit; qualities such as robustness and correctness.

-	* Doing iterative and incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development progress evidence.	+	* Doing iterative and incremental development increases the visibility of development progress (or lack of it) by increasing the frequency of development progress evidence such as demos and releasable software.

	It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.		It's best to develop software with plenty of regular visible evidence. Visibility gives confidence that progress is genuine and not an illusion, deliberate and not unintentional, repeatable and not accidental.