SlideShare a Scribd company logo
Reactive
Type-safe
WebComponents
with @skate_js
Martin Hochel
@martin_hotell
Martin Hochel
SE, Prague / Czech Republic
@martin_hotell
github.com/Hotell
Hello Prague !
▪ @ngPartyCz meetup founder
▪ Author of ngMetadata
▪ Member of @skate_js
▪
▪
Today’s talk
Will be all about
Skateboarding
This is how you do an Ollie
Reactive Type safe Webcomponents with skateJS
Problem set 1:
Create a reusable widget
Problem 1
Create
reusable widget
Library size
10.7 kB
4.9 kB
3.9 kB
Implementation size
4.2 kB
4.12 kB
2.2kB
MINIFIED + GZIPPED
32.7kB
MINIFIED + GZIPPED
Problem 1
Create
reusable widget
FUTURE JS
Problem set I1:
Create Interoperable Widget
Problem I1
Create
Interoperable widget ALPHA
BETA
GAMMA DELTA
Widget
Reactive Type safe Webcomponents with skateJS
Reactive Type safe Webcomponents with skateJS
WebComponents ?
WHY WHAT HOW
WebComponents
WHY
WebComponents
WHY
WebComponents
Reusable
Interoperable
Problem
I + I1
Solved
So can I write whole apps with
vanilla WebComponents ?
You can! but It will/may hurt
WHAT
is a WebComponent
“
Platform new primitive for building
Reusable
Interoperable
Encapsulated
Widgets
<sk-user name="Martin" age="100">
<img src="./assets/skate-deck.jpg">
</sk-user>
Custom
Elements
Shadow
DOM
JS
Modules
WebComponents
Templates
Custom
Elements
class User extends HTMLElement {}
// user.component.js
<sk-user></sk-user>
// index.html
// Global registry
window.customElements.define('sk-user', User)
window.customElements.get('sk-user') // User
Custom
Elements
API
Attributes / Properties
Events
Life Cycle hooks
// $0 === User instance
$0.setAttribute('age','18')
$0.age = 18
// Imperative (JS)
<sk-user age="100"></sk-user>
// Declarative (HTML)
Custom Elements
API
Attributes
&
Properties
Primitive
Data
export class User extends HTMLElement {
static get observedAttributes() {
return ['age']
}
_age = 0
set age(value) {
this._age = Number(value)
this.render()
}
get age() {
return this._age
}
attributeChangedCallback(name, oldValue, newValue) {
this.age = newValue
}
render() {}
}
// user.component.js
Custom Elements
API
Attributes
&
Properties
Primitive
Data
export class User extends HTMLElement {
static get observedAttributes() {
return ['age']
}
_age = 0
set age(value) {
this._age = Number(value)
this.render()
}
get age() {
return this._age
}
attributeChangedCallback(name, oldValue, newValue) {
this.age = newValue
}
render() {}
}
// user.component.js
$0.age = 18
$0.age
Custom Elements
API
Attributes
&
Properties
Primitive
Data
export class User extends HTMLElement {
static get observedAttributes() {
return ['age']
}
_age = 0
set age(value) {
this._age = Number(value)
this.render()
}
get age() {
return this._age
}
attributeChangedCallback(name, oldValue, newValue) {
this.age = newValue
}
render() {}
}
// user.component.js
$0.setAttribute('age','18')
Custom Elements
API
Attributes
&
Properties
Primitive
Data
// $0 === User instance
$0.tricks = [
{ name: 'ollie', difficulty: 'easy' },
{ name: 'kickflip', difficulty: 'medium' },
{ name: 'hardflip', difficulty: 'hard' },
]
// Imperative (JS)
<sk-user hobbies="[{
"name": "ollie",
"difficulty ": "easy"
}]"></sk-user>
// Declarative (HTML)
Custom Elements
API
Attributes
&
Properties
Rich
Data
export class User extends HTMLElement {
_tricks = []
set tricks(value) {
this._tricks = value
this.render()
}
get tricks() {
return this._tricks
}
render() {}
}
// user.component.js
Custom Elements
API
Attributes
&
Properties
Rich
Data
export class User extends HTMLElement {
_tricks = []
set tricks(value) {
this._tricks = value
this.render()
}
get tricks() {
return this._tricks
}
render() {}
}
// user.component.js
Custom Elements
API
Attributes
&
Properties
Rich
Data
export class User extends HTMLElement {
_tricks = []
set tricks(value) {
this._tricks = value
this.render()
}
get tricks() {
return this._tricks
}
render() {}
}
// user.component.js
Custom Elements
API
Attributes
&
Properties
Rich
Data
// $0 === User instance
$0.addEventListener('learntrick',(event)=>{ /* ... */ })
// Imperative (JS)
Nope
// Declarative (HTML)
Custom Elements
API
Events
export class User extends HTMLElement {
emitLearnTrick(trick) {
const eventConfig = {
bubble: true,
composed: false,
detail: trick
}
const event = new CustomEvent('learntrick', eventConfig)
this.dispatchEvent(event)
}
}
// user.component.js
Custom Elements
API
Events
export class User extends HTMLElement {
constructor() {
super()
}
attributeChangedCallback(name, oldValue, newValue) {
// do some stuff
}
connectedCallback() {
console.log('component mounted!')
}
disconnectedCallback() {
console.log('goodbye!')
}
render() {}
}
// user.component.js
Custom Elements
API
Life Cycle
Hooks
export class User extends HTMLElement {
constructor() {
super()
}
attributeChangedCallback(name, oldValue, newValue) {
// do some stuff
}
connectedCallback() {
console.log('component mounted!')
}
disconnectedCallback() {
console.log('goodbye!')
}
render() {}
}
// user.component.js
Custom Elements
API
Life Cycle
Hooks
export class User extends HTMLElement {
constructor() {
super()
}
attributeChangedCallback(name, oldValue, newValue) {
// do some stuff
}
connectedCallback() {
console.log('component mounted!')
}
disconnectedCallback() {
console.log('goodbye!')
}
render() {}
}
// user.component.js
Custom Elements
API
Life Cycle
Hooks
export class User extends HTMLElement {
constructor() {
super()
}
attributeChangedCallback(name, oldValue, newValue) {
// do some stuff
}
connectedCallback() {
console.log('component mounted!')
}
disconnectedCallback() {
console.log('goodbye!')
}
render() {}
}
// user.component.js
Custom Elements
API
Life Cycle
Hooks
export class User extends HTMLElement {
constructor() {
super()
}
attributeChangedCallback(name, oldValue, newValue) {
// do some stuff
}
connectedCallback() {
console.log('component mounted!')
}
disconnectedCallback() {
console.log('goodbye!')
}
render() {}
}
// user.component.js
Custom Elements
API
Life Cycle
Hooks
<template>
<template id="view">
<style>
:host { display: flex }
div { color: blue; }
</style>
<h2>Hello World!</h2>
<p>Yo what’s up dough?</p>
<slot></slot>
</template>
// user.template.html
<template>
<template id="view">
<style>
:host { display: flex }
div { color: blue; }
</style>
<h2>Hello World!</h2>
<p>Yo what’s up dough?</p>
<slot></slot>
</template>
// user.template.html
<template>
<template id="view">
<style>
:host { display: flex }
div { color: blue; }
</style>
<h2>Hello World!</h2>
<p>Yo what’s up dough?</p>
<slot></slot>
</template>
// user.template.html
<template>
<template id="view">
<style>
:host { display: flex }
div { color: blue; }
</style>
<h2>Hello World!</h2>
<p>Yo what’s up dough?</p>
<slot></slot>
</template>
// user.template.html
<template>
export class User extends HTMLElement {
constructor() {
super()
const template = document.querySelector('#view')
const view = template.content.cloneNode(true)
this.appendChild(view)
}
}
// user.component.html
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
LIGHT
Shadow
DOM
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<style></style>
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
<style></style>
<sk-user name="Martin" age="30">
<img src="./assets/skate-deck.jpg">
</sk-user>
<sk-user name="Martin" age="30">
#shadow-root(open)
<style></style>
<div>
<ul>
<li>Age</li>
</ul>
<slot>#refToImg</slot>
</div>
<img src="./assets/skate-deck.jpg">
</sk-user>
Shadow
DOM
constructor() {
super()
const shadowRoot = this.attachShadow({ mode: 'open' })
shadowRoot.appendChild(template.content.cloneNode(true))
}
Shadow
DOM
Isolated sandbox
API -> projection -> <slot/>
scoped CSS
<script type="module">
import './src/app.js'
</script>
<my-app></my-app>
JS
Modules
WHAT ✅
is a WebComponent
Hey!
What about browser support?
Browser
support
HOW
to build a WebComponent
Reactive
Type-safe
<sk-app>
WC App
Demo
WC App
architecture
WC App
Reactive
data-flow
sk-app
sk-user
name: string
age: number
tricks: Array<Trick>
learntrick: CustomEvent<Trick>
removetrick: CustomEvent<Trick>
export type Trick = {
name: string
difficulty: 'easy' | 'medium' | 'hard'
}
sk-user
Implementation
Types, template
type Attrs = 'name' | 'age'
type Props = {
name: string
age: number
tricks: Array<Trick>
}
const template = document.createElement('template')
template.innerHTML = `
<style> :host { … } </style>
<header>
Hello <b id="name"></b>! Let's skate!
</header>
<div>
Only <b id="age"></b> years old? Time to learn new tricks!
</div>
<form>
<input name="trickName" value="">
<select id="trickDifficulty" class="form-control">
</form>
`
// user.component.ts
export class User extends HTMLElement implements Props {
set name(value: string) {}
get name() {}
set age(value: number) {}
get age() {}
set tricks(value: Array<Trick>) {}
get tricks() {
private _tricks: Array<Trick> = []
private view: {
form: HTMLFormElement
trickList: HTMLUListElement
age: HTMLElement
name: HTMLElement
}
}
sk-user
Implementation
Define Properties
window.customElements.define('sk-user', User)
// user.component.ts
export class User extends HTMLElement implements Props {
constructor() {
super()
const shadowRoot = this.attachShadow({ mode: 'open' })
shadowRoot.appendChild(template.content.cloneNode(true))
this.view = {
form: shadowRoot.querySelector('form'),
trickList: shadowRoot.querySelector('#trick-list'),
age: shadowRoot.querySelector('#age'),
name: shadowRoot.querySelector('#name'),
}
this.view.form.addEventListener(
'submit',
this.handleNewTrickAddition
)
}
}
sk-user
Implementation
construction
// user.component.ts
export class User extends HTMLElement implements Props {
attributeChangedCallback(
name: Attrs, oldValue: string | null, newValue: string | null
) {
this.render()
}
connectedCallback() {
this.render()
}
}
sk-user
Implementation
Reactions,
Rendering
// user.component.ts
Reactive Type safe Webcomponents with skateJS
HOW
frameworks/libraries Interop with
WebComponents
index.html
<sk-user
name="Martin"
age="100"
tricks=""[{"foo":"bar"}]""
></sk-user>
app.component.html
<sk-user
[attr.name]="model.name"
[attr.age]="model.age"
[tricks]="model.tricks"
></sk-user>
App.vue
<sk-user
:name="model.name"
:age="model.age"
:tricks.prop="model.tricks"
></sk-user>
App.tsx
<sk-user
name={this.state.user.name}
age={this.state.user.age}
tricks={this.state.user.tricks}
/>
https://custom-elements-everywhere.com
“
So what’s the problem with
vanilla WebComponents ?
“
UNFORTUNATELY
THE DEVELOPER EXPERIENCE
OF BUILDING AN APPLICATION
WITH WEB COMPONENTS TODAY IS
QUITE PAINFUL
SAM SACCONE
Reactive Type safe Webcomponents with skateJS
“
Eventually
You’ll build some kind
of abstraction
From Imperative
to Declarative
rendering
lit-html
HTML templates,
via JavaScript template literals
const sayHello = (name: string) =>
html`<div>Hello ${name}!</div>`
lit-html
const container = document.querySelector('#container')
render(sayHello('Steve'), container)
// renders <div>Hello Steve!</div> to container
render(sayHello('Kevin'), container);
// renders <div>Hello Kevin!</div> to container
class App extends HTMLElement {
connectedCallback() {
console.log('App mounted')
this.render()
}
render() {
const { tricks, logs } = this
const template = html`
<ul class="log">
${logs.map(item => CreateLogEvent(item))}
</ul>
<sk-user
name="Martin"
age="30"
tricks="${tricks}"
on-learnTrick="${this.handleNewTrick}"
on-removeTrick="${this.handleRemoveTrick}"
><sk-user>
`
render(template, this.shadowRoot)
}
}
lit-html
Building API via composition & mixins
export const withShadow = <TBase>(Base: TBase) =>
class WithShadow extends Base {
constructor(...args: Array<any>) {
super(...args)
this.attachShadow({ mode: 'open' })
}
}
JS mixins
class App extends withShadow(HTMLElement) { }
class App extends withRender(withShadow(HTMLElement)) { }
Good news !
Skate JSSkate JS
Skate JSSkate JS
What is
skateJS Reactive
Pluggable
WebComponents Micro-library
Stable 4.x
Beta 5.x
2200+ ⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Reactive ?
props
View
Logic
render
Action
( click, keypress )
state
Pluggable ?
- mixins
- custom renderers
- fine grained LC hooks
Micro library ?
HOW
to build a WebComponent
with
skateJS
Core Tricks
skateJS
Renderers
- renderer-preact
- renderer-react
- renderer-lit-html
- renderer-vue ( TODO )
- custom
import { withComponent } from 'skatejs';
import withPreact from '@skatejs/renderer-preact';
export const Component = withComponent(withPreact())
Choose
renderer
import { withComponent } from 'skatejs';
import withPreact from '@skatejs/renderer-preact';
export const Component = withComponent(withPreact())
Choose
renderer
import { withComponent } from 'skatejs';
import withPreact from '@skatejs/renderer-preact';
export const Component = withComponent(withPreact())
Choose
renderer
import { h } from 'preact'
import { props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
static readonly props = {
name: props.string,
}
renderCallback() {
const { name } = this.props
return <span>Hello, {name}!</span>
}
}
customElements.define('x-hello', Hello)
Implement
Component
import { h } from 'preact'
import { props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
static readonly props = {
name: props.string,
}
renderCallback() {
const { name } = this.props
return <span>Hello, {name}!</span>
}
}
customElements.define('x-hello', Hello)
Implement
Component
import { h } from 'preact'
import { props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
static readonly props = {
name: props.string,
}
renderCallback() {
const { name } = this.props
return <span>Hello, {name}!</span>
}
}
customElements.define('x-hello', Hello)
Implement
Component
import { h } from 'preact'
import { props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
static readonly props = {
name: props.string,
}
renderCallback() {
const { name } = this.props
return <span>Hello, {name}!</span>
}
}
customElements.define('x-hello', Hello)
Implement
Component
import { h } from 'preact'
import { props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
static readonly props = {
name: props.string,
}
renderCallback() {
const { name } = this.props
return <span>Hello, {name}!</span>
}
}
customElements.define('x-hello', Hello)
Implement
Component
import { h, props } from 'skatejs'
import { Component } from './base'
type Props = {
name: string
}
class Hello extends Component<Props> {
}
declare global {
namespace JSX {
interface IntrinsicElements {
'x-hello': Props
}
}
}
Implement
Component
Reactive Type safe Webcomponents with skateJS
<sk-app>
github.com/Hotell/reactive-typesafe-webcomponents
Vanilla
vs
Skate
Vanilla With skateJS
Advanced Tricks
Advanced Tricks
- State like React
- No default renderer in core ✅
- Mixins for everything - ✅
- API for turning off ShadowDOM - ✅
- Server side rendering - ✅
- Testing with Jest - ✅
@skatejs
ecoystem
● ssr
● val
● bore
Support us !
Keep in touch
github.com/skatejs/skatejs
@skate_js
@treshugart
@martin_hotell
What did
we learn ?
Are WebCompoents
The Future of web ?
The Future is now
KEEP CALM
and
USE
WEBCOMPONENTS
Thank you ! Martin Hochel
@martin_hotell

More Related Content

PDF
Reactive Type-safe WebComponents
PDF
JavaScript Libraries (@Media)
PDF
JavaScript Libraries (Kings of Code)
PDF
jQuery (MeshU)
PDF
jQuery (BostonPHP)
PDF
jQuery Internals + Cool Stuff
PDF
Introduction to jQuery
KEY
The jQuery Library
Reactive Type-safe WebComponents
JavaScript Libraries (@Media)
JavaScript Libraries (Kings of Code)
jQuery (MeshU)
jQuery (BostonPHP)
jQuery Internals + Cool Stuff
Introduction to jQuery
The jQuery Library

What's hot (20)

PDF
jQuery in the [Aol.] Enterprise
PDF
Building Universal Web Apps with React ForwardJS 2017
PDF
JQuery in Seaside
PDF
Polymer, A Web Component Polyfill Library
PDF
Polymer & the web components revolution 6:25:14
PPT
jQuery For Developers Stack Overflow Dev Days Toronto
PPTX
FuncUnit
PDF
JavaScript Library Overview
PPTX
PDF
Why and How to Use Virtual DOM
PPTX
The Many Ways to Build Modular JavaScript
PDF
Basic Tutorial of React for Programmers
PDF
gDayX 2013 - Advanced AngularJS - Nicolas Embleton
PDF
Javascript Module Patterns
PDF
Vaadin Components @ Angular U
PDF
Enjoy the vue.js
PDF
Using ReactJS in AngularJS
PDF
From Back to Front: Rails To React Family
PDF
The Complementarity of React and Web Components
PDF
Rails + Webpack
jQuery in the [Aol.] Enterprise
Building Universal Web Apps with React ForwardJS 2017
JQuery in Seaside
Polymer, A Web Component Polyfill Library
Polymer & the web components revolution 6:25:14
jQuery For Developers Stack Overflow Dev Days Toronto
FuncUnit
JavaScript Library Overview
Why and How to Use Virtual DOM
The Many Ways to Build Modular JavaScript
Basic Tutorial of React for Programmers
gDayX 2013 - Advanced AngularJS - Nicolas Embleton
Javascript Module Patterns
Vaadin Components @ Angular U
Enjoy the vue.js
Using ReactJS in AngularJS
From Back to Front: Rails To React Family
The Complementarity of React and Web Components
Rails + Webpack
Ad

Similar to Reactive Type safe Webcomponents with skateJS (20)

PDF
The Web Components interoperability challenge - Horacio Gonzalez - Codemotion...
PDF
Interoperable Component Patterns
PDF
Web components - An Introduction
PDF
Web Components Everywhere
PDF
Thinking in Components
PDF
Building Reusable Custom Elements With Angular
PDF
Introduction to Polymer and Firebase - Simon Gauvin
PDF
Polymer - pleasant client-side programming with web components
PPTX
Web Components: The Future of Web Development is Here
PDF
Web components are the future of the web - Take advantage of new web technolo...
PPTX
Web component
PDF
Frameworks and webcomponents
PPTX
Polytechnic speaker deck oluwadamilare
PPTX
Polytechnic speaker deck oluwadamilare
PDF
Webcomponents from 0-100 - with Google's Lit
PDF
Leveraging the Power of Custom Elements in Gutenberg
PPTX
Web Components: The Future of Web Development is Here
PDF
Web Components for Java Developers
PDF
Web components: A simpler and faster react
PDF
Polymer
The Web Components interoperability challenge - Horacio Gonzalez - Codemotion...
Interoperable Component Patterns
Web components - An Introduction
Web Components Everywhere
Thinking in Components
Building Reusable Custom Elements With Angular
Introduction to Polymer and Firebase - Simon Gauvin
Polymer - pleasant client-side programming with web components
Web Components: The Future of Web Development is Here
Web components are the future of the web - Take advantage of new web technolo...
Web component
Frameworks and webcomponents
Polytechnic speaker deck oluwadamilare
Polytechnic speaker deck oluwadamilare
Webcomponents from 0-100 - with Google's Lit
Leveraging the Power of Custom Elements in Gutenberg
Web Components: The Future of Web Development is Here
Web Components for Java Developers
Web components: A simpler and faster react
Polymer
Ad

Recently uploaded (20)

PPTX
Spectroscopy.pptx food analysis technology
PDF
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
PDF
The Rise and Fall of 3GPP – Time for a Sabbatical?
PDF
NewMind AI Weekly Chronicles - August'25 Week I
PPTX
Big Data Technologies - Introduction.pptx
PDF
Profit Center Accounting in SAP S/4HANA, S4F28 Col11
DOCX
The AUB Centre for AI in Media Proposal.docx
PDF
Reach Out and Touch Someone: Haptics and Empathic Computing
PDF
Network Security Unit 5.pdf for BCA BBA.
PDF
Encapsulation_ Review paper, used for researhc scholars
PDF
Mobile App Security Testing_ A Comprehensive Guide.pdf
PDF
Advanced methodologies resolving dimensionality complications for autism neur...
PPTX
Cloud computing and distributed systems.
PDF
Encapsulation theory and applications.pdf
PPTX
MYSQL Presentation for SQL database connectivity
PPTX
Digital-Transformation-Roadmap-for-Companies.pptx
PDF
Approach and Philosophy of On baking technology
PPTX
Effective Security Operations Center (SOC) A Modern, Strategic, and Threat-In...
PDF
Machine learning based COVID-19 study performance prediction
PPTX
Detection-First SIEM: Rule Types, Dashboards, and Threat-Informed Strategy
Spectroscopy.pptx food analysis technology
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
The Rise and Fall of 3GPP – Time for a Sabbatical?
NewMind AI Weekly Chronicles - August'25 Week I
Big Data Technologies - Introduction.pptx
Profit Center Accounting in SAP S/4HANA, S4F28 Col11
The AUB Centre for AI in Media Proposal.docx
Reach Out and Touch Someone: Haptics and Empathic Computing
Network Security Unit 5.pdf for BCA BBA.
Encapsulation_ Review paper, used for researhc scholars
Mobile App Security Testing_ A Comprehensive Guide.pdf
Advanced methodologies resolving dimensionality complications for autism neur...
Cloud computing and distributed systems.
Encapsulation theory and applications.pdf
MYSQL Presentation for SQL database connectivity
Digital-Transformation-Roadmap-for-Companies.pptx
Approach and Philosophy of On baking technology
Effective Security Operations Center (SOC) A Modern, Strategic, and Threat-In...
Machine learning based COVID-19 study performance prediction
Detection-First SIEM: Rule Types, Dashboards, and Threat-Informed Strategy

Reactive Type safe Webcomponents with skateJS