3 ms·

I feel that Brooks puts a time horizon of 10 years on his predictions because of AI. If we achieve AGI, then that would be an obvious example of something overn

I feel that Brooks puts a time horizon of 10 years on his predictions because of AI. If we achieve AGI, then that would be an obvious example of something overnight which would yield (at least) a 10x improvement of productivity. But I think it was a safe bet for Brooks to say we wouldn't be there by 1997. That said, on the topic of environments and tools Brooks writes, "Surely this work is worthwhile, and surely it will bear some fruit in both productivity and reliability. But by its very nature, the return from now on must be marginal." This claim is not timeboxed to a decade, but is instead projected to perpetuity. He boldly asserts without support that that from now on, improvements to tooling environments definitionally cannot yield 10x improvements in programming. I think this is where people have taken issue, and have shown this claim to be wrong. I think this error comes from a misconception in the previous paragraph: "Language-specific smart editors are developments not yet widely used in practice, but the most they promise is freedom from syntactic errors and simple semantic errors." There is no reason to believe that language-specific smart editors could only save you from simple semantic errors and syntax. In fact, language specific editors in the ethos of Eve and Light Table supported sophisticated debugging and development modalities: - time-travel debugging capabilities that rewind the state of a program to a previous point in its execution history - what-if scenarios to test how the program would respond to different inputs without restarting it - provenance tracing of program state to see how it was calculated - live debugging and modification of a program while it's running - saving, sharing, and replaying program state to trace bugs - the ability to ask new questions about program output e.g. "Why is nothing drawing in this area of the screen?" These are not "simple semantic errors" but deep program analyses and insights that are not even supported by most (any?) mainstream languages (nor could they be without changing core language semantics or adding on new language features with orthogonal semantics). Brooks doesn't imagine any of this and dismisses it all as "marginal" whereas in my experience actually using these tools, I found them literally transformative to my productivity and workflow.

igouy 5y ago
Probably just my misunderstanding: Some of the items in your list sound like things that were features of Smalltalk IDEs back in the late 80s ? - time-travel debugging - live debugging and modification - saving, sharing, and replaying p304 "Debugger Windows" "Smalltalk/V 286 Tutorial and Programming Handbook" https://rmod-files.lille.inria.fr/FreeBooks/SmalltalkVTutorial/SmalltalkVTutorial.pdf https://rmod-files.lille.inria.fr/FreeBooks/SmalltalkVTutori... ---- And later, Rewrite Rules: A very large Smalltalk application was developed at Cargill to support the operation of grain elevators and the associated commodity trading activities. The Smalltalk client application has 385 windows and over 5,000 classes. About 2,000 classes in this application interacted with an early (circa 1993) data access framework. The framework dynamically performed a mapping of object attributes to data table columns. Analysis showed that although dynamic look up consumed 40% of the client execution time, it was unnecessary. A new data layer interface was developed that required the business class to provide the object attribute to column mapping in an explicitly coded method. Testing showed that this interface was orders of magnitude faster. The issue was how to change the 2,100 business class users of the data layer. A large application under development cannot freeze code while a transformation of an interface is constructed and tested. We had to construct and test the transformations in a parallel branch of the code repository from the main development stream. When the transformation was fully tested, then it was applied to the main code stream in a single operation. Less than 35 bugs were found in the 17,100 changes. All of the bugs were quickly resolved in a three-week period. If the changes were done manually we estimate that it would have taken 8,500 hours, compared with 235 hours to develop the transformation rules. The task was completed in 3% of the expected time by using Rewrite Rules. This is an improvement by a factor of 36. from “Transformation of an application data layer” Will Loew-Blosser OOPSLA 2002 http://portal.acm.org/citation.cfm?id=604258 http://portal.acm.org/citation.cfm?id=604258

igouy 5y ago

Probably just my misunderstanding: Some of the items in your list sound like things that were features of Smalltalk IDEs back in the late 80s ? - time-travel debugging - live debugging and modification - saving, sharing, and replaying p304 "Debugger Windows" "Smalltalk/V 286 Tutorial and Programming Handbook" https://rmod-files.lille.inria.fr/FreeBooks/SmalltalkVTutorial/SmalltalkVTutorial.pdf https://rmod-files.lille.inria.fr/FreeBooks/SmalltalkVTutori... ---- And later, Rewrite Rules: A very large Smalltalk application was developed at Cargill to support the operation of grain elevators and the associated commodity trading activities. The Smalltalk client application has 385 windows and over 5,000 classes. About 2,000 classes in this application interacted with an early (circa 1993) data access framework. The framework dynamically performed a mapping of object attributes to data table columns. Analysis showed that although dynamic look up consumed 40% of the client execution time, it was unnecessary. A new data layer interface was developed that required the business class to provide the object attribute to column mapping in an explicitly coded method. Testing showed that this interface was orders of magnitude faster. The issue was how to change the 2,100 business class users of the data layer. A large application under development cannot freeze code while a transformation of an interface is constructed and tested. We had to construct and test the transformations in a parallel branch of the code repository from the main development stream. When the transformation was fully tested, then it was applied to the main code stream in a single operation. Less than 35 bugs were found in the 17,100 changes. All of the bugs were quickly resolved in a three-week period. If the changes were done manually we estimate that it would have taken 8,500 hours, compared with 235 hours to develop the transformation rules. The task was completed in 3% of the expected time by using Rewrite Rules. This is an improvement by a factor of 36. from “Transformation of an application data layer” Will Loew-Blosser OOPSLA 2002 http://portal.acm.org/citation.cfm?id=604258 http://portal.acm.org/citation.cfm?id=604258