Everyday at LumApps, we're working on our projects using advanced technologies. Technical choices are based on two major criteria. First of all, we always search the most efficient technologies to get the best results for our applications. Also, it's really important that we enjoy ourselves and many technologies were chosen especially for that.

Google Cloud Platform

With our first project in 2012, LumDocs, we were only 3 developers, and no one else. It was important for us to focus on the code and not be slowed by everything like the configuration of a server. We also wanted from the start to be able to manage lots of request easily.

Google App Engine gave us exactly that. The load and scaling is managed automatically in a Google way. We know they can handle loads of requests. The configuration is just a simple file telling what modules we want for the server. Everything else is just our code. With all this help from Google, we were able to ship the first version really fast, and iterate from it with our first client, Aperam. We manage to fully cover their needs, and later made the application available for everyone, after some redesign once we recruited our first UX designer, Matthias.

NoSQL

Using Google App Engine, we were pushed to use Google Datastore as it was the only database available on the Cloud Platform at the time. Now there is Cloud SQL, and with Compute Engine we can even use MongoDB or anything we want.
But we still use Datastore for most of our projects. The flexibility and speed of a NoSQL database is perfect for us. And even better, the Datastore is thought to manage countless of access in parallel.

In collaboration with the Memcache given directly by Google too, we can optimize the cost and performances of our application and still be able to handle all the users we have.

The only default was the limited search capabilities. But since Google added the Search Index, we have powered our applications by the famous Google Search.

Python

Python first appeared 24 years ago, in 1991. It might not be the youngest language out there, but it is really built for modern uses. It was designed by Guido van Rossum, "its actual benevolent dictator for life" (title given by the community, just meaning that he still manage the direction of Python).

The language is designed to be appealing, easy for scripting and powerful enough for big applications. It supports object-oriented and structural programming, but also functional and aspect-oriented. It uses dynamic typing, has a garbage collector since 2.0 and supports Unicode, which is really important for our multi-language applications. But more importantly, because it's one of my favorite feature, it has list, set and dict comprehension. Converting those has never been so easy!

Every one of those features, especially the list, set and dict comprehension, are core to the philosophy of the language (past from Wikipedia):

• Beautiful is better than ugly
• Explicit is better than implicit
• Simple is better than complex
• Complex is better than complicated
• Readability counts

And that philosophy is exactly why we chose to use Python. Even though we encourage our staff to comment the code, we all now that it's better to do something simple and readable instead of something complicated that only the one who wrote it can fully understand it at first glance. Working together as a team is important, and Python helps us a lot. You might need more lines for the simple version. And most of the time you can see your error even before testing it.

Bonus point, Guido van Rossum working for Google at the time (with half of his time assigned to just manage the Python community), Google has made this language its primary one. And we clearly see it working with the Cloud Platform, and when in contact with the Googlers working on it too. It helps a lot.

Javascript & AngularJS

In the web we all know today, it's impossible to avoid Javascript. At first we used Java & GWT, but the result was still only Javascript for the client. GWT was not satisfying for us.
We had a hard time optimizing the performance, working with the DOM was painful, and the compile time grew more and more. One day, after all this time lost, we decided to switch to full Javascript. One of the best decision we made.

Switching from Java to Javascript was not hard, especially since some of us already had some experience with the language. We also chose to use AngularJS to smooth the transition. After more than 2 years, we can say confidently that we made the right choice.

The start was a breeze. AngularJS is so powerful for managing the display that it made GWT look like a prehistoric framework. Of course, like all beginners, our applications were not that good now that we have some experience. We had to make some updates on our first AngularJS application recently, we saw that our code quality is now so much better. But everyone needs to learn, even us!

After that, there was a period when we started doubting AngularJS. Our applications kept getting bigger and the performance was getting worse and worse. But of course, AnuglarJS was not at fault. We needed to take a step further and understand how a web browser work, and why our applications had a hard time running smoothly. We started working on optimizations, and now we are able to make applications so powerful, so fast, that we can't see why we'd go back and not be in the Cloud.

And with all that experience, we also made a little something called LumX.