Mobile app development versus back-end app development

One day I was listening interview with a person who was running software development courses, he was answering questions regarding the software development in different fields and what a full stack developer means. And since our Fitradar system covers several development fields I decided to share my experience about working in one or another field and how easy is to jump from one domain field to another one.

I remember back in a day when I was still a student at university several classes were focusing on business modeling and system implementation according the model. As later I found out this was a common approach for enterprise application design and development. But my first job related to software development was in the company that produced routers and its software. At that time I was writing small scripts to test different router configuration setups, I was not directly involved in router’s software development but I wanted to become a par of a development team. And so I started to explore the routers operating system which was based on Linux kernel as many other embedded systems. I soon discovered that many principles I learned in programming classes are not applied in embedded systems and instead big emphasize is put on performance. For example instead of throwing exceptions error codes were used to improve the performance. In mobile and enterprise applications that would be considered as a bad practice. Another odd thing for me was to see that there are no unit tests only integration or end to end tests, which again in enterprise application world would be considered very bad. And so at that moment it hit me that the way how one or the another system is developed depends from the domain field and not that much on the language. So for myself I distinguished following software development fields:

  • web front-end development
  • mobile application development
  • desktop application development
  • game development
  • embedded systems development
  • enterprise application development

This is by no means the full list of the domain fields where the software is developed. These are just areas I have come across in my developers career. There are many principles that cover all the fields and that is what every programming class starts with, like variables, loops, conditions, functions, but once we need to organize bigger code base the principles start to vary. In our Fitradar project we are developing two big applications: mobile application for Android and iOS and back-end system that gradually evolves in full scale enterprise application. The approaches in some parts of both systems are similar but some parts have quite different goals. So in this article I wanted to sum up the differences and common things approaching the mobile app and back-end app development in Fitradar solution. As mentioned earlier those differences really start to show up when the code base starts to become so big that you need some extra time to navigate within it. And if you don’t follow any code organization principles the time you will need to navigate around, understand and modify will grow proportionally and sometime even exponentially to the size of the code base. So for big systems we really need to organize our code. And almost all my previous articles about development were dedicated to the different approaches on how to better organize the code. The one thing I discover again and again is this – although it is important to know the principles like Object Oriented programming, SOLID and design patterns but just as important is to apply those principles only there where is needed. I remember one web project where front-end part was developed in Angular but back-end in ASP.NET MVC. Our team took over the project from the other company and had to continue to extend it with new features. When we worked with back-end part it was easy to understand and modify it because it followed well established enterprise application best practices. But we really struggled with front-end part because the code was organized according the same principles as in a back-end part and it looked like developers were ignoring many Angular built-in features and principles. And only later we found out that the developers who mainly worked with back-end designed the front-end application as well. This approach would have worked fine if the front end had been very simple application but it was so big that in order to organize the front-end code it required a knowledge of principles specific only to User Interface. And from my experience for a developer new in a domain field to start to produce decent design takes about a year and more, not counting the time needed to master the programming language itself. So therefore for big web application projects there are usually front-end and back-end developers. For smaller web applications the same knowledge about the programming might be enough. So let’s see where the focus in back-end and mobile application lays in:

  • as you can imagine even the simplest mobile app has an UI (there are some special background apps but we will not consider them here) and therefore the emphasize in mobile application in first place will be on the UI code organization and how to connect UI with the rest of the application. The UI will be the part of the system that takes the input from a user and displays the information to the user. From the other hand back-end interaction with the outside world will be via REST (or maybe GraphQL) web services where data is received and send in well formatted way. And formatting usually is done by back-end third party library. Since UI can be very complex then we need to consider principles, practices and patterns that are specific only to UI development. And that is where pure back-end developers lack the knowledge. And if no data is used then mobile app might be limited just to UI and for back-end developer that would mean that very little knowledge can be transferred from back-end development. But in case mobile application works with data stored either locally on mobile device or on a back-end server the extra layer of data persistence might be required.
  • Data layer development in mobile app and on the back-end might seem very similar. And indeed if we choose to store data on a mobile device we can chose database for this purpose and use the well known patterns like Repository and Data Access Object as we do on the back-end server, then it might give the impression that mobile app developer can develop this part of the system for both mobile and back-end application. But my experience shows that it is true only to some extent. On the mobile app data persistence layer always should be simple, because the hardware resources are very limited and it is unwise to build large scale database on the mobile device, instead data are transferred to back-end server and stored there. Database on mobile devices often is used as a cache store, where data are denormalized and structured purely for UI needs. On the other hand the back-end database design is a big thing where data normalization and performance is considered. And this time pure front-end developers might lack the knowledge of complex persistence layer design.
  • And when the system’s complexity grows more layers on the back-end start to emerge, like Domain layer and Event Bus. Inner details of Domain logic usually is something that people don’t want to expose to the outside world therefore it is implemented only on a back-end server. Domain logic implementation might require a lot of specific design patterns and practices. Which again only back-end developers might be aware of.

So at the end of the day we can still apply general software development knowledge across the domains as long as the code base stays small and simple. And that is why even high school student can produce decent software in any field as long as that peace of software is small. But once the system grows big particular domain expertise starts to become crucial, and that domain expert knowledge comes only over the years as a result of learning and practice.

Please visit our website: http://fitradar.me/ and join the mailing list! Our app is coming soon.

Repositories and Data Access Objects are still alive

In my previous articles when I was talking about Clean architecture and Domain Driven Design I mentioned one piece of domain layer – repository or more precisely repository pattern. The repository pattern is used to persist and retrieve domain models. Although repositories are mostly related to Domain Driven Design the other architectures might have the objects with the same functionality but are called different. In Fitradar application (front end and back end) the objects that are used to persist data in the database and fetch data from the database and map data to in-memory objects (aka POCO – Plain Old C# Object, POJO – Plain Old Java Object) and are not part of the Domain layer are called DAO (Data Access Objects). DAO usually are used in cases when no business logic is involved and the application needs to execute simple CRUD operation.

In Android application to work with database we use Room Persistence library but in our back-end solution we use Entity Framework Core. These two are know as Object-relational mappers or ORM. And today I wanted to explore the relationship between Domain Repositories, Data Access Objects and ORM and share some experience we had in our team working with these patterns and libraries.

If you look at the responsibilities of Repository, DAO and ORM they are very close to each other. Some years ago when ORM technology was in its inception the DAO and Repositories usually were working directly with the low level database access services. In case of .NET it was ADO.NET library and in case of Android it was SQLite library. And it was quite clear that DAO or Repository should use these libraries to persist or retrieve in-memory objects and map the data. But now-days when in application development main data access technology became ORM the border between ORM and DAO and Repository has become very blur, especially when one just switched to ORM. Working with ORM in different projects and languages our team came to conclusion that in same cases ORM can fully replace the DAO or Repository and can be used instead of it. Let’s look closer at the cases when it is appropriate to use just a ORM library and when the DAO or Repository should be used in combination with ORM:

  • If you need to save, update or delete single flat plain old object then in most cases ORM library will do the job for you. Of course EF Core and Room are capable of doing more, but then we really should investigate each case separately
  • If you need to fetch the data from single table by primary key then again in most cases you can fully relay on ORM
  • In case Domain layer aggregate has complex entity cluster hierarchy, where different entities might have different persistence state you most likely will need to write such aggregate persistence logic by yourself either using ORM or low level database access library. In our application one such aggregate is Sport Event that has Place and Organizer and some other entities. And the problem we faced when tried to save Sport Event by using built in EF Core capabilities was the different Entity State and the calculated state before Save operation. For example we had cases when we needed to create a Sport Event in Place that was not yet saved in database, and since both entities have the same Entity State EF Core tackled that case well and was able to create both entity records in database. But the problem started to appear when we wanted to create Sport Event in the Place that already had other Sport Events, now before saving aggregate Sport Event we had to fetch Place entity to make sure EF Core sets the correct Entity State. And the more entities your aggregate root has the more fetch operations might be needed. So in this case for us seemed obvious putting Entity State synchronization logic in separate Repository.
  • In case data query logic and following mapping logic is so complex that to make a code readable it is necessary to split logic in separate functions, you most likely will move those functions to separate class, Data Access Object, to persist the Single Responsibility principle.

As you can see the Repository and DAO still has their place in the modern software architecture. In case of queries in CQSR architecture query logic might be put in Application layer since anyway contrary to Commands, Queries only responsibility is data fetching, and that duplicates DAO responsibility. By choosing to put query logic in Application layer we make a direct dependency on EF Core. That is not a problem in classical three layer application, but it does not fit the Clean Architecture principle where Application layer should be aware only of Domain layer and with outer layers (EF Core belongs to the Infrastructure layer) communicates only through interfaces. In this case we should use DAO.

Please visit our website and join the mailing list. Our app is coming soon:

http://fitradar.me/

Clean architecture for our back-end

Today I want to continue discussing the architecture we came up with for our back-end service. In the previous article I brought up some arguments why it was important for us to separate read and write models. And the main thing that made it clear was that we operated with two different data sets for read and write operations. But I didn’t go much in to the details on how we arrived at such a different models. And this aspect of CQRS will be the topic of today’s article. Before we even realized we need to apply CQRS pattern in our design we decided to follow Uncle Bob’s Clean Architecture the same architecture we used in our mobile application development.

And the the reasoning that brought us to this architecture I lied down in one of my previous articles. Although on both platforms the overall architecture was the same but implementation details were quite different. The main attraction point of this architecture was possibility to build the server side application around the Domain Model and apply Domain Driven Development. There are several definitions for Domain Model and some of them you can find here but for us in the design process more important was to understand the peaces that constitute the Domain model. It allowed us in the next designing steps to decide whether we need a separate Domain model layer or entities were just enough. Quite often I notice that the architecture does not make a big difference between the bare bones domain entities and full domain model. In first case entities are just a database relational model, and they serve as in memory tables. In many cases especially in ASP.NET world (the framework we are using to build our back-end services) Object Relational Mappers like Entity Framework require to separate entities from the CRUD operations and thus giving impression that full-fledged Domain model is created, but in fact you end up with something what is called Anemic Domain model which is considered an anti-pattern. So following the advise of Eric J. Evans in his book Domain-Driven Design: Tackling Complexity in the Hart of Software we noted for ourselves following parts that should be presented in our Domain Model in order to consider it us a separate layer:

  • Entities accompanied with business methods
  • Value objects
  • Repositories
  • Aggregates
  • Bounded Context

By analyzing our model designed for Android or iOS platform and for our back-end platform we realized that only our back-end model meets Domain Model criteria and deserves a separate layer but in case of mobile phone platforms we ended up with simple entities that were the part of application or Use Cases layer.

By modeling entities we replicate real life entity attributes, like person’s name, surname or gender that are operated by methods encapsulated in the same entity or in service. At the end of the modeling process we come up with our business model that further can be converted to the Entity-Relationship model, that is used to build the database. In such way Domain model or plain entities are tightly bound to normalized ER model. And one can live only with one ER model until the moment when displayed information starts more and more deviate from the ER model and in order to fetch the data from database more complex queries are required. And this is the time when we started to consider CQRS. But now it was not clear how to integrate the CQRS in Clean Architecture layers and we turn to the mighty Google for someone’s else experience and we found this wonderful talk that showed us exactly what we were looking for and so we ended up by extending the application layer with commands and queries and adding separate Database context or our queries.

Please visit our website and join the mailing list. Our app is coming soon:

http://fitradar.me/

Study: fitness boosts brainpower in adults

Physical fitness has been associated with better brain structure and brain functioning in adults.

The findings of a study, led by Dr Jonathan Repple of the University Hospital Muenster in Germany, suggests that increasing fitness levels through exercise could result in improved cognitive ability – such as memory and problem solving – as well as improved structural changes in the brain.

A group of researchers led by Repple used a publicly available database of 1,200 MRI brain scans from the Human Connectome Project and combined it with physical testing to assess the subjects’ physical fitness. Each one’s cognitive ability was also measured. The researchers excluded subjects with pre-existing conditions, such as neurodevelopmental disorders, diabetes or high blood pressure.

The results of the study showed that physical endurance was positively associated with the global cognition scores of the subjects taking part.

In its conclusion, the group of researchers said the results of the study suggest that physical exercise could be used as a form of preventative healthcare.

“The observed pattern of results appears to support the notion of a beneficial effect of physical fitness on cognitive function,” the study reads.

“This notion is supported by the few available experimental studies indicating that physical exercise leads to increases in memory performance and brain structural integrity.

“This concept might be of relevance for a wide range of domains in health and life sciences including prevention, clinical care and neurobiological research.

“Along with previous findings, our findings point to the potential of physical fitness as a modifiable factor that might be applied as an intervention in prevention and clinical care.”

The report was simultaneously published in the Scientific Reports journal and presented at the ECNP Congress in Copenhagen, Denmark.

To read the study in full, click here.

Source: http://bit.ly/30Pqjy3

Please visit our website and join the mailing list. Our app is coming soon:

http://fitradar.me/

Keeping Write and Read operations separately

In this article I wanted to share our team experience on how we arrived at particular architecture on our back-end solution. On the back-end we wanted to work with technologies that our team is familiar with and had an experience with before but at the same time is not outdated and has a great potential in the near future. In our case it was ASP.NET Core framework. I am not going in to the endless discussion about what framework or language is the best, from my point of view it is useless since such a topic is very biased. And I already mentioned in one of my previous blogs that despite the fact that the software development supposed to be an exact science, and many aspects of it really is, the choice of language, frameworks and best practices many times is just a matter of personal preference – something that you feel more comfortable with and it doesn’t have any scientific justification. And when I will be laying down the arguments for the solution we came up with it will be presented from our team’s point of view and how it helped us to make a design and implementation more clear and easier to understand, which might not be the case for other teams.

ASP.NET Core comes comes with some prepacked architecture that satisfied our needs. For REST full Web API solution MVC is very suitable design pattern and gave us a good starting point. Dependency injection in turn allowed us easy start to write unit tests and mock dependencies. But the more complex solution became the more we saw that we need to extend our initial project with more general architecture, after all MVC is just an UI level design pattern. This wasn’t the first project in our team’s experience when we had to split application’s code in layers. Some years ago very common was 3 tier architecture:

Three tier Application

And we used this architecture quite a lot. In some projects we felt it suited our needs perfectly, but in some we had a feeling that we do some kind of workaround to fit the architecture. For some time I could not really even explain why those projects didn’t comply with the above architecture until the moment when I read about Command and Query Responsibility Segregation (CQRS) pattern. It was one of those aha moments when you discover what was really bothering you all this time. In the traditional 3 tier architecture the same data model and the same database is used for read and write operations. It works well when we need to display the same information we saved earlier. But the more complex application becomes the more a model we use to save data starts to deviate from a model we use to display data. For example most of the applications today require a user to create a profile or an account. Let’s say we save this information in table User and in order to do that we use an model with the same name. In case we want to see our account information we will fetch the data from the same table User. But this is only one use case where we are displaying the information about user. In real world applications information about user is displayed in many other pages together with other information, for example in e-store that would be information about product and product category, in blog that would be a post and so on. And in order to receive data suitable for a view complex queries with joins and sub-queries are used. And not only models for read and write operations are different but the requirements for those operations are different as well. In case of insert update and delete operations the database should be normalized that allows us to minimize duplicate data and avoid data modification issues. The database normalization usually results in more tables than initial design. The query operations on the other hand are focused more on performance, that can be improved by denormalizing tables. The beauty of CQRS is that it allows to separate the write and read flows by using different models and even different databases. In last case it would allow to scale the databases for read and write operations independently. And at some point of time this feature may become very crucial since write operations are significantly less that queries. As you can see there are several levels how far we can separate commands (insert, update, delete operations) from queries (read operations):

  • The lowest level of read and write operation separation is on Repository level – we are using the same Domain model for write operations and for display data in UI, but we have a separate method in Repository for querying database. In order to display only necessary data we have to introduce View model and map data from Domain model to View model.
  • Next level of CQRS maps View Models directly to database queries. There is no need for mapping between Domain model and View model anymore. On database level we still have normalized tables that correspond to Domain model. View models in this case correspond to queries that involves joins and sub queries.
  • The two above levels of separation sometimes are not regarded as real CQRS pattern but are known as CQS (Command Query Separation) pattern, therefore only the next level of separation when write and read operations are regarded as two separate workflows throughout an application is considered as CQRS pattern.
  • The final level of separation goes further even to the database layer, where each type of operations interact with its own database

In our back end API solution we decided to separate write and read operation on the application level and not to use a separate storage, but instead we are using SQL Views for queries. It allows us avoid data synchronization between the databases. But at the same time architecture is opened for further extension and possibility to add separate storage for queries. And so we ended up with following architecture:

Visit our website and join the mailing list. Our app is coming soon:

http://fitradar.me/