;;; -*- Mode: Text, Spell -*- Storyboard describing some of what William thinks the development environment should be like. ;;;; Version/Locking Control. Assuming that I didn't leave myself logged in, the first thing I have to do is log in and start up the development environment. Starting things up should be a rather light-weight operation, like 15 to 30 seconds delay at most. When the environment starts up, it comes up in a state that I find useful. That is not necessarily the same state that it was in when I last used it. Some time in the past, I somehow configured in the amount of state I want preserved. As a DEVELOPER, I am a member of some number of PROJECTs. In my case, this might be the Igor project and one or two personal projects. Given that I plan on doing real work today, I click on the Igor project, and a window pops up identifying the various pieces of code in that project that I am currently working on, along with whatever annotations I have added mumbling about what it was I was trying to do to those files, etc. This Work-In-Progress window can be organized into tasks and sub-tasks, however I want. For example, right at this moment, I'm supposed to be working on about 4 different major things. I have these 4 things sectioned off, and in each section there is information about the code modifications I have made to further these tasks, and the notes I've made along the way. Also, different modifications to the same piece of code can show up under different task headings. More on how that works later. Looking over the set of things I'm working on, I decide that I don't really want to work on any of them. So I pull up the global bugs/to-do list associated with the Igor project. In there I notice a new bug report that should be rather easy to fix. I somehow pull up the relevant piece of code, examine it, and figure out what is wrong. I then somehow instruct the system to lock that piece of code in preparation for fixing the problem. I then spend 20 minutes or so fixing it. After some quick tests, I commit the change to the mainline sources. This commit automatically releases my lock, makes a template log entry from the bug report (which I can edit), and annotates the bug report as being addressed by this change. After knocking off a handful of bugs (hey, it's a new system), I start to feel more motivated to work on some of the big projects I'm working on. So I click on the task I'm now interested in. After glancing over my notes for a bit, I remember where I was, pull up that piece of code, and resume work on it. And discover that I need to change some other piece of code that I haven't made any other changes to. But I don't want to lock this piece of code, because I know Rob is working on some related stuff and might need get at it, and it is going to be several weeks before I'm ready to commit my changes. So I just start modifying (a personal copy of) it without first locking it. After many days of hacking, I'm ready to test of these modifications. So I tell the system to compile up a version with my personal modifications and to run that. It figures out the minimal amount of stuff it needs to compile, compiles that, and starts up a slave running with those modifications. I play with the stuff, make more changes, etc. etc. until it all works. Once it all works, I instruct the system to commit all the modifications I've made as part of this task. First off, it locks everything that I have made modifications to without first locking. If someone else has something locked, then it tells me, and I can call them up and hassel them about it. Assuming I could get all the locks I need, then it rolls though and looks to see what has happened with the mainline versions after I started my modification. For anything that has changed, it does a three-way merge and prompts me to resolve anything it can't figure out on it's own. Note: it might have been me that made some of these other changes that I now have to merge in. For example, assume I decide to re-write how hash tables are implemented. Over the course of a couple of days, I work on re-writing hash-tables. But in the middle of that, someone notices that some minor thing about hash-tables is broken. I decide to fix myself because I have the hash-table details swapped in at the moment. But I don't want the fix to have to wait on my re-write. So I have my hash-table re-write sectioned off as one task, and make the bug fix as part of a different (probably anonymous) task. I can commit the bug fix without worring at all about the state of my re-write. But then when I go to commit the rewrite, I have to incorporate the bug-fix just as if someone else had made it. Once everything is locked and any changes that where made to the mainline incorporated into my stuff, I finish the commit process by entering in some release notes and indicating which items in the bug/to-do list this change addresses. So now I decide that I want to inflict these changes on the rest of the group. So I bring up a record of all the modifications that have been made since the last release. My various bug fixes are there, the big change I just spend the last four weeks on is there, and several changes made by other people are there. I indicate which ones I want to include to not, and tell it to make a new release incorporating these deltas. I compiles up this release and runs the various test cases though it. If everything works okay, then I can instruct it to install this release. Now I go back to working on some other task I started a while back. The system notices that the work I've already done for this task is based on an obsolete release, and notifies me of that. I have the option of continuing to use the obsolete release or updating to the new release. If I update to the new release, and the new release contains some changes to the same pieces of code that I'm working on, then it lets me perform a three-way merge. Before I can commit these additional changes, I have to update them to the latest release, but I don't have to do that right now. ;;;; Auto-Help features. I basically don't want much in this department. Some of the ideas other people have described as wanting would drive me batty. Basically, I want just a free-form text editor with some extra features like auto-indent, paren balancing, and maybe some hot-key that pulls up a description of function at the cursor. After I get done editing, and try to compile a top level form, then it would be kinda neat to maintain cross references between the errors and the actual source code they came from. And even maybe change the color of the source code to make it visually stand out. But while I'm writing code, it rarely is in any kind of state that a compiler could make sense of it. And it would seriously interfere with my productivity and sanity if I as constrained in this reguard at all. In other words: I consider auto-help features to be more of a potential hindrance then a potential help.