In February 1987, I started working at the University of Twente as
a Un. Docent (assistant professor). I established a project on distributed object-oriented
computing. Together with Anand Tripathi from the University of Minnesota, we decided
to simplify the Sina language. First we dropped the semantic network approach. We decided
to use declarative specifications, instead. We developed the interface predicate
construct. We presented our work as an object/component composition technique. After the
rejection of our OOPSLA'97 submission, we realized that the reviewers were confused with
the term object composition; they perceived as compositional structures as defined in the
object-oriented methods. What we meant was actually behavioral composition. Nevertheless,
in 1997, we were encouraged by the establishment of the delegation and reflection
techniques within the object-oriented community, since Sina originally adopted these features.
In 1987, I decided to identify my research topics based on the benefits and shortcomings of the state-of-the-art object-oriented methods. The best way to determine these was to apply object-oriented techniques to realistic examples in the form of pilot studies. At that time, however, not so many methods were available. We studied Booch's earlier publications, and defined our own method. When new methods were introduced, we updated our method carefully. Our intention was to combine what we considered to be the best of these methods. For example, we used Coad and Yourdon's layered approach and their hints for object identification, adopted Booch's notation, employed the rules of Johnson and Foote, applied the Law of Demeter, incorporated the associations and the dynamic model of OMT, and included the collaboration graphs of the Responsibility Driven approach.
Whenever we encountered a problem, we examined the methods to understand how these problems were addressed by them. In cases where we could not find a solution for our problem, we referred to the related research work. At the end of each pilot application, we tried to categorize and generalize the problems that we experienced. These problems were explicitly used to initiate our research activities. We published these obstacles in several publications.
Many students and project members participated in the pilot projects. Some pilot projects were combined with my consulting and course activities. In addition, we applied object-oriented methods for our own software development efforts.
During his master thesis study, Enis Yucesoy carried out research on the relation between object-oriented methods and application domains. Using the principles of Composition Filters, Ronald Beekelaar extended the object-oriented notations used at that time.
Around 1997, we decided to develop scenarios to test the expression power, adaptability and reusability of the object and component-oriented techniques. During their master thesis studies, Steef de Bruijn and Arjan Burggraaf developed a working application and a change case scenario. Steef compared and evaluated the C++ language and Composition Filters. Arjan compared the OMG CORBA model with Composition Filters.
We are still very active in carrying out pilot projects. This
approach is the basis of our research principle, which we termed as the Industry-As-Laboratory
approach.
Our related publicatons can be found here.
After our rejected submission to OOPSLA'87 we decided to simplify
the predicates. Basically the predicates construct was an aspect specification,
which could express inheritance, delegation and atomic delegation.
Several students at Twente worked on the implementation of the Sina language. Ruud Nijhuis
implemented the Sina compiler. The object-manager and concurrent processing constructs
were implemented by Hans Bank. Gerard van Wageningen and Jan Willem Dijkstra implemented
the interpreter. Gerard van Wageningen also implemented the abstract communication types.
Jan Willem Dijkstra implemented delegations, atomic constructs, type checking and the
deadlock detection algorithm. The user interface was built by Willem Veldkamp.
In 1989, Lodewijk Bergmans
and Koen Lesterhuis started with their M.Sc. work. Lodewijk worked on distributed
object-oriented systems in general, and distributed Smalltalk implementation of the Sina
system in particular. Koen Lesterhuis worked on distributed user interfaces to be used for
the Sina system. Nini Poortenga worked on the application of Abstract Communication Types
for constructing distributed knowledge processing systems.
Our related publications can be found here.
In March 1989, I finalized my Ph.D. thesis titled "On the Design of the Object-Oriented Language Sina". In 1989, Sina could express various data abstraction mechanisms, concurrent processing, atomic delegations and abstract communication types. However, concurrent processing mechanisms and abstract communication types were not uniformly integrated with the predicate construct and therefore they were not as composable as the data abstraction mechanisms.
 |
M. Aksit, On the Design of an Object-Oriented Language Sina, PhD. thesis, Dept. of Computer Science, University of Twente, March 23, 1989. |
After my Ph.D. defense, I visited the IBM T. J. Watson Research Center for about 4 months. I was asked to investigate the the bulky data transfer problem in remote procedure calls. I realized that the performance of remote calls could sometimes be improved by reversing the direction of calls. I termed this technique Inverse Remote Procedure Calls. This technique is similar to Java Applets however defined at procedure call level. At that time, Java Applets were not know of course. Dr. Alexander Stoyenko liked the idea and we decided to further investigate this technique together. After my return to Twente, I became an associate professor in Software Engineering.
After IBM visit, at Twente I searched for a student who could implement Inverse Remote Procedure Calls. Jan Bosch applied for the M.Sc. thesis assignment. Alexander Stoyenko moved to NJIT and visited Un. of Twente in 1991 and 1992. Alex improved the algorithm. The simulation environment was implemented by Jan Bosch. Tom Marlowe joined at a later stage. The publication of the idea took some years and due to my shortage of time, Alex, Jan and Tom finalized the paper:
|
A. Stoyenko, J. Bosch, M. Aksit and T. Marlowe, Load Balanced Mapping of Distributed Objects to Minimize Network Communication, Journal of Parallel and Distributed Computing 34, pp 117-136, 1996. |
In 1988 I started reviewing several ESPRIT projects. In 1990, I
started giving
professional courses for companies. Consulting and giving courses provided an
excellent input for our research activities and enhanced our relations with the software
industry.
Our first Sina compiler was written using Lex and Yacc, which did not integrate very well with the Smalltalk environment. I decided to implement a parse generator in Smalltalk. Rene Mosterd applied for the M.Sc. thesis on this topic. We realized that using a special inheritance mechanism called Grammar Inheritance we could enhance the parser generator functionality. Rene finalized his thesis and decided to establish a company that could market this product. The implementation, of course, had to be improved. Several people used our prototype, and the reactions were very positive. Rene, however, did not continue with his commercial ideas and due to lack of man power we stopped this research activity. I believe that the idea of inhering grammar specifications is useful, not only in building parsers, but also in specifying interoperability of protocols; protocols can be expressed as grammars and compatible grammars form a sub-grammar relationship.
|
M.
Aksit, R. Mostert & B. Haverkort, Compiler Generation
based on Grammar Inheritance, Memoranda Informatica 90-07, University of Twente,
February 1990. |
We decided to continue with the idea of interface predicates.
In Mid 1990, Lodewijk Bergmans started with his Ph.D. work on concurrent object-oriented
programming. About the same time, Sinan Vural from the Middle East Technical University
started working in our project. His main assignment was language-database integration
problems. Both Lodewijk and Sinan concluded that state-controlled predicates were
necessary. Further, there was a need for defining different predicate types. We decided to
term predicates as filters. We then added conditions and defined different filter types.
Our emphasis was to use a uniform filter specification (message processing language), and
create orthogonal and composable filters.
In 1991 we introduced several filters types. Error Filter was found useful in expressing
pre and post conditions and multiple views on objects. Dispatch Filter was defined to
implement controllable inheritance and delegation. Actually, the previously adopted
predicate construct was a combination of Error and Dispatch filters without conditions.
Dispatch Filter provided a very powerful delegation mechanism, and created new concepts
such as conditional and associative inheritance and delegation.
Filters were defined as a group activity. Several filter candidates were not selected
because either they were not composable and/or no relevant problem could be identified.
Some filters were considered as to be implemented later, such as Active and
MultipleDispatch filters.
No doubt, since his employment in mid 1990 as a Ph.D. student, Lodewijk Bergmans
contributed to the filter definitions the most. His contributions were mainly in the
definition of Error, Dispatch and Wait filters. From 1990 to 1992, we started cooperating
with Akinori
Yonezawa's group from the University of Tokyo. In 1990, they were working on the
synchronization inheritance anomaly problem. Lodewijk visited Tokyo for a month. Our
cooperation with Akinori Yonezawa and at that time his Ph.D. associate Satoshi Matsuoka
contributed very much to our understanding of the composability problems. Lodewijk
finalized the definition of Wait Filter in 1993, and thereby we could solve most of the known
anomalies.
Sinan Vural mainly contributed to the definition of Error and Dispatch filters. Sinan left
our project in 1992 and enrolled as a student of the Enschede Music Academy.
After his graduation Jan Bosch
started to work in our project. His main assignment was real-time object-oriented
programming. He also participated in the general discussions about filters. Further, as a
master student Willem van der Sterren worked on RealTime Filter and real-time
specification inheritance anomalies. Our work resulted in the definition of RealTime
Filter.
In 1992 Jan Bosch was paid from my course income and this did not offer a stable basis for
a Ph.D. work. In 1993, Jan started working on a joint project with Applied Education
Department on Intelligent tutoring systems, which had started in 1991. Our idea was to use
filters to express composable knowledge, since knowledge representation techniques were
required in building intelligent tutoring systems. However, we were not successful in
defining composable knowledge using filters.
At the end of 1993, we started defining a Ph.D. program for Jan. The idea was to work on a
suitable scheduler for RealTime Filter, since RealTime Filter was not implemented.
In 1994 Jan decided to leave for Sweden. The first intention was that I would stay as his
Ph.D. supervisor. However, we had a dispute about the Ph.D. topic and the originality of
Jan's papers written after his departure. Jan decided to go on his own way.
In 1992 Ken Wakita from
the University of Tokyo visited our group for about 6 months. His main assignment was to
specify Abstract Communication Types using filters. Although Abstract Communication Types
were introduced in my Ph.D. thesis, the technique was not integrated with filters and
therefore it was not composable with other aspects. This work resulted in the definition
of Meta Filter. Ken left to Japan and started working at the Tokyo Institute of
Technology.
In 1991 and 1992, Richard van de
Stadt, Sander Pool and Jan Bosch contributed to the C++ implementation of the Sina
programming language and its environment. Later, Sander left for the United States.
Our
related publications can be found here.
The composition filters approach mainly addressed a set of object
and aspect composition problems. However, in our pilot projects we also experienced some
methodological problems. In 1992 I realized the necessity of defining computable software
development methods. My intention showed similarities with the hermeneutics philosophy.
I proposed a new methodological framework that is used to construct the so-called hermeneutic
software. This term is taken from hermeneutic philosophy: "Hermeneutics grounds the
meaning of texts in the intentions and histories of their authors and/or in their
relevance for readers". A hermeneutic method aims at developing hermeneutic software
systems that integrate the decisions made by the designers during analysis, design and
implementation phases. Hermeneutic software development regards software as a means for
transmitting experience, views and knowledge of software engineers to the end users. In
contrast to conventional methods, a hermeneutic method makes this information explicit and
integrates it uniformly with the software. This approach is different from adding comments
or hypertext like documentation because the information collected by a hermeneutic method
becomes part of the semantics of software but not an add-on information.
Hans van Oosten (at that time he was working for Digital Netherlands), joined me in
writing a report on hermeneutics based software engineering (abstract of this report is available in Dutch). Although
we found hermeneutics a good idea, its presentation to the public and realization were
quite difficult. We decided to consider hermeneutics as a long term goal, and started to
investigate techniques to implement it. This resulted in our research activity
"method modeling using fuzzy-logic".
During his Ph.D. study, Bedir Tekinerdogan compared philosophy, mature engineering disciplines and software engineering. Within this context, hermeneutics was studied as well.
The related publication:
|
B. Tekinerdogan and M. Aksit, On the Notion of Software Engineering: A Problem-Solving Perspective, submitted, Dept. of Computer Science, University of Twente, 1999. |
This page was last modified by Mehmet Aksit on December 27, 2000.
