Parse’s going down…

I was a bit shocked reading the following article.

Just choose to use Parse. Built an extension on it. Blogged about it. Loved it with all it’s problems.

It will be shut down not tomorrow of course but January of 2017 will be here soon. 😦

That’s how life works. Heads up! I will choose an other solution and of course will blog about migration from Parse and about the new solution I will use. 🙂


Browse Wisely – The Extension

bw (1)

Through the previous posts I wrote about my experiences developing an extension. Browse Wisely is the extension I wrote about.

Browse Wisely is published now!

You just need to visit the Chrome Web Store, download it and you can get the experience of smart browsing.


Browse Wisely have the purpose to help controlling your browsing habits. You can set rules not to spend too much time on selected pages.

Set block rule with a time frame and the extension will not let you visit the selected site. It will automatically redirect you to a random Wikipedia site. You can read the article and learn new things.

Set a warning rule with defining the site you want to monitor and the time (in minutes) to warn you after. If you spent the given time on the page you will be warned. You can navigate to TED videos. Sneeze the warning for 5 minutes. Restart the timer or dismiss the whole warning panel.


It could be a pleasure to see you between my users!

If you try it feel free to write me a comment or send me an email. I’m happy for all the feedback. If you find a bug or have thoughts about features I could build in write to me.


Links to know more about the extension

To try it out

visit the store and download Browse Wisely.

To know more about the extension

visit the marketing site of Browse Wisely.

To follow the development phases read the posts

about the extensions in theory and in practice,

about React tricks with TypeScript,

about the React development,

and about the Parse and login flows.

It will be open-source soon. The skeleton of it already available.

Parse + Login with Facebook

If you create an application you probably will need to handle users somehow. If your application is front-end heavy and didn’t require big, complex database or complex server side login, you don’t want to spend too much time developing it. That was my situation with my extension as well. I wanted only store some user data and the user’s rules. Rules to control their browsing habits. So I searched for an easy to use, fast to setup and a cheap solution. That’s when Parse come into picture.


Parse is a platform. A cloud-based platform that provides a complete backend solution for your application. Parse’s goal is to totally eliminate the need for writing server code or maintaining servers.

The Parse team is using striped 1000 Provisioned IOPS volumes for MongoDB clusters running on Amazon Elastic Compute Cloud (Amazon EC2) instances. What is very impressive to hear. You can read more about it.

But let’s see what it offers to you, to the developer:

Easy to use. It is just some click to create your first application. Creating some tables is easy as well.

TIPP : Adding data and creating some extra relations between tables are more than the Launchpad is capable for. You need to use your code to do that. Sometimes it is not just the easiest way you can find it is recommended by the developers of Parse as well.

Really well documented. The basics are all in the documentation. They have FAQ section with really good answers.

TIPP : Only thing what I couldn’t get from them is a really useful documentation about authentication with Facebook if it isn’t the basic way and third party authentications. But more about it later in the second part of this blog post.

Easy to observe. You can monitor all of your data on the Launchpad. It is easy to check, update and delete the existing data.

TIPP : If you open your app on the Launchpad, choose the Data section and see nothing don’t panic. It shows you always the Analytics tab first. Change to Core and you will get your data you wanted to see.

Easy to use in code. It provides a lot of SDKs and a REST API as well to handle data from any platform.

More. It can do so much more than I used it for. It can send push notifications, show you analytics about everything and more.

Handle growth. If your app grows bigger and require more logic on back-end you have the first option to write some cloud code. There are hooks to handle the incoming and outgoing data.

After getting bigger than this you have one more step not to leave Parse just extend it. The Parse Hooks API that makes it possible to use your own Node.js server in conjunction with Parse.

But if nothing is enough you can easily export your data into JSON. Build your own server side and fill your data into your database with parsing data from the JSON files. Each table with the containing data will be one file.

And not to mention it is free. Free for commercial use until your app will be so big that it isn’t a problem paying for the services.75689840-7165-4c58-a2af-eb8a06a27c20

It is in hands of Facebook. It can build trust and give some kind of guarantee if such a big company is behind it. Like in case of React. It is used and tested in such a big user visited site like Facebook. It is part of the Facebook Open Source Program.

TIPP : Parse’s Javascrip SDK is open-source. Checking the code could help so much if you can’t find or understand something.

Developing with Parse

Parse gives you a really cool REST API to handle data in the universal mode. But if you want to have something platform specific you have options too. It provides a  lot of SDKs. It has Android, iOS, PHP, .NET an so much more. Of course it provides a JavaScript SDK as well. But working with Parse in TypeScript isn’t a problem neither because it has typings available too. You can use a direct link or install it with TSD.

Not to mention if you develop a React application using Parse you get an extra customized SDK to React.

It supports everything we need to start developing our extension.

It is one line only to initialize:


Building blocks of it are the Objects.

Parse.Object contains key-value pairs of JSON-compatible data. This data is schemaless, which means that you don’t need to specify ahead of time what keys exist on each Parse.Object.


You can use your Objects through Querys.


ruleParseObjects is the container list of all the original Parse.Objects.

Objects have the save and destroy methods on itself. So if you cast your data to something else like me you need to handle the linking between the new objects and the Parse objects. I created an IRule object from the Obejcts given by Parse, passing only the data for my React components. So I saved in my parseService class the original Obejcts as well. Linked them with the object ids to the IRule objects.


TIPP : It is important to be careful with naming convention because Parse can’t handle it. It will create new columns in your data table if you misspell something.


It is so easy to use. The goals of this post was only to show you how easy to use Parse for simple problems. After knowing the basics of Parse let’s see the bigger problem that I used it for Parse as the solution. It was the login. It has three parts to get things work. Setting up Facebook, setting up Parse and hacking the crazy things of an extension.

Login with Facebook

Using Facebook logic didn’t come so obvious for me. If you are someone like me you neither like to give access to your profile for unknown applications. But I thought about it and something I more dislike is to register myself again for something new. Problems with giving a unique nickname or finding out a new password – sometimes with too strong requirements – and of course remembering all of that is more frustrating for me. So I decided to save this procedure for my users. Made their life with that easier I think. It is just few click to register and to login. Think about it. It requires only your email – for custom registrations it is also required – your name and sometimes some public data. Only public. Data, what is already available for everyone on the internet. Actually it isn’t so strange to do that from this perspective.

It could be of course not just the Facebook to login. It could be Google+, Twitter or whatever third-party login as well. But Parse gives you the Facebook login out of the box. I decided to lunch my application with it and after some user feedbacks or after a hundred of users I will work on adding other login providers to my app. Doing so isn’t so obvious with Parse.

But let’s see how I built Facebook login into my extension in. It wasn’t as easy as I first thought.

Creating a Facebook app is easy. It is really well documented. (As I mentioned it previously by React and Parse too – Facebook does this documentations thing good, makes developer’s life easier)

Register your Facebook app.

After having the Facebook account registered as a developer the next step is to register the url of your website for getting things done. The url of your extension is chrome-extension://iccdneeippnmcmbaekeoonkckkjhojfi/UI/Popups/index.html. It runs in the local environment of users installed your extension. It isn’t the url you could use. So you can’t register your extension as a web app / website.

Here comes the trick. You need to host a site with the scripts of the Facebook init and login. After that you need to add this site to your extension as a content of an iframe. You didn’t need to create a whole login site and change your extension’s login site to it. I created only a button for this purpose. An iframe with a size of a button and the site hosted somewhere only containing a button.

OK, I can login with Facebook now but how does the extension know about it? – could be a right question. Here comes the messaging system of the extensions into the picture. But let’s see the Parse part of the login first.

Parse part

Parse gives you Facebook login out of the box. After checking the tutorial on the Parse site you could reach an incorrect conclusion as I did. I thought first that I need to use the two together as it is in the examples.



After I logged in the user that way I checked what happened. I had the logged-in user on my site, not in the extension. I thought I can post the required credentials to the extension. I checked what are stored into local storage after the login process because I saw that the Parse.User.current() method operates with the data in the storage. So I passed the local storage data to the extension saved into the local storage of the extension. After reloading the extension it could link the session on Parse side with the local storage data in the extension. Sounds terrible I know and it worked only deterministic way. Sometimes not. I needed to find something better. A real solution.

This was the first time when the documentation of Parse couldn’t help at all. So I searched for similar problems and I could find something. There is an option to give credentials for the FacebookUtils.login method of Parse. It means you can handle the two login separated. Login your user first with Facebook and after that logging your user with the Facebook’s credentials into Parse.


This was the original code of Facebook to handle login and get some user data. This site and this code will be embedded into an iframe – into an iframe of the extension. So the easiest way to send message to the extension’s background page is getting the top window and sending the message from it. The receiver code which will use Parse’s login with passing the credentials is on the following picture.


So this is the way the user can log in with using only one button. With the button loaded into an iframe hosted on a separated site which handles in the background everything else. Logs the user with Facebook in, send the login data to the extension and login user from the extension into Parse leading to the authorized user using your extension. That’s the way you can succeed all the login from the extension. It was not so easy to find out but it’s simple and clean as the result.

Summary of Extension tricks

1, Extension itself doesn’t enough if you want Facebook or Google+ login. Both – and almost all other – requires an address of your site. So you need to have a somewhere hosted site. After having the Facebook website configuration you can’t trick with calling it from your extension. It only works with the origin site built into the extension with an iframe.

2, Login with two separated steps. Login with Facebook on the hosted site and send credentials to the extension through the messaging system of the browser. After that login with this credentials to Parse. That’s how you get an authenticated user in your extension on an easy and fast way.

React – The journey begins

You could hear about React in 2015 a lot. It is a new way of creating user interfaces. Fast and easy to use. Developed, supported and used my Facebook. Sounds good! Why don’t have a look on it? That was my thinking too when I decided that I spice my extension development with this new technology.

This post will be about the some basic knowledge and about my experiences with React. I don’t want to teach you with this post how to develop in React. I have no space for that here and there are a lot of good articles about it. I will show you some sites, where to find more about React. However I need to say only the documentation of it is also a really well written source for learning React. But let’s see my thoughts about React first.


Why React?

You can hear about it a lot nowadays. Check what the strengths of it are and what they mean for you.

It follows the functional programming style.

The real benefit of adopting a functional style is that our programs can be broken down into smaller, simpler pieces that are both more reliable and easier to understand. Functional programs should be stateless and immutable.

Immutable means that you should simply create new data structures instead of modifying ones that already exist. It is obvious by simple types but it need to be followed by complex objects and arrays as well.

Stateless, which basically means they should perform every task as if for the first time, with no knowledge of what may or may not have happened earlier in the program’s execution. In more concrete terms, this means that your functions will operate only on data passed in as arguments and will never rely on outside values to perform their calculations.


Virtual DOM

It is extremly fast. Faster then any MVC fremwork rendering method or faster than template engines.

Let’s see why.  The Virtual DOM is an abstraction of the HTML DOM. It is lightweight and detached from the browser-specific implementation details.

React includes a lightweight implementation of the DOM and events system. Manipulation of the in-memory representation of the DOM is faster and more efficient than manipulating the real browser DOM, and our events system implements all events in a cross-browser way, including bubbling.

It describes the actual state of the DOM.

You can think of template languages as a function that defines your data at time=0; with React, you define your UI in a similar way — declaratively — except it specifies how your UI looks at any point in time, not just the initial load.


If you change something it will be differentieted to the actual virtual DOM in memory. It is a fast operation. After that React will change only that part of the real DOM that actually changed. It isn’t a whole rerendering of the DOM.


Data flow

No more to way binding. If you change something you change the state and changing the state will trigger a re-render. A smart rerender as it was described in the previous block about the Virtual DOM.

Two way binding was a big thing of Angular. It was a cool feature but it has a big performance cost. Checking all the changes, the dirty values through an all time running digest circle isn’t a small amount of work in background.

I looks a cool feature but think about it. Is it worth it? Do you realy need that? It is maybe not so neccessary and you could live without it. Creating simplier user interface. Maybe you don’t need inline editable values in big list. Starting an inline editor – changing the show component to edit component – is what you could do instead and that’s the way of React.



JSX could be uncomfortable at first. A new syntax and why is HTML in JS? It’s from the Devil, you could think. But think again. Why is it better and more accepted writing JS in HTML than this? If you use Angular you write expressions and bind data into HTML what could lead to a lot of trouble. Misspelling something is an easy to do but painful to find thing in a programmer’s life.

JSX, writing HTML with JavaScript code together in a .js(x) file in any editor will make you sure not to misspell something.

But if you really are against it, you can write React code without JSX. Just in pure JavaScript. JSX is only a syntax sugar. It will be transformed from an XML-like syntax into native JavaScript.


Development environment

If you are ready to start developing you will find yourself having more options to start. It is up to you how you want to develop your React application.

TypeScript (+ gulp)

TypeScript compiler supports jsx syntax and the module loading of React. TS compiler in console is enough to do all the stuff but Gulp can make your life easier.

JavaScript ES5 or JavaScript ES6

If you are not familliar yet with the new features of ES6 or your project not in that stage yet you can still use React:


You can write your React code with ES6 as well:


Or use TypeScript like:


After decideing the language  and the version. You can use more than one infrastructure to build your application.

Webpack or Gulp

It is only the decision of your taste.

Webpack can handle all your needs using React with ES5 or ES6.

Check a tutorial for setting up your Webpack.

You can download packages for Gulp to handle everything Webpack is capable for.

A small tutorial about configuring Gulp.

It is really good to have more options. What is a little worse that you can find examples on the internet in all different ways. You need to check always what you are looking at. Which language which version.


My way of thinking


Thinking in React is different than in Angular. You need to think in small components. You need to think in as few controller components as you can and as small components as you can.

I was coming from the Angular world. This was my first project with React. So my thinking could be strange a bit but I write it down and hope it will help someone understanding the React development concept easier.

First I wanted to see the end result of my development. It inspires me to see what I want at the end. That’s why I started with the quick build of the html tags and CSS classes. I created my first screen with mock data. So I saw what I will get at the end. Than I ripped the screen into pieces. Into small pieces.

Started with the smallest components and stepped always one up in my component tree:

  • The smallest, simplest element of my site was a list item. Done.
  • It needed a container, the list. Done.
  • And I needed the page itself. Done.
  • On the page with an “add new list item” button. Done.

So I collected all the components What I at first sight wanted and wrapped them into an every time bigger container. Added the CSS to the elements. Be careful it can be done with “className” and not with “class”. JSX sytax handles it that way.

After all of this I started to add the logic. This happened in the reverse way by me. I collected what I needed at the top level. The page itself got the logic to fill the list and handle the add new element action. After I have the list of the elements from a service I pushed down necessary info to the lower levels. It comes with so much property passing. There are solutions to handle this passing process but for now I wanted to see how it works in a pure React app. If you want to skip this try out thing that I’ve done you can jump a big and use e.g.: Redux from the start. Redux is a predictable state container for JavaScript apps. You can use it easily with React together. But more about it later.

The main concept what I used was that build your HTML code from the smallest to the biggest and build your logic from top to bottom.

As I created this skeleton of course I saw that it isn’t so simple. One list item have more small components that could be outsourced for a new component with passing some data to them. But the main concept remained the same build your HTML code from the smallest to the biggest and your logic from top to bottom. Create a big controller component at the top level with a fat state and give only the necessary data through properties to smaller components. You not just handle data through this system. Probably you want to handle changes. Changes of element on the lop level but modified at the bottom, in a small editor component. You need to pass handler functions from to to bottom as well.

That was the logic what I used to create my first pure React app. That made me see that I really need something better, a better way to handle all of this passing down work.

TIPP : In JavaScript you can add constraints about the properties you require for your components. In TypeScript you can use interfaces to define this. At first I created my TypeScript components with the state and properties of „any” – no constraints in Javascript. It was easier and quicker. At first. But after I created the first skeleton I started to change „any”-s to predefined interfaces. It helped me handle the growth of my application.


Development components

This components are in TypeScript. You may not need them if you are writing your code in JavaScript (ES5, ES6). But I choose this way and can show only this kind of real life example now. These components are far not all you can use. These are the main components you will run into by developing a small application.


These are the main building blocks of your React application. It is an extended class. You have to handle the state, the props, the render function and all the lifecycle methods are available.

You can have private methods and private properties as well. All of these will give you an element that have a HTML representation and optional some logic.

Here is an example:



You can initialize your actual state in the constructor of your component. After that you can set the state any time in two different ways and all the changes of the state will trigger the call of the component’s render method.

setState({mykey: 'my new value'});

setState(function(previousState, currentProps) {
  return {myInteger: previousState.myInteger + 1};

If you change the state implicitly (eg: data deep within an object changes without changing the object itself) or if your render() method depends on some other data, you can tell React that it needs to re-run render() by calling forceUpdate().This will trigger the normal lifecycle methods and will still only update the DOM if the markup changes.


Properties are coming from the parent component as a constructor parameter of your actual component.


I will show you a small example of it in TypeScript

And here is the description of all the lifecycle events you can use. It is a short and simple description of them. Didn’t wanted to just copy paste it.

The documentation from the official site.


React is for UI handling. It makes rendering easy and fast but not cares about other things. Routing is something that you may need for a smaller app as well. Like for me developing a browser extension.

It comes to React as an additional package. You need to install react-router with npm. Include into your sources.

For TypeScript users there is a React-Router d.ts beside the JavaScript sources.

Using the routing is not so difficult. Just define your routing at first and you get the navigation.


TIPP : There is one typings for Routing if you use tsd install but you can get an extended d.ts for Router from this link.

TIPP : In some examples there is a context.router but instead you can use the context.history in TypeScript.

TIPP : Passing properties through the navigation is not an obvious thing. Look after this two options.

RouteHandler component. It can have properties that will be available for all the components loaded into the place of the handler.

Or something similar to this concept but a custom way. Writing a wrapper component as the route handler component and this wrapper component will contain the data you want to pass and gives access through properties to the contained component.

More info.


Flux – Redux

Flux is the application architecture that Facebook uses for building client-side web applications. It complements React’s composable view components by utilizing a unidirectional data flow. It’s more of a pattern rather than a formal framework, and you can start using Flux immediately without a lot of new code. You can find a lot of implementations of the flux architecture, e.g.: Redux or Reflux.

Redux holds your application state in one place, and defines a minimal but sufficiently powerful way of interacting with that state.

Reflux is a simple library for uni-directional dataflow application architecture with React extensions inspired by Flux. It takes the Flux approach and streamlines it, making it both easier to work with and easier to grasp.

I hope I will have time to refactor my pure React extension and integrate the use of Redux into it. Of course I will blog about it as well. So keep visiting my site and hopefully someday in the near future it will be a blog post about it.

But until then check these cool articles in the theme:

A compare of implementations.

A flux – reflux comparison.

A Redux article.

The official Redux site.



I really liked using React. These were my first steps. Maybe for a veteran React developer there were some funny thing but I will stay on this road and will deepen my knowledge. Hope that someday I will smile on this article too, but that’s how I started that’s the way I could adopt at first this new world and hope it will help you.

If you want something really fast working component I would use React. A component. As a developer it isn’t so fast to use. If you want to write clean and nice code in React you need to do a lot of refactor through your development. So much small iteration. If you find something that you could break for a smaller, dummier component you better do it. If you need a new object or just a property to handle probably you need to pass it down from upper – controller – levels to deeper to dummy components and writing the change handling of it and so on.

As I experienced writing a whole application in React (React + something flux) is complicated. Other usage of React could be that you writing components in React and using them in an Angular project. You get the whole infrastructure that makes your life easy and you can use fast rendering components. I will give a shot to that too, will try to replace a component in our huge Angular project. Seems as an interesting work to do. That will maybe a new theme for a later blog post. Check my site and you may see it published someday. J

These were my thoughts about React but I’m interested in your ideas and opinions. Feel free to leave a comment so we can discuss them.


Some sites I can recommend

React official site.

Functional programming @ SmashingMagazine.

React @ SmashingMagazine.

React getting started @ RisingStack

React best practices @ RisingStack

React goodies 1

React goodies 2