SlideShare a Scribd company logo

TypeScript as a runtime error terminator

The Software House, profile picture
The Software House

W ostatnich latach TypeScript bez wątpienia coraz częściej staje się standardowym narzędziem w JavaScriptowych środowiskach. Pomaga wyłapać wiele błędów nim aplikacja zostanie uruchomiona, ale niestety samo jego użycie w projekcie nie jest panaceum na wszystkie tego typu błędy. Dlatego też podczas prezentacji przyjrzymy się technikom, które pozwalają zaprojektować kod, który prowadzi programistów za rączkę do świata w którym błędy w trybie runtime są rzadkością.

Software
Related topics:
Insights on Software Development
1 of 140
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
TypeScript as a runtime error terminator
Dlaczego TypeScript? ? ? ? ? ? ? ?
Problemy z JSem
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); }
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]);
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123"
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]);
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' });
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' }); // "😜"
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' }); // "😜" sum({});
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' }); // "😜" sum({});
Problemy z JSem function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' }); // "😜" sum({});
Problemy z JSem Problemy języków dynamicznie typowanych function sum(elements) { return elements.reduce((a, b) => a + b, 0); } sum([1, 2, 3]); // 6 sum(["1", "2", "3"]); // "0123" sum([undefined, 2, 3, 4]); // NaN sum({ reduce: () => '😜' }); // "😜" sum({});
Zaawansowane 👨🏫
Podstawowa ochrona typów function sum(elements: number[]) { return elements.reduce((a, b) => a + b, 0); }
Typy złożone type User = { id: string; firstName: string; lastName: string; email: string; } function createUser(user: User) { // ... }
Dziękuje za uwagę!
Dziękuje za uwagę! Pytania?
Dziękuje za uwagę! Pytania?
🐣 Podstawy
JSDoc?
👨🏫 Zaawansowany
Generyki 🤹 https://www.typescriptlang.org/docs/handbook/2/generics.html
function identity(arg: number): number { return arg; }
function identity(arg: number): number { return arg; } const x = identity(5); // x: number
function identity(arg: number): number { return arg; } const x = identity(5); // x: number const y = identity("a");
function identity(arg: number): number { return arg; } const x = identity(5); // x: number const y = identity("a");
function identity(arg: any): any { return arg; }
function identity(arg: any): any { return arg; } const x = identity(5);
function identity(arg: any): any { return arg; } const x = identity(5); const y = identity("a");
function identity(arg: any): any { return arg; } const x = identity(5); const y = identity("a"); // x: any
function identity(arg: any): any { return arg; } const x = identity(5); const y = identity("a"); // x: any // y: any
function identity<Type>(arg: Type): Type { return arg; }
function identity<Type>(arg: Type): Type { return arg; } const x = identity<number>(1); // x: number
function identity<Type>(arg: Type): Type { return arg; } const x = identity<number>(1); // x: number const y = identity<number>("1");
function identity<Type>(arg: Type): Type { return arg; } const x = identity<number>(1); // x: number const y = identity<number>("1");
function identity<Type>(arg: Type): Type { return arg; } const x = identity<number>(1); // x: number const y = identity<number>("1"); const z = identity<string>("1"); // z: string
Type inference 🕵
function identity<Type>(arg: Type): Type { return arg; } const x = identity<number>(1); // x: number const y = identity<string>("1"); // z: string
function identity<Type>(arg: Type): Type { return arg; } const x = identity(1); // x: number const y = identity("1"); // z: string
Utility Types 🛠
https://www.typescriptlang.org/docs/handbook/utility-types.html
Case study: User update
DEMO
extends
extends Constraint
extends Constraint Conditional type
Constraint 🔗
Conditional types 🚦
Conditional type <type> extends <type> ? <ok_type> : <else_type>
Conditional type <type> extends <type> ? <ok_type> : <else_type> type X = true extends boolean ? "OK" : "ERR" // "OK"
Conditional type <type> extends <type> ? <ok_type> : <else_type> type X = true extends boolean ? "OK" : "ERR" // "OK" type Y = number extends string ? "OK" : "ERR" // "ERR"
Conditional type <type> extends <type> ? <ok_type> : <else_type> type X = true extends boolean ? "OK" : "ERR" // "OK" type Y = number extends string ? "OK" : "ERR" // "ERR" type TypeName<T> = T extends boolean ? "boolean" : T extends string ? "string" : T extends number ? "number" : T extends null ? "null" : T extends Array<any> ? "array" : T extends object ? "object" : T extends undefined ? "undefined" : string;
Conditional type <type> extends <type> ? <ok_type> : <else_type> type X = true extends boolean ? "OK" : "ERR" // "OK" type Y = number extends string ? "OK" : "ERR" // "ERR" type TypeName<T> = T extends boolean ? "boolean" : T extends string ? "string" : T extends number ? "number" : T extends null ? "null" : T extends Array<any> ? "array" : T extends object ? "object" : T extends undefined ? "undefined" : string; function typeName<T>(value: T): TypeName<T> { // ... }
Conditional type <type> extends <type> ? <ok_type> : <else_type> type X = true extends boolean ? "OK" : "ERR" // "OK" type Y = number extends string ? "OK" : "ERR" // "ERR" type TypeName<T> = T extends boolean ? "boolean" : T extends string ? "string" : T extends number ? "number" : T extends null ? "null" : T extends Array<any> ? "array" : T extends object ? "object" : T extends undefined ? "undefined" : string; function typeName<T>(value: T): TypeName<T> { // ... } typeName("test"); // "string" typeName(1); // "number" typeName(JSON.parse("{}")); // string
Typ „never” ⛔
Typ „never”
Typ „never” function throwError(): never { throw new Error("Some error"); }
Typ „never” function throwError(): never { throw new Error("Some error"); } type FailedPromise = Promise<never>; function asyncError(): FailedPromise { return Promise.reject("Some error"); }
Typ „never” function throwError(): never { throw new Error("Some error"); } type FailedPromise = Promise<never>; function asyncError(): FailedPromise { return Promise.reject("Some error"); } type EmptyObject = Record<any, never>;
Typ „never” function throwError(): never { throw new Error("Some error"); } type FailedPromise = Promise<never>; function asyncError(): FailedPromise { return Promise.reject("Some error"); } type EmptyObject = Record<any, never>; const test1: EmptyObject = { x: 1 }; // Error const test2: EmptyObject = {}; // OK
Typ „never” type EmptyArray = never[]; function throwError(): never { throw new Error("Some error"); } type FailedPromise = Promise<never>; function asyncError(): FailedPromise { return Promise.reject("Some error"); } type EmptyObject = Record<any, never>; const test1: EmptyObject = { x: 1 }; // Error const test2: EmptyObject = {}; // OK
Lookup typów 🔍
type ComplexType = { foo: { a: string; b: string; c: string; bar: { x: number; y: number; } }, } type Foo = ComplexType["foo"]; // { a, b, c, ... } type Bar = ComplexType["foo"]["bar"]; // { x, y }
export type Users = { id: string, … }[]; type User =
export type Users = { id: string, … }[]; type User = Users[number];
Case study: CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } }
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
export class CommandBus { private availableHandlers: CommandHandlers ; constructor(commandHandlers: CommandHandler[]) { this.availableHandlers = commandHandlers.reduce((handlers: CommandHandlers, handler) => { handlers[handler.commandType] = handler ; return handlers ; }, {}) ; } public execute(command: any) { if (!this.availableHandlers[command.type]) { return Promise.reject(new Error(`Command: ${command.type} is not supported.`)) ; } return this.availableHandlers[command.type].execute(command) ; } } CommandHandlerA CommandHandlerB CommandA CommandB CommandBus
import LoginHandler from "../app/features/users/handlers/login.handler" ; import DeleteUserHandler from "../app/features/users/handlers/delete-user.handler" ; // HANDLERS_IMPORT S export async function registerCommandHandlers(container: AwilixContainer) { container.register( { commandHandlers: asArray<any>( [ awilix.asClass(LoginHandler) , awilix.asClass(DeleteUserHandler) , // COMMAND_HANDLERS_SETU P ]) , }) ; return container ; }
DEMO
type DeleteUserCommand = { type: string ; payload: { id?: string | null | undefined ; } } Dlaczego?
type DeleteUserCommand = { type: string ; payload: { id?: string | null | undefined ; } } type FooCommand = { type: string ; payload: {} ; } Dlaczego?
type DeleteUserCommand = { type: string ; payload: { id?: string | null | undefined ; } } type FooCommand = { type: string ; payload: {} ; } Dlaczego?
type DeleteUserCommand = { type: string ; payload: { id?: string | null | undefined ; } } type FooCommand = { type: string ; payload: {} ; } Rozwiązanie?
type DeleteUserCommand = { type: string ; payload: { id?: string | null | undefined ; } } type FooCommand = { type: string ; payload: {} ; } Rozwiązanie? type DeleteUserCommand = { type: "users/DELETE_USER" ; payload: { id?: string | null | undefined ; } } type FooCommand = { type: "foo" ; payload: {} ; }
Kiedy runtime error jest nieunikniony…
Problem: dane wejściowe
Problem: dane wejściowe Pole formularza
Problem: dane wejściowe Pole formularza Odpowiedź z serwera
Problem: dane wejściowe Request Pole formularza Odpowiedź z serwera
Problem: dane wejściowe Request Pole formularza Plik Odpowiedź z serwera
Problem: dane wejściowe Request Pole formularza Plik Zmienne środowiskowe Odpowiedź z serwera
Problem: dane wejściowe Request Pole formularza Plik Zmienne środowiskowe Odpowiedź z serwera Baza danych
Zmienne środowiskowe
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS=
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS= 3
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS= 3 MAX_FAILED_LOG_IN_ATTEMPTS=
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS= 3 MAX_FAILED_LOG_IN_ATTEMPTS= DUNNO
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS= 3 MAX_FAILED_LOG_IN_ATTEMPTS= DUNNO MAX_FAILED_LOG_IN_ATTEMPTS=
Zmienne środowiskowe MAX_FAILED_LOG_IN_ATTEMPTS= 3 MAX_FAILED_LOG_IN_ATTEMPTS= DUNNO MAX_FAILED_LOG_IN_ATTEMPTS= =3
Zmienne środowiskowe
Zmienne środowiskowe EXTERNAL_API_URL=
Zmienne środowiskowe EXTERNAL_API_URL= https://api.com/v1/
Zmienne środowiskowe EXTERNAL_API_URL= https://api.com/v1/ EXTERNAL_API_URL=
Zmienne środowiskowe EXTERNAL_API_URL= https://api.com/v1/ EXTERNAL_API_URL= foo
Case: niesprawdzona konfiguracja
Case: niesprawdzona konfiguracja URL: „foo”
Case: niesprawdzona konfiguracja Endpoint A: nie korzysta z URLa URL: „foo”
Case: niesprawdzona konfiguracja Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa URL: „foo”
Case: niesprawdzona konfiguracja Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa 🕓 czas URL: „foo”
Case: niesprawdzona konfiguracja Start aplikacji Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa 🕓 czas URL: „foo”
Case: niesprawdzona konfiguracja Start aplikacji Request do A Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa 🕓 czas URL: „foo”
Case: niesprawdzona konfiguracja Start aplikacji Request do A Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa Request do A 🕓 czas URL: „foo”
Case: niesprawdzona konfiguracja Start aplikacji Request do A Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa Request do A Request do B 🕓 czas 💥 URL: „foo”
TypeScript as a runtime error terminator
Case: zwalidowana/sparsowana konfiguracja Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa URL: „foo”
Case: zwalidowana/sparsowana konfiguracja 🕓 czas Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa URL: „foo”
Case: zwalidowana/sparsowana konfiguracja Start aplikacji 🕓 czas Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa URL: „foo”
Case: zwalidowana/sparsowana konfiguracja Start aplikacji Parsowanie kon fi guracji 🕓 czas 💥 Endpoint A: nie korzysta z URLa Endpoint B: korzysta z URLa URL: „foo”
Kontrola graniczna 🛂
Kontrola graniczna Function 🛂 Input TS App 🛂 Input
import { URL } from "url" ; export const appConfig = { externalApiUrl: new URL(process.env.EXTERNAL_API_URL || "") , maxFailedLoginAttempts: parseInteger(process.env.MAX_FAILED_LOG_IN_ATTEMPTS || "") , } ; export type AppConfig = typeof appConfig ; function parseInteger(value: string): number { const parsedInt = parseInt(value) ; if (!Number.isInteger(parsedInt)) { throw new Error(`Expected integer, got: "${value}"`) ; } return parsedInt ; }
Podsumowanie
Podsumowanie • 🧘 Single source of truth
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User)
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User) • typeof na const
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User) • typeof na const • 🔀 TS umożliwia wprowadzenie logiki na poziomie typów
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User) • typeof na const • 🔀 TS umożliwia wprowadzenie logiki na poziomie typów • Generyki + type inference
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User) • typeof na const • 🔀 TS umożliwia wprowadzenie logiki na poziomie typów • Generyki + type inference • Zablokowanie kompilacji przez niepasujący typ
Podsumowanie • 🧘 Single source of truth • Na poziomie typów (przykład z encją User) • typeof na const • 🔀 TS umożliwia wprowadzenie logiki na poziomie typów • Generyki + type inference • Zablokowanie kompilacji przez niepasujący typ • 🛂 Parsuj dane z zewnątrz jak wcześnie to możliwe
Inne fajne zagadnienia
Inne fajne zagadnienia • Typed errors • https://hegel.js.org/ • https://rlee.dev/writing/practical-guide-to-fp-ts-part-3#either
Inne fajne zagadnienia • Typed errors • https://hegel.js.org/ • https://rlee.dev/writing/practical-guide-to-fp-ts-part-3#either • Nominal/brand/opaque types • https://basarat.gitbook.io/typescript/main-1/nominaltyping • https://michalzalecki.com/nominal-typing-in-typescript/
Inne fajne zagadnienia • Typed errors • https://hegel.js.org/ • https://rlee.dev/writing/practical-guide-to-fp-ts-part-3#either • Nominal/brand/opaque types • https://basarat.gitbook.io/typescript/main-1/nominaltyping • https://michalzalecki.com/nominal-typing-in-typescript/ • Mapped types • https://www.typescriptlang.org/docs/handbook/2/mapped-types.html
Inne fajne zagadnienia • Typed errors • https://hegel.js.org/ • https://rlee.dev/writing/practical-guide-to-fp-ts-part-3#either • Nominal/brand/opaque types • https://basarat.gitbook.io/typescript/main-1/nominaltyping • https://michalzalecki.com/nominal-typing-in-typescript/ • Mapped types • https://www.typescriptlang.org/docs/handbook/2/mapped-types.html • Phantom builder pattern • https://medium.com/carwow-product-engineering/phantom-builder-pattern-in-elm-2fcb950a4e36 • https://stackover fl ow.com/questions/65029441/how-to-implement-a-type-safe-phantom-types-based-builder-in-typescript • https://blog.scottlogic.com/2020/09/16/typescript-builders.html
TypeScript as a runtime error terminator
TypeScript as a runtime error terminator
Dzięki!

More Related Content

PDF
Architektura ngrx w angular 2+
Paweł Żurowski
 
PDF
Budowa elementów GUI za pomocą biblioteki React - szybki start
Sages
 
PDF
Znaki mocy dla laików – Programowanie funkcyjne w JavaScript
The Software House
 
PDF
Podstawy AngularJS
Sages
 
ODP
Php P.Jar
Jan Jackowicz-Korczyński
 
PDF
Wprowadzenie do technologii Big Data
Sages
 
PPTX
Konrad Kokosa - Pamięć w .NET - od ogólu do szczegółu- 4developers2016
PROIDEA
 
PPT
Podstawy php
TomaszWoniakowski1
 
Architektura ngrx w angular 2+
Paweł Żurowski
 
Budowa elementów GUI za pomocą biblioteki React - szybki start
Sages
 
Znaki mocy dla laików – Programowanie funkcyjne w JavaScript
The Software House
 
Podstawy AngularJS
Sages
 
Php P.Jar
Jan Jackowicz-Korczyński
 
Wprowadzenie do technologii Big Data
Sages
 
Konrad Kokosa - Pamięć w .NET - od ogólu do szczegółu- 4developers2016
PROIDEA
 
Podstawy php
TomaszWoniakowski1
 

What's hot (13)

PPT
Podstawy php
TomaszWoniakowski1
 
PDF
Nie wszystko, co ubite, w ziemi zostaje. Wprowadzenie do Event Sourcing
The Software House
 
PDF
Technologia Xamarin i wprowadzenie do Windows IoT core
Sages
 
PPTX
Prezentacja php3
TomaszWoniakowski1
 
PDF
TGT#11 - Zostały Ci jeszcze jakieś włosy? (Testowanie programów równoległych)...
Trójmiejska Grupa Testerska
 
PDF
Wprowadzenie do języka Swift, czyli nowe podejście do programowania aplikacji...
The Software House
 
PPSX
Professional Javascript for Developers
Rule_Financial
 
PPTX
AngularJS Warsaw #4 - Dariusz Kalbarczyk "Controller as"
Dariusz Kalbarczyk
 
PDF
React Ninja - Warsztaty TDD + React + Redux + Websockets
The Software House
 
PDF
Python szybki start
Sages
 
PDF
DSL - DYI
Maciek Próchniak
 
PDF
4Developers 2015: Property-based testing w języku Scala - Paweł Grajewski
PROIDEA
 
PDF
Objective C
konryd
 
Podstawy php
TomaszWoniakowski1
 
Nie wszystko, co ubite, w ziemi zostaje. Wprowadzenie do Event Sourcing
The Software House
 
Technologia Xamarin i wprowadzenie do Windows IoT core
Sages
 
Prezentacja php3
TomaszWoniakowski1
 
TGT#11 - Zostały Ci jeszcze jakieś włosy? (Testowanie programów równoległych)...
Trójmiejska Grupa Testerska
 
Wprowadzenie do języka Swift, czyli nowe podejście do programowania aplikacji...
The Software House
 
Professional Javascript for Developers
Rule_Financial
 
AngularJS Warsaw #4 - Dariusz Kalbarczyk "Controller as"
Dariusz Kalbarczyk
 
React Ninja - Warsztaty TDD + React + Redux + Websockets
The Software House
 
Python szybki start
Sages
 
DSL - DYI
Maciek Próchniak
 
4Developers 2015: Property-based testing w języku Scala - Paweł Grajewski
PROIDEA
 
Objective C
konryd
 
Ad

More from The Software House (20)

PDF
Jak kraść miliony, czyli o błędach bezpieczeństwa, które mogą spotkać również...
The Software House
 
PDF
Uszanowanko Podsumowanko
The Software House
 
PDF
Jak efektywnie podejść do certyfikacji w AWS?
The Software House
 
PDF
O co chodzi z tą dostępnością cyfrową?
The Software House
 
PDF
Chat tekstowy z użyciem Amazon Chime
The Software House
 
PDF
Migracje danych serverless
The Software House
 
PDF
Jak nie zwariować z architekturą Serverless?
The Software House
 
PDF
Analiza semantyczna artykułów prasowych w 5 sprintów z użyciem AWS
The Software House
 
PDF
Feature flags na ratunek projektu w JavaScript
The Software House
 
PDF
Typowanie nominalne w TypeScript
The Software House
 
PDF
Automatyzacja tworzenia frontendu z wykorzystaniem GraphQL
The Software House
 
PDF
Serverless Compose vs hurtownia danych
The Software House
 
PDF
Testy API: połączenie z bazą danych czy implementacja w pamięci
The Software House
 
PDF
Jak skutecznie read model. Case study
The Software House
 
PDF
Firestore czyli ognista baza od giganta z Doliny Krzemowej
The Software House
 
PDF
Jak utrzymać stado Lambd w ryzach
The Software House
 
PDF
Jak poskromić AWS?
The Software House
 
PDF
O łączeniu Storyblok i Next.js
The Software House
 
PDF
Amazon Step Functions. Sposób na implementację procesów w chmurze
The Software House
 
PDF
Od Figmy do gotowej aplikacji bez linijki kodu
The Software House
 
Jak kraść miliony, czyli o błędach bezpieczeństwa, które mogą spotkać również...
The Software House
 
Uszanowanko Podsumowanko
The Software House
 
Jak efektywnie podejść do certyfikacji w AWS?
The Software House
 
O co chodzi z tą dostępnością cyfrową?
The Software House
 
Chat tekstowy z użyciem Amazon Chime
The Software House
 
Migracje danych serverless
The Software House
 
Jak nie zwariować z architekturą Serverless?
The Software House
 
Analiza semantyczna artykułów prasowych w 5 sprintów z użyciem AWS
The Software House
 
Feature flags na ratunek projektu w JavaScript
The Software House
 
Typowanie nominalne w TypeScript
The Software House
 
Automatyzacja tworzenia frontendu z wykorzystaniem GraphQL
The Software House
 
Serverless Compose vs hurtownia danych
The Software House
 
Testy API: połączenie z bazą danych czy implementacja w pamięci
The Software House
 
Jak skutecznie read model. Case study
The Software House
 
Firestore czyli ognista baza od giganta z Doliny Krzemowej
The Software House
 
Jak utrzymać stado Lambd w ryzach
The Software House
 
Jak poskromić AWS?
The Software House
 
O łączeniu Storyblok i Next.js
The Software House
 
Amazon Step Functions. Sposób na implementację procesów w chmurze
The Software House
 
Od Figmy do gotowej aplikacji bez linijki kodu
The Software House
 
Ad

TypeScript as a runtime error terminator