Metaprog: универсальная графическая среда программирования [в разработке] часть 4

Ничего не знаю

Это с самого начала было заметно.

для программирования в Лабвью я в книги не втыкал, а софт делаю, при этом весьма сложный

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

Я в курсе, что ты слился. Давно уже.

Зачем? Зачем вы продолжаете это?

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

Дохлая же тема, пока не будет работающей альфы, которую можно будет опробовать всем.

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

Диаграммы собираются и корректно транслируются в Си. А называешь ли ты это софтом или нет - дело десятое. Завтра жду твоих «спецификаций».

т.е. тему можно закрывать. Потому что вероятность что ТС выкатит что-то КРАЙНЕ МАЛА.

Тему уже знаешь сколько раз так «закрывали»? Только растет как на дрожжах, даже без анонимусов.

Ты предлагаешь писать Hello World как массив пикселей

Массив байтов.

SAX и DOM

Бинарный формат еще быстрее.

Массив байтов.

И как ты это пишешь? Если в диаграмме есть буковки, то это ж ненавистный тебе текст! И даже циферки - тоже текст!

Ну так байтов боишься ты, а не ОП.

Посмотри мои примеры, там строки инициализируются как массивы байтов.

Растет только благодаря тебе с котечкой. Ну и еще 2-3 человека, которые ради прикола заходят..

Я вот только что реализовал на базовом уровне ветвление (if+else). Выглядеть оно будет так:

https://i.postimg.cc/prkqLmRG/image.png

Полноценный пример делать пока лень. Теперь пора делать циклы, будут на днях.

Ну и не без твоей помощи, хотя лучше бы без нее.

Так скучно же, да и интересно чем все закончится.

Отлична! А там уже и чат можно, вроде все что нужно будет, же.

Почитай что-то про Zero-cost abstractions. Вот первая ссылка из поисковика. Заодно и посмотришь как компилятор с циклами работает.

Не вижу я в твоих диаграммах никаких массивов байтов, только буковки. Это не расходится с твоей идеологией?

По теореме Бёма-Якопини можно реализовать любой алгоритм, имея последовательное исполнение, ветвление и циклы. Осталось сделать только циклы. Еще несколько дней - и на Метапрог-диагарммах можно будет реализовать любой алгоритм.

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

Красиво же. Я вот Rust вообще не знаю (хотя в планах изучить, ибо кое-какой api-daemon именно на нём написан), но пример почти сходу понял. Не сразу, правда, въехал, что делает zip.

ТСу до такой красоты и выразительности — как до Плутона раком.

Меня сишный уровень мало колышет. Ты представляешь свои хеллоуворлды в виде диаграмм, но с такими же текстовыми блоками. Ты ж в этих блоках просто пишешь Hello World, а не придумываешь способ эту самую строку представить не в виде текста, как ты это декларируешь. Не кажется ли тебе, что это расходится с твоей концепцией «текст — зло» и не слишком уж и отличается от того же AppInventor?

Не говоря уж о том, что обрекаешь бедных погромиздов на страдания изучения того, что такое указатель, да не просто указатель, а gpointer. Где ж тут простота, а?

ТСу до такой красоты и выразительности — как до Плутона раком.

macro_rules! diagnostic_method {
    ($name:ident, $level:expr) => (
        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
        pub fn $name<T: Into<String>>(self, message: T) -> Diagnostic {
            Diagnostic::spanned(self, $level, message)
        }
    )
}
pub struct Context<'a> { _marker: PhantomData<fn(&'a ()) -> &'a ()> }

fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
    bx: &mut Bx,
    fx: &FunctionCx<'a, 'tcx, Bx>,
    memory_locals: &BitSet<mir::Local>,
    va_list_ref: &mut Option<PlaceRef<'tcx, Bx::Value>>,
) -> Vec<LocalRef<'tcx, Bx::Value>> {
   let ty = if let (true, &ty::Ref(_, ty, _)) = (by_ref, &ty.sty) {
       ty
   } else {
       ops = &ops[..ops.len() - 1];
       ty
   };
}

Да мне вот теперь интересно, как аффтар собирается представлять текстовые данные в графическом виде. Если он этого не делает — значит, он, мягко говоря, нас намахивает со своими намерениями. Если делает — значит, пусть покажет, как. Ибо по его же словам, если текст обернули в квадратик, то текстом он от этого быть не перестаёт. Вот мне и интересно, как он этот парадокс решает (с сохранением простоты понимания, естественно)…

Если ты найдешь что то похожее в Mojolicious (веб-фреймворк на Perl) дам медаль.

Указатель это переменная с адресом, что тут учить то?

С макросами какой то читаемый я пример дал, наверное не то скопировал. Лучше бы что нибудь из этого подошло: https://github.com/serde-rs/json/blob/master/src/macros.rs

Попытался прочитать. Да, правда, попытался. Но мне очень тяжело дается понимание текстового кода, особенно на незнакомых языках с незнакомыми понятиями. Что такое let например? Целое новое незнакомое понятие, что-то там весомое обозначающее, и чтобы это понять мне неизбежно придется лезть в мануалы. А делать это мне лень. То же самое качается всяких там as (так и хочется добавить вторую «s», но не скомпилируется ведь). Черт побери, в графике блоками было бы понятно сходу, чаще всего с чтением короткой всплывающей справки.

Сишку я и то еле освоил, к счастью понятий там не так уж и много и большинство касаются числовых типов. И то всякие там дополнительные extern и volatile до сих пор не до конца понимаю, но без них полнота по Бёму-Якопини не пострадает - когда будет альфа, найдутся знающие люди, чтобы вкрутить эти понятия в Метапрог вместе со справкой и интерактивной обучалкой к ним.

Указатель это переменная с адресом, что тут учить то?

Тебе — пунктуацию, как минимум, ну и ться.

А что такое gpointer? А gconstpointer? Почему в глыбе не используют обычные указатели, а придумали свой тип для них, причём даже не один?

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

Текст который предназначен для чтения человеком я буду представлять как текст. Но никаких текстовых команд для взаимодействия с машиной, скриптов итп в Метапроге не будет (за исключением сишных вставок для особых случаев типа ассемблера инлайном).

А что такое gpointer?

void*

А gconstpointer?

И так ясно.

Почему в глыбе не используют обычные указатели

Так захотели.

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

Ну так в Red нужно понять а что такое объект, а как там таблица методов сделана, а с какой точностью fpu инициализирован? (в си тоже не особо нужно понимать че такое gpointer)

Ты за деревьями потерял лес. Там смысл вообще не в let. И даже не в расте. На C++ тоже можно zero-cost abstractions изобразить.

полнота по Бёму-Якопини

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

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

#define gpointer void*

Только там по другому, через typedef, но суть та же.

Zero-cost abstractions это принцип. Который состоит в том, что код не обязательно транслировать в машинный код построчно. Долгое время люди программировали либо со слабыми абстракциями (assembler, C), либо с оверхедом (Haskell, Java). Но этот выбор не обязателен. Можно (и нужно) программировать создавая и используя мощные абстракции, при этом имея производительность и требовательность к ресурсам на уровне аккуратно написанного ассемблерного кода.

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

Я только за абстракции с нулевой стоимостью и это одна из целей Метапрога. Главное чтобы эти абстракции были просты для человека. Мне лично тяжело даются сложные «сферические абстракции в вакууме».

Если что, я в курсе, что такое gpointer и gconstpointer. Просто это явный пример того, как ради чуть более читабельного кода плодятся совершенно лишние сущности.

В этом я с тобой даже соглашусь.

Сущностей даже с этим намного меньше чем в высокоуровневых языках. Да и мало какие библиотеки таким страдают.

Мне лично тяжело даются сложные «сферические абстракции в вакууме».

Тогда ты не сможешь сделать метапрог с заявленными целями.

А что бы ты лично хотел там видеть?

Если что, я в курсе, что такое gpointer и gconstpointer.

Я ваще проблемы не понял, я как впервые увидел gpointer (в первом треде metaprog), так сразу и понял что это void*, ну и логично что оно определенно через typedef, хотя я даже не смотрел так ли это.

Мне это не интересно. Я здесь пишу только потому что «в интернете кто-то не прав».

Тебе — пунктуацию, как минимум, ну и ться.

В украинском с этим проще. Правда в белорусском еще проще - «как слышу так и пишу» - надо брать пример.

У меня когда-то были мысли в этом направлении. Но ты же скажешь сразу что тебе сложно. Почему бы IDE не общаться с компилятором бинарными блобами?

На самом деле мысль здравая и с концепцией Метапрога вяжется хорошо. Но это уже после релиза прикрутим, «в далеком светлом будущем».

Сущностей даже с этим намного меньше чем в высокоуровневых языках.

Видели ли Вы когда-нибудь Го?

Дело в том, что Си сам по себе провоцирует на всякую фигню. Например делать буферы фиксированного размера в структуре, вместо того, чтобы выделить памяти под строку

struct x {
    uint32_t age;
    char     name[255];
};

Когда появляется джентльмен с именем более 255 символов, то начинаются проблемы — причём настолько закостенелые, что проще послать его нах. Это просто пример, но скорость и «простота» (да фиг там) Си — многого стоит в плане гибкости.

Дело в том, что Си сам по себе провоцирует на всякую фигню

Нет.

Например делать буферы фиксированного размера в структуре, вместо того, чтобы выделить памяти под строку

Иногда это оправданно.

Это просто пример, но скорость и «простота» (да фиг там) Си — многого стоит в плане гибкости.

В любом языке с массивами можно такое сделать.

Видели ли Вы когда-нибудь Го?

Конечно.

Я ещё 4 страницы назад предлагал разойтись всем по своим IDE и сюда показывать либо что-то работающее, либо действительно интересные технические вопросы, а не «нет ты»...