diff --git a/README.md b/README.md
index 9c8c2d8..a94c4df 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,14 @@ Download from [release page](https://github.com/yukihirop/ultraman/releases), an
 
 If you want to install the `man`,
 
+Suppose you unzip the archive in the `./tmp` directory
+
+```bash
+install -Dm644 ./tmp/ultraman.1 /usr/local/share/man/man1/ultraman.1
+```
+
+or
+
 ```bash
 git clone git@github.com:yukihirop/ultraman.git && cd ultraman
 make install_man
diff --git a/src/cmd/export/base.rs b/src/cmd/export/base.rs
index db486be..741737f 100644
--- a/src/cmd/export/base.rs
+++ b/src/cmd/export/base.rs
@@ -16,13 +16,19 @@ pub struct EnvParameter {
     pub(crate) value: String,
 }
 
+pub struct Template {
+    pub(crate) template_path: PathBuf,
+    pub(crate) data: Map<String, Json>,
+    pub(crate) output_path: PathBuf,
+}
+
 pub trait Exportable {
     fn export(&self) -> Result<(), Box<dyn std::error::Error>>;
     //https://yajamon.hatenablog.com/entry/2018/01/30/202849
-    fn opts(&self) -> ExportOpts;
+    fn ref_opts(&self) -> &ExportOpts;
 
     fn base_export(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let opts = self.opts();
+        let opts = self.ref_opts();
         let location = &opts.location;
         let display = location.clone().into_os_string().into_string().unwrap();
         create_dir_all(&location).expect(&format!("Could not create: {}", display));
@@ -33,28 +39,34 @@ pub trait Exportable {
     }
 
     fn app(&self) -> String {
-        self.opts().app.unwrap_or_else(|| "app".to_string())
+        self.ref_opts()
+            .app
+            .clone()
+            .unwrap_or_else(|| "app".to_string())
     }
 
     fn log_path(&self) -> PathBuf {
-        self.opts()
+        self.ref_opts()
             .log_path
+            .clone()
             .unwrap_or_else(|| PathBuf::from(format!("/var/log/{}", self.app())))
     }
 
     fn run_path(&self) -> PathBuf {
-        self.opts()
+        self.ref_opts()
             .run_path
+            .clone()
             .unwrap_or_else(|| PathBuf::from(format!("/var/run/{}", self.app())))
     }
 
     fn username(&self) -> String {
-        self.opts().user.unwrap_or_else(|| self.app())
+        self.ref_opts().user.clone().unwrap_or_else(|| self.app())
     }
 
     fn root_path(&self) -> PathBuf {
-        self.opts()
+        self.ref_opts()
             .root_path
+            .clone()
             .unwrap_or_else(|| env::current_dir().unwrap())
     }
 
@@ -83,36 +95,38 @@ pub trait Exportable {
         println!("[ultraman export] {}", msg)
     }
 
-    fn write_template(
-        &self,
-        template_path: &PathBuf,
-        data: &mut Map<String, Json>,
-        output_path: &PathBuf,
-    ) {
+    fn write_template(&self, tmpl: Template) {
         let handlebars = Handlebars::new();
-        let display_template = template_path
+        let display_template = tmpl
+            .template_path
+            .clone()
+            .into_os_string()
+            .into_string()
+            .unwrap();
+        let display_output = tmpl
+            .output_path
             .clone()
             .into_os_string()
             .into_string()
             .unwrap();
-        let display_output = output_path.clone().into_os_string().into_string().unwrap();
-        let mut template_source =
-            File::open(template_path).expect(&format!("Could not open file: {}", display_template));
-        let mut output_file = File::create(output_path)
+        let mut template_source = File::open(tmpl.template_path)
+            .expect(&format!("Could not open file: {}", display_template));
+        let mut output_file = File::create(tmpl.output_path)
             .expect(&format!("Could not create file: {}", &display_output));
         self.say(&format!("writing: {}", &display_output));
+        let mut data = tmpl.data;
         handlebars
-            .render_template_source_to_write(&mut template_source, data, &mut output_file)
+            .render_template_source_to_write(&mut template_source, &mut data, &mut output_file)
             .expect(&format!("Coult not render file: {}", &display_output));
     }
 
     fn output_path(&self, filename: String) -> PathBuf {
-        let location = self.opts().location;
+        let location = self.ref_opts().location.clone();
         location.join(filename)
     }
 
     fn env_without_port(&self) -> Vec<EnvParameter> {
-        let mut env = read_env(self.opts().env_path).expect("failed read .env");
+        let mut env = read_env(self.ref_opts().env_path.clone()).expect("failed read .env");
         env.remove("PORT");
         let mut env_without_port: Vec<EnvParameter> = vec![];
         for (key, value) in env {
diff --git a/src/cmd/export/daemon.rs b/src/cmd/export/daemon.rs
index 611143a..857ce11 100644
--- a/src/cmd/export/daemon.rs
+++ b/src/cmd/export/daemon.rs
@@ -1,4 +1,4 @@
-use super::base::{EnvParameter, Exportable};
+use super::base::{EnvParameter, Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::env::read_env;
 use crate::process::port_for;
@@ -12,20 +12,7 @@ use std::path::PathBuf;
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -58,19 +45,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -168,8 +157,13 @@ impl Exporter {
     }
 
     fn environment(&self, index: usize, con_index: usize) -> Vec<EnvParameter> {
-        let port = port_for(self.opts().env_path, self.opts().port, index, con_index + 1);
-        let mut env = read_env(self.opts().env_path).expect("failed read .env");
+        let port = port_for(
+            self.opts.env_path.clone(),
+            self.opts.port.clone(),
+            index,
+            con_index + 1,
+        );
+        let mut env = read_env(self.opts.env_path.clone()).expect("failed read .env");
         env.insert("PORT".to_string(), port);
 
         let mut result = vec![];
@@ -188,51 +182,60 @@ impl Exportable for Exporter {
     fn export(&self) -> Result<(), Box<dyn std::error::Error>> {
         self.base_export().expect("failed execute base_export");
 
-        let mut data = self.make_master_data();
-        let output_path = self.opts().location.join(format!("{}.conf", self.app()));
-        self.clean(&output_path);
-        self.write_template(&self.master_tmpl_path(), &mut data, &output_path);
+        let mut clean_paths: Vec<PathBuf> = vec![];
+        let mut tmpl_data: Vec<Template> = vec![];
+
+        let output_path = self.opts.location.join(format!("{}.conf", self.app()));
+
+        clean_paths.push(output_path.clone());
+        tmpl_data.push(Template {
+            template_path: self.master_tmpl_path(),
+            data: self.make_master_data(),
+            output_path,
+        });
 
         let mut index = 0;
         for (name, pe) in self.procfile.data.iter() {
             let con = pe.concurrency.get();
             let service_name = format!("{}-{}", self.app(), &name);
             let output_path = self
-                .opts()
+                .opts
                 .location
                 .join(format!("{}-{}.conf", self.app(), &name));
-            let mut data = self.make_process_master_data();
-            self.clean(&output_path);
-            self.write_template(&self.process_master_tmpl_path(), &mut data, &output_path);
+
+            clean_paths.push(output_path.clone());
+            tmpl_data.push(Template {
+                template_path: self.process_master_tmpl_path(),
+                data: self.make_process_master_data(),
+                output_path,
+            });
 
             for n in 0..con {
                 index += 1;
                 let process_name = format!("{}-{}-{}.conf", self.app(), &name, n + 1);
-                let output_path = self.opts().location.join(&process_name);
-                let mut data = self.make_process_data(pe, &service_name, index, n);
-                self.clean(&output_path);
-                self.write_template(&self.process_tmpl_path(), &mut data, &output_path);
+                let output_path = self.opts.location.join(&process_name);
+
+                clean_paths.push(output_path.clone());
+                tmpl_data.push(Template {
+                    template_path: self.process_tmpl_path(),
+                    data: self.make_process_data(pe, &service_name, index, n),
+                    output_path,
+                });
             }
         }
 
+        for path in clean_paths {
+            self.clean(&path);
+        }
+
+        for tmpl in tmpl_data {
+            self.write_template(tmpl);
+        }
+
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/export/launchd.rs b/src/cmd/export/launchd.rs
index 0205626..4cb27cf 100644
--- a/src/cmd/export/launchd.rs
+++ b/src/cmd/export/launchd.rs
@@ -1,4 +1,4 @@
-use super::base::{EnvParameter, Exportable};
+use super::base::{EnvParameter, Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::env::read_env;
 use crate::process::port_for;
@@ -12,20 +12,7 @@ use std::path::PathBuf;
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -45,19 +32,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -110,8 +99,13 @@ impl Exporter {
     }
 
     fn environment(&self, index: usize, con_index: usize) -> Vec<EnvParameter> {
-        let port = port_for(self.opts().env_path, self.opts().port, index, con_index + 1);
-        let mut env = read_env(self.opts().env_path).expect("failed read .env");
+        let port = port_for(
+            self.opts.env_path.clone(),
+            self.opts.port.clone(),
+            index,
+            con_index + 1,
+        );
+        let mut env = read_env(self.opts.env_path.clone()).expect("failed read .env");
         env.insert("PORT".to_string(), port);
 
         let mut result = vec![];
@@ -131,36 +125,37 @@ impl Exportable for Exporter {
         self.base_export().expect("failed execute base_export");
 
         let mut index = 0;
+        let mut clean_paths: Vec<PathBuf> = vec![];
+        let mut tmpl_data: Vec<Template> = vec![];
+
         for (name, pe) in self.procfile.data.iter() {
             let con = pe.concurrency.get();
             for n in 0..con {
                 index += 1;
                 let service_name = format!("{}-{}-{}", self.app(), &name, n + 1);
-                let output_path = self.opts().location.join(&service_name);
-                let mut data = self.make_launchd_data(pe, &service_name, index, n);
-                self.clean(&output_path);
-                self.write_template(&self.launchd_tmpl_path(), &mut data, &output_path);
+                let output_path = self.opts.location.join(&service_name);
+
+                clean_paths.push(output_path.clone());
+                tmpl_data.push(Template {
+                    template_path: self.launchd_tmpl_path(),
+                    data: self.make_launchd_data(pe, &service_name, index, n),
+                    output_path,
+                });
             }
         }
 
+        for path in clean_paths {
+            self.clean(&path);
+        }
+
+        for tmpl in tmpl_data {
+            self.write_template(tmpl);
+        }
+
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/export/mod.rs b/src/cmd/export/mod.rs
index 48d0986..92364ec 100644
--- a/src/cmd/export/mod.rs
+++ b/src/cmd/export/mod.rs
@@ -11,7 +11,7 @@ pub mod supervisord;
 pub mod systemd;
 pub mod upstart;
 
-#[derive(StructOpt, Debug, Default)]
+#[derive(StructOpt, Debug, Default, Clone)]
 #[structopt(setting(clap::AppSettings::ColoredHelp))]
 pub struct ExportOpts {
     /// Specify  process management format
@@ -115,114 +115,42 @@ fn new(opts: &ExportOpts) -> Box<dyn Exportable> {
             // Read the formation from the command line option and always call it before process_len for the convenience of setting concurrency
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
         ExportFormat::Systemd => {
             let mut expo = systemd::Exporter::boxed_new();
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
         ExportFormat::Supervisord => {
             let mut expo = supervisord::Exporter::boxed_new();
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
         ExportFormat::Runit => {
             let mut expo = runit::Exporter::boxed_new();
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
         ExportFormat::Launchd => {
             let mut expo = launchd::Exporter::boxed_new();
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
         ExportFormat::Daemon => {
             let mut expo = daemon::Exporter::boxed_new();
             procfile.set_concurrency(&opts.formation);
             expo.procfile = procfile;
-            expo.format = opts.format.clone();
-            expo.location = opts.location.clone();
-            expo.app = opts.app.clone();
-            expo.formation = opts.formation.clone();
-            expo.log_path = opts.log_path.clone();
-            expo.run_path = opts.run_path.clone();
-            expo.port = opts.port.clone();
-            expo.template_path = opts.template_path.clone();
-            expo.user = opts.user.clone();
-            expo.env_path = opts.env_path.clone();
-            expo.procfile_path = opts.procfile_path.clone();
-            expo.root_path = opts.root_path.clone();
-            expo.timeout = opts.timeout.clone();
+            expo.opts = opts.clone();
             expo
         }
     }
diff --git a/src/cmd/export/runit.rs b/src/cmd/export/runit.rs
index e060bb0..0fe1085 100644
--- a/src/cmd/export/runit.rs
+++ b/src/cmd/export/runit.rs
@@ -1,4 +1,4 @@
-use super::base::Exportable;
+use super::base::{Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::env::read_env;
 use crate::process::port_for;
@@ -14,20 +14,7 @@ use std::path::PathBuf;
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -50,19 +37,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -118,8 +107,13 @@ impl Exporter {
     }
 
     fn write_env(&self, output_dir_path: &PathBuf, index: usize, con_index: usize) {
-        let mut env = read_env(self.opts().env_path).expect("failed read .env");
-        let port = port_for(self.opts().env_path, self.opts().port, index, con_index + 1);
+        let mut env = read_env(self.opts.env_path.clone()).expect("failed read .env");
+        let port = port_for(
+            self.opts.env_path.clone(),
+            self.opts.port.clone(),
+            index,
+            con_index + 1,
+        );
         env.insert("PORT".to_string(), port);
 
         for (key, val) in env.iter() {
@@ -134,18 +128,29 @@ impl Exporter {
     }
 }
 
+struct EnvTemplate {
+    template_path: PathBuf,
+    index: usize,
+    con_index: usize,
+}
+
 impl Exportable for Exporter {
     fn export(&self) -> Result<(), Box<dyn std::error::Error>> {
         self.base_export().expect("failed execute base_export");
 
         let mut index = 0;
+        let mut clean_paths: Vec<PathBuf> = vec![];
+        let mut create_recursive_dir_paths: Vec<PathBuf> = vec![];
+        let mut tmpl_data: Vec<Template> = vec![];
+        let mut env_data: Vec<EnvTemplate> = vec![];
+
         for (name, pe) in self.procfile.data.iter() {
             let con = pe.concurrency.get();
             for n in 0..con {
                 index += 1;
                 let process_name = format!("{}-{}", &name, n + 1);
                 let service_name = format!("{}-{}-{}", self.app(), &name, n + 1);
-                let mut path_for_run = self.opts().location;
+                let mut path_for_run = self.opts.location.clone();
                 let mut path_for_env = path_for_run.clone();
                 let mut path_for_log = path_for_run.clone();
                 let run_file_path = PathBuf::from(format!("{}/run", &service_name));
@@ -154,44 +159,58 @@ impl Exportable for Exporter {
                 path_for_run.push(run_file_path);
                 path_for_env.push(env_dir_path);
                 path_for_log.push(log_dir_path);
-                self.create_dir_recursive(&path_for_env);
-                self.create_dir_recursive(&path_for_log);
 
-                let mut run_data = self.make_run_data(
+                create_recursive_dir_paths.push(path_for_env.clone());
+                create_recursive_dir_paths.push(path_for_log.clone());
+
+                let run_data = self.make_run_data(
                     pe,
                     &PathBuf::from(format!("/etc/service/{}/env", &service_name)),
                 );
-                let mut log_run_data = self.make_log_run_data(&process_name);
+                let log_run_data = self.make_log_run_data(&process_name);
 
-                self.clean(&path_for_run);
-                self.write_template(&self.run_tmpl_path(), &mut run_data, &path_for_run);
+                clean_paths.push(path_for_run.clone());
+                tmpl_data.push(Template {
+                    template_path: self.run_tmpl_path(),
+                    data: run_data,
+                    output_path: path_for_run,
+                });
 
                 path_for_log.push("run");
-                self.clean(&path_for_log);
-                self.write_template(&self.log_run_tmpl_path(), &mut log_run_data, &path_for_log);
-
-                self.write_env(&path_for_env, index, n);
+                clean_paths.push(path_for_log.clone());
+                tmpl_data.push(Template {
+                    template_path: self.log_run_tmpl_path(),
+                    data: log_run_data,
+                    output_path: path_for_log,
+                });
+                env_data.push(EnvTemplate {
+                    template_path: path_for_env.clone(),
+                    index,
+                    con_index: n,
+                });
             }
         }
 
+        for path in clean_paths {
+            self.clean(&path);
+        }
+
+        for dir_path in create_recursive_dir_paths {
+            self.create_dir_recursive(&dir_path);
+        }
+
+        for tmpl in tmpl_data {
+            self.write_template(tmpl);
+        }
+
+        for e in env_data {
+            self.write_env(&e.template_path, e.index, e.con_index);
+        }
+
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/export/supervisord.rs b/src/cmd/export/supervisord.rs
index 39d91cd..98f0c44 100644
--- a/src/cmd/export/supervisord.rs
+++ b/src/cmd/export/supervisord.rs
@@ -1,4 +1,4 @@
-use super::base::Exportable;
+use super::base::{Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::env::read_env;
 use crate::process::port_for;
@@ -16,20 +16,7 @@ const ENV_REGEXP: &'static str = "\\$\\{*(?P<envname>[A-Za-z0-9_-]+)\\}*";
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -56,19 +43,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -105,8 +94,13 @@ impl Exporter {
     }
 
     fn environment(&self, index: usize, con_index: usize) -> String {
-        let port = port_for(self.opts().env_path, self.opts().port, index, con_index + 1);
-        let mut env = read_env(self.opts().env_path).expect("failed read .env");
+        let port = port_for(
+            self.opts.env_path.clone(),
+            self.opts.port.clone(),
+            index,
+            con_index + 1,
+        );
+        let mut env = read_env(self.opts.env_path.clone()).expect("failed read .env");
         env.insert("PORT".to_string(), port);
 
         let mut result = vec![];
@@ -156,28 +150,17 @@ impl Exportable for Exporter {
         }
 
         let output_path = self.output_path("app.conf".to_string());
-        let mut data = self.make_app_conf_data(service_names, data);
         self.clean(&output_path);
-        self.write_template(&self.app_conf_tmpl_path(), &mut data, &output_path);
+        self.write_template(Template {
+            template_path: self.app_conf_tmpl_path(),
+            data: self.make_app_conf_data(service_names, data),
+            output_path,
+        });
 
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/export/systemd.rs b/src/cmd/export/systemd.rs
index 9911f01..cdfbf97 100644
--- a/src/cmd/export/systemd.rs
+++ b/src/cmd/export/systemd.rs
@@ -1,4 +1,4 @@
-use super::base::{EnvParameter, Exportable};
+use super::base::{EnvParameter, Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::process::port_for;
 use crate::procfile::{Procfile, ProcfileEntry};
@@ -11,20 +11,7 @@ use std::path::PathBuf;
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -50,19 +37,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -111,11 +100,16 @@ impl Exporter {
             app: self.app(),
             user: self.username(),
             work_dir: self.root_path().into_os_string().into_string().unwrap(),
-            port: port_for(self.opts().env_path, self.opts().port, index, con_index + 1),
+            port: port_for(
+                self.opts.env_path.clone(),
+                self.opts.port.clone(),
+                index,
+                con_index + 1,
+            ),
             process_name: process_name.to_string(),
             process_command: pe.command.to_string(),
             env_without_port: self.env_without_port(),
-            timeout: self.opts().timeout,
+            timeout: self.opts.timeout.clone(),
         };
         data.insert("process_service".to_string(), to_json(&ps));
         data
@@ -128,6 +122,9 @@ impl Exportable for Exporter {
 
         let mut index = 0;
         let mut service_names = vec![];
+        let mut clean_paths: Vec<PathBuf> = vec![];
+        let mut tmpl_data: Vec<Template> = vec![];
+
         for (name, pe) in self.procfile.data.iter() {
             index += 1;
             let con = pe.concurrency.get();
@@ -135,38 +132,40 @@ impl Exportable for Exporter {
                 let process_name = format!("{}.{}", &name, n);
                 let service_filename = format!("{}-{}.service", &name, &process_name);
                 let output_path = self.output_path(service_filename.clone());
-                let mut data = self.make_process_service_data(pe, &process_name, index, n);
-
-                self.clean(&output_path);
-                self.write_template(&self.process_service_tmpl_path(), &mut data, &output_path);
+                let data = self.make_process_service_data(pe, &process_name, index, n);
+
+                clean_paths.push(output_path.clone());
+                tmpl_data.push(Template {
+                    template_path: self.process_service_tmpl_path(),
+                    data,
+                    output_path,
+                });
                 service_names.push(service_filename);
             }
         }
 
         let output_path = self.output_path(format!("{}.target", self.app()));
-        let mut data = self.make_master_target_data(service_names);
+        let data = self.make_master_target_data(service_names);
+
+        clean_paths.push(output_path.clone());
+        tmpl_data.push(Template {
+            template_path: self.master_target_tmpl_path(),
+            data,
+            output_path,
+        });
 
-        self.clean(&output_path);
-        self.write_template(&self.master_target_tmpl_path(), &mut data, &output_path);
+        for path in clean_paths {
+            self.clean(&path);
+        }
+
+        for tmpl in tmpl_data {
+            self.write_template(tmpl);
+        }
 
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/export/upstart.rs b/src/cmd/export/upstart.rs
index 0d24d0e..41ed96a 100644
--- a/src/cmd/export/upstart.rs
+++ b/src/cmd/export/upstart.rs
@@ -1,4 +1,4 @@
-use super::base::{EnvParameter, Exportable};
+use super::base::{EnvParameter, Exportable, Template};
 use crate::cmd::export::ExportOpts;
 use crate::process::port_for;
 use crate::procfile::{Procfile, ProcfileEntry};
@@ -12,20 +12,7 @@ use std::path::PathBuf;
 
 pub struct Exporter {
     pub procfile: Procfile,
-    // ExportOpts
-    pub format: String,
-    pub location: PathBuf,
-    pub app: Option<String>,
-    pub formation: String,
-    pub log_path: Option<PathBuf>,
-    pub run_path: Option<PathBuf>,
-    pub port: Option<String>,
-    pub template_path: Option<PathBuf>,
-    pub user: Option<String>,
-    pub env_path: PathBuf,
-    pub procfile_path: PathBuf,
-    pub root_path: Option<PathBuf>,
-    pub timeout: String,
+    pub opts: ExportOpts,
 }
 
 #[derive(Serialize)]
@@ -94,7 +81,12 @@ impl Exporter {
         let p = ProcessParams {
             app: self.app(),
             name: app_name.to_string(),
-            port: port_for(self.opts().env_path, self.opts().port, index, con_index + 1),
+            port: port_for(
+                self.opts.env_path.clone(),
+                self.opts.port.clone(),
+                index,
+                con_index + 1,
+            ),
             env_without_port: self.env_without_port(),
             setuid: self.username(),
             chdir: self.root_path().into_os_string().into_string().unwrap(),
@@ -111,19 +103,21 @@ impl Default for Exporter {
             procfile: Procfile {
                 data: HashMap::new(),
             },
-            format: String::from(""),
-            location: PathBuf::from("location"),
-            app: None,
-            formation: String::from("all=1"),
-            log_path: None,
-            run_path: None,
-            port: None,
-            template_path: None,
-            user: None,
-            env_path: PathBuf::from(".env"),
-            procfile_path: PathBuf::from("Procfile"),
-            root_path: Some(env::current_dir().unwrap()),
-            timeout: String::from("5"),
+            opts: ExportOpts {
+                format: String::from(""),
+                location: PathBuf::from("location"),
+                app: None,
+                formation: String::from("all=1"),
+                log_path: None,
+                run_path: None,
+                port: None,
+                template_path: None,
+                user: None,
+                env_path: PathBuf::from(".env"),
+                procfile_path: PathBuf::from("Procfile"),
+                root_path: Some(env::current_dir().unwrap()),
+                timeout: String::from("5"),
+            },
         }
     }
 }
@@ -132,12 +126,18 @@ impl Exportable for Exporter {
     fn export(&self) -> Result<(), Box<dyn std::error::Error>> {
         self.base_export().expect("failed execute base_export");
 
+        let mut clean_paths: Vec<PathBuf> = vec![];
+        let mut tmpl_data: Vec<Template> = vec![];
+
         let master_file = format!("{}.conf", self.app());
         let output_path = self.output_path(master_file);
-        let mut data = Map::new();
 
-        self.clean(&output_path);
-        self.write_template(&self.master_tmpl_path(), &mut data, &output_path);
+        clean_paths.push(output_path.clone());
+        tmpl_data.push(Template {
+            template_path: self.master_tmpl_path(),
+            data: Map::new(),
+            output_path,
+        });
 
         let mut index = 0;
         for (name, pe) in self.procfile.data.iter() {
@@ -145,37 +145,39 @@ impl Exportable for Exporter {
             let con = pe.concurrency.get();
             let process_master_file = format!("{}-{}.conf", self.app(), &name);
             let output_path = self.output_path(process_master_file);
-            let mut data = self.make_process_master_data();
-            self.clean(&output_path);
-            self.write_template(&self.process_master_tmpl_path(), &mut data, &output_path);
+
+            clean_paths.push(output_path.clone());
+            tmpl_data.push(Template {
+                template_path: self.process_master_tmpl_path(),
+                data: self.make_process_master_data(),
+                output_path,
+            });
 
             for n in 0..con {
                 let process_file = format!("{}-{}-{}.conf", self.app(), &name, n);
                 let output_path = self.output_path(process_file);
-                let mut data = self.make_process_data(pe, &name, index, n);
-                self.clean(&output_path);
-                self.write_template(&self.process_tmpl_path(), &mut data, &output_path);
+
+                clean_paths.push(output_path.clone());
+                tmpl_data.push(Template {
+                    template_path: self.process_tmpl_path(),
+                    data: self.make_process_data(pe, &name, index, n),
+                    output_path,
+                });
             }
         }
 
+        for path in clean_paths {
+            self.clean(&path);
+        }
+
+        for tmpl in tmpl_data {
+            self.write_template(tmpl);
+        }
+
         Ok(())
     }
 
-    fn opts(&self) -> ExportOpts {
-        ExportOpts {
-            format: self.format.clone(),
-            location: self.location.clone(),
-            app: self.app.clone(),
-            formation: self.formation.clone(),
-            log_path: self.log_path.clone(),
-            run_path: self.run_path.clone(),
-            port: self.port.clone(),
-            template_path: self.template_path.clone(),
-            user: self.user.clone(),
-            env_path: self.env_path.clone(),
-            procfile_path: self.procfile_path.clone(),
-            root_path: self.root_path.clone(),
-            timeout: self.timeout.clone(),
-        }
+    fn ref_opts(&self) -> &ExportOpts {
+        &self.opts
     }
 }
diff --git a/src/cmd/start.rs b/src/cmd/start.rs
index bbfd657..6d2c981 100644
--- a/src/cmd/start.rs
+++ b/src/cmd/start.rs
@@ -1,5 +1,6 @@
+use crate::opt::DisplayOpts;
 use crate::output;
-use crate::process;
+use crate::process::{self, Process};
 use crate::procfile::read_procfile;
 use crate::signal;
 
@@ -69,28 +70,51 @@ pub fn run(opts: StartOpts) -> Result<(), Box<dyn std::error::Error>> {
     let padding = procfile.padding();
 
     let barrier = Arc::new(Barrier::new(process_len + 1));
-    let mut index = 0;
+    let mut total = 0;
     let is_timestamp = !opts.is_no_timestamp;
+    let display_opts = DisplayOpts {
+        padding,
+        is_timestamp,
+    };
 
     for (name, pe) in procfile.data.iter() {
         let con = pe.concurrency.get();
-        let output = Arc::new(output::Output::new(index, padding, is_timestamp));
-        let before_index = index;
-        index += 1;
+        let index = total;
+        let output = Arc::new(output::Output::new(index, display_opts.clone()));
+        total += 1;
 
         for n in 0..con {
             let barrier = barrier.clone();
             let procs = procs.clone();
             let output = output.clone();
-            let name = name.clone();
-            let pe_command = pe.command.clone();
+            let process_name = name.clone();
+            let cmd = pe.command.clone();
             let env_path = opts.env_path.clone();
             let port = opts.port.clone();
-
-            let each_fn = process::each_handle_exec_and_output(procs, padding, barrier, output);
-            let each_handle_exec_and_output =
-                each_fn(name, n, pe_command, env_path, port, before_index);
-            proc_handles.push(each_handle_exec_and_output);
+            let opts = display_opts.clone();
+
+            let exec_and_output_thread = process::build_exec_and_output_thread(move || {
+                let proc = Process::new(process_name, cmd, env_path, port, n, index, Some(opts));
+                let proc2 = Arc::new(Mutex::new(proc));
+                let proc3 = Arc::clone(&proc2);
+                let child_id = proc2.lock().unwrap().child.id() as i32;
+
+                output.log.output(
+                    "system",
+                    &format!(
+                        "{0:1$} start at pid: {2}",
+                        &proc2.lock().unwrap().name,
+                        padding,
+                        &child_id
+                    ),
+                );
+
+                procs.lock().unwrap().push(proc2);
+                barrier.wait();
+
+                output.handle_output(&proc3);
+            });
+            proc_handles.push(exec_and_output_thread);
         }
     }
 
@@ -98,18 +122,15 @@ pub fn run(opts: StartOpts) -> Result<(), Box<dyn std::error::Error>> {
 
     // use handle_signal
     let procs2 = Arc::clone(&procs);
-    proc_handles.push(process::check_for_child_termination_thread(
-        procs,
-        padding,
-        is_timestamp,
-    ));
+    let check_for_child_termination_thread =
+        process::build_check_for_child_termination_thread(procs2, display_opts.clone());
+    proc_handles.push(check_for_child_termination_thread);
 
-    let procs = Arc::clone(&procs2);
+    let procs = Arc::clone(&procs);
     proc_handles.push(signal::handle_signal_thread(
         procs,
-        padding,
         opts.timeout.parse::<u64>().unwrap(),
-        is_timestamp,
+        display_opts,
     ));
 
     for handle in proc_handles {
diff --git a/src/log/color.rs b/src/log/color.rs
index 5400ce0..718d177 100644
--- a/src/log/color.rs
+++ b/src/log/color.rs
@@ -1,4 +1,5 @@
 use crate::log::{now, Printable};
+use crate::opt::DisplayOpts;
 use colored::*;
 
 const COLORS: [&str; 12] = [
@@ -19,8 +20,7 @@ const COLORS: [&str; 12] = [
 #[derive(Default)]
 pub struct Log {
     pub index: usize,
-    pub padding: usize,
-    pub is_timestamp: bool,
+    pub opts: DisplayOpts,
 }
 
 unsafe impl Sync for Log {}
@@ -41,11 +41,11 @@ impl Printable for Log {
     fn output(&self, proc_name: &str, content: &str) {
         let color = COLORS[self.index % COLORS.len()];
 
-        if self.is_timestamp {
+        if self.opts.is_timestamp {
             println!(
                 "{3} {0:1$} | {2}",
                 proc_name.color(color),
-                self.padding,
+                self.opts.padding,
                 content.color(color),
                 now().color(color)
             )
@@ -53,7 +53,7 @@ impl Printable for Log {
             println!(
                 "{0:1$} | {2}",
                 proc_name.color(color),
-                self.padding,
+                self.opts.padding,
                 content.color(color),
             )
         }
diff --git a/src/log/mod.rs b/src/log/mod.rs
index 39b80d1..3c08d09 100644
--- a/src/log/mod.rs
+++ b/src/log/mod.rs
@@ -1,3 +1,4 @@
+use crate::opt::DisplayOpts;
 use chrono::Local;
 
 pub mod color;
@@ -13,39 +14,50 @@ pub struct Log;
 #[derive(Clone)]
 pub struct LogOpt {
     pub is_color: bool,
+    pub padding: usize,
     pub is_timestamp: bool,
 }
 
 impl Log {
-    pub fn new(index: usize, padding: usize, opt: &LogOpt) -> Box<dyn Printable + Sync + Send> {
+    pub fn new(index: usize, opt: &LogOpt) -> Box<dyn Printable + Sync + Send> {
         if opt.is_color {
             let mut color = color::Log::boxed_new();
             color.index = index;
-            color.padding = padding;
-            color.is_timestamp = opt.is_timestamp;
+            color.opts = Self::display_opts(opt);
             color
         } else {
             let mut plain = plain::Log::boxed_new();
             plain.index = index;
-            plain.padding = padding;
-            plain.is_timestamp = opt.is_timestamp;
+            plain.opts = Self::display_opts(opt);
             plain
         }
     }
+
+    fn display_opts(opt: &LogOpt) -> DisplayOpts {
+        DisplayOpts {
+            padding: opt.padding,
+            is_timestamp: opt.is_timestamp,
+        }
+    }
 }
 
-pub fn output(proc_name: &str, content: &str, padding: usize, index: Option<usize>, opt: &LogOpt) {
+pub fn output(proc_name: &str, content: &str, index: Option<usize>, opt: &LogOpt) {
     let index = index.unwrap_or_else(|| 0);
-    let log = Log::new(index, padding, opt);
+    let log = Log::new(index, opt);
     log.output(proc_name, content)
 }
 
-pub fn error(proc_name: &str, err: &dyn std::error::Error, padding: Option<usize>, opt: &LogOpt) {
+pub fn error(proc_name: &str, err: &dyn std::error::Error, is_padding: bool, opt: &LogOpt) {
     let content = &format!("error: {:?}", err);
-    if let Some(p) = padding {
-        output(proc_name, content, p, None, opt);
+    if is_padding {
+        output(proc_name, content, None, &opt);
     } else {
-        output(proc_name, content, proc_name.len() + 1, None, opt);
+        let remake_opt = LogOpt {
+            is_color: opt.is_color,
+            padding: proc_name.len() + 1,
+            is_timestamp: opt.is_timestamp,
+        };
+        output(proc_name, content, None, &remake_opt);
     }
 }
 
@@ -64,9 +76,9 @@ mod tests {
     fn test_output_when_coloring() -> anyhow::Result<()> {
         let log = Log::new(
             0,
-            10,
             &LogOpt {
                 is_color: true,
+                padding: 10,
                 is_timestamp: true,
             },
         );
@@ -79,9 +91,9 @@ mod tests {
     fn test_output_when_not_coloring() -> anyhow::Result<()> {
         let log = Log::new(
             0,
-            10,
             &LogOpt {
                 is_color: false,
+                padding: 10,
                 is_timestamp: true,
             },
         );
@@ -105,9 +117,9 @@ mod tests {
         let error = TestError("test error");
         let log = Log::new(
             0,
-            10,
             &LogOpt {
                 is_color: true,
+                padding: 10,
                 is_timestamp: true,
             },
         );
diff --git a/src/log/plain.rs b/src/log/plain.rs
index a31d74c..e1a8a32 100644
--- a/src/log/plain.rs
+++ b/src/log/plain.rs
@@ -1,10 +1,10 @@
 use crate::log::{now, Printable};
+use crate::opt::DisplayOpts;
 
 #[derive(Default)]
 pub struct Log {
     pub index: usize,
-    pub padding: usize,
-    pub is_timestamp: bool,
+    pub opts: DisplayOpts,
 }
 
 unsafe impl Sync for Log {}
@@ -23,10 +23,16 @@ impl Log {
 
 impl Printable for Log {
     fn output(&self, proc_name: &str, content: &str) {
-        if self.is_timestamp {
-            println!("{3} {0:1$} | {2}", proc_name, self.padding, content, now())
+        if self.opts.is_timestamp {
+            println!(
+                "{3} {0:1$} | {2}",
+                proc_name,
+                self.opts.padding,
+                content,
+                now()
+            )
         } else {
-            println!("{0:1$} | {2}", proc_name, self.padding, content)
+            println!("{0:1$} | {2}", proc_name, self.opts.padding, content)
         }
     }
 
diff --git a/src/opt.rs b/src/opt.rs
index 62f08a9..7738dd1 100644
--- a/src/opt.rs
+++ b/src/opt.rs
@@ -32,3 +32,20 @@ pub enum Ultraman {
     )]
     Export(ExportOpts),
 }
+
+///// Options not related to commands /////
+
+#[derive(Clone)]
+pub struct DisplayOpts {
+    pub padding: usize,
+    pub is_timestamp: bool,
+}
+
+impl Default for DisplayOpts {
+    fn default() -> Self {
+        DisplayOpts {
+            padding: 0,
+            is_timestamp: true,
+        }
+    }
+}
diff --git a/src/output.rs b/src/output.rs
index 765c438..d00fe22 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -1,6 +1,8 @@
 use crate::log::{Log, LogOpt, Printable};
+use crate::opt::DisplayOpts;
 use crate::process::Process;
 use crate::stream_read::{PipeError, PipeStreamReader, PipedLine};
+
 use crossbeam_channel::Select;
 use std::sync::{Arc, Mutex};
 
@@ -9,14 +11,14 @@ pub struct Output {
 }
 
 impl Output {
-    pub fn new(index: usize, padding: usize, is_timestamp: bool) -> Self {
+    pub fn new(index: usize, opts: DisplayOpts) -> Self {
         Output {
             log: Log::new(
                 index,
-                padding,
                 &LogOpt {
                     is_color: true,
-                    is_timestamp,
+                    padding: opts.padding,
+                    is_timestamp: opts.is_timestamp,
                 },
             ),
         }
@@ -115,10 +117,17 @@ mod tests {
                 .stderr(Stdio::piped())
                 .spawn()
                 .expect("failed execute handle_output command"),
+            opts: None,
         }));
 
         let proc2 = Arc::clone(&proc);
-        let output = Output::new(0, 10, true);
+        let output = Output::new(
+            0,
+            DisplayOpts {
+                padding: 10,
+                is_timestamp: true,
+            },
+        );
         output.handle_output(&proc2);
 
         Ok(())
diff --git a/src/process.rs b/src/process.rs
index 6c8d3f5..ec8989b 100644
--- a/src/process.rs
+++ b/src/process.rs
@@ -1,118 +1,121 @@
 use crate::env::read_env;
 use crate::log::{self, LogOpt};
-use crate::output;
+use crate::opt::DisplayOpts;
 use crate::signal;
 use nix::sys::signal::Signal;
 use nix::sys::wait::WaitStatus;
 use nix::{self, unistd::Pid};
+use std::env::{self as os_env};
+use std::path::PathBuf;
 use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread::{self, JoinHandle};
 
 #[cfg(not(test))]
 use std::process::exit;
 
-use std::env::{self as os_env};
-use std::path::PathBuf;
-use std::sync::{Arc, Barrier, Mutex};
-use std::thread::{self, JoinHandle};
-
 pub struct Process {
     pub index: usize,
     pub name: String,
     pub child: Child,
+    pub opts: Option<DisplayOpts>,
 }
 
-// https://qiita.com/quercus491/items/9f8f590c9734c81da2bd
-pub fn each_handle_exec_and_output(
-    procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
-    barrier: Arc<Barrier>,
-    output: Arc<output::Output>,
-) -> Box<dyn Fn(String, usize, String, PathBuf, Option<String>, usize) -> JoinHandle<()>> {
-    Box::new(
-        // MEMO: Refactor when you understand your lifetime
-        move |process_name: String,
-              con: usize,
-              cmd: String,
-              env_path: PathBuf,
-              port: Option<String>,
-              index: usize| {
-            let output = output.clone();
-            let procs = procs.clone();
-            let barrier = barrier.clone();
-
-            let result = thread::Builder::new()
-                .name(String::from("handle exec and output"))
-                .spawn(move || {
-                    let mut read_env = read_env(env_path.clone()).expect("failed read .env");
-                    read_env.insert(String::from("PORT"), port_for(env_path, port, index, con));
-                    read_env.insert(String::from("PS"), ps_for(process_name.clone(), con + 1));
-                    let shell = os_env::var("SHELL").expect("$SHELL is not set");
-
-                    let tmp_proc = Process {
-                        index,
-                        name: ps_for(process_name, con + 1),
-                        child: Command::new(shell)
-                            .arg("-c")
-                            .arg(cmd)
-                            .stdout(Stdio::piped())
-                            .stderr(Stdio::piped())
-                            .envs(read_env)
-                            .spawn()
-                            .expect("failed execute command"),
-                    };
-                    let proc = Arc::new(Mutex::new(tmp_proc));
-                    let proc2 = Arc::clone(&proc);
-
-                    let child_id = proc.lock().unwrap().child.id() as i32;
-                    output.log.output(
-                        "system",
-                        &format!(
-                            "{0:1$} start at pid: {2}",
-                            &proc.lock().unwrap().name,
-                            padding,
-                            &child_id
-                        ),
-                    );
-
-                    procs.lock().unwrap().push(proc);
-                    barrier.wait();
+impl Process {
+    pub fn new(
+        process_name: String,
+        cmd: String,
+        env_path: PathBuf,
+        port: Option<String>,
+        concurrency_index: usize,
+        index: usize,
+        opts: Option<DisplayOpts>,
+    ) -> Self {
+        let mut read_env = read_env(env_path.clone()).expect("failed read .env");
+        read_env.insert(
+            String::from("PORT"),
+            port_for(env_path, port, index, concurrency_index),
+        );
+        read_env.insert(
+            String::from("PS"),
+            ps_for(process_name.clone(), concurrency_index + 1),
+        );
+        let shell = os_env::var("SHELL").expect("$SHELL is not set");
+
+        Process {
+            index,
+            name: ps_for(process_name, concurrency_index + 1),
+            child: Command::new(shell)
+                .arg("-c")
+                .arg(cmd)
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .envs(read_env)
+                .spawn()
+                .expect("failed execute command"),
+            opts,
+        }
+    }
+}
 
-                    output.handle_output(&proc2);
-                })
-                .expect("failed exec and output");
-            result
-        },
-    )
+// https://stackoverflow.com/questions/34439977/lifetime-of-variables-passed-to-a-new-thread
+pub fn build_exec_and_output_thread<F>(yielder: F) -> JoinHandle<()>
+where
+    F: FnOnce() + Sync + Send + 'static,
+{
+    thread::Builder::new()
+        .name(String::from("handle exec and output"))
+        .spawn(move || {
+            yielder();
+        })
+        .expect("failed exec and output")
 }
 
-pub fn check_for_child_termination_thread(
+pub fn build_check_for_child_termination_thread(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) -> JoinHandle<()> {
-    let result = thread::Builder::new()
+    thread::Builder::new()
         .name(String::from(format!("check child terminated")))
         .spawn(move || {
             loop {
                 // Waiting for the end of any one child process
                 let procs2 = Arc::clone(&procs);
                 let procs3 = Arc::clone(&procs);
-                if let Some((_, code)) = check_for_child_termination(procs2, padding, is_timestamp)
-                {
-                    signal::kill_children(procs3, padding, Signal::SIGTERM, code, is_timestamp)
+                if let Some((_, code)) = check_for_child_termination(procs2, opts.clone()) {
+                    signal::kill_children(procs3, Signal::SIGTERM, code, opts.clone())
                 }
             }
         })
-        .expect("failed check child terminated");
-
-    result
+        .expect("failed check child terminated")
 }
 
 pub fn check_for_child_termination(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) -> Option<(Pid, i32)> {
+    let child_termination_fn = Box::new(move |pid: Pid, message: &str| {
+        procs.lock().unwrap().retain(|p| {
+            let child_id = p.lock().unwrap().child.id() as i32;
+            if Pid::from_raw(child_id) == pid {
+                let proc = p.lock().unwrap();
+                let proc_name = &proc.name;
+                let proc_index = proc.index;
+                log::output(
+                    &proc_name,
+                    &message,
+                    Some(proc_index),
+                    &LogOpt {
+                        is_color: true,
+                        padding: opts.padding,
+                        is_timestamp: opts.is_timestamp,
+                    },
+                );
+            }
+            Pid::from_raw(child_id) != pid
+        });
+    });
+
     // Waiting for the end of any one child process
     match nix::sys::wait::waitpid(
         Pid::from_raw(-1),
@@ -120,47 +123,11 @@ pub fn check_for_child_termination(
     ) {
         Ok(exit_status) => match exit_status {
             WaitStatus::Exited(pid, code) => {
-                procs.lock().unwrap().retain(|p| {
-                    let child_id = p.lock().unwrap().child.id() as i32;
-                    if Pid::from_raw(child_id) == pid {
-                        let proc = p.lock().unwrap();
-                        let proc_name = &proc.name;
-                        let proc_index = proc.index;
-                        log::output(
-                            &proc_name,
-                            &format!("exited with code {}", code),
-                            padding,
-                            Some(proc_index),
-                            &LogOpt {
-                                is_color: true,
-                                is_timestamp,
-                            },
-                        );
-                    }
-                    Pid::from_raw(child_id) != pid
-                });
+                child_termination_fn(pid, &format!("exited with code {}", code));
                 return Some((pid, code));
             }
             WaitStatus::Signaled(pid, signal, _) => {
-                procs.lock().unwrap().retain(|p| {
-                    let child_id = p.lock().unwrap().child.id() as i32;
-                    if Pid::from_raw(child_id) == pid {
-                        let proc = p.lock().unwrap();
-                        let proc_name = &proc.name;
-                        let proc_index = proc.index;
-                        log::output(
-                            &proc_name,
-                            &format!("terminated by {}", signal.as_str()),
-                            padding,
-                            Some(proc_index),
-                            &LogOpt {
-                                is_color: true,
-                                is_timestamp,
-                            },
-                        );
-                    }
-                    Pid::from_raw(child_id) != pid
-                });
+                child_termination_fn(pid, &format!("terminated by {}", signal.as_str()));
                 return None;
             }
             _ => return None,
@@ -211,36 +178,10 @@ fn base_port(env_path: PathBuf, port: Option<String>) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use anyhow;
-    use std::sync::Barrier;
-
-    #[test]
-    fn test_each_handle_exec_and_output() -> anyhow::Result<()> {
-        let procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>> = Arc::new(Mutex::new(vec![]));
-        let procs2 = Arc::clone(&procs);
-
-        let padding = 10;
-        let barrier = Arc::new(Barrier::new(1));
-        let output = Arc::new(output::Output::new(0, padding, true));
-
-        let each_fn_thread = each_handle_exec_and_output(procs2, padding, barrier, output);
-        each_fn_thread(
-            String::from("each_handle_exec_and_output"),
-            0,
-            String::from("./test/fixtures/for.sh"),
-            PathBuf::from("./test/fixtures/.env"),
-            None,
-            1,
-        )
-        .join()
-        .expect("failed join each thread");
-
-        Ok(())
-    }
 
     #[test]
     #[should_panic(expected = "exit 0: Any")]
-    fn test_check_for_child_termination_thread() {
+    fn test_build_check_for_child_termination_thread() {
         let procs = Arc::new(Mutex::new(vec![
             Arc::new(Mutex::new(Process {
                 index: 0,
@@ -248,6 +189,7 @@ mod tests {
                 child: Command::new("./test/fixtures/exit_0.sh")
                     .spawn()
                     .expect("failed execute check_for_child_termination_thread-1"),
+                opts: None,
             })),
             Arc::new(Mutex::new(Process {
                 index: 1,
@@ -255,13 +197,20 @@ mod tests {
                 child: Command::new("./test/fixtures/exit_1.sh")
                     .spawn()
                     .expect("failed execute check_for_child_termination_thread-2"),
+                opts: None,
             })),
         ]));
         let procs2 = Arc::clone(&procs);
         let padding = 10;
 
-        check_for_child_termination_thread(procs2, padding, true)
-            .join()
-            .expect("exit 0");
+        build_check_for_child_termination_thread(
+            procs2,
+            DisplayOpts {
+                padding,
+                is_timestamp: true,
+            },
+        )
+        .join()
+        .expect("exit 0");
     }
 }
diff --git a/src/signal.rs b/src/signal.rs
index 296fad0..6793050 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -1,27 +1,26 @@
 use crate::log::{self, LogOpt};
+use crate::opt::DisplayOpts;
 use crate::process::{self, Process};
+
 use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
 use signal_hook::{iterator::Signals, SIGALRM, SIGHUP, SIGINT, SIGTERM};
-
-#[cfg(not(test))]
-use std::process::exit;
-
 use std::sync::{Arc, Mutex};
 use std::thread::{self, sleep, JoinHandle};
 use std::time::{Duration, Instant};
 
+#[cfg(not(test))]
+use std::process::exit;
+
 pub fn handle_signal_thread(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
     timeout: u64,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) -> JoinHandle<()> {
     let result = thread::Builder::new()
         .name(String::from("handling signal"))
         .spawn(move || {
-            trap_signal_at_multithred(procs, padding, timeout, is_timestamp)
-                .expect("failed trap signals")
+            trap_signal_at_multithred(procs, timeout, opts).expect("failed trap signals")
         })
         .expect("failed handle signals");
 
@@ -30,9 +29,8 @@ pub fn handle_signal_thread(
 
 fn trap_signal_at_multithred(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
     timeout: u64,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let signals = Signals::new(&[SIGALRM, SIGHUP, SIGINT, SIGTERM])?;
 
@@ -43,34 +41,35 @@ fn trap_signal_at_multithred(
                 log::output(
                     "system",
                     "SIGINT received, starting shutdown",
-                    padding - 2,
                     None,
                     &LogOpt {
                         is_color: false,
-                        is_timestamp,
+                        padding: opts.padding - 2,
+                        is_timestamp: opts.is_timestamp,
                     },
                 );
 
                 log::output(
                     "system",
                     "sending SIGTERM to all processes",
-                    padding,
                     None,
                     &LogOpt {
                         is_color: false,
-                        is_timestamp,
+                        padding: opts.padding,
+                        is_timestamp: opts.is_timestamp,
                     },
                 );
-                terminate_gracefully(procs, padding, Signal::SIGTERM, 1, timeout, is_timestamp);
+
+                terminate_gracefully(procs, Signal::SIGTERM, 1, timeout, opts.clone());
 
                 log::output(
                     "system",
                     "exit 0",
-                    padding,
                     None,
                     &LogOpt {
                         is_color: false,
-                        is_timestamp,
+                        padding: opts.padding,
+                        is_timestamp: opts.is_timestamp,
                     },
                 );
                 #[cfg(not(test))]
@@ -87,14 +86,13 @@ fn trap_signal_at_multithred(
 
 pub fn terminate_gracefully(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
     signal: Signal,
     code: i32,
     timeout: u64,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) {
     let procs2 = Arc::clone(&procs);
-    kill_children(procs, padding, signal, code, is_timestamp);
+    kill_children(procs, signal, code, opts.clone());
 
     // Wait for all children to stop or until the time comes to kill them all
     let start_time = Instant::now();
@@ -104,7 +102,7 @@ pub fn terminate_gracefully(
         }
 
         let procs3 = Arc::clone(&procs2);
-        process::check_for_child_termination(procs3, padding, is_timestamp);
+        process::check_for_child_termination(procs3, opts.clone());
 
         // Sleep for a moment and do not blow up if more signals are coming our way
         sleep(Duration::from_millis(100));
@@ -114,22 +112,22 @@ pub fn terminate_gracefully(
     log::output(
         "system",
         "sending SIGKILL to all processes",
-        padding,
         None,
         &LogOpt {
             is_color: false,
-            is_timestamp,
+            padding: opts.padding,
+            is_timestamp: opts.is_timestamp,
         },
     );
-    kill_children(procs2, padding, Signal::SIGKILL, 0, is_timestamp);
+
+    kill_children(procs2, Signal::SIGKILL, 0, opts);
 }
 
 pub fn kill_children(
     procs: Arc<Mutex<Vec<Arc<Mutex<Process>>>>>,
-    padding: usize,
     signal: Signal,
     _code: i32,
-    is_timestamp: bool,
+    opts: DisplayOpts,
 ) {
     for proc in procs.lock().unwrap().iter() {
         let proc = proc.lock().unwrap();
@@ -140,15 +138,15 @@ pub fn kill_children(
             &format!(
                 "sending {3} for {0:1$} at pid {2}",
                 &proc.name,
-                padding,
+                opts.padding,
                 &child.id(),
                 Signal::as_str(signal),
             ),
-            padding,
             None,
             &LogOpt {
                 is_color: false,
-                is_timestamp,
+                padding: opts.padding,
+                is_timestamp: opts.is_timestamp,
             },
         );
 
@@ -156,20 +154,21 @@ pub fn kill_children(
             log::error(
                 "system",
                 &e,
-                Some(padding),
+                true,
                 &LogOpt {
                     is_color: false,
-                    is_timestamp,
+                    padding: opts.padding,
+                    is_timestamp: opts.is_timestamp,
                 },
             );
             log::output(
                 "system",
                 &format!("exit {}", _code),
-                padding,
                 None,
                 &LogOpt {
                     is_color: false,
-                    is_timestamp,
+                    padding: opts.padding,
+                    is_timestamp: opts.is_timestamp,
                 },
             );
             // https://www.reddit.com/r/rust/comments/emz456/testing_whether_functions_exit/
@@ -207,6 +206,7 @@ mod tests {
                     .arg("trap_signal_at_multithred_1")
                     .spawn()
                     .expect("failed execute test-app-1"),
+                opts: None,
             })),
             Arc::new(Mutex::new(Process {
                 index: 1,
@@ -215,13 +215,21 @@ mod tests {
                     .arg("trap_signal_at_multithred_2")
                     .spawn()
                     .expect("failed execute test-app-2"),
+                opts: None,
             })),
         ]));
 
         let procs2 = Arc::clone(&procs);
         let thread_trap_signal = thread::spawn(move || {
-            trap_signal_at_multithred(procs2, 10, 5, true)
-                .expect("failed trap_signal_at_multithred")
+            trap_signal_at_multithred(
+                procs2,
+                5,
+                DisplayOpts {
+                    padding: 10,
+                    is_timestamp: true,
+                },
+            )
+            .expect("failed trap_signal_at_multithred")
         });
 
         let thread_send_sigint = thread::spawn(move || {