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

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

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

Если ты про моменты, типа:
То что плохого в том, что бы поделиться своим мнением? Причем я всегда стараюсь что бы это не выглядело как навязывание оного. Вот какого мнения я придерживаюсь.

К сожалению ничего не могу тебе посоветовать:


Получается рекурсия: чтобы рисовать диаграммы, нужен опыт, но без опыта рисовать не надо, потому что не знаешь что рисовать.
Если заменить в этом предложении слова "рисовать" на "писать" и "диаграммы" на "программы", то можно добавить в RTFM и скидывать всем новичкам, зашедшим на этот форум.

Меня ещё вот что интересует. Для тебя этот инструмент бесполезный потому что не знаешь что рисовать или потому что не умеешь?

Ну я в общем-то тоже не помню точно, почему у меня такое впечатление сложилось.

Получается, что если бы ты рассказал, где и когда применять UML было бы интереснее. Возможно, что к этому моменты ты бы и инструмент другой выбрал.

Не вижу смысла. По-крайней мере редко.

У меня есть своё видение на счёт этого, но я не уверен что смогу правильно его сформулировать. Мне бы тоже было бы интересно почитать про это, сравнить со своей точкой зрения.

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

Один из таких редких случаев - документация, согласен?

Ещё один редкий случай - сложная логика компонента, который необходимо постоянно использовать. Я понимаю, что этого стоит избегать, но ситуации бывают разные. Словесное описание в этом случае не даст полного представления, а диаграмма дополнит его. В этом случае польза будет в том, что новый человек сможет быстрее вникнуть в суть, а это важно в крупных командах/компаниях.

Пример из жизни - реализация функции require, подобной из NodeJS. Логика в ней более ветвистая, чем в NodeJS, могу скинуть диаграмму. После создания схемы стало очевидно, что описывать словами её работу будет бесполезным - диаграмма в данном случае наиболее удачно решила эту задачу. При этом, в ней нет лишнего функционала, логика не перегружена.

Я могу привести ещё примеры из практики, если надо.

:D

По идее да, только опять же как-то не было необходимости. :) Ситуация примерно такая же как с UML... Тут в общем-то такой момент, что я в основном работаю один. А UML - это больше для коммуникации между людьми.

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

Да, можешь показать диаграмму. Да и функцию.

Ну если не лень, то я за. :)

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

/*
         @startuml
         title Require.
         note top: require(namespace);
          (*) -right-> if "" then
          note top: The module\nis in the cache??
          --> [true] "Return module" as Return
          --> (*)
          else
           -right-> [false] if "" then
             note top: Start with\n'docroot://'?

             --> [true] "Load file from\n<b>namespace</b>"
             --> [Success] "Initialization module.\nSave module in cache." as Compile
             --> Return
           else
             -right-> [false] if "" then
               note top: There is a file\nwith the name\n<b>namespace</b> + '.js'?

               --> [true] "Load file from\n<b>namespace</b> + '.js'"
               --> [Success] "Create namespace" as CreateNS
               --> Compile
             else
               -right-> [false] if "" then
                 note top: There is a file\nwith the name\n<b>namespace</b> + '/package.json'?

                 --> [true] "Parse file from\n<b>namespace</b> + '/package.json'"
                 --> [Success] "Load the file,\nspecified in the package.json"
                 note right: Default file name is\n<b>namespace</b> + '.js'

                 --> [Success] CreateNS
               else
                 --> (*)
               endif
             endif
           endif
         endif
         @enduml
         */
        var require = (function () {
            var CACHE = {};
            var OPTIONS = {
                root: 'docroot://',
                extension: 'js',
                packageName: 'package.json'
            };

            function extendOptions () {
                if (!require.hasOwnProperty('options')) {
                    require.options = {};
                }

                for (var name in OPTIONS) {
                    if (OPTIONS.hasOwnProperty(name) && !require.options.hasOwnProperty(name)) {
                        require.options[name] = OPTIONS[name];
                    }
                }
            }

            function createNamespace (namespace, module) {
                namespace = namespace.split('.');

                var
                  name,
                  index = 0,
                  length = namespace.length,
                  currentNamespace = $XM;

                while (index < length) {
                    name = namespace[index++];

                    if (index === length) {
                        currentNamespace[name] = module;
                    } else if (!currentNamespace.hasOwnProperty(name)) {
                        currentNamespace[name] = {};
                    }

                    currentNamespace = currentNamespace[name];
                }
            }

            function require (namespace) {
                var
                  file,
                  path,
                  main,
                  createNS = true,
                  module = {
                      namespace: namespace,
                      exports: {}
                  };

                if (CACHE.hasOwnProperty(namespace)) {
                    return CACHE[namespace];
                }

                extendOptions();

                if (namespace.indexOf('docroot://') === 0) {
                    if ($X.file.test(namespace)) {
                        file = $X.file.load(namespace);

                        createNS = false;
                        path = namespace;
                        delete module.namespace;
                    } else {
                        throw new Error('Can`t find module on the way: "' + namespace + '"');
                    }
                } else if ($X.file.test(path = require.options.root + namespace + '.' + require.options.extension)) {
                    file = $X.file.load(path);
                } else if ($X.file.test(path = require.options.root + namespace + '/' + require.options.packageName)) {package.json
                    file = $X.file.load(path);
                    file = JSON.parse(file);

                    main = file.hasOwnProperty('main') ? file.main : namespace + '.' + require.options.extension;

                    if ($X.file.test(path = require.options.root + namespace + '/' + main)) {
                        file = $X.file.load(path);
                    } else {
                        throw new Error('Can`t find module: "' + path + '"');
                    }
                } else {
                    throw new Error('Can`t find module: "' + namespace + '"');
                }

                module.path = path;
                module.dirName = path.substring(0, path.lastIndexOf('/'));

                new Function('module', file).call(module.exports, module);

                createNS === true && createNamespace(namespace, module.exports);

                CACHE[namespace] = module.exports;

                return module.exports;
            }

            extendOptions();

            return require;
        })();

Тема интересная, но я лично пока не дорос до рисования таких схем прямо в коде или отдельной софтине. Пока хватает нарисовать диаграмму или блок схему в блокноте на бумаге, быстрее и легче воспринимается. Я так понимаю что данная тулза полезна при описании больших фронт-эндов или серверной части?
Мне гораздо интереснее практическая реализация Юнит-тестов для JS. В моей отрасли эта тема куда важнее для продакшена (софт обязательно должен быть валидирован) чем диаграммы. Пока ничего толкового не нашел кроме Jasmine. Где-то тема от x-yuri проскакивала на форуме по этому поводу...
Вот если бы этот вопрос раскрыли в полной мере... мммм... было бы просто зашибись :)

Ну тут речь о диаграммах в целом, без привязки к конкретному инструменту. А вообще да, для какого-нибудь фреймворка или серверной платформы просто необходимы диаграммы.

По поводу тестов, есть свежая библиотека от monolithed, стоит посмотреть.

Мне тоже интересно, но пусть кто-нибудь другой раскрывает. x-yuri, нет желания? :)