Scala is starting to be really popular, and there are many reasons why you might like to use it in your current projects. At akquinet we’re now using Scala inside Java applications to reduce the amount of written code and to benefit from Scala’s flexibility. However, integrating Java and Scala in the same application requires some tricks. Using Java classes in Scala is pretty straightforward; however, using Scala classes in Java is not.
Scala has several language features which cannot be directly mapped to Java, for example function types and traits. Here we will describe how these language features are compiled to Java byte code and how to access them from Java afterwards.
When building applications for specific domains, we often face a more and more important issue: how do I build the runtime required by the application? For enterprise applications, JEE application servers provide a technical stack containing all required services, but for desktop applications, or communication gateways there are no all-in-one solutions. Indeed, the runtime must fit to the environment and application requirements, making it complex to achieve in a flexible way.
akquinet launched the OW2 Chameleon project in 2009. Chameleon provides a way to build OSGi-based runtimes including the required services and your application. This article explains the motivations behind Chameleon and how Chameleon makes our software development more flexible, robust and efficient.
Maven is a great build tool that has already proven its benefits. But sometimes, you need an extension for a custom task or need. Luckily, Maven is extensible and allows you to write plugins.
Now, when implementing a Maven plugin, you generally want to test it as well. If possible, we want do do that automatically. Those tests then run on your continuous integration server and you’re notified when, unfortunately, you (or someone else) broke something. Automatic Maven Plugin tests can be done with different approaches. This post focuses on a strategy suitable for integration tests.
Android applications can grow very quickly. As they are composed of components (Activities, Services and Content Providers), it should be easy to extend an existing application to create new applications by just reusing already developed components. Recently, the akquinet Mobile Team had to develop several versions of the same application with a different set of features. This might sound easy, but Android does not really support such kind of modular development. Indeed, we faced several issues coming from the Android development model.
This blog post explains the encountered issues and how we fixed them by using rindirect. This tool allows, inside an Android application, to integrate components defined in other Android applications. This reuse pattern is close to impossible to achieve without rindirect or implies major limitations. Rindirect is developed by akquinet and is now available as open-source. This tools is well suited for Maven-based development, and so, works pretty well alongside the maven-android plugin.
Despite of not being in widespread use in the Android world, Apache Maven is a great tool to develop Android applications. Maven has a lot of advantages relevant for Android application development:
- It can be integrated on a continuous integration server, allowing continuous testing and nightly-build delivery
- It provides a strict release process avoiding errors and inconsistencies. The resulting APK are ‘marketplace-ready’
- It also provides a common way to build and package the applications
- It supports modular-development allowing the integration of classes and resources from others projects
This post explores how to quickly start developing Android applications using Maven. It presents three archetypes allowing getting a running application in less than 2 minutes!
Developing sophisticated Android applications is challenging. Despite tools provided with the SDK and the recommended ADT Eclipse Plugin, maintaining and developing an Android application is time-consuming.
This blog post introduces a series on the rationalization of Android application development. It aims to explain how the akquinet mobile team have changed the way to create Android applications to improve the efficiency and quality of the developed applications. This series covers several topics, from the utilization of Apache Maven, the integration with a continuous integration server to the customization of the logging framework.
akquinet has participated in the improvement of all the tools used and presented in this series and has also released several internally developed components as open-source projects.
The last post of this series has introduced a couple of useful options to manage built modules in a multi-module project. This post focuses on failure. Maven proposes three different way to manage failures in reactor builds: fail-fast (default), fail-at-end and fail-never which will be described in this post.
The last post of this series introduced you to a couple of useful options to manage dependencies in maven. In this post, we’ll focus on multi-module builds — a.k.a., reactor builds. Starting with version 2.1, Maven provides a couple of very interesting options allowing to avoid re-building all modules after a small change. This can save a lot of waiting for the build to complete and is what this post is all about.
This post is the first post of a Maven-related series. It focuses on the Maven command line that can do a lot more than just mvn clean install. This first post explores the options to configure the dependency resolution like using another local repository, forcing updates, and working offline.