Slashdot Mirror
Java Tools For Extreme Programming
In recent years there has been a increased emphasis on Agile Software Development. The most prominent of these methodologies is probably Extreme Programming.
What sets Extreme Programming apart from most other Agile Technologies, in my opinion at least, is that it has provided practical, easy-to-use tools to support its way of working. Most of these tools (Ant, JUnit etc) are Open Source and freely available. However popular these tools have been with the Open Source and Extreme Programming communities, it has arguably been difficult to introduce them to traditional IT development environments. This has been primarily due to the problems of justifying spending time on 'playing' with something and the difficulties of retro-fitting new tools to an existing development environment (think projects of 150+ people which have been releasing for 5-10 years for some idea of the potential problems).
It's worth noting that when embarking on a new, large-scale project it's very difficult to find a book discussing the issues of controlled builds, integration and deployment in practical terms. The most valuable aspect of Java Tools for eXteme Programming is that it's alone in its market niche.
The book is mainly useful as (a) an introduction to the various building and continuous testing tools out there and (b) a tutorial to getting them setup and working on your computer. As the authors note, there's a critical period where the user must get some result after playing with the tool for a short period of time or just give it up as 'too difficult.'
From a technical standpoint the book is very readable, but it doesn't tackle any one subject in great depth. It certainly provides enough information to get you up and running, and also, perhaps more valuably, illustrates how to integrate the tools together. It's an excellent primer for those who want to use the tools but are unsure of how exactly to start.
What's covered? Here are the chapter headings:
- Introduction and Key Concepts
- Introduction to Extreme Programming
- J2EE Deployment Concepts
- Example applications
- Mastering the Tools
- Continuous integration with Ant
- Building Java Applications with Ant
- Building J2EE applications with Ant
- Unit testing with JUnit
- Testing Container Services with Cactus
- Functional Testing with HttpUnit
- Measuring Application Performance with JMeter
- Load Testing with JUnitPerf
- API and Tag Reference
- Ant Tag Reference
- Ant API Reference
- JUnit API Reference
- Cactus API Reference
- HttpUnit API Reference
If you use some of these tools already will you learn anything? Probably -- I personally have been using JUnit to test EJBs for almost nine months now but didn't know about JUnitPerf or Cactus.
Should you buy it? If you're new to the tools, then Yes. If you work in a professional but traditional IT shop, I'd buy one for the group (I have). It'd be particularly useful when dealing with management and proposing changes to working processes, or when trying to bring co-workers up to speed and sell them the benefits of agile ways of working.
You can visit the book's website at Wiley. You can purchase the Jave Tools For Extreme Programming from bn.com. Want to see your own review here? Just read the book review guidelines, then use Slashdot's handy submission form.
this is more like the text on the back of the book. Please go into depth about the types of examples, does it discuss practical applications, and deployment plans?
"Build early and often" is one of the continuous integration mantras, and CruiseControl helps out with that. By having a coninuous build cycle, you can catch errors literally within minutes of when they're committed to the source repository. CruiseControl will email you if builds don't work, and also has a nifty servlet to let you track builds on the web. It's definitely worth a look.
This book is *terrible* for extreme programming - I don't know why they even put it in the title (um, ok - to sell more books...) It's a good book for the price though - don't just take my word for it:
amazon reviews
RC
Personally, I learn programming concepts well when I have a real book instead of web research. Either I missed this book or it's new, because learning JUnit, Cactus, and Ant all at once on a single project from only web research is rather challenging.
This is going on my shopping list.
I'm no dummy! I'm sticking with "Java for Dummies"! Oh, wait... Damn!
Last year, I actually had the opportunity to ask Kent Beck if he had any suggestions for adopting XP to large projects (200+ people across multiple geographic locations), and unfortunately, he wasn't too optimistic. He indicated that the largest projects he's tried XP on were 20 people or so.
Other issues we've had when considering adopting XP in our organization are that XP tends to assume that you will be developing for a single customer with a set of evolving - but consistent - requirements. In our reality, we have multiple customers, who want different things.
Finally, XP doesn't seem to offer any solution for testing GUIs, which make up a large part of our product.
So while I'm very excited by the promises of XP (and will likely buy this book), I think it is important to temper your enthusiasm with a healthy dose of reality, and consider that XP relies on some subtle preconditions in order to deliver on the promise of a smooth and successful development cycle.
Like woodworking? Build your own picture frames.
When will they get open source spellcheck software for Linux? dummies....
Overall, they're cheaper than bn.com (I have no association with either, but I've found good deals on these book resellers).
Sig: What Happened To The Censorware Project (censorware.org)
Hahah this thing is littered with spelling errors.. oh well, such errors should be expected from this crap site.
What does Ant (an extremely useful buildtool for Java) have to do with Extreme programming? Nothing! I can't really imagine why anyone would need a book on Ant (can't say much for the others) -- there's pretty self explanatory documentation here. Since extreme programming strikes me as a load of crap to begin with, this is all probably a good thing.
YOur right about the amazon reviews. What is it with these "reviews" that get posted here -- the table of contents for christ sakes? It seems like book reviews are just an excuse to post a affiliate link to a book store. For shame slashdot. For shame...
I am not a number! I am a man! And don't you
1) Read a book review somewhere (presently DDJ)
2) post a critic, including links to web stores
3) earn referer fees
If you want to save a few bucks ($24.50 vs. $31.99 at bn) go to bookpool.
Do you even lift?
These aren't the 'roids you're looking for.
I am a development manager with a large (20+) team; I am gradually introducing some aspects of extreme programming into the organisation, and so far, it's working pretty well.
The concept of user stories is great for getting our multiple customers to get to grips with their requirements; the tactile nature of the cards allows the planning sessions to be participatory and inclusive, the customers understand the trade-offs and the developers get to understand what they're _really_ being asked to deliver.
Pair programming and continuous testing have produced decent results; the main problems we have are accomodating sickness and holidays into the project plan.
On the other hand, our organisation does insist on some of the more traditional aspects of development management - a formal "Project Manager" role, regular progress reports to the executive team, functional and technical specifications etc.
I don't see how you could realistically hope to convert an entire team to XP overnight. The gradual introduction of some of the basic concepts - esp. those which can be explained as "quality oriented" - is a lot more likely to succeed.
I've read the book, and it's okay; the editing could have been a lot tighter (there's page after page of code printed out which outlines the application to be tested, not the tests themselves, there is a huge chunk devoted to the documentation for the tools which is available online etc.), and it kinda drifts away from the point now and then. If you want to get up to speed with Ant, jUnit etc. it's worthwhile, but don't expect to become an XP xpert.
It's all very well in practice, but it will never work in theory.
I have a question for the JUnit users out there. Basically we are doing unit tests here in the following way:
1. We mark the test code in the classes between special comment lines (so that it can be programmatically removed)
2. The tests are in static methods with the prefix "test", called by a Test.class in each package. Test.class has a main that just calls the other tests
3. Each test prints out on a single line the class it's in, the name of the test and "passed" or "failed" and the failure may have extra info as to why it failed
This is working well for us, but considering how many people are happy with JUnit I was wondering what it provides over this way of doing unit tests? Basically, I'm just looking for some of the things that JUnit has provided you (above and beyond what the above gives) and maybe a real use example, but don't really need to be sold on unit testing (we already think it's great and are doing it).
F
-no broken link
Is java an idea that never lived up to its hype of being cross-platform or do most web designers need a serious lesson in programming?
UNIX/Linux Consulting
Java is to extreme programming what battery cars are to drag racing.
Java books are portable only if you copy each page by hand and convert to your local language in the process.
When I think of extreme programming, I think of writing code on a laptop while BASE jumping or while being attacked by a shark.
As a programmer, something like Extreme Programming sounds downright scary to me. Or at the very least, something that would force me to get up out of my chair more often than I would like.
I'v enot read the book, but looking at the chapter headings they seem to have leftout one great tool for XP in Java - the various refactoring browsers that are now hitting stride for Java, including JRefactory, IDEA (my favorite IDE period), jFactor, and X-ref (for the Emacs lovers)
With the XP RefactorMercilessly principle, IDE support for for refactoring is a must on big projects. Custom writing a Perl, sed, or awk script to move a method from one class to another (in its argument list) is possible, having IDEA or another refactoring tool handle all the updates across 2000 changes in 700 files is a lot nicer.
-Frums
XP is for teams of upto 10 people. Personally I think that any methodology that isn't founded on a good design is a load of rubbish. XP is the worst form of hacking imaginable. If we really want to be considered an engineering discipline we should behave as one. Engineering requires thought, planning, requirements, design, implementation and testing, while some iteration is possible and continual delivery is possible (you can cross the bridge on foot, before you cross it in a car) within engineering, the idea of continually changing each piece is not one that fits within engineering.
XP is for hackers who want to improvise, and upon whom nobody relies for their survival. If people built houses, bridges and planes this way we'd all be up in arms about the lack of quality.
Why should Software be any different ?
An Eye for an Eye will make the whole world blind - Gandhi
The most scary part of the whole eXtreme Programming stuff is the pair coding. For those who don't know, it's the idea that all programming should be done by two people at the same time one actually coding and supposed to think "strategically" (about integration, structure and stuff like that).
:( I hope people will soon realize that it's impossible to think when you have someone watching over your shoulder.
Now some poor programmers don't even have a PC for themselves. They have to share it with a colleague and they are even denied their most basic right to have a few square meters of personal space.
I would never accept such working conditions but it's unfortunate that this seems to happen more and more.
True warriors use the Klingon Google
I was impressed by this book review, so that I was already thinking about a purchase and checking at the german amazon website (guess where I'm from?) for price and availability.
The book had two quite bad reviews there. (2.5 points out of 5, which seems to be a pretty bad rating for amazon) The main point from both was the missing link between the java build tools, which seem to be discussed considerably, and eXtreme programming.
One extreme programming tool written in Java which I haven't seen mentioned here is that of Naked Objects. I had play with it the other day and thought it quite a neat idea.
Java, Exteme Programming, Open Source. The title rings some warnings bells...
Bite down on it!
I take it the guys who build F1 race cars aren't engineers as they are constantly changing and redesigning components.
Oh yes, the "tin benders" who built the X planes during the 50s and 60s cannot have been either.
Bridgebuilding... Sheeesh!
My experience with extreme programming is that it is simply a bass-ackwards way of development.
The advocates of eXtreme pr0gramming who love to "refactor" their code on a daily basis seem to have the same mindset as the people in my upper level CS courses that would spend the entire weekend in the computer lab on their projects, and complain about their grades and the time they spent afterward.
I'd spend a couple hours making object relationship diagrams, program flow diagrams, etc beforehand. I'd show up at the lab Saturday morning at 9 and leave at noon, and the looks these students gave me were a combination of hatred, jealousy, and disbelief.
IMO, it's just a process choice. Planned, focussed development, or tinker-till-it-works.
you share a workstation when you pair prog. you don't share when u r reading mail, playing unreal etc, dpoing spike work to get a proposed idea fleshed out. and if you are in the right sort of projects and work spaces, PP is fun and productive. IMOit is very hard to do pairing for more than 2 hours at a time cos it is actually harder on yr brain - you can't goof off mentally for ten minutes when things get tough.
The tigers of wrath are wiser than the horses of instruction, but they eat more steak.
Extreme Programming has been discussed at /. before, and the links provided at the beginning of this review were useful, but the review itself falls short of mentioning how the authors integrate these tools with the extreme programming philosophy.
;P ).
Check me if I'm wrong, but from my initial readings, XP relies heavily on customer feedback, and short-term iterations serving to adjust the project plan "on-the-run" so to speak, which minimizes time loss incurred by the difficulty of making accurate long-term estimates in programming, and compensation made for fickle end users. While testing is a large part of XP, is only a part of XP. What does this book say about implementing XP on the whole? Anything? Is this just a book about tools you may use to test your software? Can I test my software if I don't use XP?
The most valuable aspect of Java Tools for eXt[r]eme Programming is that it's alone in its market niche.
Excuse me for being picky, but what is useful about that? Are you saying that this is good if you want generic text that has XP written on the cover, or what?
The links describing XP give it a nice once-over on how you can think about the process of getting release versions out the door [which users and managers like]. I haven't seen anything that deals with the aspects of applications design that span beyond iterative releases, namely, systems that are proven to assist in the overall application architecture, and systems that are proven effective for creating flexible and useable GUIs. If you have a crack team of programmers, XP will cushion the unavoidables [ software is hard to estimate, and users change their minds frequently ]. Of course, you still need competent minds at work on the overall architecture of your code, and that planning seems to be an afterthought in XP ( features first, architecture second, perhaps this is why managers like it
Also, for any large project, you are going to have developers who display special skill in certain areas, and some who display ineptitude in certain areas. Before you start saying, "well, just fire the inept", remember that firing and finding replacement talent isn't all its cracked up to be, and "failure to exhibit genius" isn't cause to send somebody packing (nor is it always wise). XP takes the stance that everybody should do everything, but oftentimes you'll find that some on your team just don't have it like the top dogs do. In many cases, you want an expert to code a critical segment and, while it'd be nice if they could teach the whole team their skills, in reality, that is not always possible. I believe in peer learning, but everybody do everything, well... excuse the pun but that sounds a little "extreme"
XP has good guidelines, but I have many questions about how to interpret those guidelines, and a text that puts XP on the cover should say something about them, IMHO. So you say this book is about tools for XP, not XP itself. Ok, then what tools does it discuss other than those used to test code? Are there any other tools? Are these tools only for use with XP?
I guess what I can take home with me is that if the buzzwords "Java" and "XP" are on your cover, than somebody will publish your book.
sunday, Sunday, SUNDAY...
At the Megaplex Arena,
Extreme, In Your Face, Programming Action!!!!
Java, Perl, C/C++, VB, and many, many more...
Geek-tastic and nerd-a-riffic!
Tickets going Fast!!!!!
Remember, this Sunday at the Megaplex, EXTEREME Programming!
We'll sell you the whole seat, but you'll only need the edge!
Yes. I have ex-coworkers who are in a very XP environment. Things they have learned include:
- XP is very tactical. You need someone at the strategic level guiding and leading.
- Productivity drops significantly after about 40 hours per week (they collect detailed statistics about defect rates showing this).
- Individual productivity appears to suffer, but the result of pair programming and short (two-week for them) iterations results in code that is easy to work on (read: good design) and very low on bugs (read: well written).
They've put a lot of support around their XP team to make XP effective, in the form of tools, processes, and people (roles). Without that, I suspect they would be disorganized and chaotic.
There's a time and a place for just about every methodology out there. XP is an effective approach to development as long as it's done in the right environment by people who understand (or can learn) how to make it work for them.
when theres [extreme ironing]
Since this thread is turning into a discussion about Extreme Programming I thought I would throw in my experiences with it. I work on a web application which when I first joined the project was run very much "by the seat of its pants". The project was in its infancy and we were in constant contact with customers who had wildly verying ideas of what the finished product should be. At that time we were testing/building constantly with no documentation other than code comments. We were also taking requests right until the release. For these reasons I say we were doing Extreme Programming. Our customers loved us and we quickly made the project one of the top projects in a very large company. On a side note I have often wondered if Extreme Programming is a simply a justification for what programmers tend to do when left on their own. Well then our success bit us in the butt. The big wigs took notice and labled us "Mission Critical". Now we spend more time documenting the application then writting code. Any requirement a customer wants has to go through several levels of review, and they are never accepted just before a release. Management now "measures" quality by number of defects openned on a release. (Yes I too reject the whole notion of measuring a quality by the counting of ANYTHING). Releases now take longer, frustrate customers more, and have lowered the moral of the developers who now feel they are simply documentation monkeys. Yet Management insists the project is better than before. The moral of the story I have taken away from this experience is that even if extreme programming is the better method for a given project management will regect it. It results in more defects being found, more change which scares the hell out of management types, and finally code which isn't well documented so that management can't replace skilled help with code monkeys at a moments notice. You don't have to count beans to make coffee. However, management won't let you make coffee at all without knowing how many beans are in each cup.
XP is about realising what you are doing, and how. There are too many projects that claim to use a one step design-build-test, overall, but end up having version 1,2,3,4 ...
...
XP realises that
a) there will be feature creep,
b) you must test, retest, and test again,
c) it's really how most developers work
If you had to change a bridge because the river got wider, would you insist on using the same parts as before - regardless of how long the bridge needs to be now?
This isn't a troll, or flamebait, its a standard old fashioned flame.
Peer Programming means continual review by two people, two bad people = bad code. 1 good + 1 bad = 1 slow average. Code review must be done by several people and must also include a senior resource to help less experienced ones.
This was also the tennant behind the Team oriented approach of the Mythical Man Month, which was based around the assumption of everyone should be good, just fire the rest.
XP is basically the re-hashing of some long held good ideas, interspersed with some total drivel from a bunch of hackers.
XP DOES say don't design the overall architecture of the system, it DOES say don't design how each service should work. It relies on the concept of Unit Tests where anyone will tell you that bad developers = bad unit tests.
XP is a sham and a fraud that is only allowed because the industry doesn't care about quality.
An Eye for an Eye will make the whole world blind - Gandhi
This isn't a flame, it's a standard old fashioned rebuttal.
Your point about pair programming is completely groundless.
Scenario 1 - no pair programming
Two bad programmers, bad code
One good programmer, one bad programmer, some bad code, some good code.
Scenario 2 - pair programming
Two bad programmers, bad code but any mistake either of them see will be removed, improving the quality of the code.
One good programmer, one bad programmer, code up to the standard of the good programmer, and the bad programmer learns, hopefully becoming better.
XP does not say 'don't design the overall system' - you are misrepresenting it. A look at this talks about the plan for each release. Sure, bad developers = bad unit tests, but bad developers = bad product, nothing will guard you against that. Nobody said 'Extreme Programming will mean you have no bad developers.'
thenerd.
The camels are coming. I'm in love.
Jump in, we'll take you for a spin, and show you round the Wheelie World
Hop on it's fun to come along, and take a look at Wheelie World.
You'll be surprised how good it feels.
To zoom around, and you'll wheel so merrily
With me,
You don't need a ticket, 'cos we'll get you on for free.
And if you see the witch Fenella, don't be worried,
'Cos there's no cause for alarm. (ha ha ha ha)
'Cos we've got Chorlton, who's a dragon,
and he'll keep you free from harm (ho ho ho ho)
It's fun at anytime of year. So put your wheels in second gear,
And then hold tight,
Alright,
We'll show you all the sights
Of Wheelie World......
Ba-dum.
Difficulty JUnit testing with a GUI? Try:
http://sourceforge.net/projects/jfcunit/
Extreme Programming = Extreme Crap!
I have this book and I'd almost recommend it but I think that the main point that needs to be made is that it's not about extreme programming (despite the title), it's about various tools that have come out of the Java (and XP) community.
The title is a very unfortunate marketing ploy. I say unfortunate because putting XP in the title will probably drive away Java programmers who don't care for XP.
But the tools it discusses (Ant, JUnit (and family), and JMeter) are applicable to any Java project, regardless of your development methodology. And beyond the first twenty pages or so of the book, the authors really don't mention XP.
I know you want/need to raise awareness about what he did, and I agree it was a nasty thing, but consider this: When I stumbled into your little dispute, and read your and his versions of things, I really ended up with no respect for either of you. It wasn't until after doing further reading (ie of stuff written not by you) that I came to realize michael really was in the wrong (regardless of his reasons, stealing the domain name was inexcusable), but most people won't take the initiative that I did and will simply laugh at the both of you and move on.
An experienced netizen like yourself should know better than to participate in such an ugly public flamefest. Shame on you, sethf.
-- phyxeld (posting AC cause it's offtopic and should start with score:0 to begin with)
p.s. I guess posts like this are what you're worried will end up in your journal if you enabled comments, eh?
Extreme Programming.
:).
:)
It's a (GOOD) marketing brand for a loose set of unrelated ways of trying to solve complex problems in the field of application programming. Not much more.
XP will work for talents (and a few trainees) who, if left alone, would probably work somewhat like that, not for "people" in general, and especially not for the workplaces that need a "development model", and sees XP as a Solution (yes the "S" is on purpose
Although people in general (especially the one who should not use XP) think it's great -- I fail to see the benefits, beyound rationalizing and "memorizing" the way talent's work.
Educated: Someone with a vast knowledge about a problem-domain, and means (often approximating algorithms) to recognize problem/solution pairs.
Talent: Someone who "just does stuff", doesn't have to think about it. Often turns out to outperform educated people by doing "The Right Thing", even when they should not be able to
Educated Talent: Rare! explosive mix! Hire at all cost!
PS: I don't think of myself as talented at more than 2-3 (smaller) things/fields.
SLOGEN [ http://ungdomshus.nu : Sebastian cover music]
Extreme programming is based on the following. Code reviews are good (questionable but we'll assume this for the moment), rewriting code is good (ditto) so doing these things ALOT (or in the parlance "to the extreme") must be really good. Basically, thinking things through is hard to do so just keep iterating on the solution till your "done". "done" is defined as the point in time when the client stops paying for your code wanking. Consequently, you don't see much of it outside of consulting.
I am not a number! I am a man! And don't you
Maybe not Extreme but I find it useful
BlueJ
Yes, software engineering is different to computer programming. Like chemical engineering and chemistry, one is a practical application of science, the other is a science itself, which the engineering discipline heavily draws upon.
BUT it's a bit extreme (pardon the pun) to say software engineering is "at the other end of the spectrum". Software engineering, like any professional engineering, is a discipline where you consciously investigate how much error is tolerable and establish a plan accordingly.
The exteme programming techniques, interweaved with tools, and managed carefully, can be great software engineering tools for the right kind of project. The skill is in choosing the ones that are suitable for the job - which may be none or all.
Sure, most of these things won't work too well ofn a safety-critical system, at least not if they are the main way to ensure the desired quality. But for a typical, small-medium business application, extreme programming might well be chosen as the most productive route to the necessary quality.
my company (hundreds of developers) is in the process of adopting XP (slightly modified) for large scale projects involving large numbers of developers. my project has 60 or 70 developers but they split us up into labs of about 10-15 coders. we also usually do pair programming (two people at a keyboard). and we don't have a set machine. it can change weekly or daily even. We don't get to make very many architechture decisions. There is a very small team (~5 people) who come up with stories and general design. I have only had a couple weeks experience doing this but here are my initial observations.
i think a lot of the things XP tries to accomplish are really good:
-- like the whole concept of greater communication. its easy to ask questions about someone else's code or how something is supposed to work when all you have to do is shout out across the room rather then email or phone tag or walking. you might not think it makes that much of a difference but it does.
-- also its really nice not being isolated in my cube in the corner all day. The lab is fun. people actually talk and not just about functionality of code.
-- at the end of the week we demo our work to everybody which is cool because i feel like my stuff gets some attention. before XP, i felt like if i did a good job, no one noticed, and if did a poor job, no one noticed. so why bother?
things which bug me about XP:
-- the end of week demo is cool right now while we are playing with some GUI stuff. but i'm a little doubtful as to how cool presenting will be for core business functionality. I mean showing yeah i made this button is kind of cool i guess. but demoing yeah i implemented this complex algorithm and its here in this method which take 4 parameters... maybe.
-- i HATE working with a partner at my keyboard. they can't use Vim, they have to use their own pansy notepad like editor and i have to sit their and watch in mute frustration while it takes my retarded partner 10 minutes to do in notepad (well, Eclipse) what i could have done in Vim in 30 seconds. In theory, XP says that my partner should learn from me, but in practice my partner doesn't want to learn a better way because they have to think. some people want to learn, but most just want to get along. its like freshman chemistry when your lab partner made you do all the work while they went bowling. Or maybe my partner know emacs instead vi. In any case back and forth with the keyboard is not simple. Finally, what if you don't like your partner. or what if they smell? seriously. its one thing to "be professional" and "get along" when they sit in a cube far far away. but when they sit next to you for 8 hours a day 5 days a week, it sucks. How many married people spend THAT much time together.
-- i think pairing is a waste of time. if my partner knows what they are doing, they don't need my help and they code away. occasionally minor design issues come up and we discuss them. i guess thats cool. but in between i'm bored. or if my partner doesn't know what they are doing, i have the choice of pointing out mistakes every 3 seconds in which case they get frustrated and i get frustrated -- i guess i'm not a very good teacher (but hey i'm a coder not a teacher) and watching them do things the long way. so usually i read a java book while my partner codes unless i have the rare partner who actually wants to learn.
-- one final problem with pair programming: what if my partner is really bad with english. this is hugely frustrating. me: "should we extend this class or make a new one over here?" partner: "yes of course!" ??!!#@$ they can be nice people and smart, but if they don't know english, discussing everything that gets typed becomes enormously slow.
-- i HATE not having my own computer. This would not be a problem if our company used unix on the desktop since unix has real roving accounts. but we use windows. so EVERY time i get on a new machine i have to install Vim, Mozilla, Cygwin and the 35 other coding tools i use, configure them, and configure explorer to show complete file names, not hide files, not download and install viruses, etc, etc, ETC, ETC!! arrrrrrrrrg!!! If you are going to do anything close to XP and pair programming it is a MUST that you use unix. about the only thing that actually roves on a roving windows account (win98) is the background color. how useful.
so thats been my experience. to sum up: greater communication is cool and pair programming is not cool.
you can email me at slashdot@NOSPAMTHANKStoiletmonster.org
disclaimer: i don't speak for my company.
One good programmer, one bad programmer, code up to the standard of the good programmer, and the bad programmer learns, hopefully becoming better.
I haven't tried pair programming, but my experience with bad programmers is that their main malfunction is often that they don't realize they're bad. They think they're super smart, and will argue ferociously for their demented complicated schemes. If you pair a good and bad programmer, you're likely to end up with either no code, or if the good programmer is willing to compromise to get something done, a loopy design that's been polished to work adequately by the oversight of the good programmer.
I guess my point is who is the most pigheaded person may have a bigger influence on the results of pair programming than who is the better programmer. And that you often get more humble the more you learn in this business.
You fucking rule man!
Sounds like the Extreme Fajitas from the Tchotchke's chain restaurant in the Office Space movie.
Would you like some Extreme Programming? Some nachos?
This
The part of extreme programming I object to is taking things that are common sense when done in moderation and then asserting that if a little bit is good then a lot is great. Code reviews are rarely as useful as say a design review is. Too often it's a "find my bugs for me" type effort or people correcting grammar in comments. The worst part is that managers assume that because other "experts" looked at the code it is valid. Since most people don't single step new code through the debugger (something that actually is useful) and which is a lot cheaper than a code review.
There's a big difference between two people sitting together to work on a problem and two people chained to the same computer in the vain hope that they will produce better results. It's the old "two men dig a hole in half the time of one" syndrome.
But that's just me and I could be wrong. Maybe it does make alot of sense.
I am not a number! I am a man! And don't you
I am a CS major with focus on software engineering. I have been working with XP and agile methodology for some time, and doing some research to apply these principles on geographically distributed projects open source projects in particular. I also started doing some research on different ways to improve the development of open source projects. I haven't received much assistance or interest from the faculty at my CS department. I am wondering if anyone, or any school doing any related work? Or is there any project established that would help even improve more open source development. I think there is a lot of good things to be learned from open source development but better tools and an established methodology can even make open source software development faster, better quality, and easier.
Unfortunately storm (xpstorm.sourceforge.net) is not mentioned. It's a tool which can replace story cards in a distributed team where XP would otherwise not be possible. Stories are versioned, risk and value can be planned and it also manages your documents. GPL.
One thing I really don't understand is why Ant reinvents the wheel.
Many people have been using makefiles successfully for years, and, now, part of the Java community comes out and says, "Make sucks. Let's just throw it away (even though it is really mature) and start over from scratch (instead of implementing Make in Java)."
I have found that the common arguments against Make really aren't very strong. The tab issue is really minor. The only issue that bugs me is that parallel builds aren't possible with most implementations. There are other more theoretical issues, such as the dependency graphing, etc., but I don't see Ant taking on these much more complex issues.
My other peeve is that Ant is fairly Java-specific, while Make is really language-independent (I use it for Java, C, C++, release management, testing, etc.).
Is the popularity of Ant really just a case of jumping on the bandwagon?
Healthcare article at Kuro5hin
A co-worker and I stumbled onto a GREAT way to do pair-programming: VNC.
It's awesome, you sit facing each other on your own computers (thus having your personal space) and then you can work together in an instant just by logging on using VNC to see the other programmer's computer. VNC is fully interactive and you both have control of the keyboard/mouse at the same time. It's perfect for pair programming.
There are many times when all you're doing in programming is a bunch of busy work. Copying and pasting fields from a database into get/sets of a Java class or something ridiculous like that that doesn't really need two heads. These can be done solo, but then when you start to get heads down into the business logic, you can just say "Hey, let's work together on this bit," and your coworker just logs on and you start collaboratively working together again.
This way there's no fighting over the keyboard ("Oh, christ! When are you going to learn to touch-type, give me that!", "No! You drive me crazy with your backspacing... I'll drive."). Whoever has the right idea can type just by doing so and the other person can watch for errors, comment on style, etc.
Mark my words, it works really well, it should be part of the XP standard.
-Russ
Me
Java Tools for eXtreme Programming Java Tools for eXtreme Programming describes techniques for implementing the Extreme Programming practices of Automated Testing and Continuous Integration using Open Source tools, e.g., Ant, JUnit, HttpUnit, JMeter, and much more. http://www.rickhightower.com/JavaXPToolkit/index.h tml
My experience with code reviews at several companies has been a bunch of people get in a room and study the printout of the source code (usually for an hour or two). As you might imagine, since people are not computers, this tends to be rather unproductive. What you would describe I would term collaboration or "getting help" which tends to be much more useful ;-)
I am not a number! I am a man! And don't you
Reviews
Review from Dr. Dobb's Journal
"It is ... a pleasure to review ... books that are both original and useful. The first is Richard Hightower and Nicholas Lesiecki's Java Tools for Extreme Programming, which describes five new Open-Source Java programming tools... Java Tools is readable and well organized... As a bonus, the authors show how to use these tools together; for example, how to automate reexecution of JUnit tests using Ant."
--Gregory V. Wilson
Check out the full review at
http://www.ercb.com/ddj/2002/ddj.0205.html
Review from JavaPro Magazine
This book is the first of its kind, covering topics that haven't been explored this directly anywhere. It does a remarkable job, covering not just the tools but the philosophy behind good unit tests and frequent, automated builds...." ... ... "The philosophy behind this material is modern and forward thinking. ... (The book has the ) potential to make you a better programmer and better able to deliver higher-quality code
on a shorter timeline. "
--Claude Duguay
Check out the full review at http://www.fawcette.com/javapro/2002_04/magazine/d epartments/bookreviews/default.asp
Review from JavaRanch (Java portal)
"...This book is a fine introduction to a whole bunch of really useful tools to boost your Java and especially J2EE programming.... This book was almost too useful to review. ... If you want to get up to speed quickly and practically on a load of useful, powerful, tools - get this book. Everyone I've shown it to has wanted their own copy ... "
--Frank Carver
Check out the full review at http://www.javaranch.com/bunkhouse/bunkhouseDesign . sp
This review became book review of the month at JavaRanch!
XProgramming.com(Online XP magazine)
"This book should appeal to XPers and non-XPers alike who recognize that automated testing and continuous integration are good things for any project." ... ... "The book is a good introduction for the uninitiated and a valuable reference for those plying their trade with these tools. Don't miss an opportunity to easily automate your Java project and spend more time delivering business value!"
--Mike Clark
Check out the full review athttp://www.xprogramming.com/xpmag/books200 20203.htm
Hacking XP (Online Italian XP magazine)
"(This book shows) The right, practical way to start up a xp java team...
The first part of the book is simply great, well written..., there's a lot of code ... The author divided the examples in a simple example (just to start to use the
tools) and in a case study, to apply the practice in a real world project. In about 240 pages you will be able to use Ant, JUnit, HttpUnit, Cactus, JMeter, JUnitPerf, and if you are not an expert there is an intro about the j2ee deployment architecture too."
--Matteo Regazzi
Check out the full review at
http://www.hxp.it/english/libri/javatoolsforxp.htm l (English)
http://www.hxp.it/libri/javtoolsforxp.html(Italian )
The reviews for the book and comments on Amazon, TheServerSide.com, JavaRanch are very encouraging. Thank you all. And, thanks to SlashDot for reviewing the book on this forum...
I'd like to thank some other folks.
This book would not be possible without the great set of tools written for building and testing J2EE. I'd like to publicly thank James Duncan Davidson et al, Mike Clark, Vincent Massol et al, Kent Beck and Erich Gamma.
James Duncan Davidson et al created Ant. The de facto build tool for Java. This is the glue for building applications and making continuos integration doable with Java.
JUnit is the regression-testing framework written by Erich Gamma and Kent Beck. After looking at this code base you can see this framework screams with design patterns and solid OOP, and is central to Extreme Programming development with Java. It is as if these guys wrote *the definitive books* on Design Patterns and Extreme Programming--oh yeah they did!
Russell Gold wrote HttpUnit, which makes functional web applications easy and fun. (It can also be combined with Cactus.)
Mike Clark extended JUnit to provide JUnitPerf, which does load testing and performance testing. This code is an excellent example of how to extend JUnit. Mike Clark is also a really nice guy.
Vincent Massol et al for creating the Cactus (was J2EEUnit). I use this tool every day at work to unit test JSP Tags and EJBs. This is a truly novel tool. (BTW Nicholas Lesiecki, the co-author of the book, is an active committer on this project.)
Vincent Massol of Cactus contributed to the creation of the book. He reviewed the chapter on Cactus. His acknowledgement was accidentally omitted from the book during publication.
I am not implying that anyone mentioned above endorses the book or name dropping. I just wanted to thank them for contributing their time and effort to create these tools and then just give them away! Without them this book would not exist.
The book has been a bestseller under software development on Amazon most of this year. Thank you. We are blown away with the success of the book.
Check out these threads about the book if you get a chance....
Thread TheServerSide.com
Nick and I answered a lot of questions about the book at the JavaRanch as well...
Thread at JavaRanch
I've posted some more background information about the book here...
Book Web Site
I'll check back and try to answer any questions about the book. Thanks again.
The web site will soon have a sample chapter on it. Later, when we write the second edition, the book web site will have early drafts for review.
--Rick Hightower Co-Author of Java Tools for Extreme Programming
rick hightower dot com
Link to book web site
Java Tools for eXtreme Programming describes techniques for implementing the Extreme Programming practices of Automated Testing and Continuous Integration using Open Source tools, e.g., Ant, JUnit, HttpUnit, JMeter, and much more.
There are other great books that cover other aspects of Extreme Programming. This book focuses on Automated Testing and Continuous Integration.
The book does mention XP throughout, but does not cover all other practices of XP in detail. This book focuses on the mechanics of XP. Other books cover the philosophy of XP quite nicely and there was no need to repeat it in this book. There is an introduction to all aspects of XP, however, the focus is on Automated Testing and Continuous Integration.
The book contains small examples and tutorials on each tool. The examples cover building, deploying, and testing Java and J2EE applications.
In addition to small examples, there are larger case studies. The case studies are larger more realistic examples. We have case studies involving XSLT, EJB, Struts, JDBC, etc.
Each case study is complete with an ant build script and several tests, written with JUnit, HttpUnit, Cactus, JUnitPerf and/or JMeter. The case studies focus on building, deploying and testing J2EE applications with Ant and JUnit.
There is also a reference section for APIs. Instead of rehashing the API documentation, the reference section has example usage, i.e., code examples for the important classes and methods.
Although this book speaks from an XP perspective, you need not practice XP to benefit from it. For example, you do not have to adopt the entire XP methodology to get value out of this book. Automated testing, for example, can help you refactor code regardless of whether you are doing pair programming or not. Continuous integration can help you detect and fix problems early in the lifecycle of the system regardless of whether your customer is on site or not.
There are some really great books on XP. Three of my favorites are as follows:
Extreme Programming Explained: Embrace Change by Kent Beck
Planning Extreme Programming by Kent Beck, Martin Fowler (favorite)
Agile Modeling: Effective Practices for Extreme Programming and the Unified Process by Scott W. Ambler
You will enjoy this book as it covers topics not covered in other books, i.e., essential topics that are critical to J2EE and Java development. This book is highly rated and is doing very well. If you are thinking about buying a copy check out these reviews reviews
rick hightower dot com
Nice to see a book that pulls together several of the great OpenSource development tools that are out there. I've often thought that with enough time and effort, one could put together a truly amazing development system with nothing but OSS and elbow grease. Unfortunately, I've only been able to really internalize Ant and CVS so far. Imagine a well integrated suite of the following...
Bugzilla
;)
NetBeans
ArgoUML
JRefactory
JUnit
Ant
CVS
Tomcat
JBoss
Linux
...and of course a little Perl to glue it all together.
Learn how to transform XP theory into concrete Java® development techniques!
Software developers live by the mantra "evolve or die." Adhering to that philosophy, Richard Hightower and Nicholas Lesiecki present you with an innovative book about Extreme Programming (XP)-- a development methodology that enables developers to build flexible, high-quality software in a quick, efficient, and cost-effective manner. This book teaches you how to implement XP in Java using open source Java XP development tools and how to master the most difficult part of the XP process: testing, integration, and deployment.
Written with experienced Java developers in mind, this book begins with a brief introduction to XP methodology and techniques, and then dives into a sample application used throughout the rest of the book to provide a real-world view of the tools and development practices in action. The authors provide concise descriptions of the key concepts behind each tool, offering code examples and step-by-step tutorials to guide readers to mastery of the technical aspects of XP development.
This book covers the following XP subjects: Automated unit and functional testing Continuous integration through build and deployment automation The value of refactoring and continuous integration How Ant, JUnit, JUnitPerf, Cactus, HTTPUnit, and JMeter can be used to achieve the goals of the XP methodology The companion Web site contains:
Wiley Computer Publishing's Java (TM) Open Source Library provides professional Java programmers with in-depth guides to the growing number of open source tools and technologies for developing , testing, and deploying Java applications.
Wiley Computer Publishing Timely. Practical. Reliable. Visit our Web site at wiley.com/compbooks/
About the Authors
RICHARD HIGHTOWER is Director of Development at eBlox, where he spearheads the company's XP adoption efforts and provides technical leadership. He is a regular contributor to Java Developer's Journal and is the former Senior Software Engineer for Java Architecture at Intel.
NICHOLAS LESIECKI has been employed in the software industry for longer than the corporate life spans of most dot-coms. He currently boasts one of the top ten Java certification scores in the nation.
You can use Ant to automate builds, deploys and testing which is crtical to extreme programming, i.e., it is called continous integration--a core practice of XP. Ant integrates nicely with JUnit to create some very nice test reports. BTW XP is about quality software discipline. Read any book on XP then think before you post!
At our small telco platform dev company, we found that pair programming didn't make the code better and lead to much longer development times. What seems to work better with all the added benefits are a small team (less than 12 developers) in an open space plan in the same room. Morning review meetings keep everyone sync'ed up and the crosstalk and over-the-shoulder checks as development occurs give the same benefits.
Life is a tale told by an idiot, full of sound and fury, signifying nothing.
William Shakespeare
I don't know how your project is organized, but I get to sign up for what I want to do, every two weeks. Sometimes I get shit jobs, but so does everyone else. If I'm feeling like SOS, I sign up for about what I did last week (a little biz logic and database changes at the moment). If I'm sick of SOS, I try something different. I came in as a GUI guy, and now I'm getting into junior Oracle wizardom.
I suspect that those who gave this book rave reviews never bothered trying to run the examples/source code which can be downloaded from the author's website. I haven't gotten any of them to run properly.
Try using Resin instead of Tomcat. The authors did all of their development on Resin (a little on JBoss).
If you can not get "any" of them to work. The problem is probably with your skill level and not the book.
The book is not a Java for Dummies book. It requires some skill with J2EE to use this book! Novices will have a tough time with this book.
CHALLENGE:
You could post the problems you are having here in this forum. Then we can judge if its the book's examples or your skillset with Java and J2EE that is the problem. Some of the examples require J2EE experience.
BTW Try using Resin. We used the Resin application server for the examples.
If you like, you can email me privately and I can try to help. rick@rickhigtower.com
rick hightower dot com