Метапрог-прототип, версия 6 + будильник на Метапроге

Что быстрее, хоть он не имеет к этой быстроте никакого отношения как и его поделка

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

Метапрог и Лабвью удобнее всего

Да.

возить мышкой по экрану медленней и мучительнее чем просто набрать текст

Так набирай все на быстром Си, а не медленном питоне, какие проблемы?

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

А ядро ОС во сколько строк?

К счастью, у меня хватило ума не идти на информатику.

Оно и видно.

Потуги антиметапрогеров смешны.

Потуги к чему? Остановить экспансию мертвопрога? Да ты, в общем-то, и сам прекрасно справляешься.

Лучше ПУНД - звучит лаконичнее, а смысл почти тот же. Потуги унылых необучаемых дворников.

Зачем? Пока что и готовых хватает.

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

Думаешь и тогда все будут кодить в тексте? По мне так будет развитие визуального программирования до виртуальной реальности и нейроинтерфейсов.

Ну могу только сказать за то, что я посмотрел по диагонали, оба языка имеют текстовый ввод, кстати второй высокоуровневый язык вообще на основе питона налабали (так что тут я был неправ, все-таки пока люди не могут отказаться от привычных средств набора и не придумали ничего эффективнее текста, но по сути на уровне условного «железа», там архитектура совсем другая, не как в привычном нам компьютере). Это если говорить о квантовых компьютерах которые делает ibm.

Еще хотелось бы видеть бенчмарк для С++ с максимумом чисто плюсовых плюшек, интересно насколько он медленнее чистого Си.

Наверное я написал жуткий говнокод, но я просто постарался портировать код из F# на С++…

// This is a personal academic project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
#include <string>
#include <vector>
#include <algorithm>
#include <chrono>
#include <random>
#include <iostream>

using namespace std;

string random_str(size_t len)
{
	constexpr char const alphabet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
	constexpr size_t alphabet_size = sizeof(alphabet) - 1; // не учитываем '\0'
	static default_random_engine gen;
	static uniform_int_distribution<> dis(0, alphabet_size-1); // оба конца диапазона включаются

	string result(len, ' ');
	transform(
		result.cbegin(), result.cend(), 
		result.begin(), 
		[&](char _) {
			return alphabet[dis(gen)];
		}
	);
	return result;
}

class random_string100 : public string
{
public:
	random_string100()
		: string(random_str(100))
	{}
};

class random_string20 : public string
{
public:
	random_string20()
		: string(random_str(20))
	{}
};

int main()
{
	for (int i = 0; i < 10; ++i)
	{
		auto begin = chrono::steady_clock::now();
		vector<random_string100> vector_string100(100000);
		size_t matches = 0;
		for (int j = 0; j < 1000; ++j) {
			random_string20 s20;
			bool found = any_of(
				vector_string100.cbegin(), vector_string100.cend(),
				[&](string const& str100)
				{
					return str100.find(s20) != string::npos;
				}
			);
			if (found) {
				++matches;
			}
		}
		auto end = chrono::steady_clock::now();
		cout << matches << " strings matches, time = "
			<< chrono::duration_cast<chrono::milliseconds>
			(end - begin).count() << '\n';
	}
}

https://imgur.com/a/o1vPxWZ

0 strings matches, time = 11990
0 strings matches, time = 11717
0 strings matches, time = 11991
0 strings matches, time = 12061
0 strings matches, time = 11933
0 strings matches, time = 11857
0 strings matches, time = 11916
0 strings matches, time = 11976
0 strings matches, time = 12243
0 strings matches, time = 12284

дурацкие нуль-терминированные строки

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

Так набирай все на быстром Си, а не медленном питоне, какие проблемы?

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

А ядро ОС во сколько строк?

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

Кстати по количеству строк:

Решение i-rinat на Python: 24 строки

Хитрое решение i-rinat на Python: 33 строки

Моё решение на F#: 33 строки

Моё решение на С++: 71 строка

Моё решение на С: 125 строк

Алгоритм не менялся…

Ок. И ПВПО - применение визуального программирования ограничено.

Кстати, у ТС концепт что переменные относятся к связям графа (традиционное определение графа зависимостей). И тут же в динамических массивах переменные относящиеся к массиву оказываются в квадратиках… ПУНД

Метапрог и Лабвью удобнее всего

Да.

Нет, ПВПО

На Метапроге можно собрать программу, написав ноль строк текстового кода.

…но вместо этого натаскав кучу квадратиков и проводков между ними.

Причём всё это добро надо как-то располагать на схеме. Я в своё время и диаграммы классов на UML рисовал, и ER-модели (куда больше) для баз данных делал. И я хорошо помню, что вот это раскидывание квадратиков и связей отнимало у меня время, вполне сравнимое с формулировкой моих мыслей, а то и куда большее. Пока всё заполнишь и расположишь — забудешь, что хотел показать-то. Причём квадратик можно нарисовать снизу, можно справа, начинаешь думать, как их компактнее уложить… бр-рр! А уж как проводки на сложной схеме протягивать, особенно если они между сущностями с разных концов диаграммы, и приходится вставлять «коленья»… Визуальная работа съедает время у содержательной, это никуда не годится.

В написании программы (текстовой) совсем по-другому. Записать какой-нибудь цикл гораздо быстрее, чем мысленно прикинуть, что именно в этом цикле должно твориться. Да IDE ещё и подсказывает, что именно я хочу написать.

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

бр-рр!

Зато выглядишь почти художником, просто картинка в тему: https://i.imgur.com/a6DNLqy.png

Отличная картинка!

да знакомая ситуация. Реально пока думаешь, как в схемах покомпактнее отобразить эти классы, таблицы - можно половину кода накатать)))

Просто у вас в свое время нормального метапрога не было…

Для таблиц и, возможно даже нелюбимых ТСом классов это, возможно, неизбежное зло: для описания связанных структур проводки добавляют наглядности. То же можно изобразить в виде набора struct или class, но наглядность будет хуже.

А вот для логики - всё с точностью до наоборот.

Тяжёлое детство, деревянные игрушки, текстовое программирование…

у вас и нет права хвалиться скоростью того, что вы не делали

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

пока ваш проект действительно ноль без палочки, он нежизнеспособен без хост-языка, так же как и любой язык на основе ллвм

Без сишного бекенда почти все современные ЯП превратятся в тыкву. arturianec100:

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

Нечестно тыкать этим аргументом только в сторону ВП. Де-факто всё современное программирование – это «В итоге ты мне предлагаешь абстракции, внутри которых опять обычный си.» Кроме разве что фортрана да кобола.

Именно этим аргументом царь провозглашает «си - ЯП, всё остальное - недоязычки». cpython на си, v8 на с++, jvm на с++…

Либо делаешь свой яп/среду разработки «внутри которых опять обычный си», хоть текстовый яп, хоть визуальный, хоть пахнущий, либо заявляешь о полной независимости от си и посылаешь в жопу ВСЮ it инфраструктуру человечества и ВСЁ делаешь с нуля.

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

Царь:

Кстати, я тут увидел против вас заходы вида «да там 200 метров бинарей - ты ничего сам не сделал». Да это же раст. Сразу проси адептов пойти и объяснится за раст.

Вот это вот:

Питон хотя бы написан с нуля :)

просто смешно. Где он написан с нуля? На чем написан интерпретатор? На самом питоне? Или таки на сишке? Да питоньи функции дергают сишку на каждый чих, а если не дергать функции из Си - питон превращается в тормознутое убожество. И Метапрог, и питон опираются на Си, только Метапрог ближе к сишному бекенду и не обмазан кучей бесполезных объектных моделей, интерпретаторов и динамических типизаций - то есть быстрее, проще и понятнее.

оба языка имеют текстовый ввод, кстати второй высокоуровневый язык вообще на основе питона налабали (так что тут я был неправ, все-таки пока люди не могут отказаться от привычных средств набора и не придумали ничего эффективнее текста, но по сути на уровне условного «железа», там архитектура совсем другая, не как в привычном нам компьютере). Это если говорить о квантовых компьютерах которые делает ibm.

Это не показатель. Корпорасты тоже порой делают глупости..

Все хотел спросить. А чем ты вообще таким занят, что у тебя нет времени читать документацию?

У меня

0 strings matches, time = 5512
0 strings matches, time = 5606
0 strings matches, time = 5678
0 strings matches, time = 5749
0 strings matches, time = 6009
0 strings matches, time = 6007
0 strings matches, time = 6146
0 strings matches, time = 6018
0 strings matches, time = 5964
0 strings matches, time = 6064

Значительно быстрее, чем F# Метапрог-прототип, версия 6 + будильник на Метапроге (комментарий)

Но до сишки недотягивает.

Ну как же, «условные схождения» пилит, уже какую неделю…

Метапрог-прототип, версия 6 + будильник на Метапроге (комментарий)

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

нет кучи PyObject и прочей лабуды

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

Строку то с консоли перевернул уже?

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

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

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

и так могу вести почти без чтения документации

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

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

и это не условные схождения

Ясно, нормального «if … then … else …» долго еще не будет. А о «elseif» и «case» вообще можно забыть надолго.

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

А я ещё вчера не мог понять, как это потребление памяти у вас меньше сотни мегабайт. Оказалось, что длина строк у меня 1000 символов. Перемерял с 100:

== time python2 py-random-choice.py
generated haystacks in 3.78 secs
found 0 needles in 21.56 secs
25.36user 0.01system 0:25.39elapsed 99%CPU (0avgtext+0avgdata 27448maxresident)k
536inputs+0outputs (2major+5808minor)pagefaults 0swaps

== time python2 py-os-urandom.py
generated haystacks in 2.14 secs
found 0 needles in 19.24 secs
21.13user 0.23system 0:21.40elapsed 99%CPU (0avgtext+0avgdata 25204maxresident)k
0inputs+0outputs (0major+5731minor)pagefaults 0swaps

== time pypy py-random-choice.py
generated haystacks in 0.63 secs
found 0 needles in 7.21 secs
7.86user 0.01system 0:07.91elapsed 99%CPU (0avgtext+0avgdata 92712maxresident)k
136inputs+0outputs (1major+12025minor)pagefaults 0swaps

== time pypy py-os-urandom.py
generated haystacks in 0.62 secs
found 0 needles in 6.95 secs
7.46user 0.13system 0:07.61elapsed 99%CPU (0avgtext+0avgdata 86576maxresident)k
0inputs+0outputs (0major+11508minor)pagefaults 0swaps

== time python3 py-random-choice.py
generated haystacks in 7.00 secs
found 0 needles in 19.86 secs
26.86user 0.01system 0:26.90elapsed 99%CPU (0avgtext+0avgdata 28116maxresident)k
920inputs+0outputs (8major+5516minor)pagefaults 0swaps

== time python3 py-os-urandom.py
generated haystacks in 1.72 secs
found 0 needles in 19.47 secs
21.04user 0.16system 0:21.21elapsed 99%CPU (0avgtext+0avgdata 26176maxresident)k
0inputs+0outputs (0major+5358minor)pagefaults 0swaps

== time pypy3 py-random-choice.py
generated haystacks in 1.24 secs
found 0 needles in 6.63 secs
7.96user 0.06system 0:08.12elapsed 98%CPU (0avgtext+0avgdata 98156maxresident)k
111504inputs+0outputs (200major+14514minor)pagefaults 0swaps

== time pypy3 py-os-urandom.py
generated haystacks in 1.36 secs
found 0 needles in 6.98 secs
7.99user 0.39system 0:08.39elapsed 99%CPU (0avgtext+0avgdata 99524maxresident)k
0inputs+0outputs (0major+16215minor)pagefaults 0swaps

Перемерял твою реализацию, но скомпиленную gcc 9.2.1:

0 strings matches, time=2.135169
0 strings matches, time=2.399030
0 strings matches, time=2.271028
0 strings matches, time=2.225919
0 strings matches, time=2.280296
0 strings matches, time=2.088634
0 strings matches, time=2.067582
0 strings matches, time=2.072497
0 strings matches, time=2.072988
0 strings matches, time=2.061398

Набросал версию с openmp:

#include <omp.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define ARRAY_SIZE UINT64_C(100000)
#define HAYSTACK_LENGTH UINT64_C(100)
#define NEEDLE_LENGTH UINT64_C(20)
#define NUM_SEARCHES UINT64_C(1000)

typedef uint8_t u8;
typedef uint32_t u32;

int main(void) {

  static const u8 xlat[] =
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghij"
      "klmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrst"
      "uvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCD"
      "EFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefgh";

  for (size_t try = 0; try < 10; try ++) {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    u8 **array = malloc(sizeof(u8 *) * ARRAY_SIZE);
#pragma omp parallel
    {
      u32 seed = omp_get_thread_num() * time(NULL);
#pragma omp for
      for (size_t k = 0; k < ARRAY_SIZE; k++) {
        u8 *hs = malloc(HAYSTACK_LENGTH + 1);
        for (size_t j = 0; j < HAYSTACK_LENGTH; j += sizeof(u32)) {
          const u32 r = rand_r(&seed);
          *(u32 *)(hs + j) = xlat[(r >> 24)] << 24 |
                             xlat[(r >> 16) & 0xffu] << 16 |
                             xlat[(r >> 8) & 0xffu] << 8 | xlat[r & 0xffu];
        }
        hs[HAYSTACK_LENGTH] = 0;
        array[k] = hs;
      }
    }

    char needle[NEEDLE_LENGTH + 1];
    for (size_t k = 0; k < NEEDLE_LENGTH; k++)
      needle[k] = xlat[k & 0xffu];
    needle[NEEDLE_LENGTH] = 0;

    size_t count = 0;
#pragma omp parallel for reduction(+ : count)
    for (size_t iter = 0; iter < NUM_SEARCHES; iter++) {
      for (size_t k = 0; k < ARRAY_SIZE; k++) {
        count += !!strstr(array[k], needle);
      }
    }

    for (size_t k = 0; k < ARRAY_SIZE; k++)
      free(array[k]);
    free(array);

    struct timespec te;
    clock_gettime(CLOCK_MONOTONIC, &te);
    printf("count = %zu; %.3f secs\n", count,
           (te.tv_sec - ts.tv_sec) + 1e-9 * (te.tv_nsec - ts.tv_nsec));
  }
}

$ gcc -march=skylake -O2 -fopenmp openmp.c && /usr/bin/time ./a.out
count = 0; 0.429 secs
count = 0; 0.509 secs
count = 0; 0.446 secs
count = 0; 0.548 secs
count = 0; 0.523 secs
count = 0; 0.616 secs
count = 0; 0.508 secs
count = 0; 0.632 secs
count = 0; 0.497 secs
count = 0; 0.760 secs
39.36user 0.02system 0:05.47elapsed 720%CPU (0avgtext+0avgdata 13464maxresident)k
0inputs+0outputs (0major+7292minor)pagefaults 0swaps

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

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

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

могу дрочить вприсядку

Маску надень, видео сними, выложи на порнхаб. Хоть народ узнает, что это за извращение.

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

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

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

Без сишного бекенда почти все современные ЯП превратятся в тыкву

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

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

просто смешно. Где он написан с нуля? На чем написан интерпретатор? На самом питоне? Или таки на сишке? Да питоньи функции дергают сишку на каждый чих, а если не дергать функции из Си - питон превращается в тормознутое убожество. И Метапрог, и питон опираются на Си, только Метапрог ближе к сишному бекенду и не обмазан кучей бесполезных объектных моделей, интерпретаторов и динамических типизаций - то есть быстрее, проще и понятнее.

Действительно смешно, да он написан с нуля на С, в чем проблема С отлично подходит для написания системного ПО и компиляторов, правда сейчас лучше конечно для этого все же С++ использовать, ну или Раст когда он там уже стабилизируется. Python не прокладка на С, он именно написан на С и это язык. Есть реализация и на питоне, pypy вроде называется. Есть и такое что дергает, что же теперь переписывать все что есть на каждый новый язык? Есть разница между дергать либц и тем что вы делаете, вы так-то даже ничего не дергаете, разве что лабвью который дергает С, кажется это в два раза больше дерганья чем у питона, боже мой, что же теперь делать… Опять вы скатываетесь в то, что сравниваете свое поделие на котором ничего нельзя написать толком, с отличным языком который вон уже и в компьютерах будущего приладили. Напишу вам еще раз хотя писал выше в этом же ответе, все что вы называете «бесполезными объектными моделями» появится и у вас, рано или поздно. У каждой из типизаций есть свои плюсы и минусы, какие в гугл, там все давно написано, а то вы толком не разобрались ни в той ни в другой, а мнение свое имеете, которое с делом правда расходится.

Это не показатель. Корпорасты тоже порой делают глупости..

Да-да, все дураки, весь мир заблуждается, а мы так и ждем ебилдов метапрога.

На Лоре с утра до ночи доказывает абсурд.

Круто.

Кажется только пропущена небольшая часть про рандом в needle.

А так да, needle же 21 байт всего, логично на стеке держать.

И записывать сразу u32, а не по char, тоже норм оптимизация.

И использовать всю энтропию rand

metaprog посмотри код Рината, может какие-то идеи сможешь уловить и использовать где-то в будущем…

в жизни есть еще много чего кроме программирования.

В Вашем случае это метла и половая тряпка?

Тяжёлое детство, деревянные игрушки, текстовое программирование…

Программирование в кодах калькулятора не совсем текстовое;-)

пропущена небольшая часть про рандом в needle.

Вот жеж. :-/

Мне вот интересно - откуда берется такая обратная зависимость между лаконичностью текстового кода и скоростью выполнения алгоритмов?

Возьмем твой пример на Си.

18 пустых строк

18 фигурных скобочек, открывающих и закрывающих функции и циклы

2 комментария

6 инклюдов

typedef char const*const* unowned_array_unowned_string;

6 typedef - в Метапрог-диагармме определения типов как отдельная сущность не нужны. Типы, которые нужно объявить транслятору, определяются только типами выходов подфункций и типами констант. Константы, входы и выходы нужных типов вытаскиваются из интерфейса функций одним щелчком мыши, еще одним - ставятся на диаграмме. В текстовом представлении надо отдельно определять тип, а вот в Метапроге отдельный блок для объявления типа не нужен. Объявления типов могут появиться только если есть блоки константы и сишной функции (если есть выход):

https://postimg.cc/SY28kB45

Входы и выходы провоцируют объявление определения типа только в колбеках.

owned_array_owned_string array_init(size_t len, owned_string(*initializer) ())

9 строк, объявлящих заголовки функций - очень многословная сущность. Прописать тип выхода, название функции, скобки, типы и названия входов, запятые - в Метапроге если функция собрана из подфункций это все делается в несколько щелчков мышью: вытягиваешь константы/входы/выходы из терминалов подфункций и вуаля, определение функции готово. При этом в Метапроге идет автоматический инлайн при кодогенерации (кроме колбеков), что хоть и может увеличить размер кода, но чаще всего полезно с точки зрения оптимизации и скорости выполнения.

void* result = malloc(size);

Прописать тип, прописать название новой переменной на аглицком, поставить знак равенства, прописать название функции с названичми переменных-аргуметов в скобках и не забыть точку с запятой в конце строки. В Метапроге - вытащить блок с функцией, подключить проводок к константе/входу/выходу другой функции или вывести ответвление от проводка, пара щелчков мышью. Для примера я повторил твою функцию my_malloc (на Метапроге уже таки можно частично собрать твой бенчмарк):

https://postimg.cc/hQVLBcHp

Самый заметный профит тут в том, что мне не нужно объявлять переменную result и вручную обращаться к ней. Он сидит в проводке с разветвлением, вместо return - выход с указателем. Еще профит - нет скобок, фигурных скобок,запятых, точек с запятыми - эту ерунду за тебя проставит транслятор.

Вместо fprintf в случае ошибки в консоль печатается сериализированная в base64 при кодогенерации цепочка вызовов функций (стектрейс), который можно вставить в Метапрог и он автоматически найдет первую функцию из стектрейса, если она есть в библиотеке диаграмм. Далее Метапрог будет вести пользователя по цепочке дебага, подсвечивая нужные блоки в порядке вызова подфункций. Это новая фича 7 версии прототипа Метапрога.

Возможно, сделаю пост с картинками к выпуску 7 версии прототипа Метапрога.

В общем и целом должно быть понятно, что чистый Си многословен в основном из-за конструкций, которые можно спрятать «под капот» транслятора. При этом в Метапроге это происходит практически без ущерба для производительности, в отличие от ООПнутых и тем более интерпретируемых текстовых ЯП.

Причём всё это добро надо как-то располагать на схеме

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

Я в своё время и диаграммы классов на UML рисовал, и ER-модели (куда больше) для баз данных делал

Ну это ж совершенно не похоже на логику в Лабвью, так ведь?

Записать какой-нибудь цикл гораздо быстрее, чем мысленно прикинуть, что именно в этом цикле должно твориться

В Лабвью еще проще. В Метапроге тоже циклы работают, но с удобством пока что все же не айс, придется допиливать или уже в «настоящем» Метапроге делать их удобными.

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

Опять же, ты судишь по опыту с диаграммами классов, а не диагарммами логики а-ля Лабвью, где есть подфункции, серьезно уменьшающие сложность и размер диагарммы.

Много чем - это чем?

Тем, что интересно. Метапрог я тоже делаю по интересу.

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

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

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

Это для базовых блоков стандартной библиотеки, когда у меня наберется достаточно блоков - будет намного проще. К тому же, большая часть работы над Метапрогом - это работа над прототипом в Лабвью, а уж в этом мне равных на ЛОРе нет.

Покажи как, видео сними что ли...

Мне вот интересно - откуда берется такая обратная зависимость между лаконичностью текстового кода и скоростью выполнения алгоритмов?

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

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

Например в том примере на F# я не разу не написал тип явно, лишь let и один раз let mutable, но все типы были известны на этапе компиляции.

Всё благодаря алгоритму Хиндли — Милнера: https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%B2%D0%BE%D0%B4_%D1%82%D0%B8%D0%BF%D0%BE%D0%B2

Так же там не было и ; , это тоже есть в различных языках, например в Kotlin и Swift тоже ; не нужна

Самый заметный профит тут в том, что мне не нужно объявлять переменную result и вручную обращаться к ней.

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

Chaining и функции расширения(например такое можно сделать в Kotlin)

    i
     .do_smth1()
     .do_smth2()
     .do_smth3()
     .do_smth4()
     //...

или range нотация в C++

auto f(Input i)
{
   i
    | do_smth1
    | do_smth2
    | do_smth3
}

или оператор pipe в F#

    i
     |> do_smth1
     |> do_smth2
     |> do_smth3

На С тоже можно было бы избежать наименование переменной если добавить ещё одну функцию unwrap, которая может быть полезна и есть с похожим смыслом в других языках

not_null_void_ptr unwrap(void* arg)
{
    if (arg == NULL)
    {
        abort();
    }
    return arg;
}

not_null_void_ptr my_malloc(size_t size)
{
    return unwrap(malloc(size));
}

Но приём f(g(h(x))) который можно использовать в С менее нагляден, чем похожие приёмы для других языков программирования.

Крыша поедет столько мануалов курить

Почему у меня не едет?

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

Убил

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

Часть твоих претензий к текстовому программированию уже решили авторы других языков программирования... F#... Kotlin и Swift

Только почему-то ценой замедления в разы, десятки, а то и сотни и тысячи раз в сравнении с Си. По-другому авторы текстовых ЯП не могут?

Например в том примере на F# я не разу не написал тип явно, лишь let и один раз let mutable, но все типы были известны на этапе компиляции. Всё благодаря алгоритму Хиндли — Милнера

Тебе лично эти типы известны и показываются? Или остается только гадать на кофейной гуще что у компилятора/транслятора на уме?

Chaining и функции расширения... range нотация в C++... оператор pipe в F#

К сожалению, «не догоняю». Одно лишь ясно на все 100: выразительность текстовых ЯП жестко ограничена текстовым представлением.

На С тоже можно было бы избежать наименование переменной если добавить ещё одну функцию unwrap

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

Но приём f(g(h(x))) который можно использовать в С менее нагляден, чем похожие приёмы для других языков программирования.

В Метапроге очень даже нагядно, и это строится вот так:

https://postimg.cc/MX3gxBF4

Если это последовательность выполнения из сишных функций, то она прямо транслируется в цепочку вида f(g(h(x))). Если это метапроговские функции (как на скрине) - то они инлайнятся: проходятся транслятором так, как будто они - всего лишь часть большой диаграммы. Если «под капотом» метапроговских подфункций сидят только сишные без каких-либо разветвлений - получится та же цепочка f(g(h(x))). И это все с нулевым или минимальным оверхедом в сравнении с рукописным Си.

Потому что уже поехала.

человек до сих пор не окуклися от базовой алгоритмистики на блок-схемах

Самая быстрая и простая, из которой можно собрать очень многое - не менее чем прототип Метапрога с онлайн-функционалом.

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

Юнионы забыл. А вообще так этого должно хватить на программу любой сложности, особенно если собирать из этого дополнительные плюшки, как, например, массивы, СУВТ и многотиповой тип.

ведь сами понимаете С он такой… коварный, все помнит, ничего не прощает.

Каковы альтернативы? Скриптуху не предлагать - у меня уже есть Лабвью.

биндинги

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

если вы кого-то цитируете, делайте это так чтобы цитаты эти были кликабельны

Тупо ссылки вставлять не проблема, хотя ты можешь использовать поиск по цитате. Кстати, прописывать в тегах кликабельность произвольного слова - пальця отвалятся. Даже стрелочки > копипастить для цитат - та еще морока. Когда на ЛОР наконец завезут проставление тегов по выделению и кнопкам? На форумах это еще в девяностых было.

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

Уже готовые ответы по сути.

да он написан с нуля на С, в чем проблема С отлично подходит для написания системного ПО и компиляторов

Для любого софта с максимально возможной производительностью.

правда сейчас лучше конечно для этого все же С++ использовать

Даже в этой теме бенчмарки показали, что плюсы сливают сишке в разы.

ну или Раст когда он там уже стабилизируется

За него тебе царь доходчиво объяснит, что это всего лишь вторичая надстройка над LLVM, которую пиарят как нечто самодостаточное, при этом большая часть функций в растовых библиотеках - unsafe, взятые из Си. Я же ни на секунду не скрываю, что прямо использую Си, как бекенд.

Python не прокладка на С, он именно написан на С и это язык

Убогая вторичная скриптуха. Если ты намекаешь на то, что Метапрог - не «язык», то пускай это будет Си с графическими плюшками, так же как С++ - не более чем Си с ООПнутыми плюшками. Только в отличие от ООП оверхеда в сравнении с чистым Си минимум, если не ноль. И да, никаких PyObject.

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

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

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

Это проблемы Лабвью, а не Метапрога. Прототип сделан на Лабвью, но планируется повторить его «на самом себе».

Опять вы скатываетесь в то, что сравниваете свое поделие на котором ничего нельзя написать толком, с отличным языком который вон уже и в компьютерах будущего приладили

Отличный тормознутый интерпретируемый недоязык с «гадай на кофейной гуще какой где тип». Я могу сравнить его с Си, как бекендом Метапрога, и сишке он явно сливает. Компьютеров будущего нет - они будут в будущем, и не факт, что это будет именно та ерунда от корпорастов, на которую ты так яростно фапаешь.

все что вы называете «бесполезными объектными моделями» появится и у вас, рано или поздно

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

У каждой из типизаций есть свои плюсы и минусы

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