Category: Material Design

From Nice To Astonishing

I was in Paris two weeks ago for the 2015 edition of the Droidcon Paris. As usual, I’ve met great people and assisted to some very nice conferences.

I also had the opportunity to present a new talk, focused on app design. Mainly inspired by the great book About Face by Alan Cooper, it’s full of advices about how to make your app even better.

Slides are available on Slideshare, so enjoy, and make your apps astonishing!

Building the astonishing: useful Android libraries for developers

When you’re developing an Android app, you can of course build everything from scratch, or use some of the thousands available open-source libraries. It’ll save you a lot of time, and often let you use complex UI animations, components, or algorithms, which you wouldn’t be able to code from scratch (or not without a lot of time). I even know some people who’d like to use nothing but libraries to build their app.

Since I’ve used a lot of libraries for Astonishing Comic Reader, I’ve decided to write this article, and talk about some of the most useful ones.


Support libraries

First of all, I’d like to quickly talk about support libraries. There are a lot of them out there, and even if new releases often come with bugs (especially Appcompat, or the brand new design support library), you have to use (some of) them. Even if you don’t require an API level 4 support, the support v4 library contains very useful stuff like fragments or retro-compatible animations. Just take a look at the revisions list.



Android annotations

Android annotations (AA) is one of my favorite Android libraries since I’ve started to develop on this platform. It simplifies your code by generating a lot of boilerplate code, like views injection, background threads, intents building, custom views, preferences, Rest API calls… Well, it does it almost all. Just take a look at the official cookbook, you’ll see what I mean.

AA actually generates subclasses from annotations, where all the code you don’t want to write is. For example, if you want to use AA on a specific activity class called MyActivity, you’re using annotations like @EActivity (to declare that your class will use AA annotations) and @ViewById (to avoid the boring findViewById). At compilation, a class called MyActivity_ (notice the “_” symbol) is generated. This is this class that you’ll declare in your manifest, and use to build intents.

AA really makes your life easier, on a lot of things. Maybe too much things, and that’s one of its flaws. It quickly creates a very strong dependency between your code and the library, and removing it might be a pain. But if you want to replace all these features with other libraries, you can start with things like Dagger and Butterknife.

The other major flaw is that it creates a lot of new subclasses (actually, one per annotated classes). Then, it almost doubles the number of methods in your code, which might dramatically lead you to the unpopular multidex error. Keep it in mind if you want to use it.


Square one

Square is an American company specialized in mobile payments. But their talented developers have developed some of the most popular Android libraries, including Otto, Dagger, Retrofit, Picasso… I’ll talk about some of them here, but you can check the complete list here.



Otto is an event bus library. Basically, it allows you to send messages across the different components of your application. And trust me, that’s sometimes very, very useful. You can for example send objects from a fragment to another or notify an activity from a custom view. It’s not a must-have in all your projects, and you should be careful about overusing it.

In ACR, I use Otto to synchronize the zoom level between the pager’s page, or to notify the view that suggestions have been loaded. You can also use it to send events about network operations, or database data retrieving.

There is a very good alternative to Otto called EventBus. I’m not very fond of it, but it has some very convenient features, like managing events trough inheritance, which Otto doesn’t.



Retrofit is a REST client library for Android which clearly eases your work with web services.

The only things you have to do is to declare an interface, containing all your API endpoints (annotated with things like @GET or @Query), and use this interface to declare a RestAdapter and a service class, which is basically your interface implementation.

What I like with Retrofit is that it’s very, very easy to use, and it’ll clearly change your life. It allows you to simply declare your endpoints, or customize them with annotations. It automatically parses you results using Gson, but you can use a custom converter if you want (XML parser for example). Easy setup, great default behaviour, and advanced customization if needed. What else?



I’ll probably write another article about image libraries, since image processing is at the core of ACR, but I got to talk about Picasso. Yes, it’s another library by Square, designed to ease image downloading and manipulation. The goal is to let developers easily display images from the Internet, and automatically handle things like cache, network failures, placeholders etc.

I’ve seen on a Google + poll that a lot of developers don’t use any library to manage images. If you don’t, do it. Right now.  Even if you’ve your own library for that. If you don’t want Picasso, you can pick something like Universal Image Loader, Glide or even Fresco. Each of these libraries have been developed, tested and improved by thousands of fellow developers. And they clearly ease your life!


JSON processing

JSON processing is nowadays a very easy task in most cases. You probably all know Gson, the Google library to parse JSON. There are alternatives like Jackson, or the new player in town: Moshi (also by Square).


Finding new libraries

Finding new Android libraries is easy: just use Google. But if you want to do it the right way, there are a lot of websites out there which are referencing new libraries each day. My favorite one is Android arsenal, but you can also visit AndroidLibs or directly test libraries on your mobile with Libraries for developers.


Holo to material design – Devoxx France 2015

I was this week at Devoxx France. Apart of the amazing conferences, I was myself doing an updated talk about Material Design. Since the Droidcon Paris (where I first did this presentation), a lot of libraries have been created to achieve various parts of the design specifications, and many apps have adopted this new approach.

I’ll update this article when the video will be available on Parleys. You can however get the slides on Slideshare:



Why you have to care: design for developers

I’m a developer. I love to learn new languages, implement algorithms and debate about which framework is the best. And if you’re reading this, you’re probably like me. But most developers use that as an excuse when it comes to design.

Have you seen all these softwares, websites, mobile apps, with poor design and user experience? You see what I mean, right? For the purpose of the demonstration, let’s take a fake example: an Android app we will call AwesomeApp (how original).

AwesomeApp has great features, but it’s so hard to use that it drives the user crazy. There is too much content on screen, loading times take ages, colors are poorly chosen… Well, an app designed by developers. Of course, developers are not designers, that’s not their job. But does that mean you have to create ugly and/or not ergonomic things? From my experience, here are what the creators of AwesomeApp would probably tell you about their app design:

  • We don’t care about design for now, we focus on features. Design will come later (actually never)
  • Our design is awesome. Look, it looks like computers in Matrix, that’s so cool (Matrix is rarely a good source of inspiration for an app design)
  • We’re not designers, we don’t know anything about that weird, black magic stuff (aka “I don’t have a Photoshop license”)
  • All our developers love our iOS design applied on Android with adaptations (which means “We keep our dev team silent, it’s better for the management team mental health”)
  • Oh you’re right, our design is ugly, we’ll improve it later (you’ll probably die before a design update comes)


When you create something, you want to offer a nice user experience. You want to create a pleasant and beautiful stuff. That’s a primary goal when you conceive something.

During many years, one of my best friends was telling me, each time I showed him a new project, “Your design looks awful”. My reply was “That’s the best I can do, I’m not a designer”. Well, this excuse was wrong. After a time I’ve started to care about design, and slowly, I’ve acquired some basic notions I can use every day at work.

Through years, I’ve learned how to use colors, when to apply margins, how to choose the size for a button… There are definitely a lot of things to learn. It’s a complete and different job, and for developers, it’s a whole brand new world. But the first thing you have to learn is to care. Care about your app (or software, or whatever product) design. Care about the final user experience. And start to care from the very beginning. Design is not a coat of paint applied at the end of the development (even if it’s a really popular trend in France).

Hello Roboto!

It has been a year since I published my last article. My blog, over the years, has becomed a mix of articles about Silverlight, Windows Phone, XNA, HTML5, and then Android, design… That’s why I’ve decided to start from scratch a brand new blog, mainly focusing on Android technologies and design. I’ll still write some articles about web technologies, because, well, it’s awesome!

Of course, you can still read the articles of the old blog using its new address:

By the way, have you noticed this nice template? It’s called MaterialWP, and it’s really nice. Take a look at it here.