ivan-kleshnin

Basics

• "The Non-Designer's Design Book", Robin Williams (book)
• "Don't Make Me Think", Steve Krug (book)

Typography

• Practical Typography (site)

Mixed

ivan-kleshnin

function swap(i1, i2, xs) {
  if (i1 == i2) return xs
  return xs.reduce((z, x, i) => {
    return i == i1 ? z :
           i == i2 ? (i1 > i2 ? [...z, xs[i1], x] : [...z, x, xs[i1]]) :
                     [...z, x]
  }, [])
}

// Например, переставить 'B' с i1 = 1 на i2 = 4

ivan-kleshnin

A tale of SSR

Attempts to recover our SSR functionality.

1. After.js [-]

• Semi-dead project. Suggest to switch to Razzle (its core)

2. Razzle [-]

ivan-kleshnin

TODO

• https://developers.google.com/web/progressive-web-apps/checklist
• https://frontendchecklist.io/

Prerequisites

• Team agreed on technology set
• Licenses, cost of infrastructure etc. covered
• Operating model (including SLAs) determined

ivan-kleshnin

Object Oriented Programming

I   Objects / Classes are main units of design
II  Objects are namespaces (expression problem, duality with Functional Programming)
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
III  Delegation / Inheritance (type dependency)
 IV  Constructors (vs data constructors)
  V  Mutability (shared state)
 VI  Fluent API (http://paqmind.com/blog/fluent-api-debunked/)
VII Instance

ivan-kleshnin

import * as R from "ramda"

let Atom = R.curry((options, actions) => {
  console.log(`@ Atom "${options.name || ""}" is called`)
  return {$: "$"}
})

let withLog = R.curry((options, Atom) => {
  return (actions) => {
    console.log(`@ Shell "withLog" is called`)

ivan-kleshnin

My code from: https://gist.github.com/penguinboy/762197

let isPlainObj = (o) => Object.prototype.toString.call(o) == "[object Object]"
// this ^ is enough. If you check prototypes – you're doing it wrong. If somethings pretends to be plain – we have to accept that
// e.g. this: https://github.com/jonschlinkert/is-plain-object is an entirely WRONG approach 

let flattenObj = (obj, keys=[]) => {
  return Object.keys(obj).reduce((acc, key) => {
    return Object.assign(acc, isPlainObj(obj[key])

ivan-kleshnin

Idris: first impression

Language

Likes

Dependent types

The idea and approach is brilliant. I hope it's the next big thing in programming.

ivan-kleshnin

/*
Pascal's Triangle
     1
    1 1
   1 2 1
  1 3 3 1
 1 4 6 4 1

The numbers at the edge of the triangle are all 1, and each number inside the triangle is the sum of
the two numbers above it. Write a procedure that computes elements of Pascal's triangle by means of

ivan-kleshnin

Parallel – 2+ processes (or cores)
Concurrent – whatever

Parallel is for increasing throughput
Concurrent is for decreasing latency

Parallel is for non-interactive (performance) (few inputs, deterministic or non-deterministic)
Concurrent is for interactive (experience) (many inputs, non-deterministic)

Parallel – how fast it gets result