Architecture and framework selection

Selecting the right architecture and the frameworks to support it can be a challenging task. There are hundreds of frameworks in the Java ecosystem and many aspects have to be considered when picking one: adherence to the architecture, learning curve, performance, maintainability, documentation and community. Aestas has the experience to help you define the software architecture that will drive your next web-scale or integration project.

Version control best practices

Large, complex projects require that your team knows how to deal with Source control. We believe that every team should know its version control system inside out because it makes a difference on the long run. Aestas can teach your team how to establish a rigorous set of rules and practices to simplify and streamline your day by day version control interaction.

Continuous integration

One of the key principles of Aestas's software development best practices is: automation. If a machine can do it, let it do it. Continuous Integration (CI) is usually the first step in automating your software release process while ensuring quality and increasing visibility. We are big fan of Jenkins and Teamcity.

Code review process

The benefits of peer code reviews are just too many to list them all here. If you care about the quality of your code and the committment of your team, you should look at enabling a simple and effective code review process. We can help you to set it up, regardless if your team is sitting in one room or spread around 3 continents.

Architecture and framework selection

Some of the performance bottlenecks can be detected even without running the code, some may need extra logging settings in order to be detected, some may need advanced monitoring and live code profiling. We can apply all of those techniques and even more to your code to help you to identify performance problems.

JVM tuning

Java Virtual Machine is a complex ecosystem that can be adjusted in many different ways. Memory sizing parameters, garbage collection algorithm settings, pause intervals and generation volumes, JIT compiler options, thread-local area and call stack sizes etc.: tuning these settings is a complex process that tightly depends on application behavior and usage patterns. We have configured many production systems for optimal JVM performance and we can do it for you.

Application server tuning

Thread pools, database connections, JMS resources and other J2EE application server shared resources are vital for the application performance. Our expertise in the leading JEE application servers guarantees that your application will always run as fast as your hardware allows.

Post-mortem analysis

Your application may fail in the most spectacular ways. We have seen it all. Fortunately, when an application dies - if properly configured - it leaves quite a lot of traces behind. We are pretty good in doing this "forensics" work by looking at of thread dumps, heap memory dumps, "flight" recordings and garbage collector logs.

Setup and tuning of cache frameworks

Good performance of most real web applications can not be achieved without introducing a cache. Different types of data require different caching, expiration, partitioning, persistence and synchronisation strategies. As part of our services we help you setting up and configuring cache for your application data to improve overall performance.

Creation of automated realistic stress and load tests

It's midnight and you are late and tired. You decide to commit the new functionality the marketing department has been eagerly waiting for. No time to test. Next morning, the new functionality goes in production. Five minutes later your cell phone starts ringing. The site is performing poorly, users are complaining about time-outs. The latest deploy has to be rolled back. Production is unhappy, CEO is furious. To continuously control how fast your application performs, we can help you creating automated performance test suites that produce reports and provides you an immediate feedback of your application's pulse.

Making sense of metrics

Collecting metrics is among the most important things you want to do to figure out if your application is healthy. Metrics are very good factors to help predicting how an application will react under a peak load. Response time, transaction time, availability, throughput, error rate may have multiple interpretations. And depending on application type some of those metrics may be more valuable than the others. Let us show you how to collect, chart and make sense of these invaluable information.

Analysis of code maintainability

Total cost of ownership closely depends on how maintainable is your code. Also agile environment requires higher level of code readability and simpler structure that will allow faster adjustment to the changing world. As part of our services we perform in-depth code analysis for identifying potential maintainability problems.

Setting up and making sense of static code analysis reports

Static code analysis tools are often used in development process. The main problem with all of them is that they treat any code in the same way. Interpreting statistics provided in the reports according to the project requirements and detecting real problems with the code is one of our specialities.

Identifying framework misuse

There are plenty of Java-based frameworks (both commercial and open source) on the market that promise to make your life easier. But they are also rather easy to misuse. Also developers sometimes fall so much in love with one specific framework that they will use it for everything they can, but it might be not appropriate in all situations. We may perform an analysis to identify potential violations as well as to help you orienting in the variety of framework components that can be used for your particular software architecture.

Security risk assessment

Web applications may expose sensitive data to the public and this may not be obvious to find out where exactly the data security is violated. Our profound experience in secure application development allows us to identify potential security problems in your code.

Architecture verification and improvement advisory

Important software architecture decisions may be made quite early in the process of developing a software product. Breaking some of the rationale behind those decisions (especially for a large code base) may bring to unpredictable loss of time and resources, and bring the code into an unmaintainable state. We can help you to identify architecture violations and advice on architecture improvements.