1. “When quality is critical"

2. Professional development and modification of Android and iOS
What do we do?
Professional development and modification of Android and iOS
Mobile apps

3. A comprehensive service
From YOUR IDEA to Google Play / App Store

4. What services do we offer?
Android and iOS app development – idea, wireframe, UI/UX design, architecture, code
Wireframes and prototypes of mobile applications
Backend CRM/CMSs and RESTful APIs for mobile applications
Design and color themes for mobile apps
Redesign mobile apps
Adding new features to existing mobile apps
Refactoring source code / Paying technical debt
All kinds of testing of mobile apps (manual and automated)
Bugfixing in timely fashion
Creating documentation, user guides and technical guides for mobile apps
Monthly support for mobile apps
User behavior tracking and analysis for mobile apps

5. How does the development process go?
Discussion and research on your idea or planned changes on an existing project
Planning, scheduling and estimating the process
Creating a prototype/wireframe of your app
UI/UX Design – the user interface
Writing specs and modeling the architecture of the app
Adding module-based features, like plug-ins
App getting tested by highly qualified professional QA Testers
Bugfixing
Releasing the app to Google play store / App Store
Warranty period

6. What technologies we use?
Clean Code
Clean Architecture
Model-View-Presenter
Domain-Driven Development
Design Patterns
Keep it simple, stupid
Test-Driven Development

7. What is the difference between Clean Code and Legacy Code ?
Time spent implementing new functionality
Time spent implementing new functionality
Probability of breaking existing functionality
Probability of breaking existing functionality
Places in the code that need to be worked on when implementing new features

8. Clean Architecture

9. The way we implement the app core
Domain-Driven Design
The way we implement the app core

10. Model-View-Presenter

11. SOLID PRINCIPLEs SINGLE RESPONSIBILITY PRINCIPLE OPEN-CLOSED PRINCIPLE
LISKOV SUBSTITUTION PRINCIPLE
INTEGRATION SEGREGATION PRINCIPLE
DEPENDENCY INVERSION PRINCIPLE

12. Design Patterns
This is a group of frequently used patterns of resolving similar problems that have emerged time and time again, until they became wildly popular and recognized. Grouping them as design patterns was a successful attempt for a more uniform way of programming, universally known and accepted, to be achieved.

13. Unit and Integration testing
Unit testing is the process of exercising code through other code, whose sole purpose it to pass arguments or create situations for our production code, and examine the results in order to verify its proper functioning.
Integration testing is exercising the interactions between separate modules in the application. A module is placed in a situation or under a circumstance that calls for some action, and we examine if it calls the right action on another module
Very few developers do unit and integration testing and even fewer do it right, but when done right it can bring tremendous value and saved hours, thus saved money for you

14. Keep it simple, stupid!!!
Most of the technologies we use can create a huge mess in the hands of an unexperienced developer, so we always remember the Keep it simple, stupid (KISS) principle! We don’t prematurely add very advanced techniques and optimizations when something much simpler will do.

15. Test-Driven Development
The benefits of Test-Driven Development
When writing our tests first:
the code we produce in order to satisfy them, is much more testable, which is a given with TDD, and it has been better decoupled, using better architecture
you are thinking about the way an outside user of the classes you write, will use them, so we create those classes with much more conveyed intent, more readable, well arranged and understandable
 we are required to write them and there is no way around it, and we don’t have to write them after the code. This way you avoid forcing yourself to write tests just to pass the requirement and basically write the happy path tests after the fact, which aren’t very useful and are annoying to write.
something in your code breaks, you are a couple of editor steps away from the last working state of the code. A minute ago everything was working, so we know the bug introduced must have been in the last couple of tweaks you introduced. That way we can eliminate bugs on the spot and not worry about breaking the code while refactoring it. The amount of long hours spent in debugging is almost eliminated.

16. “Quality is critical" Why do we so many technologies?
By now you could be asking yourself:
Why do we so many technologies?
The answer is:
“Quality is critical"

17. Contact us: If you think you could use our help: Phone:
Contact us:
Skype: Appopeia App Development