siho

     "The Mythical Man-Month" gave me a lot of insights about software
development. It is amazing how most of the book content still applied  
nearly 30 years after it was written, and that one could always relate 
old examples given in the book to recent difficulties faced by software
developers and users.

     I agreed the most with the importance of a uniform, simple,
and straightforward architecture in any software or system. Take java
for an example, it is, overall, a powerful and easy-to-use language, but
some annoying aspects made it one of my least favorite one. 
For instance, to output a line to console in java, the simplest way 
is to use "System.out.println()" -- how is one supposed to guess that 
the "right" function is under System.out instead of java.io? 
This is neither simple (lots of searching around documentation,
and lots of typing) nor straightforward.
Printing a line is a common function in a programming language, and 
the fact that it takes so much time to find the correct
function for doing a simple print is definitely not user-friendly and
not easy-to-use. 

     The java interface is also not quite consistance. Java language is
based on classes, and it provides vast quantity of functions via large
amount of given classes. However, similar functions provided by similar
classes do not have the same function names. For example, interface "List" 
had a "getFirst()" function, while interface "SortedSet" has a "first()" 
function, both do the same thing -- get the first element. This makes
guessing what the right function name is difficult, and the language
would surely be improved if the architecture had been more consistent.

      Correctness of implementation is also important. Half a year ago I 
heard a representative from VMware talking about how some bugs in Windows 
had been made used of widely that they're now "features", which they have 
to simulate and take care of. This clearly is a case where implementation
overrided specifications. Locating and generating these types of "features"
in an emulation is most likely hard and inefficient.  

      All in all, consistence is important in architecture, and ease-of-use
should be kept in mind while doing so. Moreover, implementation should 
follow the architecture strictly, to avoid discrepancy between user 
expectation and actual outcome.