development Archives | Mood Up team - software house
Computer with Node.js Django Spring Ruby on Rails logos

Which Backend Framework Is Right for Your Project?

Reading Time: 5 minutes

 

Any web development project is usually divided into two core phases: frontend and backend development. Frontend development refers to the development of all that a user would see and experience while using the app, whereas the backend handles functions such as data storage, security, scalability and data transformation. A good example is a car, whose body, dashboard and steering is essentially your frontend and define the experience you have with it. This experience, however, will not be complete without the engine, chassis and the fuel tank of the car (backend). 

A backend is vital to the successful function of any web development project, unless the webpage you require is a static one. The easiest way to have such a web page is to create one on WordPress as it allows for basic content and user management. Such a backend, however, is not useful for creating custom web applications with sophisticated requirements our clients require of us.

There are many backend languages used by developers around the world. A few, however, stand out for their ease of learning, use, development time and effort.

Node.js

Node.js is JavaScript runtime built on Chrome’s V8 JavaScript engine, allowing developers to run JavaScript code on the server. What is unique to Node.js, however, is its ability to serve data requests without waiting for the completion of another. This asynchronous nature makes it perfect for developing IoT web apps that send large numbers of requests to the server at the same time. Another advantage of using Node.js for the backend of a project is its ability to easily divide services to microservices, allowing large projects to be divided amongst the team.

What you have to also take into account is Node.js’s unopinionated nature, which gives developers little to no preloaded features when using it. The backend developers, therefore, have to start from scratch and spend more time to complete a project, despite the freedom that comes with it. Node.js is also not advised as a solution for projects that demand high computational power and require developers to keep their apps compatible with the constantly changing framework and libraries. 

The Node.js community however is an active one, with many developers from around the world contributing their projects for open source usage. One must, however, be careful as developers of lower skills have been known to use such projects in their work with clients, who end up with inferior products created from substandard code. Replacing and/or cleaning such code of dubious quality is expensive and is another reason we recommend doing some thorough research before picking a software development partner.  

Who uses it? Netflix, Walmart, Uber, Paypal, LinkedIn, Medium, eBay, NASA

Smart guy meme about stealing open source code

Django

Django is a high-level Python Web framework designed for rapid development and scaling. It’s very versatile and can be used to developing solutions for content management and scientific computing platforms. Django is also very easy to learn, understand, use and places an emphasis on speedy product development, making it ideal for small to medium projects. 

Django, however, is rather monolithic and does not allow for the division of a project into smaller parts as with Node.js. This might prove to be a disadvantage when working on large projects that need to be divided into several parts between developers. It’s also very strongly opinionated and does not allow developers much freedom as with Node.js. 

Who uses it? Disqus, Bitbucket, Instagram, Mozilla Firefox, Pinterest, The Washington Post

Austion powers meme on using Django

Spring

Spring is another successful solution build on Java, the most popular programming language in the world due to its object-oriented robustness. This popular framework for creating enterprise applications comes packed with many features and additions that allow a developer to start an application with a basic website and authorization, almost out of the box. Spring’s modularity gives developers the freedom to pick and ignore classes, helping them focus more on customer-centric development and less on reinvention. 

Spring, however, is very configuration dependent and requires a developer to write a sizable amount of boilerplate code in order to add new features. It also requires developers to undergo a steep learning curve as there isn’t much set standards and best working practices. This is one possible reason why you might encounter Spring when working with more experienced, bigger teams working on enterprise projects.

Who uses it?  Amazon, ESPN, VISA, American Express

For Christmas I want a dragon meme spring framework

Ruby on Rails

Also called “Rails” or RoR, Ruby on Rails is an object-oriented programming language that is fast gaining a name for itself. First extracted from another project due to a requirement of its author, RoR is now favoured amongst the backend development community due to its ability to create fast web solutions. It also allows for speedy development due to its convention over configuration paradigm, which essentially  “assumes” what the developer wants to do and how. 

The downside, however, is its relative recentness, which is why the RoR development community is not as large as those you would find with other backend frameworks. It’s also not very flexible and rather resource intensive when compared to other frameworks. RoR’s age also makes it evolve quite often, requiring developers to update several dependencies to ensure the product they created on RoR stays updated. 

Who uses it? Twitch, Github, Airbnb, Shopify, Bloomerang, Etsy

Dr Evil meme developers after convention over configuration

Which one should you choose?

The backend framework you need should be decided based on what you hope to achieve with your software product. This decision is best made by your software development house in close consultation with you, the project requirements, outcomes and future plans. Doing so is vital as the backend architecture you pick will decide the trajectory of development and have implications on everything from planning, design, development and testing

Need an application that is highly scalable, fast and supporting web, mobile and other devices? We recommend Node.js. Looking for a speedily developed MVP project that treats the web app and your backend as one? Go for Django or RoR. Have a computationally heavy app with a sizable number of features that require long development times and iterative developments with multiple sprints? We recommend opting for Spring as it allows for the division of the job requirements between a team and gives you control over what needs to be developed first. 

Bitcoin Post 1

How Do Mobile Bitcoin Wallets Work? – Blockchain Technology [Part 1]

Reading Time: 2 minutes

Known by almost anyone with access to the internet, cryptocurrencies such as Bitcoin are being heralded as the payment medium of the future. It is to take advantage of this that a growing number of online and traditional business are now accepting cryptocurrency payments, which is where Bitcoin Wallets become handy.


“The blockchain allows our smart devices to speak to each other better and faster”

— Melanie Swan, the Founder of the Institute for Blockchain Studies


What is a mobile cryptocurrency wallet and how to get one?

A cryptocurrency wallet is essentially an app that gives you access to your Bitcoin wallet address and therefore to your money. Such a wallet could be obtained by virtually anyone on the Google Play or App Store, to receive and send funds in cryptocurrencies like Bitcoin and Ethereum. If you have trouble choosing a wallet, we can recommend the Blockchain Luxembourg app [download for Android] & [for iOS devices] for its design and simple navigation.

As you might have guessed, Bitcoin wallets place a very high priority on security,  which is why every owner is provided with a private key that is needed to access the Bitcoin wallet and sign every transaction. One can, however, make the process a little simpler by setting up a pin code to authorise transactions. Most of such apps also utilise QR-Code technology to facilitate speedy blockchain transactions instead of having the user provide recipient address and amount manually when sending funds.

The development of mobile apps using blockchain technology however is no easy task as the product needs to be secure and stable. Such development can only be done by highly skilled developers with years of experience under their belt, as they require development that is in line with compliance and industry standards.

In the next part, we will take a look at blockchain- the underlying technology of cryptocurrency wallets and its other applications.  

Got an idea for a blockchain app? Let our experienced developers know here and have your idea come to life!

How to code pt.1 RxJava Retrofit

How to code (pt.1): RxJava + Retrofit

Reading Time: 3 minutes

RxJava is an implementation of ReactiveX library for observable streams of data or event by using combination of the Observer pattern (read more). You will find more info on Retrofit (here).

I would like to show you how to call RestFull API enpoints using RxJava and Retfrofit 2.0. We are going to show you how to switch Retrofit’s Services method to RxJava Observable as well.

RxJava and Retrofit in practice

Before we get started, let’s add needed dependency to your gradle:

compile ‘io.reactivex:rxandroid:1.2.1’
compile ‘io.reactivex:rxjava:1.1.6’

RxAndroid included classes to RxJava that makes writing reactive components in Android applications easy.

After that add retrfoit dependencies:

compile ‘com.squareup.retrofit2:retrofit:2.1.0’

If you are using GSON please add converter for retrofit. Converter is needed to deserialize HTTP bodies into your custom class model. If you are not using it Retforit deserilizes HTTP bodies into OkHttp’s ResponseBody.

compile ‘com.squareup.retrofit2:converter-gson:2.0.0-beta4’

Here is a list of official converter modules provided by Square:

  • Gson: com.squareup.retrofit:converter-gson
  • Jackson: com.squareup.retrofit:converter-jackson
  • Moshi: com.squareup.retrofit:converter-moshi
  • Protobuf: com.squareup.retrofit:converter-protobuf
  • Wire: com.squareup.retrofit:converter-wire
  • Simple XML: com.squareup.retrofit:converter-simplexml

You can create custom converter yourselft by using Converter.Factory interface.
Next dependecy will help us return Observable object from Services:

compile ‘com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4’

Thanks to that we have defined Service.

public interface APIService {
@POST(“list”)
Call loadCar();
}

In order to switch RxJava observable only one change is needed:

public interface APIService {
@POST(“list”)
Observable<Car> loadCar();
}

 

Now let’s modify your Retrofit Builder and add CallAdapter and ConverterFacvtory:

public Retrofit provideRetrofit(){
return new Retrofit.Builder()
.baseUrl(“http://api.geo.org/”)
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create(new Gson()))
.build();
}

Right, now let’s move to some examples, shall we?

Example 1

We can start and call first Restfull API method with RxJava. Let’s begin with creating simple example that will provide object car.
We are about to do some simple activty where we have included APIService object already and are ready to call loadCar using RxJava.

public class Activity extends AppCompactActivity {
APIService apiService;
@Override
protected void onCreate(Bundle savedInstanceState) {
apiService.loadCar()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
}
}

Now we want to call asynchronous task. In order to do that, we have to use subscribeOn(Schedulers.io) to execute the observable on a new thread.

If we want also to get result in main UI thread, we have to use observeOn(AndroidSchedulers.mainThread()) which means that result emits through on the main UI thread.
subscribe() method is kind of trigger. If you don’t call it the request never executes.
If you take a look closer to subscribe method you will notice that there are more overloaded methods. I prefer to use subscribe method and handle errors. I will explain this below.
Let’ modify our request and add to subscribe method parameter Subscriber.
It should look like that:

public class Activity extends AppCompactActivity {
APIService apiService;
@Override
protected void onCreate(Bundle savedInstanceState) {
apiService.loadCar()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<Car>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Car car) {

}
});
}
}

There are couple of important things. Let’s start from onNext method. That method provides you with response for loadCar request, in our example that is object Car and immediately method onComplited executes.

onNext method calls everytime unless you have kind of error, for example JSONException, IOException etc. In this case method onError called instead of onNext() and onComplited doesn’t execute.
There are couple of cases to execute onComplited and onNext instead of onError when you have error. But that is subject for next tutorial.

Example 2

Let’s see what happens when we use subscribe method without parameters. We are going to resource Observable and find couple of overloaded subscribe methods. Let’s check subscribe() method:

public final Subscription subscribe() {
Action1<T> onNext = Actions.empty();
Action1<Throwable> onError = InternalObservableUtils.ERROR_NOT_IMPLEMENTED;
Action0 onCompleted = Actions.empty();
return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
}

On the surface everything looks pretty nice. Above we have three Action object for each action in our request. But what is weird is static value:

InternalObservableUtils.ERROR_NOT_IMPLEMENTED.

Take a look closer, In InternalObservableUtils class found:

public static final Action1<Throwable> ERROR_NOT_IMPLEMENTED = new ErrorNotImplementedAction();

Implementation class ErrorNotImplementedAction with method call will throw exception:`OnErrorNotImplementedException`;

public void call(Throwable t) {
throw new OnErrorNotImplementedException(t);
}

Final note

So if we subscribe to observable using subsribe() (method without parameter) it will work fine. But as I wrote above, it is possible to get error which is handled by onError method. In this case you will have crash because of throwing exception OnErrorNotImplementedException.
We should handle error in our side either by implementing onError action or providing Subscribe object.

Hope you enjoyed this coding tutorial, you can expect more in the future.

Why code review is so important

Why Code Reviews Are Important

Reading Time: 3 minutes

One of the most important lessons we’ve learnt over time is that we are unable to provide unbiased, objective opinions of our work, let alone check it for errors. In no ways is this an admission of inferior quality of work, as we humans are liable to err due to many reasons.

This is why we as software developers need another developer of equal or higher skills to review the code produced.

“If debugging is the process of removing software bugs, then programming must be the process of putting them in.” – Edsger Dijkstra (Dutch computer scientist, winner of the 1972 Turing Award)

The reasons for code reviews vary based on many factors, including but not limited to, the project, the client, the developers and quality assurance processes built into the development cycle. Their biggest impact, however, lies in,

  1. Teaching and knowledge sharing
  2. Ensuring coding standards
  3. Defect-free software

Other very common outcomes are security, scalability, maintainability and complete unit tests.

How does it work?

“Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.” – Brian W. Kernighan (Canadian computer scientist, co-author of “C programming language”)

Code reviews are performed by developers who played no part in its creation in order to provide objective, unbiased feedback. Such feedback is not necessarily positive as their end goal is to maintain code that is readable and clear to everyone, not only for those deeply involved in the project. Such reviewers of code usually possess a checklist to find common mistakes and validate it against the company’s coding standards.

Code reviews should take place during all stages of development, except for demos or experiments. This is all the more important when the project is nearing its end, as code reviews can greatly reduce the number of bugs and are essentially a developer’s insurance for the company’s coding standards. Code reviews also go a long way towards reducing the development costs as finding and fixing bugs during development will be cheaper than finding them later on.

The code review checklist looks for common mistakes and those that are typically harder to find such as:

  1. Thread synchronization
  2. Error conditions
  3. Accounting for reference-counting
  4. Resource leaks
  5. Security problems

Remember, software development is a constant process that needs regular updates, which is why we place a heavy focus on code reviews to ensure the created code is clear to any developer who might read it.  They help keep the code organized and create a space for making comments which can be priceless for another developer who might be given the job of updating the said code late on.

They also allow a developer to pass tacit knowledge gathered from the initial mistakes made at the beginning of development to a developer who might be new to it. Code reviews are therefore an excellent means of transferring knowledge between experienced developers and rookies.

Conclusion

Code reviews help launch successful products and save money. It is also a great way of transferring knowledge from senior developers who can offer their advice to juniors, whilst the juniors can help to find errors in the code. Remember, good code review practices should be integrated into any software development cycle as they are the hallmarks of a software house you can trust.

Have an idea that we can help with? Tell us more about it here.

Powerful Designers Developers Mix

Designers + Developers = Better Products

Reading Time: 2 minutes

Today’s modern product development life cycle requires designers and developers to communicate more and collaborate, a far cry from a time when they worked in their own silos and converged only at hour-long meetings.

Such an approach to work allows for a smoother and faster development cycle, as expected of all projects that function on the Agle methodology. It also allows for

#1 Instant problem solving

Problems in a software development project need to be resolved fast, as it can interfere with the velocity and delivery of the expected product at the end of a sprint. That’s why we at Mood Up pair designers and developers, as it allows for faster feedback and brainstorming solutions.

 

#2 No more backtracking

Hiccups are part and parcel of any software development project as we cannot anticipate every issue that will pop up. We could, however, reduce the probability of such issues by pairing designers and developers, who will work simultaneously.

Such pair programming allows each other to keep track of the velocity of the project, and deliver required components on time and budget as one cannot work without the other.

 

#3 Budget-friendly project

Contrary to popular beliefs, software houses do their best to produce high-quality products at the lowest possible cost for clients.

That’s why our clients love our efficient approach to development that is only possible by uniting designers and developers.

Great product with lower billable hours = happy client

 

#4 Speed up the process

As we keep reiterating, communication is essential to our velocity in product development. Faster communication help us solve problems as they arise, reduce billable hours to our clients and get back to what we do best- code.

That’s why we recommend our approach of mixing designers and developers together to all software houses.

Remember, dynamic products require dynamic solutions.

Here is what our lead designer, Dawid had to say on this

“Communication is the key for faster development. I’ve found it incredibly useful to have developers in the same room we do our designs in. It helps us to discuss progress, what needs to be done and how we can improve on current builds so that the client gets the best product possible. Such a collaborative approach allows us to accomplish a significant amount of high-quality work in short timeframes.”

We’d love to hear your opinion about our approach to pairing designers and developers together. Is it one you would try for your project?

New Firebase is likely to become a promising Parse alternative 2 1

New Firebase is likely to become a promising Parse alternative

Reading Time: 3 minutes

When Facebook decided to shut down Parse in January, it gave developers who rely on Parse for it’s back-end services 12 months to come up with an alternative. Although Facebook open sourced Parse Server so that developers could keep their apps alive it was the fact that they didn’t have to build back-end on their own that made them choose Parse on first place.

In October in 2014 Google announced that they acquired Firebase known for it’s realtime communication, perfect fit for chat services, interactive apps and websites. However, it didn’t offer pretty much anything else like: reporting, push notifications, ad help, analytics and authentication – all major things  that developers want. But now it will and developers finally have some really promising Parse alternative.

 

Last week at Google I/O  company announced the new Firebase, avaible right now and supporting iOS, Android and JavaScript. They’ve decided to offer a lot of features, e.g. analytics for free so that they can stay involved in how developers are monetizing their apps.  Firebase will allow devs not only to track installations but also purchases and many other customer actions.

firebase-features

When Google acquired Firebase they had 110,000 registered developers on the platform, now the number has quadrupled and it will definetely grow.

“Firebase becomes the engineer-to-engineer tool to build the apps and then have insight into how to go to market and acquire users” said Brian Gracely, senior analyst at Wikibon, the research and consulting company.

All developers have to do is simply add few lines of code to their apps. This will allow gathering basic user information from the app to Firebasse but developers will be also able to adjust the analysis to their liking so that their user information will be more detailed e.g. when the button was pressed or the purchase made.

firebase-analytics

Thanks to this data, Firebase allows building audience segments and user’s behaviour as well as tracking ad campaigns performance. It can also track ad-driven actions by users across multiple ad platforms such as AdColony and Vungle.

What is Google’s aim?

This new approach to Firebase is proof that Google is aiming at becoming leader in cloud computing alongside with Amazon and Microsoft. Developers will be able to create apps faster and easier and Google will offer hosting those apps on its Cloud Platform. This might be the beginning of releasing more useful and lucrative services in near future.

However, Google still needs to gain developer’s trust, after ‘Parse trauma’ some of them are having hard time commiting their push notifications to big platforms.

Another big change was annouced regarding Google’s Universal App Campaigns. From now on it will work not only on Android apps but also on iOS mobile software. The app campaign service offers targeting most valuable users based on in-app conversions, e.g. booking a flight in travel app or reaching 5th level in game and it will offer option to pay for ads not only based on installs, but also before mentioned conversions.

Google is putting it’s effort into automating as much work they can that is needed to recognize who are the most valuable customers and exactly how much they are worth so advertisers will be able to bid accurate amount in ad auctions.

“We’re doing the heavy lifting with the ad creative and the targeting” said Sissie Hsiao, product management director for mobile app ads.

Why all the effort?

All those efforts are caused by Googl’e key concern – helping developers make more money since they still have trouble extracting revenue from Android users when compared to iOS users.

Google’s mobile ad revenues are growing and it seems that they finally caught up with Facebook in app install ads – they both claim that the number of ad-driven installs reached 2 billion.