<?xml version="1.0"?>
<rdf:RDF xmlns="http://www.w3.org/TR/REC-html40" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:nedstat="http://m1.nedstat.net/basic.js" xmlns:rss="http://purl.org/rss/1.0/" xmlns:google="http://www.google.com" >
  <rss:channel rdf:about="http://www.cs.toronto.edu/~yijun">
    <rss:title>Yijun Yu's Progress</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>A progress report of my research.</rss:description>
    <rss:image rdf:resource="http://www.cs.toronto.edu/~yijun/images/xml.gif"/>
    <rss:items>
      <rdf:Seq>
        <rdf:li resource="bio.html"/>
        <rdf:li resource="research.html"/>
        <rdf:li resource="teaching.html"/>
        <rdf:li resource="activities.html"/>
        <rdf:li resource="vim-analysis.html"/>
        <rdf:li resource="eclipse-evolution.html"/>
        <rdf:li resource="art.html"/>
        <rdf:li resource="monintoring-switching.html"/>
        <rdf:li resource="precj.html"/>
        <rdf:li resource="totalcommander/cygwin.html"/>
        <rdf:li resource="totalcommander/junction.html"/>
        <rdf:li resource="archev/index.html"/>
        <rdf:li resource="eclipse-install/README.html"/>
        <rdf:li resource="columba-eclipse.html"/>
        <rdf:li resource="ac.html"/>
        <rdf:li resource="emf.html"/>
        <rdf:li resource="OpenOME.html"/>
        <rdf:li resource="GenerativeReuse.html"/>
        <rdf:li resource="aspectPHP.html"/>
        <rdf:li resource="RefactoringGoalModel.html"/>
        <rdf:li resource="Componentization.html"/>
        <rdf:li resource="NonUniformLoopParallelism.html"/>
        <rdf:li resource="PerformanceVisualization.html"/>
        <rdf:li resource="xml_i18n.html"/>
        <rdf:li resource="GoalOrientedRefactoring.html"/>
        <rdf:li resource="yaxx.html"/>
        <rdf:li resource="CacheVisualization.html"/>
        <rdf:li resource="cacheviz.guide.html"/>
        <rdf:li resource="ISV.html"/>
        <rdf:li resource="Partitioning.html"/>
        <rdf:li resource="Wireless.html"/>
      </rdf:Seq>
    </rss:items>
  </rss:channel>
  <rss:image rdf:about="http://www.cs.toronto.edu/~yijun/images/xml.gif">
    <rss:title>Yijun Yu's Progress</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun</rss:link>
    <rss:url>http://www.cs.toronto.edu/~yijun/images/xml.gif</rss:url>
  </rss:image>
  <rss:item rdf:about="columba-eclipse.html">
    <rss:title>How to compile columba under Eclipse</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/columba-eclipse.html</rss:link>
    <nedstat:counter>AC746wWZhIZ182lDmcI0kqgv7S9Q</nedstat:counter>
    <rss:description>
<pre>
- create a directory as the columba workspace 
<code>
        mkdir %workspace%
</code>
- Extract columba source code 
<code>
	columba-win32-1.0_RC3-src.zip 
</code>
  into the following directory
<code>
	%workspace%/columba
</code>
- run eclipse with the columba workspace:
<code>
        eclipse -data %workspace%
</code>
   - close the welcome screen
- creat a columba project
   - in the ``package navigator", right click, choose 
     "new"/"project"/"java project from existing ant buildfile"
   - enter "%workspace%/columba/build.xml" as the Ant buildfile location
- fixing the compilation errors
  - edit .classpath
<code>
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;classpath&gt;
	&lt;!-- source code --&gt;
	&lt;classpathentry kind="src" path="src/addressbook/api"/&gt;
	&lt;classpathentry kind="src" path="src/addressbook/core"/&gt;
	&lt;classpathentry kind="src" path="src/addressbook/test"/&gt;
	&lt;classpathentry kind="src" path="src/columba/core"/&gt;
	&lt;classpathentry kind="src" path="src/columba/test"/&gt;
	&lt;classpathentry kind="src" path="src/mail/api"/&gt;
	&lt;classpathentry kind="src" path="src/mail/core"/&gt;
	&lt;classpathentry kind="src" path="src/mail/test"/&gt;
	&lt;classpathentry kind="src" path="res"/&gt;
	&lt;!-- junit 3.8.1 --&gt;
	&lt;classpathentry kind="var" path="ECLIPSE_HOME/plugins/org.junit_3.8.1/junit.jar"/&gt;
	&lt;!-- jre --&gt;
	&lt;classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/&gt;
	&lt;classpathentry kind="lib" path="lib/forms-1.0.5.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/jscf-0.3.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/commons-cli-1.0.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/jwizz-0.1.3.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/jhall.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/ristretto-1.0_RC3.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/macchiato-1.0pre1.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/frapuccino-1.0pre1.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/lucene-1.3-final.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/looks-1.3.1.jar"/&gt;
	&lt;classpathentry kind="lib" path="native/win32/lib/jniwrap-2.4.jar"/&gt;
	&lt;classpathentry kind="lib" path="native/win32/lib/winpack.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/jdom.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/jpim.jar"/&gt;
	&lt;classpathentry kind="lib" path="lib/je-1.7.1.jar"/&gt;
	&lt;classpathentry kind="lib" path="native/win32/lib/jdic.jar"/&gt;
	&lt;classpathentry kind="output" path="bin"/&gt;
&lt;/classpath&gt;
</code>
- remove unnecessary files
   - remove the directory "classes" 
   - delete the linked directory "api" 
   - delete "build.xml" src/*.build.xml src/*/build.xml
   - delete "maven.xml"
- compile plugins
  - create a separate eclipse projects for every plugin
<code>
	cd %workspace%/columba
	mv plugins/* ..
</code>
  - create a new Java project for each of these plugins
  - copy the .classpath from the columba and make similar modifications
- set the main class to run
   - extract columba.jar/META-INF
<code>
	jar xf columba.jar META-INF
</code>
   - removing the helpManager error: org.columba.core.help.HelpManager.java
     add the following line  to methods enableHelpOnButton, enableHelpKey
<code>
    	if (getHelpBroker()==null) return;
</code>
   - the main class is 
	org.columba.core.main.Main
   - run as Java application 
</pre>
</rss:description>
  </rss:item>

  <rss:item rdf:about="ac.html">
    <rss:title>Towards Requirements-Driven Autonomic Systems Design</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/ac.html</rss:link>
    <nedstat:counter>ADXMpQKQlcxS8FX+UciBcSL0JigA</nedstat:counter>
    <rss:description>
Autonomic computing systems reduce software maintenance costs and management complexity by taking on the responsibility for their configuration,
optimization, healing, and protection. These tasks are accomplished by switching at runtime to a different system behaviour, 
the one that is more efficient, more secure, more stable, etc.  while still fulfilling the main purpose of the system. Thus, 
identifying and analyzing alternative ways of how the main objectives of the system can be achieved and designing a system that supports all of these alternative behaviours is a promising way to develop autonomic systems. This paper proposes the use of requirements goal models as a foundation for such software development process and sketches a possible architecture for autonomic systems that can be built using this approach.
<h2>Resources</h2>
Here is the <a href="deas.pdf">tentative presentation at the 
Autonomic Computing workshop@CSER meeting in Ottawa. 
May 1st-2nd, 200 May 1st-2nd, 2005.</a>
</rss:description>
  </rss:item>
  <rss:item rdf:about="GenerativeReuse.html">
    <rss:title>Quality-based Software Reuse</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/GenerativeReuse.html</rss:link>
    <nedstat:counter>AC747ACDMydBAL7jHV1+MdOkudGA</nedstat:counter>
    <rss:description>
Work in software reuse focuses on reusing artifacts.  In this context, finding
a reusable artifact is driven by a desired functionality.  This paper proposes
a change to this common view.  We argue that it is possible and necessary to
also look at reuse from a non-functional (quality) perspective.  Combining
ideas from reuse, from goal-oriented requirements, from aspect-oriented
programming and quality management, we obtain a goal-driven process to enable
the quality-based reusability. 
<p/>
<img src="reuse/process.png"/>
<br/>
Our <a href="literature/paper/leite05caise.pdf">paper</a> has been 
accepted by the CAISE'05 conference.
</rss:description>
  </rss:item>
  <rss:item rdf:about="Componentization.html">
    <rss:title>Componentization of Legacy C/C++ Software</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/Componentization.html</rss:link>
    <nedstat:counter>AC742ggq2w20Jcxstrrvn9jmToDg</nedstat:counter>
    <rss:description>
The build architecture of legacy C/C++ software systems places groups
of program files in directories representing logical components. The 
interfaces of these components are loosely defined by a set of header 
files that are typically grouped in one common include directory.  As 
legacy systems evolve, these interfaces decay resulting in a build 
process that is both time consuming and difficult to understand.  
Moreover, the increase in the number of developers working on legacy
systems necessitates parallel development. As such, the interfaces
between various components in the system must be re-documented and 
restructured to reduce the number of contentions over components as 
well as reducing the build time.  Lastly, better defined components 
can contribute to targeted testing of components. 

<h2> Resources </h2><ul><li>
Our full paper has been accepted by 
the <a href="http://fase05.disi.unige.it/">FASE 2005 conference</a>.
</li></ul></rss:description>
  </rss:item>
  <rss:item rdf:about="RefactoringGoalModel.html">
    <rss:title>Reverse Engineering Goal Models from Legacy Code</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/RefactoringGoalModel.html</rss:link>
    <nedstat:counter>AC746wWZhIZ182lDmcI0kqgv7S9Q</nedstat:counter>
    <rss:description>
A reverse engineering process aims at reconstructing high-level abstractions
from source code. This paper presents a novel reverse engineering methodology
for recovering requirements goal models from both structured and unstructured
legacy code. The methodology consists of the following major steps: 1) Refactor
source code by extracting methods based on comments; 2) Convert the refactored
code into an abstract structured program through statechart refactoring
and hammock graph construction; 3) Extract a goal model from the structured
program abstract syntax tree; 4) Identify non-functional requirements and
derive softgoals based on the traceability between the code and the goal model.
To illustrate this requirements recovery process, we refactor requirements goal
models from two legacy software code bases: an unstructured Web-based email in
PHP (<a href="http://www.squirrelmail.org/">SquirrelMail</a>) and a structured email client system in Java (<a href="http://columba.sourceforge.net/">Columba</a>).  <br/>
<a href="slides/yu05re.ppt">The presentation at the Requirements Engineering
conference, Paris, 2005 </a> does not include all the technical details.
The following might help you repeat what we have done to 
gain more insights.

<!--<img src="refactoring/refactoring.gif"/><br/>
<b>The process for reverse engineering goal models from legacy code </b><br/>
-->

We have conducted two case studies:
<h4> <a href="http://columba.sourceforge.net/">Columba</a>: a structured Java
email client</h4>
Here is the <a href="columba-eclipse.html">instructions on how
to compile Columba inside Eclipse</a> and as a result, here is <a
href="columba/workspace.zip">the workspace of Columba under Eclipse
development</a>. The studied source code and reverse engineered
goal models are show as follows:
<li><a href="columba/original/Main.java"> the originial Columba code </a> and <a
href="columba/original/Main.xmi"> the goal model converted 
from the AST of the original program</a></li>
<li><a href="columba/refactored/Main.java"> the refactored Columba code </a> and <a href="columba/refactored/Main.xmi"> the goal model converted from AST of the refactored program</a></li>
<li><a href="columba/nfr/Main.java"> the code with identified NFR </a> and <a
href="columba/nfr/Main.xmi"> the goal model converted from the AST of the program without NFR's.</a></li>
<li><a href="columba/softgoal/Main.java"> the code with softgoals introduced to
the NFR goals </a> and <a href="columba/softgoal/Main.xmi"> the goal model converted from the AST of the program with softgoals.</a></li> 

The goal models above are created based on <a
href="columba/AST.zip">the simple meta-model for the goal models</a> using the
<a href="http://www.eclipse.org/emf">Eclipse Modeling Framework</a>. <br/> They
were generated from the abstract syntax tree of the above Java code using <a
href="columba/AST.zip"> a tool based on the JDT API</a>.

<li>After the above analysis, a goal model with the softgoals is 
visualized as follows:</li>
<img src="refactoring/columba_gm.gif" width="560"/> <br/>

<h4> <a href="http://www.squirrelmail.org/">Squirrel Mail</a>: from unstructured code to goal model </h4>
Squirrel mail is used in <a href="http://dcsweb.cs.toronto.edu/webmail">our department</a> as a Web-based email client.<br/>
<img src="refactoring/squirrel.gif" width="560" /><br/>
The refactored top-level statechart of Squirrel Mail, which
models the behavior of the browser based on the refactoring of
the PHP source code.<br/> 

<li>The code <a href="refactoring/before.f">before GOTO removal </a>
is converted from the above statechart by introducing GOTO's to the
non-Hammock graphs, i.e. multi-entry or multi-exit states.</li>
<li>The code <a href="refactoring/after.f">after GOTO removal</a> is
done through the FPT compiler. It's equivalent Java code is
shown <a href="refactoring/input.java">here</a>. </li>

<li>The <a href="refactoring/output.txt">annotated goal model</a> 
is created by <a href="refactoring/AST.zip">the AST conversion 
tool</a>. A visual representation of it is shown as follows:</li>
<img src="refactoring/smg.gif" width="560"/> <br/>
The annotated goal model converted from the structurized program.

<li>After identifying the NFRs, a goal model with the softgoals is
constructured as follows:</li>
<img src="refactoring/smg2.gif" width="560"/> <br/>

<h3> Resources </h3>
<li><a
href="ftp://ftp.cs.toronto.edu/csrg-technical-reports/510/refactoring.pdf">Here
is a technique report explaining the whole process</a>. </li>

<li><a href="http://www.eclipse.org">Eclipse</a> is a comprehensive IDE with
semi-automatic Extract Method refactoring support. We also uses its <a
href="http://www.eclipse.org/emf">EMF</a> to represent our goal models and its
<a href="http://www.eclipse.org/jdt">JDT API</a> to convert structured Java
programs into annotated goal models.</li> 

<li>Remove GOTO's using the <a href="columba/fpt/README.html">FPT
compiler</a>, which is based on the algorithms discussed in
<a href="http://csdl.computer.org/comp/trans/ts/2004/04/e0231abs.htm">this TSE paper</a>. The paper uses Hammock graph to represent
single-entry, single-exit blocks, that is also the concept behind
our refactoring tool support to know the scope of extracting methods.
</li>

<li>Currently this <a href="columba/AST.zip">AST conversion tool</a>
creates an annotated goal model for Java programs. For the other 
programming languages, such as Fortran, one can use 
<a href="http://icl.cs.utk.edu/f2j/">f2j</a>. We plan to extend the work on the FPT compiler in future, so that the step of program structurizing refactoring can be linked smoothly with the current tool support.</li>

</rss:description>
  </rss:item>
  <rss:item rdf:about="PerformanceVisualization.html">
    <rss:title>Performance Visualizations using XML Representations</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/PerformanceVisualization.html</rss:link>
    <nedstat:counter>AC747Q9sSm+g4XWvsfOYcbrc+V4Q</nedstat:counter>
    <rss:description>
Intermediate representation forms the information exchanged among different
passes of program compilation. The intermediate format proposed for
extensibility and persistence is written in XML. In this way, the program
transformations that were internal to compiler become visible. The hierarchical
structure of XML makes a natural representation for the abstract syntax tree
(AST). A compiler can parse the program source into IR, then output it as an
XML document. Separated by orthogonal namespaces, other IRs are also presented
in the same XML document, gathering program information such as dependence
vectors, transforming matrices, iteration spaces dependence graphs and cache
hints. This XML document can be exchanged between compiler and program
visualizers for parallelism and locality.
<p/><a href="literature/paper/yu04iv.pdf">The paper has been published in the IV'04 conference</a>. It has been <a href="slides/beyls04iv.ppt">presented</a> by <a href="http://www.elis.rug.ac.be/~kbeyls">Dr. Kristof Beyls</a>.

<h2> Related topics </h2><li><a href="CacheVisualization.html">Cache Behaviour Visualizations</a></li><li><a href="ISV.html">Loop Dependence Visualizations</a></li></rss:description>
  </rss:item>
  <rss:item rdf:about="aspectPHP/index.html">
    <rss:title>Implementation of apsectPHP</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/aspectPHP/index.html</rss:link>
    <nedstat:counter>AC745wXnC7b4V+LEytiHTEVKA3AQ</nedstat:counter>
    <rss:description>
<ul>
<li><a href="#zend">Based on Zend (PHP) 4.3.10 </a></li>
<li><a href="#aophp">Based on AOPHP 1.0</a></li>
</ul>
<h2> <a name="aophp"/>1. Based on AOPHP 1.0 -- Feb 17, 2005</h2>

The first implementation is adapted from 
<a href="http://www.aophp.net">aophp</a>.

AOPHP uses the RewriteEngine in Apache to redirect all the access to 
".php" to a preprocessor "AOPHP" using the "php" file name as its argument. 
The output of the AOPHP, becomes the real script processed by the PHP.

The AOPHP processor 1.0 uses a directive "//AOPHP" in the component language to
indicate which aspect will be woven. We believe this gives away the advantage
of aspect-orientation, that is, it should weave the advices without changing
the original source code, not even adding a comment line.

Thus the following code is a slight modification to their implementation.  We
assume all the aspects are already located in the same directory, as separate
files "*.aspect". Then the weaver will load all such aspects in sequence, to
weave them with the original code. 

<a href="AOPHP.java.html">AOPHP.java</a> <br/>
In the implemention above, we treat the weaving A1 as a transformation over the
original code, A2 as a transformation over the woven code by A1, etc.

An interesting problem is the order of the weaving.  

We copied the "phpport.aophp" into two aspects, and modified the output
to show which one is getting woven earlier. Since we can deal with multiple
aspects now, it is interesting to see this kind of interactions among
aspects. 

<pre>
<font color="red">
Before Talking
AOPHP Says: PHP Cant Talk Right Now
After Talking
</font>

N1: 5 | N2: 10
<font color="red">
Aspect2: Before Advice on Add Function Just Called
Before Advice on Add Function Just Called
Aspect2: After Advice on Add Function Just Called
After Advice on Add Function Just Called
</font>
TOTAL OF N1 &amp; N2: 15

</pre>

Although both aspects have "around" advices, only the first one took effect,
because the "say" method already disappeared. The second aspect weaves the
"before" advices earlier, but "after" advices also earlier! The reason I guess
is that the second aspect still weaves its advice with the original function,
rather than on the woven function.


<h2><a name="zend"/> 2. Based on the Zend compiler -- Feb 20, 2005</h2>

As the current implementation of AOPHP is through textual manipulations of the
callee function in PHP, it is unlikely that the PHP call-site will be
captured,
especially when the functions are not inside a script file, but included from
other program files. <p/>

Thus an alternative (arguerably better) way is to modify the PHP
compiler/interpretator itself so that all interceptions can be caught.
Fortunately, PHP has an open-source Zend compiler, which can be 
modified to support aspects.<p/>

Currently, I extend the PHP language with a rather simple aspect syntax,
where an "aspect" is similar to a "class", an "advice" is similar
to a "function" and a "joinpoint" is similar to an "expression".
I haven't implemented "pointcut" (the placeholder for joinpoints) and more
complex "joinpoint" yet, as for now, I think it is enough to try out the
oscommerce case study.<p/>

The <a href="zend/aspectphp-zend-patch-v2.tar.gz">aspectphp-zend-patch.tar.gz</a> is done on <a
href="http://www.php.net/downloads.php">PHP 4.3.10</a>. Simply override the
changed files, and recompile, the modified "php" will recognize and
weave an aspect-oriented PHP program as simple as <a href="zend/ex.php">this component file</a> and this <a href="zend/a.aspect">aspect</a> 
file.   
Any suggestions and contributions are welcome!!! 

<p/>
Mar 3rd, 2005 <br/>

All aspects are using "*.aspect" naming convention. The original
component PHP code does not need any change.

<a href="http://seawolf.cdf.toronto.edu:9192/aspectphp">The woven effect of the simple example is shown</a>.

<h3> Resources </h3>
<li>The changed <a href="aspectphp-aophp.zip">AOPHP package</a>.</li>
<li>The <a href="configure.html"> Windows XP configurations </a>for the AOPHP.</li>
<li>The <a href="zend/aspectphp-zend-patch-v2.tar.gz">patch to PHP 4.3.10 (Zend)</a>.</li>
<li>The running <a href="http://seawolf.cdf.toronto.edu:9192/catalog">osCommerce </a> with the following <a href="http://seawolf.cdf.toronto.edu:9192/catalog/nfr.aspect">NFR aspect</a>.</li>
<!--
<li>The <a href="zend/patch.tar.gz">patch to PHP 4.3.10 (Zend)</a>.</li>
-->
<li>The <a href="configure-zend.html"> Linux configurations </a>for the Zend.</li>
<li>The <a href="http://www.phpaspect.org/wiki/doku.php"> phpAspect</a> project
by William Candillon is highly related to the aspectPHP project. The idea
behind phpAspect is to weave the PHP code statically rather than dynamically as
aspectPHP does. Therefore the runtime performance of phpAspect is 
better, while the weaving must be carried out at the server side whenever
there is a change to the codebase.
Both projects rely on the true PHP syntax in the YACC grammar. The phpAspect weaver further
uses XSLT to transform on the YACC generated parsing tree in XML form (see the
<a href="../yaxx.html">yaxx</a> project.)</li>

    </rss:description>
  </rss:item>
  <rss:item rdf:about="aspectPHP.html">
    <rss:title>From Goals to Aspects: Discovering Aspects from Requirements
Goal Models</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/aspectPHP.html</rss:link>
    <nedstat:counter>AC745wXnC7b4V+LEytiHTEVKA3AQ</nedstat:counter>
    <rss:description>
Aspect-oriented programming (AOP) has been attracting much attention in the
Software Engineering community by advocating that programs should be structured
according to programmer concerns, such as ``efficient use of memory''. However,
like other programming paradigms in their early days, AOP hasn't addressed yet
earlier phases of software development. In particular, it is still an open
question how one identifies aspects early on in the software development
process. We show
that <a href="http://www.cs.toronto.edu/cser/aore.html">aspects can be discovered during goal-oriented requirements analysis</a>. 
<p/>
Our
proposal includes <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu04re.pdf">a systematic process for discovering aspects from
relationships between functional and non-functional goals</a>. We illustrate <a href="http://www.cs.toronto.edu/cser/aore.html">the proposed aspect-oriented
requirements engineering process</a> with a case study adapted from the
literature: the case study is on an implemented <a href="http://www.cs.toronto.edu/~jm/Pub/InfoSystems02.pdf">Media Shop
information system</a>. 
<p/><a href="http://www.oscommerce.com">OsCommerce</a> is a Web-based e-Commerce
platform developed in <a href="http://www.php.net/">PHP</a>. We used it to
recover its functional goal models. Here is <a href="tutorial/oscommerce.txt">some configuration steps for osCommerce</a>.
<p/>
AOP has been implemented for tradidtional programming languages such as Java
(<a href="http://eclipse.org/aspectj/">aspectJ</a>), C (<a href="http://www.cs.ubc.ca/labs/spl/projects/aspectc.html">aspectC</a>),
C++ (<a href="http://www.aspectc.org/">aspectC++</a>) 
and C# (<a href="http://www.cs.tcd.ie/publications/tech-reports/reports.02/TCD-CS-2002-55.pdf">aspectC#</a>). 

At the time of writing the paper, aspect-oriented PHP was not available yet.
Recently a simple implementation is available <a href="aspectPHP">aspectPHP</a>, with
which we are going to verify our candidate aspects.
<h3> References </h3>

[1] Castro, J., <a href="http://www.cs.toronto.edu/~mkolp/">Kolp, M.</a>, <a href="http://www.cs.toronto.edu/~jm">Mylopoulos, J.</a>, &quot;<a href="http://www.cs.toronto.edu/~jm/Pub/InfoSystems02.pdf">Towards
Requirements-Driven Software Development Methodology: The Tropos Project</a>,&quot;
Information Systems, June 2002. 
<p/>
[2] <a href="http://www.cs.toronto.edu/~yijun">Y. Yu</a>, <a href="http://www-di.inf.puc-rio.br/~julio/">J.C.S.P. Leite</a>, <a href="http://www.cs.toronto.edu/~jm">J.  Mylopoulos</a>. <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu04re.pdf">From goals
to aspects: discovering aspects from requirements goal models</a>&quot;. <a href="http://www.cs.toronto.edu/~yijun/slides/yu04re.ppt">presented</a> at the
<a href="http://www.re04.org">Requirements Engineering 2004 conference</a>.
<p/>
[3] C. Zhang, H.-A. Jacobsen, Y. Yu. "Linking Goals to Aspects". In Early Aspects workshop at the AOSD conference. 2005.
<p/>
[4] <a href="http://www.aosd.net">AOSD.NET</a>

    </rss:description>
  </rss:item>
  <rss:item rdf:about="xml_i18n.html">
    <rss:title>Making XML Document Markups International</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/xml_i18n.html</rss:link>
    <nedstat:counter>AB6WxgOf1/e/ca8jDT/h7s3+93DA</nedstat:counter>
    <rss:description>
In name and in practice, the World-Wide Web (hereafter Web)
is used around the world, beyond English-speaking areas. This creates a
tremendous need to internationalize standard terminology used in the
technologies that make the Web possible. Existing efforts on XML
internationalization (i18n) and localization (i10n) have focused on the content
of XML documents instead of terms used in markup (annotations) such as elements
and attributes. The SGML standard ISO 8879 supports the use of Unicode (ISO
10646) throughout a document, including markups.  However, most elements and
attributes of XML documents are still defined in English, thereby limiting
their use among non-English speakers. <br/>
The <a
href="http://www3.interscience.wiley.com/cgi-bin/fulltext/109675953/PDFSTART">full
paper in the SPE 35(1):1-14</a> presents an XSLT-based method that can
completely localize the markup of XML documents into different natural
languages. We also describe
how the proposed technique can be applied to translation problems in
<a href="yaxx.html">programming (e.g. C and Java)</a> or documentation (e.g.
LaTeX or other formatting languages) so that a program or a document can be
converted to and from an XML format.<br/>
A shorter paper &quot;<a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu03ai.pdf">Localizing
XML documents using XSLT</a>(<a href="http://www.cs.toronto.edu/~yijun/cxsl.html">HTML</a>)&quot; has been previously <a href="http://www.cs.toronto.edu/~yijun/slides/ai2003.ppt">presented in the
Applied Informatics 2003 conference</a> with the following <a href="http://www.cs.toronto.edu/~yijun/slides/ai2003/ai2003.zip">demonstation
kit</a>.  </rss:description>
  </rss:item>
  <rss:item rdf:about="yaxx.html">
    <rss:title>YAXX: YAcc eXtension to XML, version 0.12 released</rss:title>
    <rss:link>http://mcs.open.ac.uk/yy66/yaxx.html</rss:link>
    <nedstat:counter>AB5Wqgwr67uUynfKHtWqchIurVSQ</nedstat:counter>
    <rss:description>
The YAXX tool is an XML extension to YACC (Bison), a well-known
compiler-compiler.  Given a program and its YACC grammar, YAXX outputs the
internal parse tree of the program as an XML document. The generated XML
conforms to the DTD that is also generated from the YACC grammar and it can be
transformed back to a valid program through a very simple XSLT.
<p/>
The <a href="http://code.google.com/p/yaxx/">YAXX project is hosted at Google Code</a>.  Example grammars include <a href="http://yaxx.googlecode.com/svn/trunk/ansic/">ANSIC</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/gcc-3.4.0/">GCC 3.4.0</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/java/">Java 1.1</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/fortran/">Fortran 77</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/sql/">SQL</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/sql/">Embedded SQL</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/xml/">XML</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/ada95/">Ada 95</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/csharp/">C#</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/php/">PHP</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/js_parse_tree/">Javascript</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/telos/">Telos</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/nfr/">NFR</a>, 
<a href="http://yaxx.googlecode.com/svn/trunk/bibtex2-0.95/">BibTeX</a>, 
etc. We are also working on the BISON grammar.

<h2> Applications </h2>
The tool has been applied 
<ul><li> To internationalize programs through the XSLT in <a href="xml_i18n.html">Making XML documents International</a></li><li> To <a href="http://sf.net/projects/tropos">convert knowledge
representations in Telos</a> (see <a href="OpenOME.html">OpenOME</a>) or <a href="GenerativeReuse.html">NFR</a> into goal models or graphviz DOT
graphs. </li><li> To debug GCC for an efficient collection of the program unit dependence
graph in <a href="http://www.cs.toronto.edu/cser/header.html">the header restructuring project</a>. </li>
<li>To weave aspect-oriented PHP programs in the <a
href="http://www.phpaspect.org/wiki/doku.php">PHPAspect project</a> by William Candillon.
The project has been chosen by the <a href="http://code.google.com/soc/php/appinfo.html?csaid=E21E7E68ED9618C">Google
Summer of Code in 2006</a>.</li> 
</ul><h2> Related work </h2><ul><li> G. McArthur, J.
Mylopoulos, S.K.K. Ng. <a href="http://csdl.computer.org/comp/proceedings/wcre/2002/1799/00/17990199abs.htm">
An Extensible Tool for source Code Representation Using XML</a>, Ninth Working
Conference on Reverse Engineering (WCRE'02) October 29 - November 01, 2002
Richmond, Virginia.</li><li> B. A. Malloy and J. F. Power. <a href="http://www.cs.clemson.edu/~malloy/papers/wcre02/paper.pdf">Program
Annotation in XML: a Parser-Based Approach</a>, Proceedings of WCRE 2002,
Working Conference on Reverse Engineering, Richmond, Virginia, USA, pages
190--198, October 28 - November 1, 2002. </li><li><a href="http://www.cs.washington.edu/homes/gjb/papers/javaml/javaml.html">JavaML:
A Markup Language for Java Source Code</a></li><li><a href="http://www.tel.fer.hr/users/mtopol/jezix/">Jezix </a></li><li><a href="http://www.alphaworks.ibm.com/tech/ret4j">Mamas' and Kontogiannis'
JavaML</a></li></ul><h2> Resources </h2><ul><li><a href="http://prdownloads.sourceforge.net/yaxx/yaxx-0.11.tar.gz?download">YAXX
0.11 download</a></li>
<li><a href="http://ftp.gnu.org/gnu/bison/">Bison download</a></li>
<li><a href="http://gnuwin32.sourceforge.net/packages/bison.htm">Bison for
Windows download (version 2.1)</a></li>
</ul></rss:description>
  </rss:item>
  <rss:item rdf:about="cacheviz.guide.html">
    <rss:title>User's Guide for the Cache Visualizer</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/cacheviz.guide.html</rss:link>
    <nedstat:counter>AC747gNun0GCs6Una/ce0ia/lsIg</nedstat:counter>
    <rss:description>
<ol>
<li> Download a demo for the cache simulator + visualization implemented as a
pure Java <a
href="http://winpar.elis.rug.ac.be/ppt/cacheviz/cacheviz_demo.zip">application
</a></li>
<li> Extract the files into a subdirectory, namely "foo/cacheviz"</li>
<li> Change the path of the Java executable in the "test.bat" or "test.sh"</li>
<li> The only parameter needed for test is "foo.is.bz2", which is the
trace data generated from the corresponding "foo.f".</li>
</ol>

A more advanced visualizer is available upon request through Prof. Erik
D'Hollander. Currently we shall distribute it through email with consent that
this tool is under the research license of ELIS, Ghent University.

Major new features include:
<ol>

<li>Faster cache simulation has been re-implemented in C++ which links directly
with the instrumentation tools in the FPT or the ORC compilers.  The profiler
has been successfully preparing data for the runtime loop dependence analyzer,
the reuse distance simulator and also the cache simulator. (Kristof and
Yijun)</li>

<li>Thus the raw trace file is not necessary now. The trace is preprocessed by
the C++ cache simulator to get the simulation result into a trace file into
plain text, then processed through Perl script into XML. The Java application
consumes the XML file to show the graphics. (Yijun)</li>

<li> The Java application places focus on the graphic features for
both Trace and Histogram views, such as Zooming, Filtering, Overlapping, and
hyperlink back to the exact hotspots in an editor of the original source code.
The GUI is implemented in JDK/Swing.  (Bart and Yijun)</li>

<li> A still faster presentation is made through Eclipse/SWT as a resource
plugin, see the recent <a href="joachim/presentatie.ppt">presentation</a> for
thesis defense of Joachim Vermeir (in Dutch) for a glimpse of the latest
development.  Charts has been integrated to visualize performance counters
(Joachim, Kristof and Yijun)</li>

</ol>

A more recent development to visualizing cache behavior is hosted 
by Kristof Beyls as the <a href="http://elis.ugent.be/~kbeyls/rdvis">reuse distance visualizer</a>. The new tool is able to analyze the
platform-independent reuse distance metric to pinpoint the capacity
miss behavior for program executions.
<hr/>

<address>
Erik D'Hollander<br/>
Kristof Beyls<br/>
Bart Kerkhof<br/>
Joachim Vermeir<br/>
Yijun Yu <br/>
</address>
    </rss:description>
 </rss:item>
   <rss:item rdf:about="CacheVisualization.html">
    <rss:title>Visualizing the Impact of the Cache on Program Execution</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/CacheVisualization.html</rss:link>
    <nedstat:counter>AC747gNun0GCs6Una/ce0ia/lsIg</nedstat:counter>
    <rss:description>Cache behavior of a program has an ever-growing strong
impact on its execution time. Characterizing the behavior by visible patterns
is considered a way to pinpoint the bottleneck against performance. <br/>
We present a framework of visualization for trace distributions to extract the
useful cache behavior patterns. We focus on cache misses, reuse distances,
temporal or spatial localities, etc. The histograms of these distribution
patterns measure the behavior in quantity, revealing effective program
optimizations. The performance bottlenecks are exposed as hot spots highlighted
in the source code, showing the exact locations to apply suitable
optimizations. The impact of the source-level program optimizations, again, can
be verified by <a href="http://www.cs.toronto.edu/~yijun/cacheviz.guide.html">the visualization tool</a>. <p/>
The work has been <a href="http://www.cs.toronto.edu/~yijun/slides/us_trip2001.ppt">presented</a> in <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu01iv.pdf">the Information Visualization (IV'01) 2001 conference</a>.
More details are published <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu04ccai.PDF">in the CCAI journal</a>. <p/></rss:description>
  </rss:item>
  <rss:item rdf:about="NonUniformLoopParallelism.html">
    <rss:title>Non-uniform dependences partitioned by recurrence chains</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/NonUniformLoopParallelism.html</rss:link>
    <nedstat:counter>AC748AALRYmBydsx9PwAYFTOkcpg</nedstat:counter>
    <rss:description>Non-uniform distance dependences in loop nests are a known obstacle to find
parallel iterations. To find the outermost loop parallelism in these
``irregular&quot; loops, a novel methods is presented based on
recurrence chains. The scheme organizes non-uniformly dependent
iterations into lexicographically ordered monotonic chains. While the
initial and final iteration of monotonic chains form two parallel
sets, the remaining iterations form an intermediate set that can be
partitioned further. When there is only one pair of coupled array
references, the non-uniform dependences are represented by a single
recurrence equation. In that case, the chains in the intermediate set
do not bifurcate and each can be executed as a WHILE loop. The
independent iterations and the initial iterations of monotonic
dependence chains constitute the outermost parallelism. The proposed
approach compares favorably with other treatments of non-uniform
dependences in the literature. When there are multiple recurrence
equations, a dataflow parallel execution can be scheduled using the
technique extensively to find maximum loop parallelism.
<p/><a href="literature/paper/yu04icpp_draft.pdf">The paper accepted by the
ICPP 2004 conference can be downloaded</a>, <a href="slides/yu04icpp.ppt">Here is the presentation</a>.
<p/>

Related tools are <a href="ISV.html">our ISV loop parallelism visualization tool</a>, <a href="PerformanceVisualization.html"> the XML extension to the FPT compiler</a> and <a href="http://www.cs.umd.edu/projects/omega/">the Omega Calculator for integer programming (University of Maryland)</a>.
</rss:description>
  </rss:item>
  <rss:item rdf:about="precj.html">
    <rss:title>Speedup Java Compilations by Restructuring Class Libraries</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/precj.html</rss:link>
    <nedstat:counter></nedstat:counter>
<rss:description>
Class loading is on the critical path for compiling object-oriented programs,
for executing them when large-scale software libraries are loaded at runtime,
and for executing large-scale Java Web applications. Hence the performance for
these processes can suffer from large loads of class libraries. This automated
tool improves class load performance by restructuring Java class libraries. We
demonstrate through experiments universal gain of performance in the
compilation and execution of medium-size Java programs.
<h2>Update</h2>
The project is now hosted at 
<a href="http://code.google.com/p/precj/">Google Code</a>.
</rss:description>
</rss:item>
   <rss:item rdf:about="totalcommander/junction.html">
    <rss:title>Configure junction inside total commander</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/totalcommander/junction.html</rss:link>
    <nedstat:counter>ADab8Qd500HAIkgR+FbGyDQlVqEg</nedstat:counter>
<rss:description>
<pre>
- get junction.exe
- create two buttons
  - junction.exe, parameters: %T%N %P%N
  - junction.exe, parameters: %P%N /d
</pre>
</rss:description>
</rss:item>
   <rss:item rdf:about="totalcommander/cygwin.html">
    <rss:title>Configure Cygwin inside total commander</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/totalcommander/cygwin.html</rss:link>
    <nedstat:counter>ADab8Qd500HAIkgR+FbGyDQlVqEg</nedstat:counter>
<rss:description>
<pre>
September 13, 2006 

<b>Problem.</b> 
In total commander, I often want to open a cygwin shell window to
put the selected directory as the current one.  
However, when a cygwin window is opened, the current directory always 
stick to the HOME, which is for me, "d:\cygwin\home\Yijun Yu". Then to
access a file in the visible directory of Total commander, I have to
issue a "chdir" to something like 
"/cygdrive/c/path/to/commander/directory". 
How annoying! Then how to work around this problem?

<b>Solution.</b>
It is a combination of small tricks. 
1. Create a shortcut button on the commander toolbar
  Right click at toolbar, choose "Change..."
  Append a command, fill in the following information:
  <img src="cygwin.png"/>
2. Edit the start script of cygwin, namely D:\cygwin\cygwin.bat:
 
@echo off
echo cd "%*" > "D:\cygwin\home\Yijun Yu\.cdpath"
D:
chdir D:\cygwin\bin
bash --login -i

3. Create two scripts in your home directory 
   (e.g. "D:\cygwin\home\Yijun Yu"):
.profile:
  . .bashrc
.bashrc:
  source .cdpath

That's it. When you open any directory in total commander, just
click the cygwin.ico button, you will launch a cygwin shell in
the proper place. Enjoy!
</pre>
    </rss:description>
   </rss:item>

  <rss:item rdf:about="eclipse-install/README.html">
    <rss:title>Installing/uninstalling of an Eclipse product automatically -- created on June 7, 2005</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/eclipse-install/README.html</rss:link>
    <nedstat:counter>ADab8Qd500HAIkgR+FbGyDQlVqEg</nedstat:counter>
<rss:description>

<h2> 1. Background </h2>
<a href="http://www.eclipse.org">Eclipse</a> is a family of software products, 
also known as a <a href="http://www.sei.cmu.edu/productlines/index.html">software product-line family</a>.  

An Eclipse product is organized into features or plugins. For example, the
standard Eclipse 3.0.1 installation contains 7 features, and 84 plugins.
This is reflected by the following physical directory structures:
<pre>
   eclipse_product\
      features\
      plugins\
</pre>

Not all features and plugins are necessary for every user tasks, for example,
a C/C++ development user may want the <a href="http://www.eclipse.org/cdt">CDT product</a>, whereas the Java
developer does not need it. Therefore, we consider to create a script
to automatically install/uninstall any Eclipse product.

When the Eclipse platform starts, it first looks at its configuration directory
to see which features should be enabled, then every plugin needed in the 
execution will be *lazily* loaded by the platform. Therefore, 
the installation of an Eclipse product requires to copy the product features
and plugins into the Eclipse installation directory. The uninstallation of an
Eclipse product requires to remove the product features and plugins from the
Eclipse installation directory.

<h2>2. Problem </h2>
The installation/uninstallation may be a lengthy process involving 
copying files. 
<h2>3. Solution </h2>
In Unix system, one can ease it by <a href="http://www.linuxinfor.com/english/man1/ln.html">creating logical
symbolic links</a> of the product directories to the Eclipse platform 
directory to alleviate the physically moving problem.
Symbolic links are not supported by Windows. Then
how to immitate the symbolic link mechanism 
to achieve the fast installation/deinstallation on Windows?
In Eclipse, one can create a directory in the workspace 
to mirror a directory in the file system. But the directories 
in the Eclipse installation directory can not be created this way. 
Our answer relies on the technique to 
<a href="http://answers.google.com/answers/threadview?id=341355">use the *junction* utility for the NTFS file system</a>.
<h3> 3.1 Junction point </h3>
In NTFS, a junction point is the information associated with a directory 
that can be parsed by a system call. *junction* is a system utility provided
by the system internals web site, to use the junction point to record 
information of a remote *real* directory such that the NTFS is "cheated"
to believe the directory is the remote directory. For example:
<pre>
c:\&gt; junction foo d:\foo
</pre>
will create a mirror of the d:\foo as c:\foo.  Here C: must be in a
NTFS file system, whereas D: can be any file system format.

Junction point is more powerful than the "subst" utility in the DOS file
system which mirrors a disk letter to a remote directory (I have
written a chapter on how to use *subst* utility to achieve symbolic
link effect some years ago). Here the remote directory is *mounted* to any
directory in the NTFS file system.

An important difference between a junction point and a symbolic link in
Unix, unfortunately, is that the junction point is treated as really
the remote directory. In other words, if one deletes the junction point
directory, all files under the remote directory will be removed.

To remove a junction point directory safely without removing the remote
files, the junction point is deleted by detaching it from the
remote directory. This can be done by the *junction* command by the "/d"
option:
<pre>
c:\&gt; junction /d foo
</pre>

<h3> 3.2 Scripting </h3>

The following is a Windows script to install the product to Eclipse 
platform.
<pre>
1  @echo off
2  set ECLIPSE=c:\eclipse
3  pushd %ECLIPSE%\features
4  for /D %%d in (%1\features\*) do @junction %%~nxd %%~dpnxd 
5  cd ..\plugins
6  for /D %%d in (%1\plugins\*) do @junction %%~nxd %%~dpnxd 
7  popd
</pre>
First, let's assume the script has one argument that can be addressed
by %1 in the script. This argument is used as the directory of the
Eclipse product to be installed and the product has prepared a
*features* and a *plugins* subdirectory to hold the features and
plugins respectively. <br/>

Line 1 turns off the echoing of each following command in the script. <br/>
Line 2 assumes that the Eclipse platform is installed under C:\eclipse
directory. <br/>
Line 3 pushes the current directory in the directory stack, then change 
the current directory to the Eclipse features directory. <br/>
Line 4 loops for every subdirectory (/D) to call the *junction* command.
The first argument given to the *junction* command is the filename and
extension name of the directory, the second argument is the full name
of the directory including its drive letter and full path. <br/>
Line 5 changes the current directory to the Eclipse plugins directory and
Line 6 calls the *junction* command in a similar matter as Line 4. <br/>
Finally, Line 7 changes the currenct directory back to the one popped from
the directory stack.

The following similar script uninstall the Eclipse product:
<pre>
1  @echo off
2  set ECLIPSE=c:\eclipse
3  pushd %ECLIPSE%\features
4  for /D %%d in (%1\features\*) do @junction /d %%~nxd
5  cd ..\plugins
6  for /D %%d in (%1\plugins\*) do @junction /d %%~nxd
7  popd
</pre>

<h3> 3.3 Single button solution </h3>

<a href="http://www.ghisler.com/">Windows total commander</a> is a shareware
inheriting most of the functionalities of a Norton commander. (It is one of my
favorite tool to play on Windows, 
recommended by <a href="http://ibmpar.elis.ugent.be:8080/edh.html">Prof. Erik H. D'Hollander</a>.)
The tool is very easy to be customized. Here is how you can create a single
toolbar button to automate the above script.
<pre>
1. Install the total commander, of course.
2. Press 1, 2 or 3 to the shareware question of Total commander to be
   able to use all its functionality.
<img src="totalcmd.png"/>
The file system is viewed by two parallel panes. The left-hand side shows
the Eclipse platform directory.  The right-hand side shows the Eclipse product
directories, such as CDT (org.eclipse.cdt.sdk-3.0.0-M6-win32),
<a href="http://sourceforge.net/projects/etex/">ecletex for latex</a>, 
<a href="http://www.cs.toronto.edu/km/openome">ome4eclipse</a>, 
<a href="http://sourceforge.net/projects/lavadora/">Lavadora webservice for Eclipse</a>, etc. and also our scripts under the *eclipse-install* directory.
(I will write a separate tip on the usage of the latex plugins).
3. Now create a tool bar button by right click at the toolbar, apply *change...", fill in the following parameters:
<img src="totalcmd_toolbar.png"/>
Here %P%N indicate the Eclipse product directory that you just selected.
4. Place your mouse on one of the product directories, then press the
toolbar button. When you open the Eclispe plugin directories, you can see
the installed directories: the small shortcut decorator on the directory names
are created as junction point directories.
<img src="totalcmd_after.png"/>
</pre>
5. Alternatively, if you know which products to be installed before hand,
in the eclipse-install directory, prepare a script as follows:
<pre>
call eclipse-install d:\ome4eclipse
call eclipse-install d:\org.eclipse.cdt.sdk-3.0.0-M6-win32
call eclipse-install d:\latex
call eclipse-install d:\webservice
</pre>
Then doubleclick this script will install all products at once.
<h2> Resources </h2>
The scripts can be <a href="eclipse-install.zip">downloaded here.</a>

<h2> <a name="updates">Updates </a> </h2>
<pre>
December 7, 2005 

The tutorial still works, but I found two simpler workarounds:
1) create a "links" subdirectory under the %ECLIPSE_HOME% directory. 
   For each product, create a file links/%product%.link which contains
   a single line:
       path=%path_to_product%
2) create an empty .eclipseextension file under the %product%/eclipse
   directory, then use "Help/Manage configuration" dialog to add
   an extension to the %product% directory
To me, the first alternative is better, since you may fully automate
the reconfiguration of Eclipse without using its dialog.

Note that the following technique may still be used to create a symbolic
link to the links directory because it is still under the Eclipse 
SDK installation directory and could be removed along with the 
Eclipse SDK.
</pre>

Feb 28, 2005 <p/>

The OpenOME project uses <a
href="http://episteme.cs.toronto.edu/ome/browser/trunk/eclipse-3.1.2-win32.bat">
this script </a> to select the Eclipse products without physically copying them, on
the basis of the above finding.

<p/>
August 1, 2006

<p/>
Eclipse products can now be customized by <a href="http://yoxos.com/ondemand/">a
downloading service that bundles them on the demand of a client</a>.
<p/>

September 15, 2006
<p/>

One can perform automated update of Eclipse products at command line. 
This is slower than the previous solution, but platform independent...
See <a href="http://episteme.ai.toronto.edu/ome/wiki/AutoUpdate">how we update the OpenOME product and its dependent products
automatically for its users/developers</a>.

</rss:description>
  </rss:item> 
  <rss:item rdf:about="ISV.html">
    <rss:title>Loop Parallelization using the 3D Iteration Space Visualizer</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/ISV.html</rss:link>
    <nedstat:counter>AC747wxQ9YOHjA0bdSwBY9opEZvA</nedstat:counter>
    <rss:description><a href="http://winpar.elis.rug.ac.be/ppt/isv/index.html">A 3D-iteration space visualizer (ISV)</a> is presented to analyze the
 parallelism in loops and to find loop transformations which enhance
 the parallelism. Using automatic program instrumentation, the
 iteration space dependency graph (ISDG) is constructed, which shows
 the exact data dependencies of arbitrarily nested loops. Various
 graphical operations such as rotation, zooming, clipping, coloring
 and filtering, permit a detailed examination of the dependence
 relations. Furthermore an animated dataflow execution shows the
 maximal parallelism and the parallel loops are indicated
 automatically by an embedded data dependence analysis. In addition,
 the user may discover and indicate additional parallelism for which <a href="Partitioning.html">a suitable unimodular loop transformation is
calculated</a> and verified.
 The ISV has been applied to parallelize algorithmic kernel programs, <a href="http://winpar.elis.rug.ac.be/ppt/cfd/index.html">a CFD (Computational
Fluid Dynamics) simulation application</a>, the detection of statement level
parallelism and loop variable privatization.The applications show that the
visualizer is a versatile and easy to use tool for the high performance
application programmer.  

<p/>
The work has been published <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu01jvlc.pdf">in the Journal of Visual Languages and Computing.</a>.
A shorter paper has been <a href="http://www.cs.toronto.edu/~yijun/slides/vl2000.ppt">presented at the Visual Languages 2001 conference.</a>
A <a href="http://www.cs.toronto.edu/~yijun/slides/isv.ppt">longer tutorial has been given to the ELIS colleagues.</a>
The <a href="http://winpar.elis.rug.ac.be/cgi-bin/ppt/isv.pl">applet tool can
be demonstrated online</a>, while <a
href="http://www.cs.toronto.edu/~yijun/isv/setup.zip"> a standalone application can be downloaded</a>, which has been
applied in the course <a href="http://winpar.elis.rug.ac.be/cgi-bin/courses/view.asp?key=1">TW06-1661
Parallelle en gedistribueerde systemen (Parallel and Distributed Systems)</a>
given by <a href="http://ibmpar.elis.ugent.be:8080/edh.html">Prof.  Erik H. D'Hollander</a> in Ghent University, Belgium.
<p/>
<!--The <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu01jvlc.pdf">JVLC paper</a> has been cited by the <a href="http://portal.acm.org/citation.cfm?id=1013208.1013209">Advances in dataflow programming languages</a> in the ACM Computer Surveys.-->

<h2>Resources</h2>
<li> <a href="http://www.cs.toronto.edu/~yijun/isv/isv.feature_1.0.0.bin.dist.zip">Packaged as a feature for Eclipse 3.0.1</a>,
which is kept up-to-date in Eclipse update site from 
http://www.cs.toronto.edu/~yijun/isv/update</li>
<li> <a href="http://www.cs.toronto.edu/~yijun/isv/photran-2.1.0-full+isv-win32.zip">Packaged with the Eclipse product Photran 2.1.0</a></li>
<li> <a href="http://winpar.elis.rug.ac.be/ppt/isv/setup.exe">Run ISV as a standalone application for Windows</a></li>
<li> <a href="http://winpar.elis.rug.ac.be/ppt/isv/applet.htm">Run ISV as an applet demo</a></li>

<li> <a href="http://www.cs.toronto.edu/~yijun/isv/isv-examples.zip">Example data</a></li>


</rss:description>
  </rss:item>
  <rss:item rdf:about="emf.html">
    <rss:title>Goal Models through the Eclipse Modelling Framework</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/emf.html</rss:link>
    <nedstat:counter>AC746wWZhIZ182lDmcI0kqgv7S9Q</nedstat:counter>
    <rss:description>

<code>Goal.java</code>
<pre>
package edu.toronto.cs.goalmodel;
import java.util.List;
/** @model */
public interface Goal {
	/** @model */
	String getName();
	/** @model default=0 */
	LabelType getLabel();
	/** @model */
	DecompositionType getType();
	/** @model */
	Goal getParent();
	/** @model type="Goal" containment="true" opposite="parent" */
	List getGoal();
	/** @model type="Topic" containment="true" */
	List getTopics();
	/** @model type="Contribution" containment="true" */
	List getRule();
	/** @model type="Property" containment="true" */
	List getProperty();
}
</pre>
<code>Contribution.java</code>
<pre>
package edu.toronto.cs.goalmodel;
/** @model */
public interface Contribution {
	/** @model type="ContributionType" */
	int getType();
	/** @model */
	Goal getTarget();
}
</pre>
<code>DecompositionType.java</code>
<pre>
package edu.toronto.cs.goalmodel;
/** @model */
public final class DecompositionType {
	/** @model name="OR" */
	public static final int OR = 0;
	/** @model name="AND" */
	public static final int AND = 1;
	/** @model name="LEAF" */
	public static final int LEAF = 2;
}
</pre>
<code>ContributionType.java</code>
<pre>
package edu.toronto.cs.goalmodel;
/** @model */
public final class ContributionType {
	/** @model name="HELP" */
	public static final int HELP = 1;
	/** @model name="HURT" */
	public static final int HURT = -1;
	/** @model name="MAKE" */
	public static final int MAKE = 2;
	/** @model name="BREAK" */
	public static final int BREAK = -2;
} 
</pre>
<code>LabelType.java</code>
<pre>
package edu.toronto.cs.goalmodel;

/** @model */
public final class LabelType {
	/** @model name="Satisfied" */
	public static final int SATISFIED = 2;
	/** @model name="Denied" */
	public static final int DENIED = -2;
	/** @model name="PartiallySatisfied" */
	public static final int PARTIALLY_SATISFIED = 1;
	/** @model name="PartiallyDenied" */
	public static final int PARTIALLY_DENIED = -1;
	/** @model name="Unknown" */
	public static final int UNKNOWN = 0;
	/** @model name="Conflict" */
	public static final int CONFLICT = 4;
} 
</pre>
<code>Topic.java</code>
<pre>
package edu.toronto.cs.goalmodel;
/** @model */
public interface Topic {
	/** @model */
	String getTopic();
}
</pre>
<code>Property.java</code>
<pre>
package edu.toronto.cs.goalmodel;
/** @model */
public interface Property {
	/** @model */
	String getName();
	/** @model */
	String getValue();
}
</pre>

    <h2>Resources</h2>
<li><a href="http://www.eclipse.org/emf">EMF</a> </li>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="Partitioning.html">
    <rss:title>Parallelizing Compiler: Loop Partitioning</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/Partitioning.html</rss:link>
    <nedstat:counter>AC748Q9MAwlPuwuqucUCUS07t6sw</nedstat:counter>
    <rss:description>
A new technique to parallelize loops with variable distance vectors is
presented. The method extends previous methods in two ways. First, the present
method makes it possible for array subscripts to be any linear combination of
all loop indices. The solutions to the linear dependence equations established
from such array subscripts are characterized by a pseudo distance matrix (PDM).
Second, it allows us to exploit loop parallelism from the PDM by applying
unimodular and partitioning transformations that preserve the lexicographical
order of the dependent iterations. The algorithms to derive the PDM, to find a
suitable loop transformation and to generate parallel code are described,
showing that it is possible to parallelize a wider range of loops
automatically.  
<p/>
The paper has been published in <a href="literature/paper/yu00icpp.pdf">the International Conference on Parallel Processing (ICPP) 2000</a>. <p/>
The algorithm has been implemented in <a href="http://winpar.elis.rug.ac.be/ppt/fpt">the FPT compiler</a>.
</rss:description>
  </rss:item>


  <rss:item rdf:about="GoalOrientedRefactoring.html">
    <rss:title>Software refactoring guided by multiple soft-goals</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/GoalOrientedRefactoring.html</rss:link>
    <nedstat:counter>AC745gg7bc9rBDeW7nsNgjXI4M2A</nedstat:counter>
    <rss:description>Software refactoring is intended to enhance the
        quality of a software by improving its understandability,
        performance, as well as other quality attributes.  We adopt
        the NFR goal model framework of [Mylopoulos, 1992] in order to
        analyze software qualities, to determine which software
        refactoring transformations are most appropriate. In addition,
        we use software metrics to evaluate software quality
        quantitatively. Our framework adopts and extends work reported
	in [Ladan 2001]. More details can be found at <a href="http://www.cs.toronto.edu/cser/softgoal.html">the CSER project descriptions</a>.

<p/>
A <a href="http://www.cs.toronto.edu/~yijun/literature/paper/yu03reface.pdf">position paper</a> has been <a href="http://www.cs.toronto.edu/~yijun/slides/yu03reface1.ppt">presented</a> at <a href="http://www.swen.uwaterloo.ca/~reface03/">the REFACE@WCRE'03 workshop in conjunct with the WCRE'03 conference</a>. </rss:description>
  </rss:item>
  <rss:item rdf:about="Partitioning.html">
    <rss:title>Parallelizing Compiler: Loop Partitioning</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/Partitioning.html</rss:link>
    <nedstat:counter>AC748Q9MAwlPuwuqucUCUS07t6sw</nedstat:counter>
    <rss:description>
A new technique to parallelize loops with variable distance vectors is
presented. The method extends previous methods in two ways. First, the present
method makes it possible for array subscripts to be any linear combination of
all loop indices. The solutions to the linear dependence equations established
from such array subscripts are characterized by a pseudo distance matrix (PDM).
Second, it allows us to exploit loop parallelism from the PDM by applying
unimodular and partitioning transformations that preserve the lexicographical
order of the dependent iterations. The algorithms to derive the PDM, to find a
suitable loop transformation and to generate parallel code are described,
showing that it is possible to parallelize a wider range of loops
automatically.  
<p/>
The paper has been published in <a href="literature/paper/yu00icpp.pdf">the International Conference on Parallel Processing (ICPP) 2000</a>. <p/>
The algorithm has been implemented in <a href="http://winpar.elis.rug.ac.be/ppt/fpt">the FPT compiler</a>.
</rss:description>
  </rss:item>
  <rss:item rdf:about="Wireless.html">
    <rss:title>Wireless network and mobile computing</rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/Wireless.html</rss:link>
    <nedstat:counter>AC748galL68b64Ib+kazaR94j5fw</nedstat:counter>
    <rss:description>
In mobile wireless systems data on air can be accessed by a large number of
mobile users. Many of these applications such as wireless internets and traffic
information systems are pull-based, that is, they respond to on-demand user
requests. In this work, we study the scheduling problems of on-demand
broadcast environments. Traditionally, the response time of the requests has
been used as a performance measure. In this work we consider the performance
as the average cost of request composed of three kinds of costs access time
cost, tuning time cost, and cost of handling failure request. Our main
contribution is a self-adaptive scheduling algorithm named LDFC , which
computes the delay cost of data item as the priority for broadcast. It performs
well compared with some previous algorithms in this context.
<p/>
The work has been published in the <a href="">ACM Journal of Wireless
Network</a>. An earlier short paper was <a href="">presented to the MSWiM
workshop in conjunct with the MobiCom 2001 conference, Rome</a>.
</rss:description>
  </rss:item>
  <!--
  <rss:item rdf:about="maps/ou.html">
    <google:coordinates name="office">52.025881,-0.709734</google:coordinates>
    <google:coordinates name="home">52.018474,-0.717373</google:coordinates>
    <rss:description>
  <td align="left" width="50%">
    Department of Computing<br/>
    Faculty of Maths, Computing &amp; Technology <br/>
    The Open University <br/>
    Walton Hall, Milton Keynes, MK7 6AA <br/>
    United Kingdom (U.K.) <br/>
    Office: 2nd Floor East, Janie Lee Building <br/>
    Email: <a href="mailto:Y.Yu@open.ac.uk">Y.Yu AT open.ac.uk</a>
    Tel: +44(0) 1908-655562 <br/>
    Fax: +44(0) 1908-652335 <br/>
    <a target="_blank" href="http://www.google.com/calendar/render?cid=yijun.yu%40gmail.com"><img src="http://www.google.com/calendar/images/ext/gc_button1_en-GB.gif" border="0"/></a>
    </td>
    </rss:description>
  </rss:item>
  -->
  <rss:item rdf:about="openre.html">
    <rss:description>
<div style="text-align:center; width:1680px; margin-left:auto; margin-right:auto;">
<div style="text-align:center; font-size:12px; font-family:verdana; margin-left:auto; margin-right:auto; width:1680px;">
	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://www.cs.toronto.edu/km/openome" title="The i* diagram in openome">An i* diagram in OpenOME</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://www.computer.org/portal/web/csdl/doi/10.1109/ssiri.2010.36" title="Model-based security argumentation">Model-based security argumentation</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/22105" title="Architectural evolution">Architectural evolution</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/10264" title="Understanding monitoring and switching problems">Understanding monitoring and switching problems</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/24121/" title="Security argumentation">Security argumentation</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/19397/" title="Requirement dependencies">Requirement dependencies</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/22231/" title="Aspect-oriented code generation for RBAC">Aspect-oriented code generation for RBAC</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/19427/" title="Diagnosing failures using event calculus">Diagnosing failures using event calculus</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://oro.open.ac.uk/19395/" title="Monitoring and diagnosing software requirements">Monitoring and diagnosing software requirements</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://en.wikipedia.org/wiki/problem_frames_approach" title="The Problem Frames approach">The Problem Frames approach</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://www.cs.toronto.edu/km/istar/" title="The i*/Tropos requirements methodology">The i*/Tropos requirements methodology</a>
 | 	<a style="text-decoration:none; color:black; font-size:12px; font-family:verdana;" href="http://computing-research.open.ac.uk/trac/openre" title="The Open Requirements Engineering Lab">The Open Requirements Engineering Lab</a>(<a href="http://computing-research.open.ac.uk/trac/openre/wiki/MikiFAQ">Miki</a>) 
</div>
<img id="Image-Maps_1201012010608535" src="http://mcs.open.ac.uk/yy66/openre.png" usemap="#Image-Maps_1201012010608535" border="0" width="1680" height="954" alt="" />
<map id="_Image-Maps_1201012010608535" name="Image-Maps_1201012010608535">
<area shape="rect" coords="270,72,580,669" href="http://www.cs.toronto.edu/km/openome" alt="i* diagram in openome" title="i* diagram in openome"    />
<area shape="rect" coords="54,113,116,134" href="http://www.computer.org/portal/web/csdl/doi/10.1109/ssiri.2010.36" alt="model-based security argumentation" title="model-based security argumentation"    />
<area shape="rect" coords="53,135,105,149" href="http://oro.open.ac.uk/22105" alt="architectural evolution" title="architectural evolution"    />
<area shape="rect" coords="697,75,1418,304" href="http://oro.open.ac.uk/10264" alt="understanding monitoring and switching problems" title="understanding monitoring and switching problems"    />
<area shape="rect" coords="690,303,1411,532" href="http://oro.open.ac.uk/24121/" alt="security argumentation" title="security argumentation"    />
<area shape="rect" coords="693,536,1416,705" href="http://oro.open.ac.uk/19397/" alt="requirement dependencies" title="requirement dependencies"    />
<area shape="rect" coords="692,707,1415,920" href="http://oro.open.ac.uk/22231/" alt="aspect-oriented code generation for rbac" title="aspect-oriented code generation for rbac"    />
<area shape="rect" coords="271,668,691,919" href="http://oro.open.ac.uk/19427/" alt="diagnosis failures using event calculus" title="diagnosis failures using event calculus"    />
<area shape="rect" coords="581,74,691,668" href="http://oro.open.ac.uk/19395/" alt="monitoring and diagnosing software requirements" title="monitoring and diagnosing software requirements"    />
<area shape="rect" coords="5,202,262,528" href="http://en.wikipedia.org/wiki/problem_frames_approach" alt="the problem frames approach" title="the problem frames approach"    />
<area shape="rect" coords="11,180,267,202" href="http://www.cs.toronto.edu/km/istar/" alt="the i* goal-oriented requirements methodology" title="the i* goal-oriented requirements methodology"    />
<area shape="rect" coords="1419,74,1675,922" href="http://computing-research.open.ac.uk/trac/openre" alt="the open requirements engineering lab" title="the open requirements engineering lab"    />
</map>
<!-- Image map text links - End - -->
</div> 
    </rss:description>
  </rss:item>
  <rss:item rdf:about="index.html">
<!--
    <rss:title>Dr. Yijun Yu</rss:title>
-->
    <rss:link>http://www.cs.toronto.edu/~yijun/index.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
<style type="text/css">
#mapImage_holder {
    text-align:center;
 }
#mapImage {
    border:1px solid #000;
 }
</style>

<script type="text/javascript">
  var maps=new Array();
       maps[0]='mct.png,#mct';
       maps[1]='openre.png,#openre';
       maps[2]='arevol.png,#arevol';
       maps[3]='art.png,#art';
       maps[4]='ms.png,#ms';
       maps[5]='diagnose.png,#diagnose';
  var c=0;
  var speed=500*10; //set for 10 secs, change to suit needs.

function swapMap() {
   obj=document.getElementById('mapImage');

if(c==maps.length) {
   c=0;
 }
   obj.src=maps[c].split(',')[0];
   obj.useMap=maps[c].split(',')[1];
   c++;
setTimeout('swapMap()',speed);

 }

window.onload=swapMap;
</script>
<table border="0" cellpadding="0">
 <tr>
 <td width="50%">
<table><tr>
  <td align="left">
	<table border="0" cellpadding="5"><tr><td>
    <img src="YijunYu.jpg" border="0" width="120"/></td><td>
<h3>Yijun Yu (<a href="bio.html">Bio</a>)</h3>
    Senior Lecturer<br/>
    Department of Computing/Centre for Research in Computing<br/>
    Faculty of Maths, Computing &amp; Technology<br/>
    The Open University<br/>
    Walton Hall, Milton Keynes, MK7 6AA, 
    United Kingdom <br/>
    Email: <a href="mailto:Y.Yu@open.ac.uk">y.yu AT open.ac.uk</a><br/>
    Tel: +44 (0) 1908 6 55562
	</td></tr>
</table>
    </td>
</tr>
</table> </td>
<td widht="60%">
<div id="mapImage_holder">
<img id="mapImage" src="mct.png" alt="" usemap="#mct" border="0" width="470" height="238" />
</div>
<div>
<map id="mct" name="mct">
<area shape="rect" coords="0,0,840,477" href="http://oro.open.ac.uk/29450" alt="Meaningful Changes Tool" title="mct - The Meaningful Changes Tool"/>
</map>
</div>

<div>
<map id="openre" name="openre">
<area shape="rect" coords="135,36,290,335" href="http://www.cs.toronto.edu/km/openome" alt="i* diagram in openome" title="i* diagram in openome"    />
<area shape="rect" coords="27,57,58,67" href="http://www.computer.org/portal/web/csdl/doi/10.1109/ssiri.2010.36" alt="model-based security argumentation" title="model-based security argumentation"    />
<area shape="rect" coords="27,68,53,75" href="http://oro.open.ac.uk/22105" alt="architectural evolution" title="architectural evolution"    />
<area shape="rect" coords="349,38,709,152" href="http://oro.open.ac.uk/10264" alt="understanding monitoring and switching problems" title="understanding monitoring and switching problems"    />
<area shape="rect" coords="345,152,706,266" href="http://oro.open.ac.uk/24121/" alt="security argumentation" title="security argumentation"    />
<area shape="rect" coords="347,268,704,353" href="http://oro.open.ac.uk/19397/" alt="requirement dependencies" title="requirement dependencies"    />
<area shape="rect" coords="346,354,708,460" href="http://oro.open.ac.uk/22231/" alt="aspect-oriented code generation for rbac" title="aspect-oriented code generation for rbac"    />
<area shape="rect" coords="136,334,346,460" href="http://oro.open.ac.uk/19427/" alt="diagnosis failures using event calculus" title="diagnosis failures using event calculus"    />
<area shape="rect" coords="291,37,346,334" href="http://oro.open.ac.uk/19395/" alt="monitoring and diagnosing software requirements" title="monitoring and diagnosing software requirements"    />
<area shape="rect" coords="3,101,131,264" href="http://en.wikipedia.org/wiki/problem_frames_approach" alt="the problem frames approach" title="the problem frames approach"    />
<area shape="rect" coords="6,90,134,101" href="http://www.cs.toronto.edu/km/istar/" alt="the i* goal-oriented requirements methodology" title="the i* goal-oriented requirements methodology"    />
<area shape="rect" coords="710,37,838,461" href="http://computing-research.open.ac.uk/trac/openre" alt="the open requirements engineering lab" title="the open requirements engineering lab"    />
</map>
</div>
<div>
<map id="arevol" name="arevol">
<area shape="rect" coords="0,0,840,477" href="http://oro.open.ac.uk/28753/" alt="Assessing Architectural Evolution" title="arevol - Architectural Evolution Assessment tool"/>
</map>
</div>
<div>
<map id="art" name="art">
<area shape="rect" coords="0,0,840,477" href="http://mcs.open.ac.uk/yy66/art.html" alt="Automated Refactoring Tool" title="art - Automated Refactoring Tool"/>
</map>
</div>
<div>
<map id="ms" name="ms">
<area shape="rect" coords="0,0,840,477" href="http://oro.open.ac.uk/21835/" alt="Monitoring/Switching" title="ms - Monitoring/Switching Problems"/>
</map>
</div>
<div>
<map id="diagnose" name="diagnose">
<area shape="rect" coords="0,0,840,477" href="http://oro.open.ac.uk/19395/" alt="Monitoring/Diagnosing" title="diagnose - Monitoring/Diagnosing Software Requirements"/>
</map>
</div>



<br/>
</td>
  </tr>
  </table>
<hr/>
  <table>
<tr>
<td>
<li> <img src="new.gif" height="20" border="0"/><a href="http://oro.open.ac.uk/32501/"><u>ICSE12</u></a>: <font color="red">How to protect your changes in generated code?</font> Maintaining invariant traceability through bi-directional transformations.</li>
<li> <a href="http://oro.open.ac.uk/29450/"><u>ASE11</u></a>: <font color="red">What changes matter to you?</font> Specifying and detecting meaningful changes in programs.</li>
<li> <a href="http://oro.open.ac.uk/28980/"><u>RE11b</u></a>: <font color="red">Is your PIN entry device secure?</font> RISA: a risk-based argumentation method for practical security.</li>
<li> <a href="http://oro.open.ac.uk/29060/"><u>RE11a</u></a>: <font color="red">Are your sites down?</font> Requirements-driven self-tuning for the survivability of web systems.</li>
<li> <a href="http://oro.open.ac.uk/28753/"><u>ESE</u></a>: <font color="red">What happened to the Eclipse architecture over the years?</font> Assessing architectural evolution.</li>
<li> <a href="http://computing-research.open.ac.uk/trac/openre"><u>OpenRE</u></a>: <font color="red">Can we model requirements together?</font> Using the Open Requirements Engineering lab.</li>
<hr/>
</td>
</tr>
  <tr>
  <td>
My expertise is in developing <a href="http://computing-research.open.ac.uk/sead/index.php?page=topic&amp;group=ASE&amp;theme=">Automated Software Engineering</a> methods (e.g., <a
	href="http://oro.open.ac.uk/29450/"><u>normalising</u></a>, <a
	href="http://oro.open.ac.uk/19395"><u>reasoning</u></a>, <a
	href="http://oro.open.ac.uk/19397"><u>aspect-orientation</u></a>, <a
	href="http://oro.open.ac.uk/13074/"><u>visualization</u></a>, and <a
	href="http://oro.open.ac.uk/6944/"><u>restructuring</u></a>), <br/>
aiming at solving problems in research areas such as <a href="http://computing-research.open.ac.uk/sead/index.php?page=topic&amp;group=RE&amp;theme=">Requirements Engineering</a> 
<!--
[
<a href="http://oro.open.ac.uk/29060/"><u>RE11a</u></a>,
<a href="http://mcs.open.ac.uk/yy66/paper/chen10re.pdf"><u>RE10</u></a>,
<a href="http://oro.open.ac.uk/19427/"><u>RE09</u></a>, 
<a href="http://portal.acm.org/citation.cfm?id=1475853"><u>RE08</u></a>,
<a href="http://oro.open.ac.uk/10264/"><u>RE07</u></a>, <a href="http://oro.open.ac.uk/6946/"><u>RE06</u></a>, <a href="http://oro.open.ac.uk/6945/"><u>RE05</u></a>,  <a href="http://oro.open.ac.uk/6943/"><u>RE04</u></a>]
-->
, <a href="http://computing-research.open.ac.uk/sead/index.php?page=topic&amp;group=SA&amp;theme=">Software Maintenance and Evolution</a> 
<!--
[
<a href="http://oro.open.ac.uk/29450/">ASE'11</a>,
<a href="http://oro.open.ac.uk/28753/">ESE</a>,
<a href="http://oro.open.ac.uk/11975/"><u>ICSM08a</u></a>, <a href="http://oro.open.ac.uk/19406/"><u>ICSM08b</u></a>, <a href="http://oro.open.ac.uk/6944/"><u>ICSM05</u></a>]
-->, <a href="http://computing-research.open.ac.uk/sead/index.php?page=topic&amp;group=SP&amp;theme=">Security and Privacy</a>, and the <a href="http://computing-research.open.ac.uk/sead/index.php?page=topic&amp;group=ESSD&amp;theme=">Empirical Studies on Software Development</a><!--[
<a href="http://oro.open.ac.uk/28980/">RE11b</a>,
<a href="http://oro.open.ac.uk/21678/"><u>COMPJ</u></a>, <a href="http://oro.open.ac.uk/22231/"><u>ASE10</u></a>, <a href="http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4639385&amp;tag=1"><u>ASE08</u></a>, <a href="http://portal.acm.org/citation.cfm?doid=1321631.1321736"><u>ASE07</u></a>]
-->.
<br/>Currently I am interested in making evolving systems adapt to contextual changes that are deemed <a href="http://oro.open.ac.uk/29450/">meaningful</a> to the stakeholders (therefore <a href="http://oro.open.ac.uk/7781/"><b><u>requirements-driven</u></b></a>).

<p/>
	  <h3> Research Prototypes</h3> 
<li><a href="http://sead1.open.ac.uk/mct">Meaningful Changes Tool</a></li>
<li>Traceability: <a href="http://mcs.open.ac.uk/yy66/art.html">Automated Refactoring</a>, <a href="http://sead1.open.ac.uk/linkit">Link It</a></li>
<li><a href="http://computing-research.open.ac.uk/trac/openre">The Open Requirements Engineering Lab</a>: <a href="http://computing-research.open.ac.uk/trac/openre/wiki/MikiFAQ">Miki</a>, <a href="http://sead1.open.ac.uk/openpf">OpenPF</a>, <a href="http://mcs.open.ac.uk/yy66/paper/yu11re.pdf">OpenArgue</a> (<a href="http://sead1.open.ac.uk/risa">RISA</a>), <a href="http://www.youtube.com/watch?v=OWwzcNeSuJM">SecMER</a>, <a href="http://www.cs.toronto.edu/km/openome/">OpenOME</a> </li>
<li><a href="http://computing-research.open.ac.uk/trac/arevol">Architectural Evolution</a> (<a href="http://sead1.open.ac.uk/arevol">Visualization</a>)</li>
<li>Monitoring: <a href="http://mcs.open.ac.uk/yy66/monitoring-switching.html">Switching</a>, <a href="http://oro.open.ac.uk/19395/">Diagnosing</a></li>
<hr/>

  </td>
 </tr>
</table>

		<!-- START OF PUBLICATIONS FEED CODE PART 2 -->
		<div class="OROPublicationsSection">
		<h1 class="OROPublicationsSectionTitle">Recent publications</h1>
		<p>
		  View by: <select id= "OROPublicationsTypeSelectBox" name="pubtype" onchange="updateOROFeedType(this);">
		    <option value="date">Date</option>
		    <option value="type">Type</option>
		    <option value="bibtex">BiBTeX</option>
		  </select>
		</p>
		<script type="text/javascript">
			show("yy66");
		</script>
		</div>
		<!-- END OF PUBLICATIONS FEED CODE PART 2 -->
    </rss:description>
  </rss:item>
  <rss:item rdf:about="research.html">
    <rss:title>Research Topics and Demonstrations</rss:title>
    <rss:link>research.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
    <ul type="disc">
      <li><a href="http://sead1.open.ac.uk/linkit">Maintaining invariant traceability through bidirectional transformations</a> (<a href="http://sead1.open.ac.uk/linkit">blinkit</a>)</li>
      <li><a href="http://computing-research.open.ac.uk/trac/openre">The Open Requirements
      Engineering lab</a> (<a href="http://computing-research.open.ac.uk/trac/openre">openre</a>)</li>
      <li><a href="http://sead1.open.ac.uk/risa">Risk and argumentation
     for good-enough security requirements</a>(<a href="http://sead1.open.ac.uk/risa">risa</a>)</li>
      <li><a href="http://sead1.open.ac.uk/mct">Specifying and detecting meaningful changes</a> (<a href="http://sead1.open.ac.uk/mct">mct</a>)</li>
      <li><a href="vim-analysis.html">Recovering Problem Structures from Execution Traces</a> (<a href="http://computing-research.open.ac.uk/repos/galar/trunk">Galar, username: guest, password: checkout</a>)</li>
      <li><a href="art.html">An Automated Refactoring Toolkit</a> (<a href="http://computing-research.open.ac.uk/repos/art">ART</a>, username: guest, password: checkout)</li>
      <li><a href="monitoring-switching.html">Specifying Monitoring and
Switching Problems in Context</a> (<a href="http://computing-research.open.ac.uk/repos/sat">repo</a>, username: guest, password: checkout)</li>
      <li><a href="http://computing-research.open.ac.uk/trac/arevol">Light-Weight Extraction of Eclipse Component Dependencies</a></li>
      <li><a href="RefactoringGoalModel.html">Reverse engineering source code into goal models</a> </li>
      <li><a href="http://www.cs.toronto.edu/km/openome">Goal-oriented requirements engineering tools</a> (<a href="http://www.cs.toronto.edu/km/openome/preparation.html">OpenOME</a>)</li>
      <li><a href="aspectPHP.html">Discovering aspects from requirements goal models</a> (<a href="aspectPHP">aspectPHP</a>)</li>
      <li><a href="http://www.cs.toronto.edu/cser/header.html">Reducing build time through precompilations</a> <br/>(For C/C++ <a href="ftp://ftp.cs.toronto.edu/csrg-technical-reports/504/demo.tar.gz">pcc</a>, For Java <a href="precj.html">precj</a>)</li>
      <li><a href="Componentization.html">Componentization of legacy C/C++ software</a></li>
      <li><a href="http://www.cs.toronto.edu/~yijun/work/lp">Literature Programming</a> (<a href="http://code.google.com/p/literature-programming">download</a>)</li>
      <li><a href="yaxx.html">Parsing program syntax tree into XML</a> (<a href="http://prdownloads.sourceforge.net/yaxx/yaxx-0.11.tar.gz?download">yaxx</a>)</li>
      <li><a href="xml_i18n.html">Making XML document markups international</a> (<a href="http://www.cs.toronto.edu/~yijun/slides/ai2003/ai2003.zip">cxsl</a>)</li>
      <li><a href="PerformanceVisualization.html">Performance visualization
using XML</a> (<a href="http://www.cs.toronto.edu/~yijun/work/xfpt/">XFPT</a>)</li>
      <li><a href="CacheVisualization.html">Cache impact visualization</a>(<a href="http://www.cs.toronto.edu/~yijun/cacheviz.guide.html">cacheviz</a>)</li>
      <li><a href="ISV.html">Loop dependence visualization</a> (
<a href="http://winpar.elis.rug.ac.be/ppt/isv/index.html">ISV</a>)</li>
      <li><a href="NonUniformLoopParallelism.html">Non-uniform dependences partitioned by recurrence chains</a></li>
      <li><a href="Partitioning.html">Parallelizing compiler: loop partitioning</a></li>
      <li><a href="Wireless.html">Wireless network and mobile computing</a></li>
      <li><a href="GenerativeReuse.html">Quality-based software reuse</a> (<a
      href="http://www.cs.toronto.edu/km/q7/q7.zip">Q7</a>)</li>
     <li><a href="ac.html">Towards Requirements-Driven Autonomic Systems Design</a></li>
      <li><a href="GoalOrientedRefactoring.html">Software refactoring guided by multiple soft-goals</a></li>
    </ul>
    </rss:description>
  </rss:item>

  <rss:item rdf:about="teaching.html">
    <rss:title>Teaching Materials</rss:title>
    <rss:link>teaching.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
<ul>
<li> M889 -- Computer Forensics (course chair) </li>
<li> M883 -- Requirements Engineering (course member) </li>
<li> M362 -- Developing Concurrent Distributed Systems (course member) </li>
<li> M257 -- Putting Java to Work (course member) </li>
<li>
<a href="http://www.cdf.toronto.edu/~csc408h/summer/">CSC408H1Y 2005</a>
(Tips<a href="eclipse-install/README.html">1</a>, <a
href="http://www.cdf.toronto.edu/~csc408h/summer/handouts/tutorial-v3.zip">2</a>)
</li><li>
<a href="http://www.cs.toronto.edu/~yijun/ece450h/">ECE450H1S 2005</a>
(Tips <a href="http://www.cs.toronto.edu/km/openome">1</a>)
</li>
<li>
<a href="http://www.cs.toronto.edu/~yijun/csc408h/">CSC408H1F 2004-2005</a> (Tips <a href="http://www.cs.toronto.edu/~yijun/csc408h/handouts/WebServices-HOWTO.html">1</a>)
</li>
	
Two cents tips: <li><a
href="http://www.cs.toronto.edu/~yijun/eclipse-install/README.html">eclipse-install</a>, <a href="http://www.cs.toronto.edu/~yijun/totalcommander/cygwin.html">totalcmd+cygwin</a></li>

</ul>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="activities.html">
    <rss:title>Activities</rss:title>
    <rss:link>activities.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
<h3> Conferences and workshops I attended, have we met before? </h3>
<a href="http://www.cse.msu.edu/ase2007/">ASE'07</a> |
<a href="http://www.re07.org/home/">RE'07</a> |
<a href="https://www-927.ibm.com/ibm/cas/cascon/index.shtml">CASCON'06</a> |
<a href="http://www.ifi.unizh.ch/req/events/RE06/index.html">RE'06</a> 
|
<a href="http://www.isr.uci.edu/icse-06/">ICSE'06</a> 
|
<a href="http://www.cs.toronto.edu/km/retr">RETR</a>@
<a href="http://www.rcost.unisannio.it/wcre2005/">WCRE'05</a>
|
<a href="http://www.inf.u-szeged.hu/icsm2005/home.php">ICSM'05</a>
|
<a
href="https://www-927.ibm.com/ibm/cas/cascon/workshopsignup/displayWorkshop?PublicView=true&amp;Slot=TUEPM&amp;Num=38">EASS</a>@
<a href="https://www-927.ibm.com/ibm/cas/archives/2005/papers/index.shtml">CASCON'05</a>
|
<a href="http://crinfo.univ-paris1.fr/RE05/index.html">RE'05</a>
|
<a href="http://gnomo.fe.up.pt/~caise/index.php">CAiSE'05</a>
|
<a href="http://www.deas2005.cs.uvic.ca/">DEAS</a>@<a href="http://www.cs.wustl.edu/icse05/Home/index.shtml">ICSE'05</a>
|
<a href="http://fase05.disi.unige.it/">FASE</a>@<a href="http://www.etaps05.inf.ed.ac.uk">ETAPS'05</a>
|
<a href="http://trese.cs.utwente.nl/early-aspects-AOSD2005/">Early Aspects</a>@<a href="http://aosd.net/2005/index.php">AOSD'05</a>
|
<a href="http://research.nii.ac.jp/WIRI/">WIRI</a>@<a href="http://icde2005.is.tsukuba.ac.jp/">ICDE'05</a>
|
<a href="http://www.dsl.uow.edu.au/abwe05/">ABWE</a>@<a href="http://www.icwe2005.org/">ICDE'05</a>
|
<a
href="https://www-927.ibm.com/ibm/cas/archives/2004/workshops/workshop_60.shtml">FRSA</a>@<a href="https://www-927.ibm.com/ibm/cas/archives/2004/papers/index.shtml">CASCON'04</a>
|
<a href="http://www.re04.org/">RE'04</a>
|
<a href="http://www.informatik.uni-trier.de/~ley/db/conf/tes/tes2004.html">TES</a>@<a href="http://www.vldb04.org/">VLDB'04</a>
|
<a href="http://www.ecn.purdue.edu/icpp2004/">ICPP'04</a>
|
<a href="http://www.graphicslink.demon.co.uk/IV05/">IV'04</a>
|
<a href="https://www-927.ibm.com/ibm/cas/cascon/">CASCON'03</a>
|
<a href="http://swen.uwaterloo.ca/~reface03/">REFACE</a>@<a href="http://www.cs.ualberta.ca/~wcre2003">WCRE'03</a>
|
<a href="http://www.iasted.org/conferences/2003/austria/ai.htm">AI'03</a>
|
<a href="http://www.iasted.org/conferences/2002/cambridge/pdcs.htm">PDCS'02</a>
|
<a href="http://www.graphicslink.demon.co.uk/IV01/">IV'01</a>
|
<a
href="http://www.informatik.unibw-muenchen.de/mmb/mmb39/acm.html">MSWiM</a>@<a
href="http://www.research.ibm.com/acm_sigmobile_conf_2001/">MobiCom'01</a>
|
<a
href="http://www.informatik.uni-trier.de/~ley/db/conf/iv/iv2001.html">VMPDP</a>@<a href="http://web.engr.oregonstate.edu/~burnett/vl2000/">VL'00</a> 
|
<a
href="http://csdl2.computer.org/persagen/DLAbsToc.jsp?resourcePath=/dl/proceedings/&amp;toc=comp/proceedings/icpp/2000/0768/00/0768toc.xml">ICPP'00</a>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="archev/index.html">
    <rss:title>Graph-Centric Tools for Understanding the Evolution and Relationships of Software Structures</rss:title>
    <rss:link>archev/index.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>

  We present a suite of small tools, implemented as a pipeline of text
  file manipulating scripts, that, on the one hand, measure the
  evolution of any software structure that can be represented as a
  directed graph of software elements and relations and, on the other
  hand, visualise any three attributes of any set of software
  artefacts that can be related to the elements shown in the graph. We
  illustrate the applicability of the tool with our work on the
  evolution of the Eclipse architecture and the relation between bugs
  and components.
	    
	    
<hr/>
<h2> Resources </h2><ul>
<li> <a href="http://computing-research.open.ac.uk/repos/rev07/trunk/src/workspace/trace2png-0.1/test/">Spectral Graph Architecture Visualisation, username: guest, password: checkout</a>	</li>
<li> <a href="http://computing-research.open.ac.uk/repos/eclipse-evol/trunk/eclipse/">Light-weight extraction of reference architecture from metadata</a>	</li>
<li> <a href="http://mcs.open.ac.uk/yy66/wcre08">Result of visualisations</a></li>
</ul>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="vim-analysis.html">
    <rss:title>Recovering Problem Structures from Execution Traces</rss:title>
    <rss:link>vim-analysis.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
Software systems evolve in response to changes in stakeholder requirements.
Lack of documentation about the original system can make it difficult to
analyze and implement new requirements. Although automatic recovery of all
requirements from an implementation is usually not possible, we suggest that
the recovery of problem structures, which in turn inform the problem analysis
of new requirements, is feasible and useful.  In this work, we propose a
tool-supported approach to recover and maintain structures of problems,
solutions, and their relationships, by recovering causal control and data
dependencies between components. Extracting low-level program structures is
done fully automatically, while higher-level descriptions of problem structures
are obtained interactively. We validate our approach using a case study of a
medium-sized open-source software system.
<hr/>
<!--
Here are two scenarios to use our script:

<ol>
	<li>
		Comparing similarity of the same feature in two versions.

<pre>
yy66@PCMA783:~/work/projects/vim-feature/compare$ test.sh vim64 vim71 setspell
</pre>
As a result, the script will report the following
<pre>
Level IFunc UFunc RFunc IFile UFile RFile IFileExact UFileExact RFileExacl ICall UCall RCall IACall UACall RACall IACallExact UACallExact RACallExact
0 7 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 25 37 0 3 4 0 3 4 0 18 28 0 2 3 0 2 3 0
2 63 110 0 17 22 0 10 22 0 61 113 0 15 23 0 14 23 0
3 89 165 0 20 25 0 6 25 0 93 183 0 23 39 0 20 39 0
4 103 203 0 21 28 0 6 28 0 113 238 0 28 52 0 23 52 0
5 118 233 0 21 29 0 4 29 0 132 281 0 33 63 0 27 63 0
6 131 255 0 21 30 0 4 30 0 150 320 0 35 70 0 29 70 0
7 139 273 0 21 31 0 4 31 0 165 361 0 39 80 0 32 80 0
8 150 287 0 21 31 0 4 31 0 179 398 0 41 83 0 33 83 0
9 157 295 0 21 32 0 4 32 0 190 418 0 41 84 0 33 84 0
10 162 298 0 21 32 0 4 32 0 197 432 0 42 84 0 33 84 0
11 167 301 0 21 32 0 4 32 0 207 440 0 43 85 0 34 85 0
12 172 307 0 22 32 0 4 32 0 217 462 0 45 85 0 34 85 0
13 173 308 0 22 32 0 4 32 0 218 464 0 45 85 0 34 85 0
14 175 310 0 22 32 0 4 32 0 227 473 0 45 85 0 34 85 0
15 176 311 0 22 32 0 4 32 0 228 474 0 45 85 0 34 85 0
16 176 311 0 22 32 0 4 32 0 228 474 0 45 85 0 34 85 0
17 176 311 0 22 32 0 4 32 0 228 474 0 45 85 0 34 85 0
18 176 311 0 22 32 0 4 32 0 228 474 0 45 85 0 34 85 0
19 176 311 0 22 32 0 4 32 0 228 474 0 45 85 0 34 85 0
-1 177 313 0 22 32 0 4 32 0 229 488 0 45 85 0 34 85 0
</pre>
where "-1" stands for the MAX level. The first row is discarded in the
result table.
	</li>
	<li>
		Comparing similarity of two features in the same version.
<pre>
yy66@PCMA783:~/work/projects/vim-feature/compare$ test2.sh vim70 i_Ctrl_x_s setspell
</pre>
As a result, the script will report the following
<pre>
Level IFunc UFunc RFunc IFile UFile RFile IFileExact UFileExact RFileExacl ICall UCall RCall IACall UACall RACall IACallExact UACallExact RACallExact
0 9 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 30 37 0 3 4 0 2 4 0 21 27 0 2 3 0 2 3 0
2 82 101 0 17 22 0 15 22 0 75 98 0 14 21 0 14 21 0
3 135 167 0 24 27 0 18 27 0 144 188 0 31 46 0 30 46 0
4 170 226 0 26 30 0 17 30 0 188 273 0 38 62 0 36 62 0
5 188 267 0 27 32 0 16 32 0 209 332 0 42 78 0 40 78 0
6 207 291 0 29 32 0 16 32 0 245 369 0 54 85 0 51 85 0
7 235 314 0 30 33 0 17 33 0 293 422 0 67 100 0 63 100 0
8 257 337 0 30 33 0 17 33 0 339 471 0 72 106 0 67 106 0
9 269 348 0 32 34 0 19 34 0 366 506 0 76 111 0 71 111 0
10 278 356 0 32 34 0 18 34 0 386 531 0 76 113 0 71 113 0
11 284 359 0 32 34 0 18 34 0 399 543 0 80 115 0 75 115 0
12 287 364 0 32 34 0 16 34 0 415 567 0 80 115 0 73 115 0
13 287 367 0 32 34 0 16 34 0 415 574 0 80 115 0 73 115 0
14 289 368 0 32 34 0 16 34 0 421 578 0 80 115 0 73 115 0
15 290 368 0 32 34 0 16 34 0 422 578 0 80 115 0 73 115 0
16 290 368 0 32 34 0 16 34 0 422 578 0 80 115 0 73 115 0
17 290 368 0 32 34 0 16 34 0 422 578 0 80 115 0 73 115 0
18 290 368 0 32 34 0 16 34 0 422 578 0 80 115 0 73 115 0
19 290 368 0 32 34 0 16 34 0 422 578 0 80 115 0 73 115 0
-1 293 371 0 32 34 0 16 34 0 437 593 0 80 115 0 73 115 0
</pre>
where "-1" stands for the MAX level. The first row is discarded in the
result table.
	</li>
</ol>
-->

<h2> Resources </h2><ul>
<li> <a href="http://computing-research.open.ac.uk/repos/galar/trunk">Galar repository, username: guest, password: checkout</a>	</li>
<li> <a href="http://computing-research.open.ac.uk/repos/galar/trunk/test/results">Result datasheets</a>, username: guest, password: checkout</li>
</ul>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="eclipse-evolution.html">
    <rss:title>Light-Weight Extraction of Eclipse Component Dependencies</rss:title>
    <rss:link>eclipse-evolution.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
One way to analyse the overall evolution of complex systems that have thousands
of modules is to view them at a coarse level of abstraction, e.g. at the
architectural level of components and their dependencies. A typical example of
a complex system that has a structure capable of accommodating long-term growth
is the Eclipse platform and its plugin architecture. We briefly
presents a tool for the extraction of two different kinds of dependencies among
Eclipse plugins. The extraction is lightweight and scalable because it does not
use program analysis; instead it uses the metadata provided for each plugin.
Our tool produces a graph of dependencies and a table with the dependency
fan-in and fan-out for each plugin. Collecting this information over various
releases we are able to see the evolution of the overall architecture of
Eclipse.  
<h2> Resources </h2><ul>
<li> Our submission to the Challenge of MSR'08 has been accepted.  </li>
<li>
<a href="tool/java/eclipse-evol/eclipse.zip">Scripts and data</a>
</li>
<li>
<a href="http://computing-research.open.ac.uk/repos/eclipse-evol"> Subversion Repository</a>
username: guest
password: checkout

</li>
</ul>
    </rss:description>
  </rss:item>
  <!--
  <rss:item rdf:about="template.html">
    <rss:title> ... </rss:title>
    <rss:link>... </rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
<h2> Resources </h2><ul><li>
</li></ul>
    </rss:description>
  </rss:item>
  -->
  <rss:item rdf:about="art.html">
    <rss:title>Automated Refactoring Tool</rss:title>
    <rss:link>art.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
Our Automated Refactoring Toolkit (ART) supports regressively applying automated refactoring operations to Eclipse projects. These refactoring operations can be used as semantic-preserving patches to source code such that traceability between design and implementation can be maintained.  The toolkit currently contains two automated utilities:
<ul>
<li>
<a href="tool/java/art">Refactoring engine, a command-line tool that performs refactoring operations specified in our language</a>;
</li>
<li>
<a href="http://computing-research.open.ac.uk/repos/art/trunk/work/ops.xsl">Operation transformer, an XSL stylesheet that converts XML-based Eclipse refactoring scripts into our specification language</a>
username: guest
password: checkout
</li>
</ul>

<h2> Resources </h2><ul>
<li>
<a href="tool/java/art">Download ART</a>
</li>
<li>
<a href="http://computing-research.open.ac.uk/repos/art">Browse Subversion Repository</a>
username: guest
password: checkout
</li>
</ul>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="monitoring-switching.html">
    <rss:title>Specifying Monitoring and Switching Problems in Context</rss:title>
    <rss:link>monitoring-switching.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
Context-aware applications monitor changes in their operating environment and
switch their behaviour to keep satisfying their requirements. Therefore, they
must be equipped with the capability to detect variations in their operating
context and to switch behaviour in response to such variations. However,
specifying monitoring and switching in such applications can be difficult due
to their dependence on varying contextual properties which need to be made
explicit. In this work, we present a problem-oriented approach to represent
and reason about contextual variability and assess its impact on requirements;
to elicit and specify concerns facing monitors and switchers, such as
initialisation and interference; and to specify monitoring and switching
behaviours that can detect changes and adapt in response. We illustrate our
approach by applying it to a published case study.  
<h2> Resources</h2><ul><li>
<a href="http://computing-research.open.ac.uk/repos/sat">The SAT solver repository </a>
username: guest
password: checkout
</li></ul>
    </rss:description>
  </rss:item>
  <rss:item rdf:about="bio.html">
    <rss:title>Biography of Dr. Yijun Yu</rss:title>
    <rss:link>bio.html</rss:link>
    <rss:description>
<tr>
  <td width="30%"> 
<b>Bio.</b> Yijun Yu graduated from the Department of Computer Science at <a
  href="http://www.fudan.edu.cn">Fudan University</a> (B.Sc. 1992, M.Sc. 1995, Ph.D. 1998). He was a postdoc. research fellow at the <a href="http://www.elis.rug.ac.be">Department of Electrical Engineering</a> in <a
  href="http://www.rug.ac.be">Ghent University</a> (1999--2002), then he
worked as a research associate at the <a href="http://www.cs.toronto.edu/km">Knowledge Management
lab</a> of the <a href="http://www.cs.toronto.edu">Department of Computer Science</a> in <a href="http://www.cs.toronto.edu/DCS/Research/software.html">University of Toronto</a> (2003-2006). Since October 2006, he has become a Senior Lecturer at the <a href="http://computing.open.ac.uk">Department of Computing</a> in The <a
href="http://www.open.ac.uk">Open University</a>. He is a member of the <a href="http://www.computer.org/">IEEE Computer Society</a> and the <a href="www.bcs.org">British Computer Society</a>.  <p/>
</td> 
</tr>

    </rss:description>
  </rss:item>

</rdf:RDF>

