Discussion About SAPUI5?

What is SAPUI5?

SAPUI5 (SAP user interface for HTML 5) is a collection of libraries that developers can use to build desktop and mobile applications that run in a browser. With SAP's SAPUI5 JavaScript toolkit, developers can build SAP web applications using HTML5 web development standards.

SAPUI5 is a collection of libraries that developers can use to build desktop and mobile applications that run in a browser.

SAPUI5 combines latest web technologies like HTML5, JavaScript and CSS into a toolkit. It can be used for building Web applications on the SAP platform.

Using SAPUI5 developers can build SAP Web applications using HTML5 Web development standards, according to business intelligence expert Ethan Jewett.

"HTML5 is a set of standards around browser-based technologies [like] JavaScript HTML and CSS, [otherwise known as] Cascading Style Sheets," Jewett says. "SAPUI5 is a library that combines all of those things into a toolkit for building actual Web applications. SAPUI5 … is a higher-level framework for building Web applications on the SAP platform."

Applications can be built using SAPUI5 that connect to any type of back-end system (or that just run in the browser and don't connect to any back-end system at all). However, the original goal of SAPUI5 (and still one of the main goals) was to develop an application framework for use in SAP environments, according to Jewett.

Video for SAPUI5

Small Discussion about Polymer.Js?

What is Polymer.Js?

Polymer.js is a JavaScript library created by Google that allows reusing the HTML elements for building applications with components. Polymer is an open-source JavaScript library developed by Google developers

Polymer provides a number of features over vanilla Web Components:

Simplified way of creating custom elements
Both One-way and Two-way data binding
Computed properties
Conditional and repeat templates
Gesture events

Polymer.js places a hefty set of requirements on the browser, relying on a number of technologies that are in still in the process of standardization (by W3C) and are not yet present in today’s browsers.

Examples include the shadow dom, template elements, custom elements, HTML imports, mutation observers, model-driven views, pointer events, and web animations. These are marvelous technologies, but at least as of now, that are yet-to-come to modern browsers.

The Polymer strategy is to have front-end developers leverage these leading-edge, still-to-come, browser-based technologies, which are currently in the process of standardization (by W3C), as they become available.

The recommended polyfills are designed in such a way that (at least theoretically) will be seamless to replace once the native browser versions of these capabilities become available.

Video for Polymer.Js
https://www.youtube.com/watch?v=tvafAyxkuVk

Discussion About WinJs?

What is WinJs?

The Windows Library for JavaScript (abbreviated as WinJS) is an open source JavaScript library developed by Microsoft.

WinJS started as a technology that was specific to Windows Store apps, but has evolved to aim at working in any Web browser. WinJS provides helpers that facilitate the development of Windows Store apps using HTML5 and JavaScript.

The library consists of modules and functions that expose the Windows Runtime in a way that is consistent with JavaScript coding conventions. WinJS makes it possible to add Windows UI controls in HTML. This is accompanied by support for data binding and a template engine.

Other JavaScript frameworks, such as JQuery, can work side-by-side with WinJS. The library comes with additional declaration files for a rich developer experience using TypeScript, a strict superset of JavaScript with annotations.

TypeScript enables for code completion and refactoring while maintaining compatibility with JavaScript.

WinJS is a set of JavaScript toolkits that allow developers to build applications using HTML/JS/CSS technology forged with the following principles in mind:

Provide developers with a distinctive set of UI controls with high polish and performance with fundamental support for touch, mouse, keyboard, and accessibility

Provide developers with a cohesive set of components and utilities to build the scaffolding and infrastructure of their applications.

Steps to install

git clone https://github.com/winjs/winjs.git
cd winjs
npm install -g grunt-cli
npm install
grunt

Video for WinJs

https://www.youtube.com/watch?v=7I0R1yA7mrA

Discussion About Svelte.Js?

What is Svelte?

Svelte is a different take on the idea of building UIs. Rather than being a library that runs in the browser to create your UI, it's a compiler that turns your component into simple JavaScript, with no need for virtual DOM diffing or any of the other techniques that UI libraries use

The web's JavaScript bloat crisis, solved.

Svelte turns your templates into tiny, framework-less vanilla JavaScript.
Simple and familiar. Build apps out of composable, easy-to-write blocks using languages you already know.
Super fast, rock solid. Compile-time static analysis ensures the browser does no more work than it needs to.

In Svelte, an application is composed from one or more components. A component is a reusable self-contained block of code that encapsulates markup, styles and behaviours that belong together.

Like Ractive and Vue, Svelte promotes the concept of single-file components: a component is just an .html file. Here's a simple example:

<h1>Hello {{name}}!</h1>
Svelte turns this into a JavaScript module that you can import into your app:
// main.js
import App from './App.html';
const app = new App({
target: document.querySelector( 'main' ),
data: { name: 'world' }
});
// change the data associated with the template
app.set({ name: 'everybody' });
// detach the component and clean everything up
app.destroy();

Video for Svelte

https://www.youtube.com/watch?v=wtL3SP7bu5Q

Discussion About Angular 2 Directives?

What are Angular Directives?

Directives are a way to teach HTML new tricks. During DOM compilation directives are matched against the HTML and executed. This allows directives to register behavior, or transform the DOM.

Directives Types

Components
Structural Directives
Attribute Directives

1. Components

Component decorator allows you to mark a class as an Angular component and provide additional metadata that determines how the component should be processed, instantiated and used at runtime.

Components are the most basic building block of an UI in an Angular application. An Angular application is a tree of Angular components. Angular components are a subset of directives. Unlike directives, components always have a template and only one component can be instantiated per an element in a template.

@Component({
selector: 'myApp',
template: `<h1>Query Home</h1>`
})
class homePage{
}

2. Structural Directives

Structural directives are responsible for HTML layout. They shape or reshape the DOM's structure, typically by adding, removing, or manipulating elements.

As with other directives, you apply a structural directive to a host element. The directive then does whatever it's supposed to do with that host element and its descendants.

Example

<div *ngIf="isPageEnable" class="app-name">Query Home</div>

3.Attribute Directives

Attributes directives are responsible for change the appearance or behavior of an element, component, or another directive.

Example

<p appHighlight>Highlight me!</p>

Video for Directives

https://www.youtube.com/watch?v=PiJkT3VNTS8

Small Discussion About Axios.Js?

What is Axios?

Axios is a promise-based HTTP client that works both in the browser and in a node.js environment. It basically provides a single API for dealing with XMLHttpRequest s and node's http interface. Besides that, it wraps the requests using a polyfill for ES6 new's promise syntax

Node Command

npm install axios

Bower Command

bower install axios

Features

Make XMLHttpRequests from the browser
Make http requests from node.js
Supports the Promise API
Intercept request and response
Transform request and response data
Cancel requests
Automatic transforms for JSON data
Client-side support for protecting against XSRF

The user interface is split up into three sections:

GET Request
GET Request with Parameters
POST Request

With each of these three sections the user is able to try out a specific use case for Axios.

Video for Axios

https://www.youtube.com/watch?v=1vbpBDWu1AQ

Small Discussion About Supersonic Framework?

What is Supersonic ?

Supersonic is a robust user interface framework (UI) for developing hybrid mobile applications. The framework integrates with any REST API (Application Programming Interface) and allows data interaction/modification in the backend. With Supersonic, one can design API-connected mobile applications for iOS and Android.

Supersonic is a framework with an elegant balance of simplicity and power. By using the best of what AngularJS, web components and HTML5 have to offer, Supersonic has crafted a level of sophistication that is years ahead of the competition.

Supersonic UI is a game-changer. It's an Ionic fork that changes the way you think about hybrid app performance. Supersonic's declarative UI style makes building complex mobile apps a breeze. In the background, the seamless interplay of native UI and HTML5 bakes an end-result that is 100% indistinguishable from any native app.

Supersonic bridges the gap by using native UI elements when HTML and CSS just don't cut it. No more position: fixed; header bars, slow tabs or choppy animations. Page transitions, modals, navigation bars, tab bars, drawers – and a whole lot more – are fully native. That means unparalleled performance and no App Store rejections.

Video for SuperSonic

https://www.youtube.com/watch?v=7uppxfhxl48

Small Discussion About Guard in Angular?

What is Guard?
Guards make sure that the application user with the access permission can access that particular area in the application.
It is mainly used to protect routes.

Guard Types:

CanActivate - this guard helps decide whether a route can be activated or not.
CanActivateChild - this guard helps to decide whether children routes of a route can be activated or not.
CanDeactivate - this guard helps decide whether a route can be deactivated or not.
CanLoad - this guard helps decide whether a module can be loaded lazily or not

Guards can be implemented in different ways, but after all it really boils down to a function that returns either Observable<boolean>, Promise<boolean> or boolean. In addition, guards are registered using providers, so they can be injected by Angular when needed.

To register a guard we need to define a token and the guard function. Here’s what a super simple guard implementation could look like:

@NgModule({
...
providers: [
provide: 'CanAlwaysActivateGuard',
useValue: () => {
return true;
}
],
...
})
export class AppModule {}

Video for Guard

https://www.youtube.com/watch?v=0Qsg8fyKwO4

Discussion About SAPUI5?

References

Your comment on this post:

Related Articles