> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aseeflow.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Set Up a Java Project for DMN

Now you are ready to set up your first process application project in the IDE of your choice (for example IntelliJ IDEA, Eclipse, or VS Code).

## Terminology: processes vs. decisions

DMN is a modeling language for *decisions*, whereas BPMN is a language for *processes*. This tutorial focuses on decisions. However, the Java project contains classes and files with names like `ProcessApplication` and `processes.xml`. These are generally applicable and can be used with both processes and decisions.

## Create a new Maven project

Create a new Maven project named `dinner-dmn`. Use your IDE's *New Maven Project* wizard — choose a simple project and skip the archetype selection.
Since you are setting up a WAR project, set **Packaging** to `war`. You can also create the project directly from the `pom.xml` shown below.

## Add ASEE Flow Maven dependencies

The next step consists of setting up the Maven dependencies for your new process application. Add the following dependencies to the `pom.xml` file of your project:

```xml theme={null}
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>org.aseeflow.bpm.getstarted</groupId>
  <artifactId>dinner-dmn</artifactId>
  <version>0.1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
    <aseeflow.version>1.0.0</aseeflow.version>
    <maven.compiler.release>11</maven.compiler.release>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.aseeflow.bpm</groupId>
        <artifactId>aseeflow-bom</artifactId>
        <version>${aseeflow.version}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>org.aseeflow.bpm</groupId>
      <artifactId>aseeflow-engine</artifactId>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>6.0.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.3.2</version>
        <configuration>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>
```

Now you can perform the first build. Select the `pom.xml` in the Package Explorer, right-click, and select **Run As > Maven Install**.

<Note>
  **Catch up: get the sources of Step-1**

  ```bash theme={null}
  git clone https://github.com/aseeflow/aseeflow-get-started-dmn.git
  git checkout -f Step-1
  ```

  Or [download as a `.zip`](https://github.com/aseeflow/aseeflow-get-started-dmn/archive/Step-1.zip).
</Note>

## Add a process application class

Next, create a package — for example `org.camunda.bpm.getstarted.dmn` — and add a process application class to it. The process application class constitutes the interface between your application and the process engine.

```java theme={null}
package org.camunda.bpm.getstarted.dmn;

import org.camunda.bpm.application.ProcessApplication;
import org.camunda.bpm.application.impl.ServletProcessApplication;

@ProcessApplication("Dinner App DMN")
public class DinnerApplication extends ServletProcessApplication
{
  //empty implementation
}
```

## Add a META-INF/processes.xml deployment descriptor

The last step to set up the process application is to add the `META-INF/processes.xml` deployment descriptor file. This file lets you provide a declarative configuration of the deployment(s) this process application makes to the process engine.

This file needs to be added to the `src/main/resources/META-INF` folder of the Maven project.

```xml theme={null}
<?xml version="1.0" encoding="UTF-8" ?>

<process-application
    xmlns="http://www.camunda.org/schema/1.0/ProcessApplication"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <process-archive name="dinner-dmn">

    <process-engine>default</process-engine>
    <properties>
      <property name="isDeleteUponUndeploy">false</property>
      <property name="isScanForProcessDefinitions">true</property>
    </properties>
  </process-archive>

</process-application>
```

At this point you have successfully set up the process application, and you can start modeling your first decision table.

<Note>
  **Catch up: get the sources of Step-2**

  ```bash theme={null}
  git clone https://github.com/aseeflow/aseeflow-get-started-dmn.git
  git checkout -f Step-2
  ```

  Or [download as a `.zip`](https://github.com/aseeflow/aseeflow-get-started-dmn/archive/Step-2.zip).
</Note>

## Next step

Continue to [create a decision table](/get-started/dmn/model).