Parler централизованный (Gab или Minds и то больше подходят на эту роль). Signal тоже и еще номер телефона требует.

Предлагаю совместными усилиями составить список децентрализованных\федеративных проектов в этой ветке, дополняйте.

Мессенджеры:
Tox — p2p мессенджер (текст, аудио, видео)
Matrix — федеративный IM-протокол с клиентами в духе Discord или Slack (текст)
XMPP — без комментариев
Mesh — p2p мессенджер
Keybase — p2p мессенджер

Социальные сети:
Aether — p2p социальная сеть
Diaspora* — федеративный аналог Facebook
Friendica — федеративный аналог Facebook
Mastodon — федеративный аналог Twitter (на основе форка сделан Gab)
GNU Social — федеративный аналог Twitter
Twister — p2p аналог Twitter (проект заброшен, но работает)
Salut à Toi — децентрализованный Twitter на стероидах
Pump.io — федеративная социальная сеть
Patchwork — p2p социальная сеть
Kune — децентрализованная социальная сеть
Secure Scuttlebutt — p2p социальная сеть

Видеохостинги:
DTube — децентрализованный аналог YouTube
PeerTube — децентрализованный аналог YouTube

Поисковые системы:
YaCy — распределенный поисковик

Другое:
GNUNet — децентрализованная сеть
I2P — децентрализованная сеть
Tor — децентрализованная сеть
Freenet — децентрализованная сеть
Zeronet — децентрализованный хостинг
Yggdrasil — меш сеть
Beaker — браузер с поддержкой распределенного хостинга
Phantom — децентрализованный протокол анонимизации трафика
Unhosted — полудецентрализованный протокол хостинга

К примеру, здесь есть небольшой список: prism-break.org/eo

Знаете, пытаюсь понять вашу мысль, но не получается. Говорите какими-то общими фразами, а я люблю конкретику. А уже причем тут статический анализ вообще не ясно.

Признаюсь, близко с этими либами не знаком, но мне всегда думалось, что это урезанные и ускоренные версии React, которые не то чтобы не превосходят React по возможностям, а наоборот имеют еще меньше функционала.

Давайте может конкретно, какие такие возможности есть у Inferno или Preact, которых нет в Svelte? Вот список функциональных возможностей, которые есть в Svelte:

1. Однофайловые и много-файловые компоненты
2. Использование любых предпроцессоров кода (eg Coffescript) и стилей (eg SCSS) и шаблонов (eg Pug)
3. Встроенная система Scoced-стилей компонента + вырезка неиспользуемых стилей (unused style removal)
4. Композиция компонентов и инекция с помощью слотов (slot)
5. Полностью реактивный встроенный стейт компонентов
6. Реактивные вычисляемые свойства (computed props) компонентов
7. Опциональное двойное связывание (two-way binding) как для пользовательского ввода, так и для компонентов
8. Хуки жизненного цикла (life-cycle hooks)
9. Наблюдатели (observers)
10. Кастомные события и proxy-события
11. Экшены (декораторы) над dom узлами и поддержкой синхронизации данных
12. Анимации переходов (transitions)
13. Язык шаблонов с поддержкой JS выражений
14. Дерективы
15. Методы и хелперы
16. Иерархический глобальный Store на основе классов c вычисляемыми свойствами, событиями и хуками (тоже все реактивное)
17. Поддержка асинхронных данных (можно хранить промисы в стейте и резолвить их по месту назначения)
18. Полная поддержка SVG с соответствующим namespace
19. Специальные компонент тег для рекурсивного вложения компонента (удобно для TreeView, например)
20. Специальный тег для декларативной работы с window
21. Специальный тег для декларативной работы с head
22. Специальный тег для динамической подмены компонентов
23. Поддержка Custom Elements стандарта из коробки
24. Поддержка SSR с гидрацией на клиенте (hydrate)
25. Набор фичей самого компилятора, который будет расширяться

Возможно не все привел и что-то упустил, но это не суть. Можете перечислить что из этого умеет Inferno или Preact, или даже React, и мы посмеемся вместе?))) Ну и жду от вас список возможностей оных, которых нет в Svelte)))

Рассказал все, что узнал за 4 недели. Уже появились новые, более эффективные архитектуры. Постараюсь разобрать, как они работают и сделать краткий обзор на них.

Со времени написания первой статьи прошло 3.5 года, а воз и ныне там. Моя позиция проще: не пытаться заменить мозг технологией, а дополнить его и усилить при помощи технологии. По этой причине, хотелось бы узнать, на каких принципах конструировать новые архитектуры? Этого я пока не нашел нигде. Все только и делают, что конструируют на основе каких-то своих догадок и инсайтов. Если для этого придется отказаться от «нейрона бабушки», то откажусь без колебаний: мы же не секта какая-то :-)

При просмотре двенадцати статей «Логики сознания» пришла идея, что необходимо оперировать не только весами синапсов, но и их положением и, возможно, даже количеством синапсов в свертке. Так в классической конволюционной сети оперируют девятью синапсами в свертке, расположенными в виде квадрата 3×3. Затем появилась операция выбрасывания части синапсов при обучении (dropout). Затем перешли к пространственной свертке (dilated convolution). Вполне возможно, что все это движется в сторону оперирования положением и количеством синапсов в свертке.

Итак, добавляем пространственную организацию синапсов при свертке (сворачиваем не только квадратиком, но и более сложными двумерными фигурами). Пока не понятно, как добавить «динамическую перестройку контекстных карт». Каким образом синапсы будут перемещаться по предыдущему слою? Каким образом будет выбираться их количество?

Во второй статье узнал, что, вообще, можно отказаться от сверток, а использовать другие математические операции. Но какие, пока не понял.

Начните с простой задачи. Например, классификация одного объекта на изображении. Пример с предметами одежды. Воспользуйтесь сервисом Kaggle. Пройдите курс по TensorFlow.

Машинное обучение — это прикладная область знания. Только решением задач можно научиться чему-то конкретному.

Yolo (включая последнюю третью версию YOLO3) и SSD, не говоря о древних R-CNN и аналогах, уже устарели. Их имеет смысл использовать только если есть ограничения, например запуск на мобильной платформе очень упрощённые версии этих сетей. Они могут распознавать только крупные объекты и работают с маленькими разрешениями от 224х224 до 300-600 максимум. После них появилась архитектура RetinaNet, которая сразу нормально работает с разрешениями под 1300х800 и распознает мелкие объекты размером с десяток пикселей. Однако и она уже устарела. Ей на смену пришли более новые CenterNet и EfficientDet, которые так же хорошо распознают мелкие детали, но работают точнее и быстрее. Эти нейросети снова вернули времена, когда на одном GPU за пару дней можно было обучить state-of-the-art распознавалку на конкурс. Из старых сетей разве что Faster R-CNN и пара AutoML моделей от гугла ещё удерживают позиции, но они очень медленные (хотя FasterRCNN и была в свое время самая быстрая из своего семейства).

Просто смотрите графики

Распознавание штампов на документах, распознавание каптч, распознавание и решение математических уравнений, подсказка хода в шахматах (для шахматистов-читеров). Есть приложения для распознавания видов грибов, но несоветую )). На СТО по звуку автомобиля делать предварительную диагностику поломки. Многие используют для наблюдения за домашними животными (впустить-выпустить из дома). Камеры, которые фотографируют не просто движение, а определенный вид птиц или диких животных. Системы домашнего наблюдения: кто-то стоит около дома, сразу идет СМС и фото хозяину дома. Поднятие шлагбаума только для номеров авто из жильцов дома. Подсчет людей в толпе. Мгновенный подсчет многих предметов (гороха какого-нибудь). На конвейере отсеивание гнилых яблок и картошки. Изменение стиля фотографии «под старину» или под картину знаменитого художника. Помощь фотошоперу: продвинутые фильтры, устранение заднего фона и т.д. Фактически все современные смартфоны ретушируют фотографии с помощью нейросетей и классических алгоритмов, убирают шум, делают фото ярче (все).
Постепенно ведутся работы по преобразованию текста в изображение: вы пишете текст, а нейросеть рисует картинку.
У меня есть идея сделать регулярные публикации по новинкам машинного обучения. Там даю разные идеи по применению нейросетей. Я уже сделал 5 рассылок, а шестую и далее планирую публиковать на Хабре.

Почитайте это.

Вспоминая университетский курс спиновой химии, хочу отметить, что вопрос о влиянии слабых магнитных полей на кинетику биохимических реакций, в частности со свободными радикалами, остается слабо изученным, но доказанным по факту. Вот Изменение скоростей некоторых биохимических реакций внутри клетки не может не влиять на ее работу, но, когда, насколько сильно и как это проявляется на макроуровне — мне не ясно. Может профессиональные биологи подскажут в этом контексте.
Ссылка 1
Ссылка 2
Сылка 3

А вообще я вот подумал, даже интересно результат увидеть. Сделайте честный тест на js/ts, примерно такой:

Мы не можем держать в памяти 1 млн объектов, многовато, поэтому будем генерировать их на лету:

let ind = 0;
getNextLineSyn = () => {
  const [, now] = process.hrtime();
  while (true) {
     // simulate sync reading from file
     const [, diff] = process.hrtime(now);
     if (diff > 1_000_000) {
        break;
     }
  }
  return { id: ind++; ...};
}

и его асинхронную версию

getNextLineAsync = async () => {
   await preciseTime(1_000_000, 'ns'); // simulate async reading from file
   return { id, ...};
}

И дальше две функции: searchSync, searchAsync.

Потом сравните производительность одного запроса. И производительность нескольких запросов (время выполнения одного запроса должно вырасти, но суперпозиция асинхронной версии должна быть быстрее, стартовая гипотеза). И можно даже больше заморочаться — запустить ноду как кластер и посмотреть как изменятся показания.

Я даже не прошу заморачиваться с параллельным асинхронным поиском в данном случае. Тогда это будут действительно репрезетативные данные.

P.S. PreciseTime, само собой, не может быть while (true) внутри очевидно, так что придется повозиться, впрочем можно обойтись, конечно, и setTimeout(1);

К сожалению, готовлю сейчас другую статью, но тем не менее, думаю после него приступлю к Deno.
ну а пока могу оставить ссылку на gist 9 месячной давности, в котором я собирал материалы
gist.github.com/irustm/fe60d7d91238ba3d30d5ddd7320309aa

Добавлю на всякий случай.
Чтобы включить отладку мобильного устройства по USB, нажмите на 3 точки справа вверху, там More tools, Remote devices.
На мобиле надо включить Режим разработчика, например, так.
Теперь на мобиле открывайте тот зловредный сайт и на вкладке Application смотрите его service workers и отключайте их.
Ещё можно удалить его куки, а также записи в Local Storage (в соответствующих разделах), если они есть.

Предыдущие — в предыдущих обсуждениях. Когда тебе нечего ответить, начинаешь съезжать на чушь.

Мне начинают надоедать голословные утверждения.

Многовато ошибок нашлось в таком маленьком куске кода.

Сколько конкретно?

И кстати, ваша версия не собирается Rust 1.33 на ideone из-за заемщика. С — стабильность.

Потому что код написан с использованием возможностей NLL. Пользоваться новыми языковыми возможностями — плохо?

Результ исправленный

А вот это хорошо, спасибо. Тогда вот такой замер:

fn main() {
    let mut input: Vec<_> = (1..1000000).rev().collect();
    let now = Instant::now();
    let result = {
        sort_imp(&mut input);
        input
    };
    let time = now.elapsed();
    println!("{:?}", result);
    println!("{}", time.as_secs_f64());
}

Выдает на моей машине 0.013585. Собирал с

[profile.release]   
lto = true
codegen-units = 1

Кстати, в варианте на хаскелле я тупанул, он вычисление начального списка из миллиона элементов тоже считает. Вот в таком виде:

main :: IO ()
main = do
    let list = reverse [1..1000000] :: [Int]
        !input = V.fromList list :: U.Vector Int
    start <- getCPUTime
    let !result = qsort input
    end <- getCPUTime
    let !diff = (fromIntegral (end - start)) / (10^12)
    print result
    printf "Computation time: %0.9f sec\n" (diff :: Double)
    return ()

на моей машине выдает 0.015625000 sec

Вот не зря я статью писал, но никто её не читает...

Вот вам на хаскелле пример, чистый ФП язык

{-# LANGUAGE BangPatterns #-}
import qualified Data.Vector.Generic as V
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Unboxed as U
import System.CPUTime
import Text.Printf

qsort :: (V.Vector v a, Ord a) => v a -> v a
qsort = V.modify go where
    go xs | M.length xs < 2 = return ()
          | otherwise = do
            p <- M.read xs (M.length xs `div` 2)
            j <- M.unstablePartition (< p) xs
            let (l, pr) = M.splitAt j xs
            k <- M.unstablePartition (== p) pr
            go l; go $ M.drop k pr

main :: IO ()
main = do
    let input = reverse [1..1000000] :: [Int]
    start <- getCPUTime
    let !result = qsort $ V.fromList input :: U.Vector Int
    end <- getCPUTime
    print result
    let diff = (fromIntegral (end - start)) / (10^12)
    printf "Computation time: %0.9f sec\n" (diff :: Double)
    return ()

На моей машине миллион интов сортируются за 0.09375 sec.

Хотел сравнить с вашим вариантом:

fn main() {
    let mut input: Vec<_> = (1..1000000).rev().collect();
    let result = {
        sort_imp(&mut input);
        input
    };
    println!("{:?}", result);
}

fn sort_imp<T: Ord + Copy>(arr: &mut Vec<T>) {
    fn swap<T: Ord + Copy>(arr: &mut Vec<T>, i: usize, j: usize) {
        let t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    fn sort1<T: Ord + Copy>(arr: &mut Vec<T>, l: usize, r: usize) {
        let pivot = arr[(l + r) / 2];
        let mut i = l;
        let mut j = r;
        while i <= j {
            while arr[i] < pivot { i += 1; }
            while arr[j] > pivot { j -= 1; }
            if i <= j {
                swap(arr, i, j);
                i += 1;
                j -= 1;
            }
        }
        if l < j { sort1(arr, l, j); }
        if j < r { sort1(arr, i, r); }
    }

    sort1(arr, 0, arr.len() - 1);
}

Но к сожалению он паникует в рантайме. У вас где-то отрицательный usize получается.

---

Какие выводы тут можно сделать? Ну, например такой, что на ФП вполне можно забить на неизменяемость в угоду производительности (не устану это повторять из раза в раз).

Во-вторых раст вряд ли вообще выйдет назвать ФП языком. Тут и факт того, что боксы дорогие, да и эргономика языка: с точки зрения любого фп Fn/FnMut/FnOnce это одно и то же, в расте — совершенно разные типы, от которых невозможно абстрагироваться (привет HKT/GAT). Чтобы было понятно, как влияют разные трейдофы на язык, сравние вот такую вот стейт монаду написанную на скале (раз уж у нас в статье примеры на ней):

def stateMonad[S]: Monad[State[S, ?]] = {
 type StateS[T] = State[S, T]
 new Monad[StateS] {
  override def mreturn[A](a: => A): StateS[A] = 
    State(s => (a, s))

  override def bind[A, B](f: StateS[A])(g: A => StateS[B]): StateS[B] =
   State[S, B](
     s1 => {
       val (a, s2) = f.run(s1)
       g(a).run(s2)
     }
   )
 }
}

И вот такой вот простейший читаемый раст:

use std::marker::PhantomData;

struct StateM<F, S, A>(F, PhantomData<S>)
where
    F: FnOnce(S) -> (A, S);

fn mreturn<A, S>(a: A) -> StateM<impl FnOnce(S) -> (A, S), S, A> {
    StateM(move |s| (a, s), PhantomData)
}

fn bind<F, S, A, B, U, R>(m: StateM<F, S, A>, f: U) -> StateM<impl FnOnce(S) -> (B, S), S, B>
where
    F: FnOnce(S) -> (A, S),
    U: FnOnce(A) -> StateM<R, S, B>,
    R: FnOnce(S) -> (B, S),
{
    StateM(move |s| {
        let (a, s) = (m.0)(s);
        (f(a).0)(s)
    }, PhantomData)
}

с 6(!!) генерик параметрами вместо двух. А там где в ФП их будет 3-4 в расте будет под два десятка.

Ну и в-третьих сама кор тима не склонна такие вещи внедрять.