Discussion About ShapeJS?

What is ShapeJS?

ShapeJS is a language designed to make creating and sharing 3D printable objects easy. Based on Javascript, it provides a rich set of solid modeling primitives over top a powerful voxel engine.

The combination enables control of 3d printed objects down to printer resolution levels. The voxel approach has many advantages over typical triangle systems and aligns well with how 3d printers actually manufacture items.

Scripts include a parameter definition to allow interactive exploration of interesting variants via an automatically generated user interface

ShapeJS provides assistance in generating correct wall-thickness and manifold objects through per-voxel level control.

Supports use of 2D Image data to be mapped onto 3D objects without compromising functional design.
Per-voxel level control enables generation of printable products at printer native resolutions.

It used to be hard to create applications that generate 3D printable geometry.With ShapeJS it's as simple as a few lines of code!

Example:

ShapeJS Scripts are Javascript programs over top the AbFab3D Voxel library. All standard Javascript functionality is supported.

Video for Shape.Js

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 ShapeJS?

References

Your comment on this post:

Related Articles