sustainablepace / humbledev

The Humble Developer

The humble developer

A journal of things learnt along the way.

Installation

Because I always forget.

Webserver

First, install php5 and apache2 via sudo apt-get install php5. Then enable Apache's rewrite module via sudo a2enmod rewrite.

Create a virtual host configuration file 001-humbledev.conf in Apache, typically at /etc/apache2/sites-available/, with the following content

<VirtualHost *:80>
        ServerName humbledev

        ServerAdmin [email protected]
        DocumentRoot /home/christoph/projects/humbledev

        <Directory /home/christoph/projects/humbledev/>
        	Options Indexes FollowSymLinks
	        AllowOverride All
        	Require all granted
        </Directory>

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

The setting AllowOverride All allows the .htaccess settings to override the global settings.

Add the configuration to Apache

sudo a2ensite 001-humbledev.conf

and reload the service

sudo service apache2 reload

Add the server name to your hosts file

sudo vim /etc/hosts

like this

127.0.0.1	localhost humbledev

License

create a new file keys.php in the folder site/config, with the following content

<?php
define( 'KIRBY_LICENSE', 'YOUR_LICENSE_KEY' );
?>

and add your own license key. The file is in .gitignore so it is not visible in Github.

humbledev's Issues

Question about package structure and hexagonal architecture

Great series of articles on DDD. I've really enjoyed it.

I still have some dilemmas around some of the architectural elements.

1. What is your approach for structuring projects using hexagonal architecture (gradle modules and package layout)?

2. We usually have many bounded contexts within a single app. Should we:
   2.1. Introduce hard boundaries between bounded contexts, each bounded context having its own maven/gradle module with application/domain packages. Each of the bounded contexts would have a separate infrastructure module implementing rest/persistence.
   2.2. Have a single maven/gradle module structured using package by feature where each of the features would have application/domain packages. Infrastructure would reside in a separate maven/gradle module one module for rest-api and another one for persistence.
   2.3. For both 2.1 and 2.2 we need a combiner module that would package modules like a lego.

The following is my current understanding of the hexagonal architecture:

1. Application
	1. UseCase interface 
	2. UseCase implementation 
		1. Use repository interface from the domain
	3. Command objects are self-validating 
2. Domain
	1. Entities
		1. Self-validating
	2. SPI
		1. Output Port - Repository interface
3. Infrastructure
	1. Adapters
		1. Rest
			1. Includes application module
			2. Spring Controllers
				1. DTO Validation
				2. Create command and invoke use case
		2. Persistence
			1. Includes domain module
			2. Implement repository using JDBI
4. Bootstrap
	1. SpringBootApplication launcher
	2. Maven project includes modules
	3. Load Application/Domain services into the Spring context by scanning @DomainService annotations.