victor-homyakov

Приёмы оптимизации кода по скорости

Организационные

• Культура разработки performance-first: https://tonsky.me/blog/performance-first/
• Бюджет скорости: https://wp-rocket.me/blog/performance-budgets/
• Performance mantra: http://www.brendangregg.com/blog/2018-06-30/benchmarking-checklist.html

Не зависящие от языка и его реализации

• Rosetta Code - реализации задач на разных языках: http://rosettacode.org/wiki/Collections
• Статьи по основным структурам данных:

slikts

React context vs Redux in 2020

The [React docs][condoc] give some example use cases for context:

Context is designed to share data that can be considered “global” for a tree of React components, such as the current authenticated user, theme, or preferred language.

The common property of these use cases is that data like the current theme doesn't change often and needs to be shared deep down the component tree, which would be cumbersome with "[prop drilling][drill]". Something else that needs to be shared everywhere is the application state when using a "single source of truth" pattern, so it would follow that the context API would help with that as well, but there's a catch: components that use context will rerender every time that the provided value changes, so sharing the whole application state through context would cause excessive render lifecycles.

artalar

type M = [any, any];
type Delete<k, m extends M> = k extends m[0]
  ? m extends [k, any]
    ? never
    : m
  : m[0] extends k
  ? [unknown, unknown]
  : m;
type Add<k, v, m extends M> = [k, v] | Delete<k, m>;
type Get<k, m extends M> = k extends m[0]

kevvzub

import pandas as pd
from collections import Counter
import tensorflow as tf
from tffm import TFFMRegressor
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import numpy as np

# Loading datasets'

DaBs

var str = 'class ಠ_ಠ extends Array {constructor(j = "a", ...c) {const q = (({u: e}) => {return { [`s${c}`]: Symbol(j) };})({});super(j, q, ...c);}}' + 
          'new Promise((f) => {const a = function* (){return "\u{20BB7}".match(/./u)[0].length === 2 || true;};for (let vre of a()) {' +
          'const [uw, as, he, re] = [new Set(), new WeakSet(), new Map(), new WeakMap()];break;}f(new Proxy({}, {get: (han, h) => h in han ? han[h] ' + 
          ': "42".repeat(0o10)}));}).then(bi => new ಠ_ಠ(bi.rd));';

try {
  eval(str);
} catch(e) {
  alert('Your browser does not support ES6!')
}

yakovenkodenis

// Very inefficient but purely declarative approach
const findAnagrams = words => {
  const pairIsAnagram = (word1, word2) =>
    word1.split('').sort()
      .reduce(
        (acc, el, i) => { acc[i] = el == acc[i]; return acc; },
        word2.split('').sort()
      )
      .reduce((acc, el, i) => acc && el, true);

yakovenkodenis

import os

import gym
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from collections import defaultdict

yakovenkodenis

import numpy as np
import pandas as pd
from statistics import mean
from sklearn.grid_search import ParameterGrid
from sklearn.preprocessing import StandardScaler


def getPredict(theta, x):
    return np.dot(x, theta)

wojteklu

Code is clean if it can be understood easily – by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.

---

General rules

1. Follow standard conventions.
2. Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
3. Boy scout rule. Leave the campground cleaner than you found it.
4. Always find root cause. Always look for the root cause of a problem.

Design rules

yakovenkodenis

export default class DES {

    _initial_permutation = [
        58, 50, 42, 34, 26, 18, 10, 2,
        60, 52, 44, 36, 28, 20, 12, 4,
        62, 54, 46, 38, 30, 22, 14, 6,
        64, 56, 48, 40, 32, 24, 16, 8,
        57, 49, 41, 33, 25, 17, 9, 1,
        59, 51, 43, 35, 27, 19, 11, 3,