<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Projects on Eclipse DataEggs</title>
    <link>https://www.eclipse.org/dataeggs/projects/</link>
    <description>Recent content in Projects on Eclipse DataEggs</description>
    <generator>Hugo -- gohugo.io</generator><atom:link href="https://www.eclipse.org/dataeggs/projects/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>ecd.che</title>
      <link>https://www.eclipse.org/dataeggs/projects/ecd.che/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/ecd.che/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements. All plots and tables are computed from the actual data as provided in the downloads.</description>
    </item>
    
    <item>
      <title>ee4j.glassfish</title>
      <link>https://www.eclipse.org/dataeggs/projects/ee4j.glassfish/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/ee4j.glassfish/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.emf-parsley</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.emf-parsley/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.emf-parsley/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.emfcompare</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.emfcompare/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.emfcompare/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.epsilon</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.epsilon/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.epsilon/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.gendoc</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.gendoc/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.gendoc/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.m2t.acceleo</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.m2t.acceleo/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.m2t.acceleo/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.mdt.ocl</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.mdt.ocl/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.mdt.ocl/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>modeling.sirius</title>
      <link>https://www.eclipse.org/dataeggs/projects/modeling.sirius/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/modeling.sirius/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.apogy</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.apogy/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.apogy/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.app4mc</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.app4mc/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.app4mc/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.collections</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.collections/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.collections/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements. All plots and tables are computed from the actual data as provided in the downloads.</description>
    </item>
    
    <item>
      <title>technology.ease</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.ease/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.ease/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.egit</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.egit/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.egit/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.epf</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.epf/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.epf/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.jgit</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.jgit/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.jgit/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>technology.paho</title>
      <link>https://www.eclipse.org/dataeggs/projects/technology.paho/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/technology.paho/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>tools.cdt</title>
      <link>https://www.eclipse.org/dataeggs/projects/tools.cdt/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/tools.cdt/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
    <item>
      <title>tools.tracecompass</title>
      <link>https://www.eclipse.org/dataeggs/projects/tools.tracecompass/datasets_report/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.eclipse.org/dataeggs/projects/tools.tracecompass/datasets_report/</guid>
      <description>About this document This document is a R notebook, dynamically created from the numbers extracted on the project. It lists all datasets published for the project, providing basic numbers, figures and a quick summary, and serves as a test case to make sure that all the required data is present and roughly consistent with requirements.</description>
    </item>
    
  </channel>
</rss>
