Добро пожаловать!

Я Дож, программирование — моё хобби. По мере того, как я осваиваю что-то новое, стараюсь об этом написать пост.
На текущий момент в блоге затронуты следующие темы: vim, free pascal, lisp, forth, m4
Занимаюсь разработкой своего языка под названием DEmbro, подбробней: wiki и svn
Для постов, не связанных с программированием, у меня есть отдельное жж.
Показаны сообщения с ярлыком мысли. Показать все сообщения
Показаны сообщения с ярлыком мысли. Показать все сообщения

февраля 24, 2012

Реанимация DEmbro

DEmbro был в коме более месяца. Разработки не только не велись, но даже скомпилировать проект из транка было невозможно, т.к. makefile для сборки был в подвешенном состоянии. Вчера, наконец, я смог выделить время и реанимировал компиляцию в линуксе, а сейчас приступил к написанию универсальной сборки, чтобы и в posix-окружении, и в windows работало, причём без конфигурационных инструментов. Пришлось использовать небольшой хак. :)

У меня в голове есть несколько глобальных мыслей о DEmbro, и я решил их потихоньку оформлять в виде текстов в этом блоге. (Кстати, заметил, что то, что в моей голове выглядит мощно, в записанном виде получается чем-то незначительным или бредовым. Поэтому не претендую на то, что тут что-то умное.)

Мысли о «собери DEmbro сам»

Я понял, что не хочу иметь большую монолитную систему, какими обычно являются компиляторы/интерпретаторы. Хочу получить эдакий конструктор «собери DEmbro сам», с возможностью определять базовый набор команд в бинарнике, особенности DEmbro-машины и прочее. Польза от этого следующая:

  1. Лёгкость в совершении глобальных изменений.
  2. Возможность в случае возникновения специфической задачи быстро сделать специализированное под эту задачу ядро DEmbro
  3. (Следствие пункта 1.) Возможность тестирования и прикидок -- можно попробовать несколько решений и посмотреть какое из них ведёт себя лучше.
Приведу пример — RetroForth. Это талантливо написанная реализация одного из диалектов форта, но полностью лишённая гибкости. А именно: всё заточено под 16-битный асм, каждая следующая команда реализуется через предыдущие, в качестве шитого кода только машинный код. Нет возможности изменить что-то в ядре (форматы хранения словарных статьей, базовый набор команд, производимые оптимизации). И т.д.

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

Мысли о совместимости версий

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

Однако, я не хотел бы себя загонять в рамки бесконечной поддержки предыдущих версий. Т.е. если я захочу переназвать кучу команд, изменить тонкости их поведения и т.д., то я это и сделаю (и уже делал). Это, конечно же, приведёт к тому, что код, расчитанный на предыдущие версии дембро, в новых версиях не будет работать. Чтобы, однако, не терять старый код, будет возможность включать режим старых диалектов, как-то так:
include" units/dialects/dembro.0.23.de"
DIALECT DEMBRO0.23
// код, расчитанный под старую версию DEmbro
\DIALECT
// тут снова можем писать код для новой версии DEmbro

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

Возможно, даже, будет что-то типа такого :)
include" units/dialects/retroforth.de"
DIALECT RETROFORTH
...
\DIALECT


Читать дальше......

сентября 20, 2011

Полнота по Тьюрингу — насколько это хорошо?

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


Читать дальше......

апреля 02, 2011

Контекстные параметры

Часто в программе существуют объекты-менеджеры. Например, гуи-менеджер — объект,
при помощи которого осуществляется управление кнопками, окошками, полями ввода
и т.д. Чтобы создать кнопку, нужно указать в каком именно гуи-менеджере создаём.
Чтобы установить кнопке стиль, нужно этот стиль получить из гуи-менеджера.
  Button := GuiManager.CreateButton;
  Button.SetStyle(GuiManager.GetStyle('glamur'));

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

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

Самое тупое решение — создать глобальную переменную GuiManager и пусть к ней
обращаются функции CreateButton, GetStyle и прочие. А что если в программе
нужно работать с несколькими менеджерами? Нужно просто в нужные моменты
менять значение глобальной переменной. Что делать, если нужно работать с
разными менеджерами из разных потоков? Переписать GuiManager с глобальной
переменной под зависящую от потока.

Хоть этот метод и решает поставленную задачу, он мне не нравится. Вместо него
напрашивается концепция «контекстных параметров». Её мне не удалось реализовать
на паскале, но я надеюсь, что получится реализовать в Lisp'е и DEmbro.

Идея вот в чём: у функции мы выделяем некоторый набор параметров и объявляем их
контекстными. Например:
  function CreateButton(context GuiManager: TGuiManager): TGuiButton;
Здесь мы указали, что параметр GuiManager контекстный. От этого мы не теряем
возможностей, функцию можно вызвать обычным образом:
  Button := CreateButton(GuiManager);
при этом выполнится она так же, как и обычная функция.

Отличие заключается в возможности опустить передачу параметра:
  Button := CreateButton();
При этом компилятор автоматически подставит GuiManager внутрь, обратившись
к идентификатору в текущей области видимости. Т.е.

  procedure DoSomething(GuiManager: TGuiManager);
    procedure DoSomethingDeep;
    var
      GuiManager: TGuiManager;
    begin
      Button := CreateButton(); // в CreateButton передастся локальная переменная
                                // функции DoSomethingDeep
    end;
  begin
    Button := CreateButton(); // в CreateButton передастся параметр
                              // функции DoSomething
  end;


Может даже так получится, что GuiManager — это функция, сама содержащая
контекстный параметр:
  var
    App: TApp;

  function GuiManager(context App: TApp): TGuiManager;
  begin
    Result := App.GuiManager;
  end;

  ....

  Button := CreateButton(); // эквивалентно CreateButton(GuiManager(App))



Теперь несколько слов о возможном синтаксисе в паскаль-семействе. Контекстные
параметры поведением очень похожи на параметры со значением по умолчанию. Чтобы
подчеркнуть это, возможно, что имеет смысл заменить синтаксис, использованный выше, на
такой:
  function CreateButton(GuiManager: TGuiManager = context): TGuiButton;


Читать дальше......

ноября 15, 2010

Name typization

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

Динамическая типизация — это когда переменная может принимать значение любого
типа. Как только с переменной нужно проделать какое-то действие (сложение, например),
интерпретатор узнаёт тип переменной, и в зависимости от этого выбирает операцию.
Это очень удобно, не нужно заботиться о явном указании типа. Но работает медленней.

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

[Upd] Всё, что идёт ниже, про упрощение статической типизации.

Я осознал, что бывают такие переменные, у которых всегда один и тот же тип.
Например, у меня переменные I и J всегда имеют тип Integer, переменные
Name и FileName тип TString, P тип Pointer и т.д. Было бы весьма удобно иметь
возможность указать привязанные к именам типы, чтобы потом их явно не
указывать. Как-то так:


typization I, J, N, M, K: Integer;
typization Name, FileName, Dir: TString;

procedure LoadFilesInDir(Dir);
var
  Files: TArrayOfString;
  I;
begin
  GetFilesInDir(Dir, Files);
  for I := 0 to High(Files) do
    LoadFile(Files[I]);
end;


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

К примеру, в математическом модуле, все переменные с именами M, H, Mat, Matrix будут
являться матрицами, V, A, B, Vec, Vector — векторами, Q, R, Quat и Quaternion —
кватернионами и т.д. Вот было бы хорошо, если бы можно было делать так


typization M, H, Mat, Matrix: TMat4f;
typization V, A, B, Vec, Vector: TVec3f;
typization Q, R, Quat, Quaternion: TQuat;

function Add3f(A, B): TVec3f;
function Dot3f(A, B): TVec3f;
function Cross3f(A, B): TVec3f;
function Len3f(V): Single;

function Apply3f(M, V): TVec3f; overload;
function Apply3f(Q, V): TVec3f; overload;


Возможно, что иногда даже можно бы было не объявлять переменную, компилятор сам
бы создал локальную с таким именем. Например, если в функции используется
переменная I, то скорее всего она локальная и имеет тип Integer (потому что этот
тип указан в typization секции).


procedure LoadFilesInDir(Dir);
var
  Files: TArrayOfString;
begin
  GetFilesInDir(Dir, Files)
  for I := 0 to High(Files) do
    LoadFile(Files[I]);
end;


Читать дальше......

Постоянные читатели

Обо мне

Моя фотография
Мой e-mail: vitek_03(at)mail(dot)ru