Усложнение программы в ходе её работы

анонiмус? ты ли это?

В каких-то странных местах ты читаешь.

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

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

А вот функциональные чаще применяются (-лись) для искусственного интеллекта. Сейчас-то область применения расширилась. Но вот в искусственном интеллекте усложнение важно. Причем автоматическое.

В чём проблема разбить программу на отдельные функции то?

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

т.е. ты считаешь что скомпилированный бинарь пухнет? нет, он не меняется.

Видимо мусьё глаголит о том, что во время выполнения в памяти разворачиваются стопицот структур и нагенеренных ASTов. Что, в принципе логично.

ФП подразумевает возможность использования функторов, так же, как ООП позволяет изменение поведения объектов в процессе работы.

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

Оп, ссылку!

Вот прочитал в одном месте

Не читай больше в этих местах.

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

Один из возможных сценариев:

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

А вот функциональные чаще применяются (-лись) для искусственного интеллекта.

Если ты про семейство лиспов, то «автоматическое усложнение» в процессе работы объясняется больше метапрограммированием.

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

А что такое AST? И как их генерируют?

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

А что за функторы в ФП? В Прологе знаю, здесь - нет.

Если ты про семейство лиспов, то «автоматическое усложнение» в процессе работы объясняется больше метапрограммированием.

Где про это популярно описано? Вроде у Хюввенена есть, но не уверен точно. Где-то ещё можно прочесть?

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

а в императивных все упрощается, ага ;)

А что такое AST?

Abstract Syntax Tree. Научись уже гуглить.

И как их генерируют?

Например, макросами.

Если совсем не в теме (судя по всему, так и есть), можешь посмотреть, например, Practical Common Lisp.

Где-то ещё можно прочесть?

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

А что за функторы в ФП?

class Functor f where
    map :: (a -> b) -> f a -> f b

Пишу на Си для МК и даже на огромных проектах

Для МК бывают огромные проекты?

посмотри bundle.sh

например в The Unix Programming Environment

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

т.е. специализация программы в некотором наперёд заданном диапазоне (что теже автоконфигураторы и прощии обобщённые алгоритмов библиотеки делают) решённая техническая задача.

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

удачи.

Представь себе.

К стмкам хардварно подключается внешняя RAM, NAND флэш, дисплей по RGB интерфейсу и возможности становятся просто безграничными.

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

Представь себе.

К стмкам хардварно подключается внешняя RAM, NAND флэш, дисплей по RGB интерфейсу и возможности становятся просто безграничными.

Представил. Назвать это МК не смог.

Ето 2016, детка. Прошли времена, когда микроконтроллерщики страдали из-за недостатка памяти. Частенько ещё к стмкам подключается внешний DSP, а иногда и плис. Вот так и живём.

Ето 2016, детка

Детка у тебя в штанах.

Прошли времена, когда микроконтроллерщики страдали из-за недостатка памяти. Частенько ещё к стмкам подключается внешний DSP, а иногда и плис. Вот так и живём.

SLOC «гигантского» проекта хватило бы.

SLOC «гигантского» проекта хватило бы.

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

Микроконтроллеры используют обычно не потому что это дешевле, а т.к. благодаря их периферии(особенно я обожаю DRM в STM32 - это нечто) и особенностям архитектуры они способны обеспечить работу в realtime'е

Расслабься, скайнета нет и не будет, а ит-поп читать не надо.

Да у тебя, смотрю, косая сажень в пальцАх.

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

Любой способ можно применить самым неожиданным образом. Посмотрю на этот, может что-то выужу для себя.

а в императивных все упрощается, ага ;)

Нет, там всё статично.

удачи.

Спасибо!

Тут уже что-то мелькнуло про дата-дривен программы. Наверное, нужно туда копать.

Оп, ссылку!

Какую ссылку хочешь?

Спасибо про дата-дривен! Тоже про него думал.

А вот функциональные чаще применяются (-лись) для искусственного интеллекта.

Минский уже умер, GOFAI толком не интересен.

Минский уже умер

Ну и что? Искусственный интеллект на нём одном не сошёлся.

Должна быть какая-то защита от изобретения великов. Например:

;;; scheme
;;; было add
(define add (lambda (x y) (+ x y)))
(print (add 1 2)) ;;; 3

;;; кибер-мозг накодил q
(define q (list 'lambda (list 'x 'y) (list '+ 'x 'y)))
(print ((eval q) 1 2)) ;;; 3

Как узнать, что «q» уже известно и называется «add» ?

Хранить алгоритм функций в каком-нибудь нормальном (в математическом смысле) виде. После вывода сравнивать.

Нет, там всё статично.

статично еще не значит что иммутабельно

Для q получается

(define q (list 'lambda (list 'x 'y) (list '+ 'x 'y)))
(print q) ;;; (lambda (x y) (+ x y)) - список

(map print q)
;;; lambda
;;; (x y)
;;; (+ x y) - пригодно для сравнения

Как на ихнем, ангельском называется свойство языка (реализации) - «дляимени узнать определение» ? В C-либах вроде introspection , в r7rs и srfi такого нет.

Программист на ПРОЛОГе, мало знакомый с функциональщиной.
Нечасто такое увидишь.

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

Introspection руками для своих функций написать можно. Что-то вроде:

(define-syntax-rule (define* (name args ...) body ...)
  (begin
    (set-hash! descriptions 'name (cons '(args ...) '(body ...))
    (define (name args ...) body ...))) 

А дальше везде меняешь define на define*

Ок, спасибо. (Стандартные - аналог аксиоматических понятий, их прошить где-то в другом месте.)

Еще остается вопрос с let - считать их определением или искать среди define-d . (Странно, что в языке для ИИ не предусмотрен искаробочный сброс в читаемый, загружаемый обратно файл. Натуральный И. треть времени спит, а утром вспоминает на чем остановился вчера.)

Еще остается вопрос с let - считать их определением или искать среди define-d

let по смыслу — временные данные.

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

Вообще-то предусмотрен. read и write.

Про write не понял, она не показывает определение функции.

;;; chibi-scheme

(define a1 (lambda (x) (+ 1 x)))
(write a1)

;;; #<procedure a1>

Про write не понял, она не показывает определение функции.

(define* (a1 x) (+ 1 x)))
(write (hash-ref descriptions 'a1))