2014 dxdy logo

Научный форум dxdy

Математика, Физика, Computer Science, Machine Learning, LaTeX, Механика и Техника, Химия,
Биология и Медицина, Экономика и Финансовая Математика, Гуманитарные науки




Начать новую тему Ответить на тему На страницу Пред.  1, 2, 3, 4  След.
 
 Re: Эффективное изложение информации
Сообщение09.03.2021, 23:16 


12/07/15
1698
По аналогии с мультипликативным показателем TF-IDF, который определяет специфичность, можно придумать TF-DF:

TF - мера важности в частности (определяется по мнению юзера, областям его интересов, значения 0.0 - скрыть, 1.0 - показать)

DF - мера важности в целом (частота использования функции/переменной в других проектах)

для сравнения: IDF - мера специфичности в целом (обратно пропорционально частоте слова в корпусе документов)

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение10.03.2021, 22:41 


21/01/09
115
Цитата:
в основном к ним обращаются через 5 вот этих методов a(), b(), c(), d(), e(), остальное используется крайне редко

В С++ выручает условная компиляция. Для своих тестовых целей можно использовать всю библиотеку, но если надо показать код людям, выбирается только малая часть, автоматически выводится в новые исходники. При большой важности дела и вручную стоит подредактировать.
Если участки кода очень похожие и достаточно длинные, делается новая функция, в том числе inline. Многое зависит от мастерства программиста, и желания, при работе на количество знаков в тексте такого желания не будет.
А в более общем философском смысле тут нужен серьёзный интеллект.
Цитата:
либо полностью интересно (показать), либо полностью неинтересно (скрыть)

Как минимум должно быть ранжирование информации по ценности одномерным списком, только "да" или "нет" этого конечно мало.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение11.03.2021, 01:31 


12/07/15
1698
В листинге программы все держится на списках:
- список директив
- список деклараций глобальных переменных, функций, классов
- список атрибутов функций
- список параметров функций
- список методов и полей класса
- список локальных деклараций
- список инструкций (тела функций)
- и т.п.
Каждого перечисленного типа списков в программе может быть несколько и вся эта совокупность образует сложность программы.

На данный момент вырисовывается такая картина: пользователь выбирает сферу своих интересов, открывая список переменных и функций проекта. Он указывает Y, затем начинает указывать X. Объекты X и Y - это некоторые списки переменных и функций. Набор (X, Y) полностью определяет вход-выход и общее пространство задачи. X - левая граница, Y - правая граница. Как вариант, кросс-референсный подход - начать с одной переменной и расширять пространство интересуемой задачи влево и вправо.
В зависимости от этого разворачиваются или сворачиваются абстрактные списки (в терминологии языка, который я описывал выше). Списков много, и их сворачивать-разворачивать долго, указанием XY-сферы гораздо проще и быстрее. Сворачивание и разворачивание (фолдинг) - это очень важный процесс перемещения по уровням абстракции кода и в настоящее время мы видим, что IDE предлагают до сих пор шастать по коду линейно (скроллинг с элементами ручного фолдинга), а не гибко экспоненциально, так сказать.
Пока мы научились делать фолдинг списков целиком. Список целиком раскрылся или целиком свернулся, а хотелось бы еще частично скрывать списки, т.е. раскрыть потенциал абстрактных списков.
Однако все элементы списка изначально равнозначны, и невозможно определить, какой из них скрыть, а какой отобразить.

-- 11.03.2021, 03:38 --

computer в сообщении #1508620 писал(а):
А в более общем философском смысле тут нужен серьёзный интеллект.

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

-- 11.03.2021, 04:04 --

computer в сообщении #1508620 писал(а):
В С++ выручает условная компиляция. Для своих тестовых целей можно использовать всю библиотеку, но если надо показать код людям, выбирается только малая часть, автоматически выводится в новые исходники. При большой важности дела и вручную стоит подредактировать.
Если участки кода очень похожие и достаточно длинные, делается новая функция, в том числе inline. Многое зависит от мастерства программиста, и желания, при работе на количество знаков в тексте такого желания не будет.
А в более общем философском смысле тут нужен серьёзный интеллект.


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

Mihaylo в сообщении #1508632 писал(а):
Однако все элементы списка изначально равнозначны, и невозможно определить, какой из них скрыть, а какой отобразить.

В принципе, я допускаю, что разработчик вручную разметит списки и эта информация сохранится вместе с кодом. У каждого элемента списка появится некий коэффициент важности, допустим, от 0.0 до 1.0 или в виде просто разбиения элементов на категории важности.
И тогда к левым-правым XY-границам интересов можно будет добавить уровень сложности (up - сложнее, down - попроще).
Сейчас непонятно, как реализовать непротиворечивую систему рейтингов. Было бы правильнее понять, как мы понимаем, что одна функция важнее другой. Чем это определяется и много других вопросов.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение11.03.2021, 07:23 


12/07/15
1698
Сжатое (абстрактное) описание можно разрабатывать:
- на библиотеку,
- на фреймворк,
- на операционную систему,
- на процессор и железо в целом,
- и т.д.
Можно описывать подробно, можно описывать лишь только отдельные важные части. Описание может составить как сам разработчик системы, так и сам пользователь (в силу своих способностей).
Имея абстрактное описание сторонних систем, можно отследить скрытые взаимосвязи. Например, можно отследить причину, почему возникает исключение в операционной системе Windows. Это действительно было бы здорово! Представьте, вы заходите на stackoverflow, спрашиваете, почему возникает исключение, связанное с обращением к памяти в программе на языке С++, вам скидывают абстрактное описание Windows+компилятор. Это может быть текстовый файлик на 1 кБ, может даже 100 байт, а может объемистый 10 МБ. Вы подгружаете его в IDE, находите в описании Windows нужное исключение, задаете в качестве Y-границы, затем указываете всю свою программу в качестве X и потом постепенно сдвигаете X в сторону Y, с целью локализации возможных причин ошибки.
Вместо абстрактного описания на stackoverflow на натуральных языках должно быть абстрактное описание на искусственном языке, которое может быть проанализировано средствами IDE. Собственно я такой язык предлагаю.
Чуть позже скину сжатые описания исходного кода пирамидальной сортировки на Java, чтобы не было слишком абстрактно.))) Исходный код сортировки не очень подходит для сжатия, так как внутренние взаимосвязи довольно тесные, но это осуществимая задача.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение11.03.2021, 19:12 


12/07/15
1698
https://ru.wikibooks.org/wiki/Реализации_алгоритмов/Сортировка/Пирамидальная#Java

Уровень абстракции 0 (Исходный код)

(Оффтоп)

Код:
/**
* Класс для сортировки массива целых чисел с помощью кучи.
* Методы в классе написаны в порядке их использования. Для сортировки
* вызывается статический метод sort(int[] a)
*/
class HeapSort {
   /**
    * Размер кучи. Изначально равен размеру сортируемого массива
    */
   private static int heapSize;
   
   /**
    * Сортировка с помощью кучи.
    * Сначала формируется куча:
    * @see HeapSort#buildHeap(int[])
    * Теперь максимальный элемент массива находится в корне кучи. Его нужно
    * поменять местами с последним элементом и убрать из кучи (уменьшить
    * размер кучи на 1). Теперь в корне кучи находится элемент, который раньше
    * был последним в массиве. Нужно переупорядочить кучу так, чтобы
    * выполнялось основное условие кучи - a[parent]>=a[child]:
    * @see #heapify(int[], int)
    * После этого в корне окажется максимальный из оставшихся элементов.
    * Повторить до тех пор, пока в куче не останется 1 элемент
    *
    * @param a сортируемый массив
    */
   public static void sort(int[] a) {
      buildHeap(a);
      while (heapSize > 1) {
         swap(a, 0, heapSize - 1);
         heapSize--;
         heapify(a, 0);
      }
   }
   
   /**
    * Построение кучи. Поскольку элементы с номерами начиная с a.length / 2 + 1
    * это листья, то нужно переупорядочить поддеревья с корнями в индексах
    * от 0 до a.length / 2 (метод heapify вызывать в порядке убывания индексов)
    *
    * @param a - массив, из которого формируется куча
    */
   private static void buildHeap(int[] a) {
      heapSize = a.length;
      for (int i = a.length / 2; i >= 0; i--) {
         heapify(a, i);
      }
   }
   
   /**
    * Переупорядочивает поддерево кучи начиная с узла i так, чтобы выполнялось
    * основное свойство кучи - a[parent] >= a[child].
    *
    * @param a - массив, из которого сформирована куча
    * @param i - корень поддерева, для которого происходит переупорядочивание
    */
   private static void heapify(int[] a, int i) {
      int l = left(i);
      int r = right(i);
      int largest = i;
      if (l < heapSize && a[i] < a[l]) {
         largest = l;
      }
      if (r < heapSize && a[largest] < a[r]) {
         largest = r;
      }
      if (i != largest) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   /**
    * Возвращает индекс правого потомка текущего узла
    *
    * @param i индекс текущего узла кучи
    * @return индекс правого потомка
    */
   private static int right(int i) {
      return 2 * i + 2;
   }
   
   /**
    * Возвращает индекс левого потомка текущего узла
    *
    * @param i индекс текущего узла кучи
    * @return индекс левого потомка
    */
   private static int left(int i) {
      return 2 * i + 1;
   }
   
   /**
    * Меняет местами два элемента в массиве
    *
    * @param a массив
    * @param i индекс первого элемента
    * @param j индекс второго элемента
    */
   private static void swap(int[] a, int i, int j) {
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 1 (убраны комментарии)

(Оффтоп)

Код:
class HeapSort {

   private static int heapSize;
   
   public static void sort(int[] a) {
      buildHeap(a);
      while (heapSize > 1) {
         swap(a, 0, heapSize - 1);
         heapSize--;
         heapify(a, 0);
      }
   }
   
   private static void buildHeap(int[] a) {
      heapSize = a.length;
      for (int i = a.length / 2; i >= 0; i--) {
         heapify(a, i);
      }
   }
   
   private static void heapify(int[] a, int i) {
      int l = left(i);
      int r = right(i);
      int largest = i;
      if (l < heapSize && a[i] < a[l]) {
         largest = l;
      }
      if (r < heapSize && a[largest] < a[r]) {
         largest = r;
      }
      if (i != largest) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   private static int right(int i) {
      return 2 * i + 2;
   }
   
   private static int left(int i) {
      return 2 * i + 1;
   }
   
   private static void swap(int[] a, int i, int j) {
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 2 (убраны атрибуты методов)

(Оффтоп)

Код:
class HeapSort {

   int heapSize;
   
   void sort(int[] a) {
      buildHeap(a);
      while (heapSize > 1) {
         swap(a, 0, heapSize - 1);
         heapSize--;
         heapify(a, 0);
      }
   }
   
   void buildHeap(int[] a) {
      heapSize = a.length;
      for (int i = a.length / 2; i >= 0; i--) {
         heapify(a, i);
      }
   }
   
   void heapify(int[] a, int i) {
      int l = left(i);
      int r = right(i);
      int largest = i;
      if (l < heapSize && a[i] < a[l]) {
         largest = l;
      }
      if (r < heapSize && a[largest] < a[r]) {
         largest = r;
      }
      if (i != largest) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   int right(int i) {
      return 2 * i + 2;
   }
   
   int left(int i) {
      return 2 * i + 1;
   }
   
   void swap(int[] a, int i, int j) {
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 3 (убраны типы данных)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (heapSize > 1) {
         swap(a, 0, heapSize - 1);
         heapSize--;
         heapify(a, 0);
      }
   }
   
   void buildHeap(a) {
      heapSize = a.length;
      for (i = a.length / 2; i >= 0; i--) {
         heapify(a, i);
      }
   }
   
   void heapify(a, i) {
      l = left(i);
      r = right(i);
      largest = i;
      if (l < heapSize && a[i] < a[l]) {
         largest = l;
      }
      if (r < heapSize && a[largest] < a[r]) {
         largest = r;
      }
      if (i != largest) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   right(i) {
      return 2 * i + 2;
   }
   
   left(i) {
      return 2 * i + 1;
   }
   
   void swap(a, i, j) {
      temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 4 (условия из if, циклов for и while, выражений в присвоениях и аргументы в вызовах методов заменены на сигнатуры abstract-функций)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (abstract(heapSize)) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (i = abstract(a)) {
         heapify(a, i);
      }
   }
   
   void heapify(a, i) {
      l = left(i);
      r = right(i);
      largest = i;
      if (abstract(l, heapSize, a[i], a[l])) {
         largest = l;
      }
      if (abstract(r, heapSize, a[largest], a[r])) {
         largest = r;
      }
      if (abstract(i, largest)) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   right(i) {
      return abstract(i);
   }
   
   left(i) {
      return abstract(i);
   }
   
   void swap(a, i, j) {
      temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 4.1 (схлопывание тривиальных языковых конструкций return ...)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (abstract(heapSize)) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (i = abstract(a)) {
         heapify(a, i);
      }
   }
   
   void heapify(a, i) {
      l = left(i);
      r = right(i);
      largest = i;
      if (abstract(l, heapSize, a[i], a[l])) {
         largest = l;
      }
      if (abstract(r, heapSize, a[largest], a[r])) {
         largest = r;
      }
      if (abstract(i, largest)) {
         swap(a, i, largest);
         heapify(a, largest);
      }
   }
   
   right(i) {...}
   
   left(i) {...}
   
   void swap(a, i, j) {
      temp = a[i];
      a[i] = a[j];
      a[j] = temp;
   }
}


Уровень абстракции 5 (замена локальных переменных в методах, циклах for, abstract-функциях на abstract-функцию)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (abstract(heapSize)) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (abstract(a)) {
         heapify(abstract(a));
      }
   }
   
   void heapify(a, i) {
      l = left(i);
      r = right(i);
      largest = i;
      if (abstract(abstract(i), heapSize, a[i], a[abstract(i)])) {
         largest = abstract(i);
      }
      if (abstract(abstract(i), heapSize, a[abstract(i)], a[abstract(i)])) {
         largest = abstract(i);
      }
      if (abstract(i, abstract(i))) {
         swap(a, i, abstract(i));
         heapify(a, abstract(i));
      }
   }
   
   right(i) {...}
   
   left(i) {...}
   
   void swap(a, i, j) {
      temp = a[i];
      a[i] = a[j];
      a[j] = abstract(a[i]);
   }
}


Уровень абстракции 5.1 (схлопывание вложенных abstract-функций, правые части присвоения локальных переменных заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (abstract(heapSize)) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (abstract(a)) {
         heapify(abstract(a));
      }
   }
   
   void heapify(a, i) {
      l = ...;
      r = ...;
      largest = ...;
      if (abstract(i, heapSize, a)) {
         largest = ...;
      }
      if (abstract(i, heapSize, a)) {
         largest = ...;
      }
      if (abstract(i)) {
         swap(abstract(a, i));
         heapify(abstract(a, i));
      }
   }
   
   right(i) {...}
   
   left(i) {...}
   
   void swap(a, i, j) {
      temp = ...;
      a[i] = a[j];
      a[j] = abstract(a[i]);
   }
}


Уровень абстракции 5.2 (присвоения локальных переменных целиком заменены на многоточие, «неиспользуемые» методы left() и right() заменены на многоточия)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (abstract(heapSize)) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (abstract(a)) {
         heapify(abstract(a));
      }
   }
   
   void heapify(a, i) {
      ...;
      if (abstract(i, heapSize, a)) {
         ...;
      }
      if (abstract(i, heapSize, a)) {
         ...;
      }
      if (abstract(i)) {
         swap(abstract(a, i));
         heapify(abstract(a, i));
      }
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = a[j];
      a[j] = abstract(a[i]);
   }
}


Уровень абстракции 6 (условия из if, циклов for и while заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (...) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (...) {
         heapify(abstract(a));
      }
   }
   
   void heapify(a, i) {
      ...;
      if (...) {
         ...;
      }
      if (...) {
         ...;
      }
      if (...) {
         swap(abstract(a, i));
         heapify(abstract(a, i));
      }
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = a[j];
      a[j] = abstract(a[i]);
   }
}


Уровень абстракции 6.1 (схлопывание тривиальных инструкций if)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(a);
      while (...) {
         swap(abstract(a, heapSize));
         heapSize--;
         heapify(abstract(a));
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(a);
      for (...) {
         heapify(abstract(a));
      }
   }
   
   void heapify(a, i) {
      ...;
      if (...) {
         swap(abstract(a, i));
         heapify(abstract(a, i));
      }
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = a[j];
      a[j] = abstract(a[i]);
   }
}


Уровень абстракции 7 (имена аргументов в вызовах методов и abstract-функций заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(...);
      while (...) {
         swap(...);
         heapSize--;
         heapify(...);
      }
   }
   
   void buildHeap(a) {
      heapSize = abstract(...);
      for (...) {
         heapify(...);
      }
   }
   
   void heapify(a, i) {
      ...;
      if (...) {
         swap(abstract(...));
         heapify(abstract(...));
      }
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = ...;
      a[j] = abstract(...);
   }
}


Уровень абстракции 7.1 (abstract-функции заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(...);
      while (...) {
         swap(...);
         heapSize--;
         heapify(...);
      }
   }
   
   void buildHeap(a) {
      heapSize = ...;
      for (...) {
         heapify(...);
      }
   }
   
   void heapify(a, i) {
      ...;
      if (...) {
         swap(...);
         heapify(...);
      }
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = ...;
      a[j] = ...;
   }
}


Уровень абстракции 8 (инструкции if, for, while заменены на многоточие; фактически получается карта использования функций и присвоений)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {
      buildHeap(...);
      ...;
      swap(...);
      heapSize = ...;
      heapify(...);
   }
   
   void buildHeap(a) {
      heapSize = ...;
...;
      heapify(...);   
   }
   
   void heapify(a, i) {
      ...;
      swap(...);
      heapify(...);
   }
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {
      ...;
      a[i] = ...;
      a[j] = ...;
   }
}


Уровень абстракции 9 (тела методов заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(a) {...}
   
   void buildHeap(a) {...}
   
   void heapify(a, i) {...}
   
   ...() {...}
   
   ...() {...}
   
   void swap(a, i, j) {...}
}


Уровень абстракции 10 (имена аргументов методов заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   void sort(...) {...}
   
   void buildHeap(...) {...}
   
   void heapify(...) {...}
   
   ...() {...}
   
   ...() {...}
   
   void swap(...) {...}
}


Уровень абстракции 11 (имена выходных параметров методов заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {

   heapSize;
   
   ... sort(...) {...}
   
   ... buildHeap(...) {...}
   
   ... heapify(...) {...}
   
   ...() {...}
   
   ...() {...}
   
   ... swap(...) {...}
}


Уровень абстракции 12 (поля и методы класса заменены на многоточие)

(Оффтоп)

Код:
class HeapSort {...}


Уровень абстракции 13 (весь код заменен на многоточие, весь код абстрактный)

(Оффтоп)

Код:
{...}


-- 11.03.2021, 21:16 --

К сожалению, форум не позволяет совместить код и оффтопик (спойлер). Советую начать просматривать преобразования с конца (начать с уровня 13).

Порядок преобразований (абстрагирований) не самый оптимальный, но самое главное понять суть.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение11.03.2021, 20:57 
Заслуженный участник


27/04/09
28128
Mihaylo в сообщении #1508712 писал(а):
К сожалению, форум не позволяет совместить код и оффтопик (спойлер).
Позволяет, если использовать для кода code. Это не такой хороший тег как syntax, но однако же лучше чем ничего. Отступы он немного ест, но гораздо меньше, чем если код оставить без тегов совсем. Плюс код, засунутый в syntax, спойлерится в какой-то мере сам собой. Не совсем до конца, но опять же лучше чем ничего. Наконец можно было бы обернуть все уровни сокращения в один большой syntax, разделив их там каким-нибудь двойным переводом строки для пущей раздельности. Тогда они точно бы не раздували пост — но кстати вообще такой цели вроде и не стоит? Пусть будет длинным, почему нет?

А вот зачем может понадобиться так много уровней градации простого сокращения (впротивовес тому чтобы показывать прошлые (или гипотетические прошлые) менее сложные версии кода?

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение11.03.2021, 23:46 


12/07/15
1698
Эти избыточные градации могли бы быть бы полезны для анализа. Про многие из них вы можете сказать "фу, ерунда", но этот вывод нужно было бы сделать.

Спасибо за подсказку про code, попробую попросить модераторов исправить пост.

 Профиль  
                  
 
 Posted automatically
Сообщение12.03.2021, 01:33 
Супермодератор
Аватара пользователя


09/05/12
23358
Кронштадт
 i  Тема перемещена из форума «Computer Science» в форум «Карантин»
Пожалуй, лучше, если вы поправите все это сами. Когда покончите с оформлением кода, сообщите об этом в теме Сообщение в карантине исправлено.

 Профиль  
                  
 
 Posted automatically
Сообщение12.03.2021, 11:31 
Супермодератор
Аватара пользователя


09/05/12
23358
Кронштадт
 i  Тема перемещена из форума «Карантин» в форум «Computer Science»

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение12.03.2021, 20:14 


12/07/15
1698
Продолжаю свои рассуждения вслух... :D
Все эти абстрактные языки и навигаторы XYUD - это все конечно круто. Но меня интересует вопрос на данный момент такой: почему самым важным в исходном коде является наличие или отсутствие зависимости между двумя переменными? Я ощущаю и многие согласятся со мной, что нам важно узнать, а зависит ли переменная $y$ от переменной $x$. Нам неинтересно название функции, ибо зная сигнатуру функции, можно понять, как ей следовало бы называться, более того, имя выходной переменной зачастую совпадает с именем функции, например, getXCoord().
Нам больше всего нужен граф зависимостей и в первую очередь граф самых важных переменных - и это в первую очередь выходных переменных из зоны Y. Почему???

-- 12.03.2021, 22:27 --

Не от того ли, что граф зависимостей легко построить, в нем каждая дуга - это один бит информации (либо True - есть дуга, либо False - дуги нет). Но при этом граф позволяет выполнять декомпозицию задачи.
Ощущение эффективности информации в графе зависимостей есть, а доказательство этого факта вызывает затруднения.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение12.03.2021, 22:04 
Заслуженный участник


27/04/09
28128
Mihaylo в сообщении #1508914 писал(а):
Нам больше всего нужен граф зависимостей и в первую очередь граф самых важных переменных - и это в первую очередь выходных переменных из зоны Y. Почему???
Может быть потому что вы рано обрадовались и это всё-таки не универсалия.

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

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

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

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение13.03.2021, 07:22 


12/07/15
1698
arseniiv в сообщении #1508932 писал(а):
Может быть потому что вы рано обрадовались и это всё-таки не универсалия.

arseniiv в сообщении #1508932 писал(а):
В упрощении задач есть польза, но только когда, когда мы в курсе, что именно мы оставили в стороне и что никуда не делось из реальности.

Может быть этот граф зависимостей полезен, чтобы первоначально сориентироваться, не оставить ничего в стороне, определить XYUD-границы задачи? А определение границ задачи очень важно для сокращения объема обрабатываемой информации, для снижения сложности.
Только это происходит очень мучительно в нынешних реалиях:
1. Если код свой, то граф зависимостей является конструктом в голове.
2. Если код чужой, то граф зависимостей выстраивается сначала на высоком уровне, оцениваются степени важности для объектов языка, затем идет попытка найти связи с текущей задачей (из-за которой влезли в чужой код). Если нет понимания, то итерация повторяется для более низкого уровня абстракции. Так потихоньку граф выстраивается в голове и ищется уровень абстракции, наиболее адекватный текущей задаче. Как-то так.

arseniiv в сообщении #1508932 писал(а):
А когда мы залезаем в жутко императивный код со множеством присваиваний одной и той же переменной в разные моменты времени, никакого единственного натурального графа зависимостей переменных вообще не получится. Одной переменной присвоится значение выражения, включающего значение другой, а потом наоборот другой присвоится что-то, считающееся по значению первой… а потом ещё какие-нибудь условные присваивания, и наивно понимаемый граф зависимостей выродится во что-то сильно связное и малополезное («всё зависит от всего», это нью-эйдж какой-то уже), а какое-то одно самое улучшенное улучшение такого графа не существует. Если учитывать выполнение программы (в смысле циклов и условий), мы вообще скорее закончим на графозначном конечном автомате, а не одном графе.

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

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение13.03.2021, 08:36 


12/07/15
1698
Я надеюсь, что вы понимаете, что я подразумеваю под XYUD-границами задачи. Это некоторая часть программы, которая интересует разработчика в данный момент времени. XY-границы - это вход-выход задачи. UD - это уровень детализации на данном уровне абстракции.
Сама задача (проблема) изначально формулируется на человеческом языке или на уровне восприятия органами чувств, например, "при нажатии на кнопку приложение зависает", "неправильно подсчитывается сумма расходов", "окно всегда отображается поверх остальных, а должно скрываться, когда расчет завершился".
Иногда имеется четкое понимание, что является X и Y в данной задаче, а иногда понятно только X или только Y.
"При нажатии на кнопку приложение зависает" - здесь, допустим, осознается только X, а Y теряется где-то в недрах операционной системы. В таком случае, разработчик определяет X, а Y пока приравнивает X, то есть смотрит на один элемент программы. Затем пошагово сдвигает Y вправо, вовлекая в рассмотрение все больше и больше зависимостей.
Сейчас IDE позволяют пошагово отслеживать зависимости (инструментарий uses/used by). Однако этот инструментарий как-то куцо связан с автоматическим выходом на нужный уровень абстракции.
Пошаговое расширение XY-границ избавляет от необходимости построения полного графа зависимостей. То есть граф зависимостей - нужная штука, но не всегда есть возможность по нему найти границы задачи. Правда я допускаю, что это связано с тем, что IDE не позволяет задавать, например, Y в области, выходящей за пределы исходного кода. Зависание приложения Windows - размытая правая граница Y, которая может находиться в компиляторе, операционной системе и даже в железе (памяти не хватило). Программисту следовало бы думать, допустим, на уровне дампа памяти, но у него только функции, переменные, типы данных, классы... Он заходит на stackoverflow и ему подсказывают, какие причины зависания могут быть. Пока этого понимания нет, можно иметь хоть какой крутой навигатор по коду, но ничего не выйдет.

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение13.03.2021, 11:18 


07/08/14
09/08/21
3877
Попытка № 2
upgrade в сообщении #1507980 писал(а):
Mihaylo в сообщении #1507883 писал(а):
Например, возьмем и скроем в исходном коде С++ указания типов данных (bool, int, float, double, string)... Заменим на абстрактное auto. Или просто сотрем.
Это не сжатие, это перенос части обработки информации с "сервера" на "клиент", Клиент в данном случае обладает пониманием что есть типы данных, на это понимание у него отводится память и работа его процессора и когда он встречает код без указания типов, он как минимум понимает, что это код без типов.

Когда англичанин говорит русскому Yes, чтобы русский его понял, у него в голове должно УЖЕ быть соответствия вида "Yes=Да=утверждение/согласие ..."
Оттого, что вы вместо "yes" начнете использовать более короткое "да" информация не сожмется (общий объем, который требуется обработать).
Тоже самое происходит в клиент-серверной структуре: клиент не считает у себя то, что считает сервер из-за этого может казаться, что на клиенте все летает и все просто.
По-моему, вы вообще куда-то не туда едете с эффективным изложением. Для начала надо определить что есть эффективное изложение.
Например, на палочках: какое изложение информации с вашей т.з. эффективнее - $3$ в десятеричной или $11$ в двоичной? Почему?

 Профиль  
                  
 
 Re: Эффективное изложение информации
Сообщение13.03.2021, 18:17 


12/07/15
1698
Эффективное изложение - это когда ты не излагаешь то, что не требуется, а из того, что требуется, умеешь выбрать самое значимое.
Не всегда нужно говорить "yes", можно и промолчать вовсе. И дело тут не в тезаурусе собеседника, дело в том, что у собеседника другая проблема - он просто не хочет разговаривать, ему от "yes/no" ни холодно, ни жарко...

 Профиль  
                  
Показать сообщения за:  Поле сортировки  
Начать новую тему Ответить на тему  [ Сообщений: 50 ]  На страницу Пред.  1, 2, 3, 4  След.

Модераторы: maxal, Toucan, PAV, Karan, Супермодераторы



Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения

Найти:
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group