ePages developers from all company locations convened in Hamburg to spend an amazing time together on software development topics! It was all about interesting lectures and workshops, healthy discussions and knowledge transfer among different teams of the Research & Development department.
Curtains up for these fantastic topics:
Spotlight: ePages software architecture
Team Black started the R&D Day presenting their approach on a new software architecture that should be the technical foundation for ePages in the years to come.
The following principles drive the teams’ work:
- support development on the product in teams distributed across epages locations
- create an architecture that is easy to change and to maintain
- focus on the Java ecosystem.
Each software development team should be able to independently deliver a piece of software that is ready for production deployment. In addition, it should be possible to quickly change parts of the system without creating side effects. In order to achieve that, they split up the product in business domains, where each domain is implemented in a vertical that:
- represents a deployable unit
- is exclusively responsible for its functionality
- owns its data
- provides REST API to leverage access to its functions
- communicates with other verticals only by using REST-based interfaces or events
- its micro-architecture needs to follow some high-level guidelines to ensure it is operational within the macro-architecture.
Spotlight: App & Theme Store
Team Red presented the architecture of the App & Theme Store. The Store allows merchants to customise the design of their shop with certain themes. Furthermore, they can add additional functionalities to their shop by installing apps developed by external developers using the ePages APIs.
They explained the different app types, the store currently supports:
- REST apps that use the ePages REST API
- Themes and Affiliates
The challenge was to provide an architecture which not only allows external developers to develop and submit their app easily, but also to provide an administration tool for the product management which allows them to distribute the apps to the different providers.
Despite the brief time frame of the session and the complexity of the architecture, Team Red succeeded and presented, in an understandable way, several diagrams and live demos of the different App Store use cases:
- Developers point of view: How an app developer can submit an app
- Product Management’s point of view: How PM is able to review an app and manage apps for the different shop types
- Merchants point of view: How to install and uninstall an app in the merchant’s administration area.
Spotlight: New Storefront
Team Unity shared insights on the new storefront and editor. They explained how they plan to integrate this into the existing ePages product using the ePages REST API.
Using node.js and akka, React and webpack they accomplished a cool and slick implementation.
Hands-on: Microservices
In this workshop, the participants gained first-hand experience of the new ePages architecture. They completed hands-on exercises illuminating common microservice patterns, like synchronous and asynchronous communication and persistence - and had fun building a microservice-based pizza bakery.
Spotlight: Automating Jenkins
Check out our blog post Infrastructure as code: automating Jenkins to find out more. Stay tuned for an upcoming update on this topic.
Spotlight: Test Automation
Ideally, new features and bug fixes are available on the live systems as soon as they are implemented and verified. In order to achieve that, there is a clear necessity for automated tests. For each application layer, specific test automation tools and techniques exist:
- the Presentation layer is what the user gets to see
- the Functionality layer represents the API of the system
- the Unit layer consists of the source code components.
Each of these approaches has advantages and disadvantages. That’s why it is important to know about those and then invest into a well-balanced test portfolio. The testing community came up with a metaphor which suggests how much emphasis should be laid on each test level: the Test Pyramid. Detailed reasons for this are described in the SWOT analysis for each respective test level. In short: if we focus too much on the UI test automation, we will run into problems with the test maintenance and the runtime of the tests. Our result: 70% Unit tests, 20% Integration tests, 10% UI tests.
Read further here in our blog post The ePages Selenium Framework.
Hands-on: Writing tests
In line with the Test Automation lecture, Team Ocean did a nice workshop session on writing tests. They dealt with:
- Differences between test types
- Why mocking is needed and how to do it
- How to structure code so that it can be tested
- How to use mock frameworks
- Best practices for testing.
Hands-on: How to use Docker
In this workshop we ran a client/server app using Docker, as described in our blog post Improving the development workflow with Docker. The participants learned about Docker CLI, Docker Compose, Docker Hub as well as the general software lifecycle and best practices when using Docker.
About the author
