<!DOCTYPE html>
<html lang="en-us">

  <head>
  <meta charset="utf-8">
  <meta name="robots" content="all,follow">
  <meta name="googlebot" content="index,follow,snippet,archive">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Contributing</title>
  <meta name="author" content="" />

  
  <meta name="keywords" content="iot, smart mobility, kuksa, appstacle">	
  

  
  <meta name="description" content="Eclipse KUKSA community website">	
  

  <meta name="generator" content="Hugo 0.42.1" />

  <link href='//fonts.googleapis.com/css?family=Roboto:400,100,100italic,300,300italic,500,700,800' rel='stylesheet' type='text/css'>

  
  <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
  <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

  
  <link href="https://www.eclipse.org/kuksa/css/animate.css" rel="stylesheet">

  
  
    <link href="https://www.eclipse.org/kuksa/css/style.turquoise.css" rel="stylesheet" id="theme-stylesheet">
  
  <link href="https://www.eclipse.org/kuksa/css/style.kuksa.css" rel="stylesheet" id="theme-stylesheet">


  
  <link href="https://www.eclipse.org/kuksa/css/custom.css" rel="stylesheet">

  
  
    <!--[if lt IE 9]>
        <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
        <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
    <![endif]-->
  

  
  <link rel="shortcut icon" href="https://www.eclipse.org/kuksa/img/favicon.ico" type="image/x-icon" />
  
  <link rel="apple-touch-icon" href="https://www.eclipse.org/kuksa/img/kuksa-icon.png" />
  

  <link href="https://www.eclipse.org/kuksa/css/owl.carousel.css" rel="stylesheet">
  <link href="https://www.eclipse.org/kuksa/css/owl.theme.css" rel="stylesheet">

  <link rel="alternate" href="https://www.eclipse.org/index.xml" type="application/rss+xml" title="Eclipse KUKSA">

  
  <meta property="og:title" content="Contributing" />
  <meta property="og:type" content="website" />
  <meta property="og:url" content="/kuksa/contributing//" />
  <meta property="og:image" content="img/kuksa-incubation-logo-h-428x128.png" />
  
  
  <link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
  <script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script> 
  
  <script src="https://www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/eclipsefdn.videos.min.js"></script>
  <link href="https://www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/eclipsefdn-video.min.css" rel="stylesheet" type="text/css">
  <script>eclipseFdnVideos.replace();</script>

</head>


  <body>

    <div id="all">

        <header>

          <div class="navbar-affixed-top" data-spy="affix" data-offset-top="200">

    <div class="navbar navbar-default yamm" role="navigation" id="navbar">

        <div class="container">
            <div class="navbar-header">
                <a class="navbar-brand home" href="https://www.eclipse.org/kuksa/">
                    <img src="https://www.eclipse.org/kuksa/img/kuksa-incubation-logo-h-428x128.png" alt="Contributing logo" class="hidden-xs hidden-sm" height="80">
                    <img src="https://www.eclipse.org/kuksa/img/kuksa-incubation-logo-h-428x128.png" alt="Contributing logo" class="visible-xs visible-sm" height="50">
                    <span class="sr-only">Contributing - go to homepage</span>
                </a>
                <div class="navbar-buttons">
                    <button type="button" class="navbar-toggle btn-template-main" data-toggle="collapse" data-target="#navigation">
                      <span class="sr-only">Toggle Navigation</span>
                        <i class="fa fa-align-justify"></i>
                    </button>
                </div>
            </div>
            

            <div class="navbar-collapse collapse" id="navigation">
                <ul class="nav navbar-nav navbar-right">
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/">Home</a>
                    
                  </li>
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/about/">About</a>
                    
                  </li>
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/documentation/">Documentation</a>
                    
                  </li>
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/blog/">Blog</a>
                    
                  </li>
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/contributing/">Contributing</a>
                    
                  </li>
                  
                  <li class="dropdown">
                    
                    <a href="/kuksa/resources/">Resources</a>
                    
                  </li>
                  
                </ul>
            </div>
            

            <div class="collapse clearfix" id="search">

                <form class="navbar-form" role="search">
                    <div class="input-group">
                        <input type="text" class="form-control" placeholder="Search">
                        <span class="input-group-btn">

                    <button type="submit" class="btn btn-template-main"><i class="fa fa-search"></i></button>

                </span>
                    </div>
                </form>

            </div>
            

        </div>
    </div>
    

</div>




        </header>

        <div id="heading-breadcrumbs">
    <div class="container">
        <div class="row">
            <div class="col-md-12">
                <h1>Contributing</h1>
            </div>
        </div>
    </div>
</div>


        <div id="content">
            

            <div class="container">

                <div class="row">

                    <div class="col-md-12">

                        <div>
                          

<p><strong>Get in touch</strong> ! There is the</p>

<h3 id="kuksa-dev-mailing-list-https-accounts-eclipse-org-mailing-list-kuksa-dev-and-a"><a href="https://accounts.eclipse.org/mailing-list/kuksa-dev">kuksa-dev mailing list</a> and a</h3>

<h3 id="bi-weekly-zoom-meeting-https-eclipse-zoom-us-j-537310990-every-thursday-on-even-calendar-weeks-from-1-2pm-cet-cest"><strong>bi-weekly</strong> <a href="https://eclipse.zoom.us/j/537310990">Zoom meeting</a> every Thursday on even calendar weeks from 1-2pm (CET/CEST).</h3>

<hr />

<hr />

<h1 id="howto-contribute-to-eclipse-kuksa">HowTo contribute to Eclipse Kuksa</h1>

<p>Great that you are interested in contributing to Eclipse Kuksa.
We really looking forward to receive your contribution!</p>

<p>In the project we agreed upon the following approach to add contributions to the project.</p>

<ol>
<li>Meet the Definition of Done (DoD)</li>
<li>A review took place for the code</li>
<li>The new feature was at least once tested manually, deployed to a running test instance</li>
<li>Clearly outline third party dependencies</li>
</ol>

<h2 id="definition-of-done">Definition of Done</h2>

<p>First, we have DoD for solved issues. Please check if you met all the items in the following list:</p>

<ul>
<li><p>File headers in file OK (see section <a href="#licensing-and-file-header">License Headers</a> for details)</p></li>

<li><p>Each new feature is developed in a separate branch</p>

<ul>
<li>Development branches should be named like<code>&lt;github-nickname&gt;/&lt;issue&gt;/&lt;description&gt;</code>, e.g. bs-jokri/#2/fix-connection-handling</li>
</ul></li>

<li><p>Coding style</p>

<ul>
<li>Clean code is encouraged (see ‘Clean Code’ by Robert C. Martin or the
<a href="https://www.bbv.ch/images/bbv/pdf/downloads/V2_Clean_Code_V3.pdf">Clean Code Cheatsheet</a>.
Reviewers might refer to specific clean code practices to help improve contributed code.</li>
</ul></li>

<li><p>Avoid (serious) compiler warnings</p></li>

<li><p>Add tests for new / added functionality</p></li>

<li><p>All tests pass</p>

<ul>
<li>Unit testing as it is already present</li>
<li>You have more - use them!</li>
</ul></li>

<li><p>Documentation</p>

<ul>
<li>Provide the necessary technical documentation of your feature in the respective
Github repository that you contribute to. Documentation is in markdown and it either
included in the top-level README.md file of the Github repository, or linked from
there.</li>
<li>Update the high-level overview of Kuksa in the <a href="https://github.com/eclipse/kuksa.integration/wiki">kuksa.integration Wiki at Github</a>.
From the wiki, provide links to relevant technical documentation in the Github repositories.</li>
</ul></li>

<li><p>Commit style</p>

<ul>
<li>Please write brief and useful commit messages: Separate the subject from body with a blank line because the subject line
is shown in the git history and should summarize the commit body. Use the body to explain what and why vs. how.
<a href="https://chris.beams.io/posts/git-commit/#seven-rules">https://chris.beams.io/posts/git-commit/#seven-rules</a> has more tips and details.</li>
<li>Before you push your commits to a repository, you can squash your commits into one or more logical units of work, e.g. if
you want to add a new feature solely in a single commit.</li>
<li>The <a href="https://git-scm.com/book/en/v2/">Pro Git book</a> has a great section on <a href="https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History">Rewriting
History</a> and a section
on <a href="https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History#_squashing">Squashing</a>.</li>
<li>Rebase during pull (i.e. <code>git pull --rebase</code>) instead of merging so all commits can
be signed off. You can also
<a href="https://stackoverflow.com/questions/13846300/how-to-make-git-pull-use-rebase-by-default-for-all-my-repositories">configure git to rebase by default</a></li>
<li>you IDE will also have according configuration options.</li>
<li>If you are not a committer to the project your commits need to be signed off with a valid Eclipse user account. Check the Eclipse handbook for details (<a href="https://www.eclipse.org/projects/handbook/#resources-commit">Eclipse Project Handbook</a>).</li>
</ul></li>
</ul>

<p>If you checked your code according to the DoD and you feel it can be merged to master, please create a PR to master.
Each PR that is merged to master has to pass all tests and needs a code review of some other person of the project that looks onto your contribution from another angle,
i.e. didn&rsquo;t work with you on the new feature. Probably a good idea is to have someone from another organization doing the review.
Maybe you already have someone in mind doing the review, then request a review from this person via the github review functionallity.</p>

<h2 id="review">Review</h2>

<p>If you conduct a code review, please look at the following issues:</p>

<ul>
<li>Is code style ok, not really formatting, but issues like style attributes in HTML tags or exception handling useful</li>
<li>Are DoD items reached</li>
<li>Are there any design / architecture issues</li>
<li>Does the new feature fit the overall project goal, is it suitable for the community</li>
</ul>

<h2 id="manual-test">Manual Test</h2>

<p>If applicable the new  feature should at least be deployed and tested by someone before actually merged to master.
This could be done by the same person that is doing the review but could be performed  by another person.</p>

<p>After review and tests are finished it should be documented who actually did the review and the test.
Do this with the following lines in the comments of the PR.</p>

<pre><code>review-by:email@domain.com
</code></pre>

<p>and</p>

<pre><code>tested-by:email@domain.com
</code></pre>

<h2 id="third-party-dependencies">Third party dependencies</h2>

<p>If you use third party content (import / include &hellip;), you are required to list each third party content explicitly with its version number in the documentation or your pull-request comment.
Please note that GPL software cannot be approved for Eclipse Kuksa.</p>

<h2 id="licensing-and-file-header">Licensing and file header</h2>

<p>All files contributed require headers - this will ensure the license and copyright clearing at the end.
Also, all contributions must have the same license as the original source.</p>

<p>If a file has relevant functionality add the official EPL-2.0 header as described here
<a href="https://www.eclipse.org/legal/epl-2.0/faq.php#h.q72cnghf29k0">https://www.eclipse.org/legal/epl-2.0/faq.php#h.q72cnghf29k0</a></p>

<p>We recommend to use the releng copyright tool at:
<a href="https://wiki.eclipse.org/Development_Resources/How_to_Use_Eclipse_Copyright_Tool">https://wiki.eclipse.org/Development_Resources/How_to_Use_Eclipse_Copyright_Tool</a></p>

<pre><code>/*********************************************************************
* Copyright (c) {date} {owner} [and others]
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
**********************************************************************/
</code></pre>

<p>(please adapt comment characters usage)</p>

<p>For small files such as property files, configuration files or standard XML files:</p>

<pre><code># Copyright &lt;COPYRIGHT_HOLDER&gt;, &lt;YEAR&gt;. Part of the Eclipse Kuksa Project.
#
# All rights reserved. This configuration file is provided to you under the
# terms and conditions of the Eclipse Distribution License v1.0 which
# accompanies this distribution, and is available at
# http://www.eclipse.org/org/documents/edl-v10.php
</code></pre>

<h2 id="eclipse-contributor-agreement">Eclipse Contributor Agreement</h2>

<p>Before your contribution can be accepted by the project team contributors must
electronically sign the Eclipse Contributor Agreement (ECA).</p>

<ul>
<li><a href="http://www.eclipse.org/legal/ECA.php">http://www.eclipse.org/legal/ECA.php</a></li>
</ul>

<p>Commits that are provided by non-committers must have a Signed-off-by field in
the footer indicating that the author is aware of the terms by which the
contribution has been provided to the project. The non-committer must
additionally have an Eclipse Foundation account and must have a signed Eclipse
Contributor Agreement (ECA) on file.</p>

<p>For more information, please see the Eclipse Committer Handbook:
<a href="https://www.eclipse.org/projects/handbook/#resources-commit">https://www.eclipse.org/projects/handbook/#resources-commit</a></p>

                        </div>

                    </div>

                </div>
                

            </div>
            

            
        </div>
        

        <footer id="footer">
    <div class="container">

        <div class="col-md-4 col-sm-6">
            <h4>Legal</h4>
		    <ul>
		      <li><a href="https://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
		      <li><a href="https://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
		      <li><a href="https://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
		      <li><a href="https://www.eclipse.org/legal/epl-2.0/">Eclipse Public License</a></li>
		      <li><a href="https://www.eclipse.org/legal/">Legal Resources </a></li>
		      <li><a href="https://www.eclipse.org/security/">Eclipse Security </a></li>
		    </ul>
        </div>
        
        <div class="col-md-4 col-sm-6" align="center">
            <p><strong>Eclipse Kuksa</strong> has its origins in the <a href="https://itea3.org/project/appstacle.html">APPSTACLE project</a> that is part of the European ITEA3 programme</p>
            <hr class="hidden-md hidden-lg hidden-sm"/>&nbsp;<p>
           <a href="https://itea3.org/"> <img src="https://www.eclipse.org/kuksa/img/itea3.png" class="img-responsive" width="200" alt="ITEA3"/></a>
		    
       	   <p>Copyright © 2019 <a href="http://eclipse.org">The Eclipse Foundation</a>. <br/>All Rights Reserved.</p>
        </div>

        	<div class="col-md-4 col-sm-6">
            <p class="pull-right">
              Template by <a href="http://bootstrapious.com/free-templates">Bootstrapious</a>.
              

              <br/>Ported to Hugo by <a href="https://github.com/devcows/hugo-universal-theme">DevCows</a>
            </p>
       	</div>

    </div>
    
</footer>


<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
  












    </div>
    

    
<script src="//code.jquery.com/jquery-3.1.1.min.js" integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=" crossorigin="anonymous"></script>
<script src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>

<script src="//cdnjs.cloudflare.com/ajax/libs/jquery-cookie/1.4.1/jquery.cookie.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/waypoints/4.0.1/jquery.waypoints.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/Counter-Up/1.0/jquery.counterup.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/jquery-parallax/1.1.3/jquery-parallax.js"></script>

<script src="//maps.googleapis.com/maps/api/js?v=3.exp"></script>

<script src="https://www.eclipse.org/kuksa/js/hpneo.gmaps.js"></script>
<script src="https://www.eclipse.org/kuksa/js/gmaps.init.js"></script>
<script src="https://www.eclipse.org/kuksa/js/front.js"></script>


<script src="https://www.eclipse.org/kuksa/js/owl.carousel.min.js"></script>


  </body>
</html>
