I have some very rough idea, but I like to explain it anyway. 
We have seen many software development methodology and they 
promissed many things and failed miserably, of course they 
achieved some limited successes too. 
    But I think the following method looks very promissing. 
First, most software development tools require very precise 
description of the problems, and precise syntax for certain 
languages. And if we do not give enough details, boom. 
We got stuck anyway and don't know where to go. 
But guys like me do not have precise details when I began. 
I have very vague ideas like this one. A little by little 
these ideas begain to take shapes by itself. 

    Can we translate these idea evolving process to the software 
development cycles?  I think there may be some way to do so. 
One aspect of this model allows partial specification of ideas, 
and some details can be left out. How this is possible is 
well lets figure out later, but I think there could be some 
method to do so. Partial specification naturally introduces 
partial computation or partial mapping. 

We can use 
     1. some symbolic computation method or 
     2. lazy evaluation or 
     3. use default value or 
     4. compute by example method or 
     5. ask questions when you don't know how to do method. 
       (some idea about partial computation.) 

Each computing entity(or module or instance of class) consists of 
     1. message receiving part 
     2. parsing and figuring out what that message means part 
     3. providing service for that received message (body) 
     4. when needed we may ask some other service from other computing entity 
     5. delivering result by message part 
     6. when we are delivering results we can deliver to 
        several relavent entities so each entity can use 
        these result when they are ready or ... 
    ------------------------------------------------------------------------- 
     7. each entity can act as a client or as a server or both 
     8. entity is not sub program or module 
         they are rather like COM - server or CORBA - server 
     9. they are similar to web browser and web server combined. 
    10. message is consist of xml style document 
    11. each entity contains xml-parser 
    12. there are usual CASE-tool like services for message passing 
         and receiving... 

You may wonder well I have seen all of these things before, 
so what is big fuss about this model or new methodology things? 

I think this model is different from other models. 

     1. This model is guranted (can be mode ) to run no matter what 
         the specification of your entity is. 
     2. This model allows partial specification and later can introduce 
        more detailed specification. 
     3. You can play with your ideas easily. 
     4. You can observe that how your rough idea is translated to some 
         beginning stage of each entity and how those entities are affected, 
         in other words dynamic nature of your specifications. 
     5. Even you didn't provide the body of entity, default body is created 
         and all the information is logged automatically for later use. 
  

                              July 8, 1999              Sang Cho 
  

Related works: 

1. A Design: Theory and Implementation of an Adaptive, Agent-Based 
    Method of Conceptual Design. 

2. The Principles of  Design  by Nam Pyo Suh. 

3. The Enhydra Jave/XML Application Server. 

4. PAISLey by Pamela Zave, and A Multiparadigm Programming. 

5. DesignArchiveOnline 

6. Architectural Styles, Design Patterns, and Objects 

7. 40 Principles: TRIZ Keys to Technical Innovation 
    by Genrikh Altshuller, Lev Shulyak (Translator), Steven Rodman