Why Banks and Telecoms Need to Embrace Innovative Identity Technologies

Emergent trends in biometric data, persistent identity, blockchain technology, and security, have banks and telecom companies on their toes when it comes to effectively using identity validation while being mindful of customers’ needs. In a panel discussion at Mobile World Congress in Barcelona last week, leaders and advocates for new identity technologies discussed the implications for the financial services and telecom industries.

The Future of Identity panel featured Xavier Codo (CEO at ICAR), Fernando García-Quismondo (Group Technology at Grupo Santander), Xavier Anglada (CEO of International Operations at Cash Credit Group), Josep Grau (Digital Innovation Manager at Caixa Bank) and Oscar Mancebo Ortiz (Head of Mobile Connect at Telefonica Group Level).
There is currently no mechanism to ensure individuals have one digital identifier, and so the challenge now is how to connect all the content available to represent an individual in the digital world. Banks and telecoms are obsessed with protecting the data security of individuals, but at the same time, are tired of being hemmed in by regulatory protocols. ‘We need to over-communicate and explain to them that we need to do things radically different now. We need to share information about an individual. It’s critical’, said Xavier Anglada, CEO of International Operations at Cash Credit Group. Cash Credit is a fast-growing FinTech institution with an innovative, analytics-based credit scoring system that uses mobile operators’ big data. By partnering with telecoms, media players, and payment platforms, they offer subscribers a range of economic and financial credit products.
Banks and telecoms have to leverage different data sources to create links between them. While establishing an ecosystem for the sharing of data while balancing customers’ rights to privacy, the sharing of information reduces onboarding costs and creates a frictionless process. Enterprises need to change the way they build services and place the user at the centre. Training customers to use new technology is extremely important, plus internal onboarding and change management within.
Over time, and highly dependent on context, the perception of different biometrics activities can change. For example, getting your fingerprints done at the airport for security purposes might be perceived as negative and intrusive, whereas using the fingerprint identifier on your iPhone may be novel and cool. In the end, if customers find value in the technology they’ll adopt it. Banks have to give the customers the power, and customers have a great responsibility that is implied as well. They have control over their data, and enterprises need to make it simple and easy, plus minimize their number of interactions.
By using the features that blockchain offers, such as a shared user base that is encrypted, banks still need to effectively manage liability issues. For example, who is in responsible for security intrusions and mistakes that occur? What are the new protocols and procedures? The new technology is absolutely disruptive, and revolutionary, but it won’t work in a vacuum alone. It requires more complex solutions and systems in place, as soon as possible.
Learn about our Process
Rangle Flow is an application development process we designed to help our clients build the best software using modern JavaScript development. Contact us to acquire more insight into your product development and increase communication across the team, which allows you to steer your project with a high level of precision

Link: http://blog.rangle.io/why-banks-and-telecoms-need-to-rigorously-embrace-innovative-identity-technologies/

Previewing the WebAssembly Explorer

WebAssembly is a new, cross-browser format for programs on the Web. You can read all about it in Lin Clark‘s six-part Cartoon intro to WebAssembly. Unlike JavaScript, WebAssembly is a binary format, which means developers need new tools to help understand and experiment with WebAssembly. One such tool is Mozilla’s WebAssembly Explorer. The video below […]

Link: https://hacks.mozilla.org/2017/03/previewing-the-webassembly-explorer/

Best Tools For Developers To Minify Javascript

Put succinctly, minifying is the technique of removing the unnecessary characters from the source code. This is also known as code compression and minimization. A lot of production websites are using JavaScript minification, but it has its own technique to compress scripts into smaller tracks. In order to execute different difficult tasks successfully, web developers get tremendous benefits from great JavaScript minifying tools. In the development tasks, these enhanced JavaScript minifying tools assist developers and help in improving the code. Minifying your source code will improve load time and also the performance of web applications. Here are some of my favorite:
YUI Compressor
This is a command line tool printed in Java and expanded by Yahoo. If you want to minify quickly, the YUI compressor is a great fit for your needs. It is 100% secure and gives an elevated compression ratio as compared to other tools.

Link: https://dzone.com/articles/best-tools-for-developers-to-minify-javascript-1?utm_medium=feed&utm_source=feedpress.me&utm_campaign=Feed%3A+dzone%2Fwebdev

Angular constructor versus ngOnInit

Angular has many lifecycle hooks, as well as a constructor. In this post, we’ll quickly cover the differences between the ngOnInit lifecycle hook which has been the source of some confusion for those getting started with Angular.
So, why do we need the ngOnInit lifecycle hook when we’ve got the constructor available?
What’s the difference?
The constructor method on an ES6 class (or TypeScript in this case) is a feature of a class itself, rather than an Angular feature. It’s out of Angular’s control when the constructor is invoked, which means that it’s not a suitable hook to let you know when Angular has finished initialising the component.
Demonstrating the constructor alone:
import { Component } from ‘@angular/core’;

@Component({})
class ExampleComponent {
// this is called by the JavaScript engine
// rather than Angular
constructor() {
console.log(‘Constructor initialised’);
}
}

// internally calls the constructor
new ExampleComponent();

Note that the main piece here is that the JavaScript engine calls the constructor, not Angular directly. Which is why the ngOnInit (and $onInit in AngularJS) lifecycle hook was created.
By adding this lifecycle hook, Angular can fire a method once it has finished setting the component up, and as the naming suggests, the hook is part of the component lifecycle:
import { Component, OnInit } from ‘@angular/core’;

@Component({})
class ExampleComponent implements OnInit {
constructor() {}

// called on demand by Angular
ngOnInit() {
console.log(‘ngOnInit fired’);
}
}

const instance = new ExampleComponent();

// Angular calls this when necessary
instance.ngOnInit();

Constructor usage
Bearing this in mind, there is a suitable scenario for using the constructor. This is when we want to utilise dependency injection – essentially for “wiring up” dependencies into the component.
As the constructor is initialised by the JavaScript engine, and TypeScript allows us to tell Angular what dependencies we require to be mapped against a specific property:
import { Component, ElementRef } from ‘@angular/core’;
import { Router } from ‘@angular/router’;

@Component({})
class ExampleComponent {
constructor(
private router: Router,
private el: ElementRef
) {}
}

You can read more on Angular’s dependency injection here.

This essentially will bind Router to this.router, making it accessible as part of the component class.
ngOnInit
ngOnInit is purely there to give us a signal that Angular has finished initialising the component.
This phase includes the first pass at Change Detection against the properties that we may bind to the component itself – such as using an @Input() decorator.
Due to this, the @Input() properties are available inside ngOnInit, however are undefined inside the constructor, by design.
import { Component, ElementRef, Input, OnInit } from ‘@angular/core’;
import { Router } from ‘@angular/router’;

@Component({})
class ExampleComponent implements OnInit {
@Input()
person: Person;

constructor(
private router: Router,
private el: ElementRef
) {
// undefined
console.log(this.person);
}

ngOnInit() {
this.el.nativeElement.style.display = ‘none’;
// { name: ‘Todd Motto’, location: ‘England, UK’ }
console.log(this.person);
}
}

The ngOnInit lifecycle hook is a guarantee that your bindings are readily available.

Link: https://toddmotto.com/angular-constructor-ngoninit-lifecycle-hook