<?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="precj.html"/>
        <rdf:li resource="totalcommander/cygwin.html"/>
        <rdf:li resource="totalcommander/junction.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
paper presents an automated tool that 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>
We submitted a draft describing the approach to ASE'07.  
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 paper, 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 paper 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="40%">
    Computing Department <br/>
    Faculty of Maths &amp; Computing <br/>
    The Open University <br/>
    Walton Hall, Milton Keynes, MK7 6AA <br/>
    United Kingdom (U.K.) <br/>
    Office: Room 310 <br/>
    Tel: +44(0) 1908-655562 <br/>
    Email: <a href="mailto:Y.Yu@open.ac.uk">Y.Yu AT open.ac.uk</a>
    <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="index.html">
    <rss:title><a href="http://mcs.open.ac.uk/yy66">Dr. Yijun Yu</a></rss:title>
    <rss:link>http://www.cs.toronto.edu/~yijun/index.html</rss:link>
    <nedstat:counter>ABjMCAbjU4uQjRKt8T0WytVYjGGg</nedstat:counter>
    <rss:description>
<table border="0" cellpadding="0">
 <tr>
  <td align="left" width="40%">
    Senior Lecturer <p/>

    Computing Department <br/>
    Faculty of Maths &amp; Computing <br/>
    The Open University <br/>
    <a href="maps/ou.html">Walton Hall</a>, Milton Keynes, MK7 6AA <br/>
    United Kingdom (U.K.) <br/>
    Office: Room 310 <br/>
    Tel: +44(0) 1908-655562 <br/>
    Email: <a href="mailto:Y.Yu@open.ac.uk">Y.Yu AT open.ac.uk</a>
    </td>
  <td>
  <b>Bio.</b> <a href="http://mcs.open.ac.uk/yy66">Yijun Yu</a> graduated from the C.S. Department of <a
  href="http://www.fudan.edu.cn"><!--<ruby><rt>&#22797;&#26086;</rt><rb>Fudan</rb></ruby>-->Fudan
  University</a> (B.S. 1992, M.S. 1995, Ph.D. 1998). He was a postdoc at the <a
  href="http://www.elis.rug.ac.be">ELIS</a> Department in <a
  href="http://www.rug.ac.be">Ghent University</a> (1999--2002), then he
works as a research associate for the <a href="http://www.cs.toronto.edu/km">Knowledge Management
lab</a> in the <a href="http://www.cs.toronto.edu">Department of Computer Science</a>, <a href="http://www.cs.toronto.edu/DCS/Research/software.html">University of Toronto</a> (2003-2006). In October 2006, he became a Senior Lecturer in the <a href="http://computing.open.ac.uk">Department of Computing</a>, <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>.  <p/>
His research interests are in Automated Software Engineering and Requirements Engineering. 
  </td>
 </tr>
</table>
    </rss:description>
  </rss:item>
</rdf:RDF>
