Хоть и не пятница, но все же. Есть необходимость написать пару-тройку простеньких утилиток, что-то для заказчика, что-то просто другу в помощь, который сейчас пытается с нуля на производстве одну сложную хренотень поднять, что-то для себя. Целевая ОС (кроме меня) - винда.

Для себя я такие писал по привычке либо на питоне (без гуя), либо на джаве со свингом (с гуем). А тут че-то на волне новости про новые культи и их креатор меня поперло вновь потыкать в плюсы. Ведь когда-то я на них писал, собирал «дистрибутивы» под все ОС, что меня дико радовало. Я даже поставил креатор с кьютом, посмотрел на дефолтный код…

И вот сижу и думаю - а стоит ли снова лезть во все эти указатели, ссылки и прочие самсебеногострелы? Да, вроде бы ничего такого сложного нет, но тем не менее от привычной джавы отличается, что потребует изменения мышления и ломки мозга. Зато работать будет кроссплатформенно в итоге и нативно, а не с плясками вокруг джава-машины.

Об абзаце выше: когда отдаешь человеку, который комп умеет только включать и мышевозить по заданному алгоритму, нативное приложение (читай екзешник), то он его просто запускает и оно работает. Не важно, что рядом с ним лежат dll файлы кьюта, оно просто работает. Если отдавать ему джавашное приложение, то нужно либо как-то учить его ставить нужную джаву и объяснять, как стартануть джарник (проходили такой процесс, такое себе), либо паковать нужную джаву в «дистрибутив» и писать промежуточное нативное стартовалово (либо екзешник, либо батник), что добавляет немного лишних действий при распространении утилиты.

Вопроса как бы и нет. Просто мысли вслух. А стоит ли?

Андрей Шитов, известый Perl-разработчик, решил в этом году попробовать как можно больше языков программирования и поделиться опытом с читателями.

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

В рождественском календаре этого года (с 1 по 24 декабря), я буду ежедневно публиковать статьи повествующие об основах различных языков программирования: один день - один язык. Чтобы сделать обзоры более полезными, я постараюсь придерживаться единого формата и разобрать аспекты языка, необходимые для написания следующих мини-проектов:

• Hello, World!
• Функция, вычисляющая факториал рекурсивно или в функциональном стиле
• Программу, создающую массив объектов и выполняющую полиморфный вызов методов на них
• Реализацию сонной сортировки (sleep sort). Данный алгоритм не применяется в боевых условиях, но замечательно демонстрирует возможности языка в разрезе конкурентности

Список языков:

• День 1. TypeScript
• День 2. Rust
• День 3. Julia
• День 4. Kotlin
• День 5. Современный C++
• День 6. Crystal
• День 7. Scala
• День 8. Dart
• День 9. Hack
• День 10. Lua
• День 11. Raku
• День 12. Elixir
• День 13. OCaml
• День 14. Clojure
• День 15. Nim
• День 16. V
• День 17. Go
• День 18. Hy
• День 19. Red
• День 20. Mercury
• День 21. Elm

>>> Подробности

Немного поизучал Rust, и решил собрать все преимущества заявляемые адептами.

1. Из-за знания компилятором, что & mut - это уникальная ссылка, то параметры функции не будут алиаситься с обычной ссылкой:

fn f(s: & mut str, s2: & str) -> type // s и s2 указывают на разную память, 100% компилятор знает об этом
// в стандарте С++ нет restrict

2. Возможно, большие возможности в compile-time чем у С++, в частности упоминается возможность прочитать файл во время компиляции:

const IMAGE: &[u8] = include_bytes!("/path/some_file.png");

3. Map в rust реализован с помощью алгоритма BTreeMap, а в С++ - std::map красно-чёрное дерево, BTreeMap быстрее…

4. HashMap в rust - открытая адресация, в С++ std::unordered_map - метод цепочек, открытая адресация быстрее…

5. В rust нет объектов, везде используется memcpy, а тот же resize вектора делается через realloc, бысрее чем move конструкторы в С++

помогите дополнить список.

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

Состоялся релиз go-ipfs (эталонной реализации IPFS, написанной на языке Go) версии 0.4.18. Вероятно, это самый значительный релиз в недавней истории; на его подготовку ушло 3 месяца. Со времени предыдущей новости об IPFS на LOR прошло уже более четырёх лет.

IPFS (InterPlanetary File System) — это гипермедийный протокол и распределённая файловая система, созданная с использованием идей, реализованных в Git и BitTorrent, и нацеленная на то, чтобы заменить или дополнить существующий Web. IPFS похож на BitTorrent Swarm, ноды которого обмениваются объектами Git-репозитория. IPFS основан на идее адресации по содержимому — один и тот же блок данных всегда будет иметь один и тот же адрес, вне зависимости от его физического расположения. В отличие от BitTorrent, данные разбиваются на блоки по границе файла, таким образом один и тот же файл может быть переиспользован в разных каталогах без необходимости повторного выделения места на диске. В отличие от Freenet и Perfect Dark, ноды хранят только те данные, которые они явно запросили. IPFS способен интегрироваться с существующими системами разрешения имён — с классическим DNS в настоящее время, с Tor .onion, Namecoin .bit и возможно, некоторыми другими в будущем.

Особенности этого релиза:

Титульные особенности этого релиза — экспериментальная поддержка QUIC, новый алгоритм маршрутизации pubsub-сообщений, возможность подписывания pubsub-сообщений, а также переписанная команда ipfs p2p. Однако всё это лишь вершина айсберга.

( читать дальше... )

>>> Официальный сайт

>>> Каталог приложений, созданных на основе IPFS

>>> Дополнение для интеграции IPFS в веб-браузеры

>>> Подробности и полный список изменений

Есть задача - пройтись по текстовому файлу и найти максимальное число одинаковых последовательно идущих строчек. Задача весьма синтетическая, просто надо продемонстрировать, что

• Потоково обрабатывается некий объем данных;
• Есть состояние - надо помнить предыдущую строку в файле при обращении к следующей.

Решение в лоб на IORef-ах (m1.hs):

module Main where

import Data.IORef
import Control.Monad (forM)

main :: IO ()
main = do
   input    <- getContents
   lastLine <- newIORef (Nothing)
   counter  <- newIORef (0)
   result   <- newIORef (0)

   let incr    = modifyIORef counter (\x -> x `seq` x+1)
       reset s = do c <- readIORef counter
                    r <- readIORef result
                    writeIORef result (max c r)
                    writeIORef lastLine (Just s)
                    writeIORef counter  1

   forM (lines input) $ \line -> do
     ml <- readIORef lastLine
     case ml of
       (Just s) -> if s == line then incr else reset line
       Nothing  -> reset line

   r <- readIORef result
   putStrLn $ "Largest subsequence of equal lines: " ++ show r

Более модное решение с трансформером StateT (m2.hs):

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Main where

import Control.Monad (forM)
import Control.Monad.State.Strict

data AppContext = AppContext { ctxLastLine :: Maybe String
                             , ctxCounter  :: Integer
                             , ctxResult   :: Integer
                             }

initialContext :: AppContext
initialContext = AppContext { ctxLastLine = Nothing
                            , ctxCounter  = 0
                            , ctxResult   = 0
                            }

newtype App a = App (StateT AppContext IO a)
                deriving (Monad, MonadIO, MonadState AppContext)

runApp (App app) = execStateT app

incr :: App ()
incr = do
   cnt <- gets ctxCounter
   modify $ \s -> s { ctxCounter = cnt+1 }

reset :: String -> App ()
reset l = do
   cnt <- gets ctxCounter
   res <- gets ctxResult
   modify $ \s -> s { ctxLastLine = Just l
                    , ctxCounter  = 1
                    , ctxResult   = max res cnt
                    }

processLine :: String -> App ()
processLine line = do
   ll <- gets ctxLastLine
   case ll of
      (Just s) -> if line == s then incr else reset line
      Nothing  -> reset line

main :: IO ()
main = do
   input <- getContents
   s <- runApp (forM (lines input) processLine) initialContext
   putStrLn $ "Largest subsequence of equal lines: " ++ show (ctxResult s)

Интересно, как поведут себя оба варианта на обработке, скажем, «Улисс» Джойса (txt, 1.6 MB):

[dmatveev@localhost memq]$ ghc --make m1.hs -rtsopts -prof
[1 of 1] Compiling Main             ( m1.hs, m1.o )
Linking m1 ...
[dmatveev@localhost memq]$ ghc --make m2.hs -rtsopts -prof
[1 of 1] Compiling Main             ( m2.hs, m2.o )
Linking m2 ...
[dmatveev@localhost memq]$ du -sh ulysses.txt
1.6M    ulysses.txt
[dmatveev@localhost memq]$ wc -l ulysses.txt
33055 ulysses.txt
[dmatveev@localhost memq]$ time cat ulysses.txt | ./m1 +RTS -hd -i0.001
Largest subsequence of equal lines: 5

real    0m1.599s
user    0m1.577s
sys     0m0.021s
[dmatveev@localhost memq]$ time cat ulysses.txt | ./m2 +RTS -hd -i0.001
Largest subsequence of equal lines: 5

real    0m19.360s
user    0m19.123s
sys     0m0.091s

ШОК! Посмотрим, что там с памятью:

[dmatveev@localhost memq]$ hp2ps -e8in -c m1.hp
[dmatveev@localhost memq]$ hp2ps -e8in -c m2.hp

m1.png, m2.png

Очевидно, что во втором примере что-то течёт, а я что-то глобально упустил.

Вопросы:

1. ЧЯДНТ?
2. Как быть?
3. Как правильно готовить монадические ивентлупы с изменяемым состоянием?

З.Ы. Да, я знаю, что на awk это решается проще и быстрее, суть-то не в этом, а в вопросе №3. Извините за неровный почерк.

Приветствую!
Интересует что-то вроде карты (в виде традиционной карты или майндмапа) отражающей важнейшие концепции программирования, их место и значимость, пререквизитные или составляющие их концепции, возможно связи между ними или что еще вам кажется имеющим значение. Встречал ли кто такое или сам рисовал? Не надо постить тут оглавление из Страуструпа или что-то подобное. Надеюсь, смысл реквеста понят верно.
PS
Заранее прошу прощение у всех зелёных, оставшихся тут без еды.

Интересно узнать рейтинг популярности отдельных частей функционала ЛОРа. Возможно результаты этого голосования станут почвой для приятных нововведений и исправления недочётов.

Предложения и пожелания в комментариях приветствуются.

Пользователи линукса обладают богатейшими средствами для разработки. Но часто они лишь используют существующие приложения и плачут на ЛОРе что они убогие, так как в них нет их супернужной фичи.

Хочу чтобы лоровцы поделились историями успеха написания приложений для себя любимого, для своего десктопа или сервера. Причем интересно услышать не о серьезных проектах, заранее рассчитаных на широкую аудиторию, а о том как лорчане использовани средства разработки для решения своих личных задач. Если потом поделились - хорошо

Из желательного - максимальная <b>простота</b> развертывания. Наименьшее количество глюков для следующего джентельменского набора - Tomcat(or jetty), NGINX, Spring(всякое). Спасибо.