Password Strength Meter – Javascript


This past week I’ve been working on a javascript script that should be able to identify the most common bad habits of password typing, and I did it because most of the password strength scripts did not fit my expectations.

When developing a form to setup the user’s password it’s always a big spend of effort worrying about how I should warn the user about the weakness points of it’s password.

So I made a research and among many password strength sites I have found the which have a great set of items checked on the algoritm. Unfortunately the website does not provide a tool to add it in our web projects, so I decided to to make a script based on it.

The idea was to make a resource which can be easily add to web projects, so I’de choose Javascript and JQuery as the base of the project.

The finished script provides more than 15 verification items on password safety and can be fount at my github account free of charge.



types of coders – clean code

On all these years (about 20) working with many developers, with different styles of coding and different languages, I saw people doing some strange and funny things, also some bad and good practices.


After a lot of time dealing with these kind of developers I had the chance to read a very nice book called Clean Code which have many suggestions about how to write a clean and readable code with contribution of some great names of the development history like: Bjarne Stroustrup, inventor of C++, Kent Beck’s author of Implementation Patterns, Grady Booch, author of Object Oriented Analysis and Design with Applications, Dave Thomas, founder of OTI, godfather of the Eclipse strategy, and others.


After reading that book I always keep an eye on my code to keep it as clean as possible, and also, I remember all that weird codes from the past that I would like to list below:

  • The never grows developer:
    • When we start learning how to develop, we always have some sample code like x = y + 1 or i++, but these are only samples for the beginers and does not mean that the developer should continue to use x, y and i as constant and variable names.
    • Also, the never grows developer, always try to use the same functions and procedures to solve modern problems which probably already have a function or some kind of library to do that;
  • The no indent developer:
    • This comer from the newbies developer which does not have indentation on code, believe it still happens, specially these days with script languages where everyone tries to put everything in just one line;
  • The no comments developer:
    • This one never puts a comment in the code, even if the code looks like:
      function calculate (p, y, v) {
      return ((p+y*v)^3 ? true : 0);
  • The comment all developer:
    • This one is also so bad as the no comments developer:
      function save (userName) { // functionsave the user name
      var name = userName; // get the user name paramenter
      saveToDatabaseFunction(name); // save the name on database
      result true; // always return true after saving
  • The no-name vars:
    • This kind of developer likes to solve the problem without worrying about who will come after him/her:
      test = array();
      x = (s>0 ? s : 1);
      for (i=0; i++; i<=x){
      test[i] = x*2;
      test ? x ? i?
  • The all-in-one file developer:
    • This one does not worry about the classes names or the structure of the project, this developer only creates a file called functions or util and add code and functions and classes there.
  • The economic developer:
    • This one still thinks that our computers have only just 640K of memory or that our internet bandwidth is about 9600bps. This developer usually tries to do all in just one line:

      if (getContentFromForm() + (X[j]+X[i]) * (Y[j]-Y[i]) > 0 ? (Xj Yj - Xi Yi) + (Xi Yj - Xj Yi) : Xj Yj - Xj Yi + Xi Yj - Xi Yi)){ result (Y[j]-Y[i]); }

Many strange things came and I believe that many more will come. Until there I keep reading and practicing to do the best that I can.

Do your best also, maybe we will read our code.

A Very Simple API 


There comes a time in the life of a developer where he/she is forced to deal with an API, be a desktop or a web developer, in some time it will be necessary.


Also, maybe, the developer will need to create it’s own API and then is where the things get a little bit difficult. There is a lot of concerns, discussions and suggestions around API standards but none of them are still the definitive right way to build an API, so as always each developer builds the code as it wants.

For me, everytime that I need to deal with a webservice, I study a lot, check the new standards look at the client needs and make the best effort to make the most light and precise services that the client wants. But thats the hard way, the easy way should be, to unpack a generic API code adjust some settings and start to delivery services… Should be like this.


There are some nice tutorials and tools on internet about building an API, like with laravel and with apigility, but almost all have some framework dependencies and then I though in something more simple, just with the basic stuff, why not?


Considering all that, and on all the effort spend on every new webservice, I decided to make a very simple API pack with the basics to make a webservice to work, so here is what I tried to covered:

  • Auto detect XML-RPC or REST request;
  • Standard formated XML or JSON automatically (depending of the request);
  • Automatic deal with errors and/or warnings (saving in a log);
  • Resources to return standard field answers on requests;
  • Code injection protection;
  • Method request control and run according to the operation method request (POST, GET, PUT, DELETE, OPTIONS, PATCH);
  • Versioning control;
  • URL friendly following at least level 2 maturity level;
  • Start point to build my own custom webservice methods;

It’s not easy to cover all the resources of an API and still keep the code simple and dependencies free but I tried. In the end the result was very good but still have some work to do.

The code is avalibale on my github account and it’s free to use and to contribute. Note that this is not the “state of art” and any kind of contribution will be welcome.

The very simple API pack worked just fine and  can be used on every new project with just a few lines of set up on an specific settings file. Also, the use is very simple:

  1. Extend the main class AbstractService:
    class MyServiceName extends \classes\AbstractService
  2. Initialize the service with the needed settings:

    public function execute()
    $this->initialize(['allowedMethods'=>[AMT_GET, AMT_POST, AMT_OPTIONS],
  3. Add the code on the respective method and call the answer method:

    public function onPost()
    //... your code here
    'message' => 'Here are the fields that the API received',
    'fields' => $this->getFields()
  4. Call the API from the browser:

… and voilà!

Sample JSON answer using AJAX on vsapi

Also, an error message:

JSON error answer using AJAX on vsapi

And, a XML answer:

XML answer using PHP on vsapi

Developing for Elementary OS – Setup and Compiling

Weekends are a great time to enjoy doing what you like to do, ins’t it? I like to code and read and learn new technologies, experience new computer languages, so past weekend I did something that I was planning to do a long time, try to code something to Elementary OS.

Why the Elementary OS? Well, first of all, I like to try new tech stuff, in second, the Elementary OS makes me feel good to use, a strange feeling, different from using another linux distro. I don’t know, I think I’m in love for it…. ok, let’s stop with this bullshit and back to develop.


Basically, the Elementary OS is over GTK 3 and uses Vala as main language (or not a language) to develop it’s applications. The Elementary “Getting Starter” section for developers already conduces you through very detailed steps to build your first app and to get involved with this magic enviroment.

In the end you get a very nice hello world simple app and a few resources. It’s a very nice experience to see your work running natively.


But I found that the steps are too much detailed, not that it’s bad but sometimes I would like to do it more quickly as I already know many of these basic stuff. Also, in sometimes I felt a little lost, so in the end, I decided to make a simple to-do list of the summary of how to setup a new enviroment to a new project, check it out:

  1. sudo apt install elementary-sdk
    It will install all dependencies to compile your app.
    Just need to do this step at the first time, don’t need it on your second project.
  2. create your project folder and sub-folders:
  3. create the main project file:
  4. Add sample content on your .vala file:
    int main (string[] args) {
       Gtk.init (ref args);
       var window = new Gtk.Window ();
       window.title = "Hello World!";
       window.set_border_width (12);
       window.set_position (Gtk.WindowPosition.CENTER);
       window.set_default_size (350, 70);
       window.destroy.connect (Gtk.main_quit);
       var button_hello = new Gtk.Button.with_label ("Click me!");
       button_hello.clicked.connect (() => {
       button_hello.label = "Hello World!";
       button_hello.set_sensitive (false);
     window.add (button_hello);
     window.show_all ();
     Gtk.main ();
     return 0;
  5. create the CMakeLists file:
  6. Add the basic content on the./project/CMakeLists.txt, copy it from:
  7. Change the following content on the ./project/CMakeLists.txt to fit your project:
    should be on line: 39 ===> # files we want to compile
  8. Change the following content on the ./project/CMakeLists.txt to define your executable file name:
    should be on line: 17 ===> set (EXEC_NAME “com.github.yourusername.yourrepositoryname”))
  9. Add translation information to the ./project/CMakeLists.txt, copy from:
    (step 2)
  10. Create the translation CMake file file:
  11. Add content to the translation file ./project/po/CMakeLists.txt, from:
    (step 3)
  12. Create the base for your shortcut app file:
  13. Add content on .desktop file, copy from:
  14. Create the App Center File information, on:
  15. Add content on .appdata.xml file, copy from:
  16. Create your author’s file info, on:
  17. Add content on ./project/AUTHORS file, copy from:
  18. creating cmake information, run on ./project/build:
    cmake -DCMAKE_INSTALL_PREFIX=/usr ../
  19. creating the translations, run on ./project/build:
    make pot
  20. compiling your project, run on ./project/build:
  21. finally run your compiled project:


Also, I want to share some useful links that I found it may help you to save some time:

The ValaDoc Reference: The references for all commands and functions that you will need to make a Vala app.

The Vala Tutorials: A lot of tutorial codes, file manipulations, fields, components and more.

Elementary OS sample libs: A preview of the Elementary OS lib components

Elementary OS widgets: The native OS components to use on the apps

GTK3 Icons reference: May be you need this

The DoodleSpark reference to Elementary OS Icons


Generic or Custom API, which one to use?


On the past month I was working in a project, that seemed to be easy on the beginning, to create a kind of service that should be the core to delivery coordinates and weather information of trucks, airplanes and ships from an specific company, and, the project has extended a little (as always), because the client also wanted to add some extra resources like user control, sell credits to use the service among other details. In fact, it wasn’t so easy as I expected but in the end, we did it.

Our team made some research before develop anything and concluded that an API should be the right service to complete this project.

An API is not just a JSON or XML content, it’s more than that, it can have many aspects and involve different types of access, depending of the needs, the most common types are the RESTFul service which is more like an architecture over HTTP using different methods to make the operations and the RPC (Remote Procedure Call) service which is usually done via POST method sending payload information to define the operations. It was important to us to know exactly what are the client needs and what we should start to use.

Knowing about these and some other dificulties of building a web service API, we did what any sane developer would do… search on internet for some basic and simple API to build over it our own solution. Well, we didn’t find something easy and simple, but we have found the Zend apigility which is a fantastic API-based architecture and is based on Zend Framework, so we just gave a chance for it.


The apigility tool offered a great tutorial, many sample codes and can be setup almost by the admin enviroment, also, a complete set of answer types, allowed methods, filters, validations and is also documentation ready, it’s really amazing.


But, “with great power comes great responsibilities”. The apigility is based on Zend framework, so it’s implicit necessary to have a good knowledge on the framework to make  a good job, also, we don’t felt like this is the right solution for this project, it was more like “A cannon to hunt a little bird”, and more crucial, the Zend framework would push us to do extra documentation and can be a possible problem in future updates, for the client, as we don’t have too much professionals available with this knowledge. So, we give up of apigility for now.

After some long discussions, following the team instincts, feelings, making some sketches, we kept the idea of making by ourselfs a PHP web service API, which should exactly fit our needs without lack or overage of resources.

There is a lot of discussions around the API standards and if it should be adopted or not, among them are the swagger specification and the Open API Initiative which are supported by many stakeholders like Google, Microsoft, IBM, Paypal and other giants.

We didn’t followed all the standard specifications that we found, but we focused in almost all of them to finish our API.

Was it worth? Well, we were a team of 3 person, we planned, documented, developed, tested and done the service in about 5 days and the client is happy and the project is working, so, the team and the client thinks it was worth it, that’s what matters. 🙂

Sample use of the tracking API

Wireframing Before Code

Starting a new software project is not an easy task for anyone, specially if you have a great imagination and some coding habilities. Sometimes the process of creating a simple app or utility can become a big and infinite nightmare with endless resources and pending ideas if it is not very well planned.

Among the traditional steps of documentation of a software project I usually like to start with the wireframing step (or sketch as some people like to say), where turns it possible to see how the final product will looks like and also bring some insights about the resources that need to be planned on the tasks. This kind of effort can save a lot of time, believe.


When wireframing the screens of the project is possible to see some options and some limitations that you only would remember when you see the final product. Also, this effort makes the process of filtering bad ideas that seemed to be good on your mind but did’t going well when applied.


There is not a standard way for wireframing, it is just a way to put your ideas and thoughts in a way that you and your coworkers can see what you are thinking to do. Follow some design patterns (mobile-patterns, pttrns) are a good choice if you dont know where to begin.

As wireframing is not a trivial task for me, and I just do it when start a new project, I don’t have a favorite app to do this, instead of that I always make a search on internet an find what is trending. On my past project I found the mockflow web app which is a very complete tool with a lot of resources and also have components that are similar to those used on developing, like: bootstrap, htm5, android, iphone, etc.

Mockflow is a paid app and also have a free version, which is limited by the number of pages that you can add on the wireframe project. For a free version is good enough.