) was the programming language and environment that originally defined objects for me - and many others including WardAndKent
. I'm convinced that using Smalltalk helped me on the way to a philosophy of development that is very close to ExtremeProgramming
, as discriptigated on Wiki.
So could XP have arisen without Smalltalk?
I've wondered this myself. I've even asked if XP only works in Smalltalk and been told absolutely not. Although JavaLanguage
coding goes a little slower, the difference appears to be bounded and not often significant compared to other project costs. But could XP have been discovered/assembled on a Java project? That's hard to say. -- WardCunningham
It would *have* to be discovered, otherwise Java programmers would shoot themselves. With today's compile-as-you-go IDEs Java can be pretty iterative, and there are REPLs aplenty. The biggest differences are the lack of MetaProgramming and "real" introspection, inability to (easily) change code that you don't have the source for, and lack of expressiveness.
I have come to believe that ExtremeProgramming
is an example of a more abstract methodology that ChristopherAlexander
has named a "GenerativeProcess?
". Another related example is a DesignPattern
, and I think GenerativeProcesses
tie these two closely-related topics together. I wonder if this community might resume making technical progress again if we turned our attention to ways that we can intentionally and explicitly use GenerativeProcesses
in our work. Notice that I resist the temptation to describe this as a software development "methodology", because it's larger than that. Alexander notes that the very largest architectural patterns concern the necessary tension between the natural geographic and geologic features of a given site - hills, rivers, swamps, etc. - and the intended use of that site. In a similar vein, I suggest that every
"technical problem" (including software problems) has a "social" aspect, and every "social problem" has a technical aspect. GenerativeProcesses
start with this simple observation and build on it, whereas ConstructiveProcesses begin
by arbitrarily attempting to separate these two fundamentally intertwined aspects of reality. The net result is that we sometimes make matters worse rather than better.
in particular, and SmalltalkLanguage
more generally, embodies the essence of GenerativeProcesses
. Perhaps both ExtremeProgramming
s are mature enough that we can begin building on them to explore the nature of GenerativeProcesses
Smalltalk is significant for a number of reasons, not least to show in history that true quality in one area begets it in others. But can anyone yet ListenToTheCode
in Java like KentBeck
does in Smalltalk? How much does AlanKay
matter to XP? -- RichardDrake
I just wrote a (possibly biased) HistoryOfExtremeProgramming
expecting to answer this question. Interesting that we both connect XP to AlanKay
. Still, I thought that I would be saying more about pure objects and ReFactoring
than I, in fact, did. -- WardCunningham
We have to face that fact that Smalltalk is a pretty extreme language.
A methodology is a description of the practices; the people on any given project choose to follow the practices or not. You might prefer to say, "ExtremeProgramming
is the only methodology in which the practices are easy enough that people can actually follow them", or "ChryslerComprehensiveCompensation
is the only project on which I have seen the team members actually following the described practices". And then we could ask how they managed to do that. And Kent might say that XP was partially derived from documenting what they did do, so of course they did that. And then Ron would say, well, actually, they didn't always manage to do that. And then some other project would speak up, saying, "We managed to follow 7 of the 10 practices". Etc.
I consider XP a HighDisciplineMethodology
, one in which the people will actually fall away from the practices if they don't have some particular mechanism in place to keep them practicing. Ron is that mechanism at the moment. Should (when) Ron leave, then unless he is replaced in his role, I quite expect to see the team not following the practices properly in less than 6 months. -- AlistairCockburn
for further coach / discipline discussion.
to evolve required a hospitable environment. Someone somewhere needed to observe that there was a better, faster, more entertaining way to develop software. And in order for that to happen you needed someone who was
developing software better, faster, and smiling most of the time. XP was not created, it was evolved. Could this happen with CeePlusPlus
? Of course not. Accepted methodologies being used with languages like C++ do not have the capacity to evolve into XP. Besides, nobody smiles while using C++. -- DonWells
I smile while using C++. I just don't smile while using C++ under WinThirtyTwo.
I smile and laugh while using C++ under Win32. (And curse and sob...)
It seems to me that XP emphasizes the dynamic approach, especially feedback. I think it would be less likely to arise in a culture BesottedWithStaticTypeChecking
. -- DaveHarris
When I asked could XP have arisen without Smalltalk, I did have in mind the lack of static TypeChecking
but also what I consider a whole load of other more beautiful things about the SmalltalkLanguage
and environment (which may or may not be achievable in the end with a StaticallyTyped
The dynamic approach, especially feedback
is exactly right. Very related to it are SmalltalkLanguage
's uniformity, reflection and economy of concept (areas where JavaLanguage
is at least significantly better than CeePlusPlus
). Because of the lack of distraction and very high feedback you could say that, for the person who took the time to be really at home in it, Smalltalk became a great environment in which to think about something else - the success of one's projects as defined by one's customers. I believe that this kind of thinking led to XP. See also IsXpAnUnselfconsciousProcess
My gut feel is that Smalltalk was necessary in history to give rise to XP. Looking back in a few years time, XP may turn out to be the biggest contribution Smalltalk has made to commercial SoftwareDevelopment
. And it will help push Java and all end-user scripting systems in exactly the right, reflexive, maximum feedback direction. See NewLanguagesForXp.
I think that ExtremeProgramming
has been an evolutionary process. The industry is reaching the point where the ExtremeProgramming
methodology would evolve because of the inadequecies of existing methodologies requires a better solution. Without Smalltalk it probably would have taken another decade or two before things in the industry would gel just right for XP to evolve and be born, but it would have happened. I think of Smalltalk as a catalyst that eased the birth of XP, however, the idea is just too strong for the birth to have not eventually come about.
James Burke, a historian, had an excellent series on PBS called "Connections" which deals with technological innovations and how they arise. His theory is that the pieces, the ideas come together and fit together the way a puzzle fits together. When that happens the next evolutionary step can be taken. This is where I feel we are at in this moment of time. We have reached the saturation point where the different components that are the core pieces of XP are starting to take root throughout the industry.
I have seen countless times on other projects, in the prototype stage, the seed of PairProgramming
. It was typically felt that during the prototype stage a pair team can be much more productive. A team can figure out things quicker, and come up with more robust solutions, and this is considered a working norm for that stage of a project. Unfortunately teams were broken up after the initial prototype stage because it was felt more could be accomplished by individual members each working on separate tasks. I still have a hard time understanding this mentality when it is so apparent what pair teams accomplish.
To get to this next step it has taken people of vision to pull the pieces together to create a new and greater whole which is ExtremeProgramming
My first reaction when I heard about ExtremeProgramming
? It seemed just a good formalization of what any practitioner of ObjectOrientedProgramming
comes to understand. In the world of CeePlusPlus
, several notable programmers have been saying the same things with different packaging: BjarneStroustrup
has condensed it down to BuildLearnAbstract
I more wonder if object-oriented programming in general could have arisen so well without the example of SmalltalkLanguage
. I don't think so. -- ScottJohnston
Here's a thought: maybe it's not XP and Smalltalk that are inextricably linked, but XP and a fully-realized and extendable ObjectOriented
application framework. Before XP there was ModelViewController
, right? I can see how to apply and scale the practices of XP once a lot of the constructs of the domain have been agreed upon and are in common use.
came before XP. ModelViewController
also came from Smalltalk. -- DougSwartz
There is no doubt in my mind that ExtremeProgramming
could have been developed in the LispLanguage
community or the ErlangLanguage
community (see FunctionalProgrammingLanguage
s). Maybe Java, but I doubt it because the Java development systems are not interactive enough or incremental enough, and the JavaLanguage
is not expressive enough. I think it takes a simple yet expressive language and a set of tools, libraries, and frameworks that get to the essence of developing software as we currently know it. Many people in the Lisp community have been doing things much like XP for decades. The Erlang community at EricssonInc
describe many XP-like advantages over using CeeLanguage
, CORBA, and Java when developing their telecommunications systems. -- PatrickLogan
See also NewLanguagesForXp
I was doing many XP-like things in ForthLanguage
20 years ago especially RefactorMercilessly
. If Forth had managed to keep up with technology, XP might have arisen from it. -- JonGrover
And I have been doing similar things in Fortranlanguage for a RealTime
system for many years: PairProgramming
, for instance. -- NissimHadar
So, the answer is clearly yes: XP could have arisen in, say, Lisp.
's view the two central concepts of SmalltalkLanguage
are Objects and LateBinding
, and the latter came from LispLanguage
. In EarlyHistoryOfSmalltalk
he also mentions PrologLanguage
as an early example of LateBinding
techniques. (Sources include his ACM Queue interview at http://acmqueue.com/modules.php?name=Content&pa=showpage&pid=273
. He seems to be using a broad definition of LateBinding
which takes in Dynamism, Introspection and even languages as metastructures built on top of a small set of primitives. See for example http://www.lisarein.com/alankay/tour.html#latebinding
.) So Smalltalk wasn't the first 'dynamic language', or the first to be built from a small kernel. It shouldn't need saying that this is not a criticism of Smalltalk! But it does suggest that XP could have arisen from the user community of some other dynamic language. Or indeed that it (effectively) *did* arise, given the history of XPish practises among developers in those other languages.
So the metaquestion (sorry) is how precisely to interpret the terms 'Extreme Programming' and 'Smalltalk' in the question. If you take them as shorthands for 'agile techniques' and 'dynamic languages' respectively, then the question is to what extent dynamic/late-binding languages were essential to the development of agile approaches. Or you could be more specific (in some way) in your use of either term. Choose an interesting question and an enlightening answer. :)
Definitely. Many ancient cultures have anticipated ExtremeProgramming
. In the caves of France, AustraliaCountry
, and Mother Africa we see cave paintings hauntingly similar to XP. And of course many legends passed down through the ages echo XP in spirit and in some surprising details (ScripturalEvidenceForXp
). At many points in history have shadow organizations been formed to protect the secrets of XP. Only with modern technology has it been made available to the masses.
I've always found it interesting that some of the key tenets of both ExtremeProgramming
, such as factoring and implementing a minimal design, were common in the literature of ForthLanguage
in the 1970s. Even the introductory books about ForthLanguage
used the term "factoring."
For me it's always funny to follow WhatIf?
scenarios. Thats though theoretically the question is meaningless, the implied context and the answers are not. Meaningless because Smalltalk evolved (as was stated above). You cannot simply take it out of the picture, all other related ideas would immediately become inconsistent (esp. e.g. for Java). And even if you did, then the answer would be NO. Thats because XP evolved too (as was also stated above). Without Smalltalk it wouldn't be XP. There could have evolved something that is like XP in some sense. But then there could have evolved something that is like Smalltalk. But the answers are meaningful anyway. Everybody immediately assumes some plausible interpretation of the question, that makes sense and answers that. In this case one insight is, that one needs a sufficiently flexible environment to develop a flexible process (how is it called in biology? pre-adaption?). -- GunnarZarncke