Разработка SkyLine : нерассказанная история

Введение

Это немного личная статья, скорее образовательная статья, эта статья будет носить более личный характер и описывать ступеньки, которые я предпринял для разработки своего языка программирования SkyLine. Для тех, кто новичок и не следил за процессом разработки, я разработал язык программирования под названием SkyLine, также известный как CSC. CSC/SL — это язык программирования, называемый основным языком кибербезопасности. Это язык, разработанный в первую очередь для мира кибербезопасности, который имеет богатую внутреннюю часть (в настоящее время находится в разработке), которая будет предназначена для приложений или задач, основанных на кибербезопасности. .

Идея

В настоящее время вы, возможно, спрашиваете себя: «Что этот язык может предложить такого, чего нет в других». Правда в этом и честная правда на данный момент ничто, поскольку у нее нет никаких физических доказательств, таких как тесты или даже библиотеки, которые могут доказать, что ее идея полностью приветствуется во вселенной. Итак, позвольте мне просто объяснить общую идею, объяснить, как она была создана, а затем, наконец, перейти к тому, как разработчики (в настоящее время только я) работают над тем, чтобы воплотить эту идею в жизнь. Лично для меня программирование никогда не было чем-то, чем я хотел бы заниматься в качестве повседневной работы, поскольку это была простая область, которую я полагал, что должен понять, прежде чем переходить к кибербезопасности. Я начал с таких языков, как Python и других более старых и странных языков. Это начало было довольно грубым, так как я не чувствовал, что чему-то учусь, просто потому, что я просто не двигался дальше, и к тому же Python не был языком для меня. Когда я понял, что больше не хочу использовать python и что он стал относительно медленным для задач, которые я хотел выполнить и завершить, я в конечном итоге вернулся назад во времени и коснулся всего от языков, таких как FORTRAN, до таких языков, как pascal. и перл. Я нашел свое место в фортране на некоторое время, затем переключился на perl, оба из которых были чрезвычайно быстрыми языками и просто работали, однако, как и в случае с python, мне было трудно двигаться дальше, конечно, по другой причине. Фортран в конечном итоге было приятно сохранить, я до сих пор пишу на этом языке, однако найти какую-либо помощь или заставить людей помочь вам в этом будет чрезвычайно сложно, потому что, давайте будем честными, ФОРТРАН просто не так популярен, как раньше. в день. Я продолжал прыгать по языкам так много раз, пока не достиг точки, когда я могу изучать и понимать большинство, если не все языки программирования, которые не были эзотерическими, включая такие языки, как java. Я полагал, что это было связано с тем, что я перескакивал через столько языков программирования, что в итоге просто выработал образ мышления, который научил меня тому, что большинство языков одинаковы с большинством концепций. Вы могли заметить, что типы данных, условные операторы, циклы, математика и многое другое в компьютерном программировании остается прежним, однако его синтаксическая реализация меняется НАМНОГО. В конце концов я начал свой путь к кибербезопасности, и мне стало очень любопытно, какой язык работает лучше всего, и, насколько мне известно, ruby ​​и C++ были лучшими языками для кибербезопасности, и вот почему.

• 1(go): Go — очень быстрый язык, это также язык со статической типизацией, его синтаксис и многопоточность очень многословны, его стандартная библиотека также чрезвычайно велика. Это сделало такие задачи, как внедрение полезной нагрузки, создание изображений, сброс метаданных и манипулирование двоичными данными, очень и очень простыми, особенно с учетом того, что пользовательский тип данных закрепился в камне.
• 2(ruby): Ruby был одним из первых объектно-ориентированных языков программирования, которые я выучил (за исключением python). Его модульная система и многословность действительно выделяли его, не говоря уже о том, что там было много жемчужин для кибербезопасности.
• 3(C++): C++ был для меня языком ядра, его было легко использовать и с ним было легко работать, когда дело доходило до эксплойтов более низкого уровня, таких как игровые читы или создание собственных драйверов и других форм кода эксплойтов и обходчиков. Поскольку C++ имеет такую ​​чрезвычайно богатую стандартную библиотеку и в основном основан на памяти, он просто работал для кибербезопасности.

Однако была одна вещь, которой не хватало всем этим языкам, — кибербезопасность. Когда вы смотрите на такие языки, как python, вы видите плагины и библиотеки, такие как PWNTOOLS, а если вы смотрите на ruby, вы можете видеть хакерские библиотеки, такие как hacker gems, но вы также замечаете, что все эти библиотеки чрезвычайно раздуты или имеют очень ограниченную гибкость. Это означает, что хакеры и даже хакеры-защитники должны придумывать собственные решения своих уникальных проблем. Теперь, конечно, языки программирования общего назначения, такие как python, не были предназначены для кибербезопасности, и разработчики никогда не планировали использовать его даже в качестве языка, основанного на кибербезопасности. Из-за этого такие языки, как python, могут разочаровывать в работе, особенно при работе с программами, основанными на кибербезопасности, которые либо дают вам слишком много настроек и мало документации, либо не настраивают и содержат множество документации. Со временем я начал разрабатывать концепции для языков программирования и понял, чего не хватает многим языкам и что нужно миру кибербезопасности. Мир кибербезопасности был бы на самом деле приличным, если бы существовал язык, который работал только с кибербезопасностью, не был бы перегружен раздражающими функциями и уязвимыми функциями, был бы современным и быстрым и использовал бы алгоритмы на бэкенде. Так что именно здесь я начал понимать, что, возможно, я мог бы быть человеком, который разрабатывает язык программирования только для этого. В то время я не обладал или даже не знал навыков, необходимых для создания полноценного, готового к работе, компилируемого/интерпретируемого языка программирования.

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

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

Initate RadicalProcBar Block {
   ( UNIT ->
      Class Structure {
          RPC>*MODULE (modulename) START* 
                  ||
                    RPCO INIT {{{
                        (  ----> RPCOUTPUT << PREPARE("hello world")    )
                            ~> RPCOUTPUT
                    }}}
                  ||  
    RPC>*MODULE (modulename) END^
      }

    ) 
      [
                    RPC -> RPCL15_Count | RPC.BRICK => {{{
                    RPC:::Unit::SYMBOL | RPC.BRICK START
                      RPC::Unit->StartKerel()
                      RPC::Unit->Driver()->_result
                      Call SubROUTINE95 ==> RPC::DEBUGUNIT()->modulename#*&>RESULTS
                                         ||
                    RPCO INIT {{{
                        (  ----> RPCOUTPUT << PREPARE(RESULTS)    )
                            ~> RPCOUTPUT
                    }}}
                  ||  
                      !!!-> rpcn 
                                This is where the HTML code will be renedered by the engine
                      !!!<-  

                    RPC::Unit::SYMBOL | RPC.BRICK END
                }}}
      ]
} END RadicalProcBar Block

Этот язык был очень запутанным и был назван языком ядра радикальной обработки, который в конечном итоге стал частным языком программирования с закрытым исходным кодом для генерации HTML и управления процессами. Глядя на этот код, вы можете быть крайне сбиты с толку и удивляться, почему я вообще выбрал этот дизайн или откуда он взялся. Черт возьми, вы даже можете ломать голову, пытаясь придумать язык, откуда я это взял. По правде говоря, этот язык должен был стать одним из очень немногих, у которых не было общего вдохновения, поскольку его идея дизайна была предназначена исключительно для меня и лучше всего работала бы со мной. Объясняя приведенный выше код, мы можем его разбить.

Initate RadicalProcBar Block {

каждый файл должен иметь начальный блок, вы можете думать об этом как о классе в java или C #, но вместо того, чтобы работать как класс, он работал как структура на бэкэнде. В каждом блоке 15 полей, ниже вы найдете основные обязательные или рекомендуемые ветки.

• Единица: единица под блоком была известна как BU или блочная единица. Блок-юнит выполнял роль определения любых классов, которые подпадали под него, если вы хотели создать класс, вам нужно было создать модуль, а если вы хотели создать модуль, вам нужно было создать модуль -> класс -> модуль.
• Класс: работал как любой другой класс, однако классы были структурированы больше как сами структуры типов и не действовали как классы во время выполнения.
• Модуль: работал как любой стандартный модуль, но вместо того, чтобы быть модулем, действовал скорее как пространство имен внутри класса, чем как модуль.
• Дерево: деревья не являются обязательным полем, но если вы хотите объявить константные переменные или нужные константные переменные, это то место, где они будут размещены и объявлены.
• Блок: Блоки — это просто еще один оператор блока внутри модуля, поскольку для каждого объявленного модуля потребуется один или два блока. Блоки объявляются с помощью

[]

поэтому запуск базового блока будет выглядеть так

Initate RadicalProcBar Block {
   ( UNIT ->) []
} END RadicalProcBar Block

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

RPC -> RPCL15_Count | RPC.BRICK => {{{
                    RPC:::Unit::SYMBOL | RPC.BRICK START
                      RPC::Unit->StartKerel()
                      RPC::Unit->Driver()->_result
                      Call SubROUTINE95 ==> RPC::DEBUGUNIT()->modulename#*&>RESULTS
                                         ||
                    RPCO INIT {{{
                        (  ----> RPCOUTPUT << PREPARE(RESULTS)    )
                            ~> RPCOUTPUT
                    }}}
                  ||  
                      !!!-> rpcn 
                                This is where the HTML code will be renedered by the engine
                      !!!<-  

                    RPC::Unit::SYMBOL | RPC.BRICK END
                }}}

В случае ниже эта программа вызывает

RPC -> RPCL15_Count | RPC.BRICK => {{{

Что сообщает компилятору в модуле RPCL (Radical Processing Core Line), что количество строк этого блока может быть ТОЛЬКО 15 строк, что-либо большее или меньшее будет незаконным и приведет к выходу компилятора. Затем эта переменная основывается на вызове стандартной встроенной функции для запуска нового блока. Вы можете передать результат встроенного значения модуля с помощью конвейера. Затем мы используем символ =› для объявления кирпичей. У кирпичей было три поля, в том числе следующие.

• LBRACE #1: Первая скобка будет содержать любые аргументы, которые кирпич примет при вызове. Например

RPC -> RPCL15_Count | RPC.BRICK => { ->STRING->STRING{{

Говорит, что кирпич будет принимать два строковых аргумента

• LBRACE #2: эта фигурная скобка сообщит возвращаемые значения этого блока кода.

RPC -> RPCL15_Count | RPC.BRICK => {{STRING,BOOLEAN,INTEGER,USINGED{

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

• LBRACE #3: Эта фигурная скобка будет определять оператор блока для блока, в котором находится все, что будет выполняться и запускаться компилятором.

RPC:::Unit::SYMBOL | RPC.BRICK START
                      RPC::Unit->StartKerel()
                      RPC::Unit->Driver()->_result
                      Call SubROUTINE95 ==> RPC::DEBUGUNIT()->modulename#*&>RESULTS

Этот блок кода также чрезвычайно сбивает с толку, для каждого блока блока должен быть символ блока, а для каждого символа блока должен быть конвейер, передающий аргументы вызову RPC.BRICK с аргументом «START», который запустит выполнение этого блока. . В идеале вы могли бы использовать «STOP» или «HALT», чтобы остановить выполнение блока в зависимости от его состояния, это были известны как типы данных S и H, которые я разработал специально для RPC. После этого мы видим, что вызываем модульный кирпич и говорим компилятору загрузить состояние ядра, которое будет передано драйверу. Этот драйвер ядра был просто простым отладчиком процессов, который загружался в заданный процесс, если процесс не имеет имени, отладчик подключался к выполнению компилятора или самой запущенной программы. Наконец мы видим

Call SubROUTINE95 ==> RPC::DEBUGUNIT()->modulename#*&>RESULTS

Функция вызова подпрограммы — это функция из стандартной библиотеки языка RPC, это будет учитываться в бэкенде языка программирования для вызова функции подпрограммы. Эта подпрограмма будет вызываться из внутреннего интерфейса языка для запуска отладчика ядра, который привязан к классу имени модуля и блоку, который мы определили выше. Это очень-очень странный способ разработки и вызова подпрограмм, но мне показалось, что так безопаснее. Вам может быть интересно, что означает SubRoutine95. SubRoutine95 — это ключевое слово, которое не только инициирует подпрограмму стандартных библиотек, но и вызывает подпрограммы на основе Fortran. Учитывая, что в то время я был довольно здоровенным разработчиком fortran95, я хотел, чтобы компилятор этого языка был написан на C++ с внутренней поддержкой Fortran. Вызов некоторых функций из серверной части, таких как DEBUGINIT, — это все функции, которые должны быть написаны на Фортране и выполняться как модули внутри движка. Это очень сбивает с толку, я знаю, но в то время это было просто проще. Теперь иногда вам нужно будет отлаживать эти функции, чтобы заставить их работать, а это значит, что если вы хотите получить результат вызова подпрограммы отладки, вам потребуется написать подмодуль в том же кирпиче вот так.

  Call SubROUTINE95 ==> RPC::DEBUGUNIT()->modulename#*&>RESULTS
                                         ||
                    RPCO INIT {{{
                        (  ----> RPCOUTPUT << PREPARE(RESULTS)    )
                            ~> RPCOUTPUT
                    }}}
                  ||  

Вот тут-то и пригодилась функция, называемая tree’s. В RPC тип, известный как TREE, выступал в качестве расширения подпрограмм, функций, блоков, классов, модулей, структур типов и многого другого. Это позволило пользователю сильно изменить язык на серверной части. В этом случае мы начинаем дерево с двумя каналами ||, а затем вызываем RPCO INIT, что расшифровывается как Radical Processing Core Output Initiation. Это подготовит компилятор к выводу кода, 3 скобки останутся прежними, но одна вещь, которую вы заметите, отличается здесь, это запутанный вариант использования — и ›. Позволь мне объяснить

(  ----> RPCOUTPUT << PREPARE(RESULTS)    )
                            ~> RPCOUTPUT

Эта строка здесь может быть добавлена ​​и изменена как

(  ----> RPCOUTPUT << PREPARE(RESULTS) ) ~> RPCOUTPUT

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

• -› : это возьмет вывод и отформатирует его как полную строку, но без новой строки, похожей на «печать».
• - — > : это возьмет вывод и отформатирует его как полную строку, но с новой строкой, похожей на «println»
• -—-> : этот тип стрелки указывает выходному модулю RPC форматировать его как адрес, что означает, что результаты от DEBUG будут отформатированы с помощью систем ведения журнала, чтобы указать дату и время, а затем вернуться к назначенным местам в памяти.
• ----> : Это был самый подробный уровень вывода для DEBUG. Это позволит не только отформатировать даты, но и запустить трассировку стека для вызываемых функций и подпрограмм, а также позволит обнаруживать проблемы или время задержки и даже регистрировать время, необходимое для выполнения каждого отдельного блока на серверной части. Это намного тяжелее и легче вникать.

Как вы можете видеть, даже самая маленькая вещь в этом языке является самой сложной функцией и может сделать так много. Наконец, в этом блоке кода мы используем простую клавишу, чтобы направить его в качестве вывода, а не ввода с помощью <<, а затем вызываем встроенную функцию с именем PREPARE. PREPARE была функцией, предназначенной для обеспечения безопасности вывода до того, как он будет отправлен в качестве вывода или до того, как он будет выполнен. Это проверит наличие плохого Unicode, невидимых точек Unicode, бесполезных пробелов, бесполезного Unicode, бесполезных символов и многого другого, что могло быть результатом проблемы с декодированием. Наконец, мы передаем его на RPCOUT, сообщая движку/компилятору, что он должен наконец выполнить его и вывести результаты. Этот тип дерева был построен, чтобы быть чрезвычайно глубокой концепцией и быть самой сложной вещью для понимания из-за количества безопасности и кода, который в конечном итоге стоял за ним, даже по сей день макетная версия этого была очень, очень разочаровывающей. . Только код синтаксического анализа дерева состоял из более чем 10 000 строк кода, а вызовы подпрограмм даже не были завершены! Выяснив, что мне следует сделать лучшую версию языка, я сохранил базовый эзотерический стиль и в итоге получил свой собственный файл .RPCLCCPQ++CM, он был известен как суперфайл для RPC и мог включать следующие языки и мог содержать следующие значения.

• C++
• C
• Луа
• RPC
• Классы
• Модули
• Дерево

и многое другое. Такой файл будет выглядеть примерно так.

@#{<lualib>}#@
@#{<libc>}#@
@#{<supersetc>}#@
@#{<stdlib>}#
@#{CLASS(filename.rpc++)}#@
@#{$$MOD(rpch++)$$}#@

RPC Class Structure {
    RPC>*MODULE (modulename) START* 
            ||
                RPCO INIT {{{

                        (  ----> RPCOUTPUT << PREPARE("hello world")    )

                            ~> RPCOUTPUT
                }}}
            ||  
    RPC>*MODULE (modulename) END^
}

String : String : interface{} => CALL_LUA(X, Y, Z) -> LUA {
    a=math.abs(Y-Y) 
    b=math.abs(X-X)
    c=math.sqrt(a*a+b*b)
    print(c)
}

VOID : => CALL_CPP() -> C++ {
    const auto data = nullptr;
    namespace functions {
        void functiontocall();
    };
}

String : => CALL_C(message) -> C {
    printf("%s", message);
}

Это все еще очень запутанно, но намного приятнее и читабельнее. Верхний уровень программы определяет импорт в языковые библиотеки, потому что в RPC вы сможете подключать не только lua, но и C, Fortran, C++ и даже подмножество RPC, называемое RPCT, который был языком шаблонов для HTML, похожим на этот. .

init RPC templating
    {
        (
            [
                RPC -> RPCL6_Count | RPC.BRICK => {{{
                    RPC:::Unit::SYMBOL | RPC.BRICK START
                      RPC::Unit->StartKerel()
                      RPC::Unit->Driver()->_result
                      !!!-> rpcn 
                                This is where the HTML code will be renedered by the engine
                      !!!<-  

                    RPC::Unit::SYMBOL | RPC.BRICK END
                }}}
            ]
        )
    }
end RPC templating

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

RPC->INITATE_______BACKENDCALLTOKERNELEVTERMSOCKS__#(ALLOW C++20, C++11, C++13, PYTHON, LUA, GO)-? IMPORT FROM("ENGINE.DLL")

{{{{{{
  @TEMPLATING_ROFF_RUN [
          (
            RPC->INITATE->TREECUT ||  
                JOB -> INI_FILE_CONFIG_LOAD_FROM("/USR/SHARE/BACKEND")
                PROG MAIN()
                {
                  IMPORT("ALL")
                  seq->:All, Seq, 2s, CPP/PY/L/GO/RB, ;;; -> to sequence of type ...interface{}
                }
                END PROG MAIN()
            ||
          )
      ]
}}}}}

Это была простая настройка для импорта и разрешения C++ и других языков программирования перед запуском файлов супернабора. Как вы все еще можете видеть, это очень, очень запутанно, очень раздражает и все это просто странно. Так я сделал SkyLine. Модернизированная версия RPC, которая действительно делает то, что нужно. Идея RPC изначально заключалась в том, чтобы помочь себе в моих собственных операциях, таких как вредоносное ПО, эксплойты и разработка встраиваемых систем. Это быстро стало проблемой, которую я просто не хотел заканчивать или заботиться о ней, поэтому я изменил эту идею на что-то современное, я изменил синтаксис, дизайн и значение. RPC, как было сказано выше, был чрезвычайно странным и дурацким, но хотел быть современным, несмотря на наличие устаревшей кодовой базы и устаревшей идеи, поэтому я взялся за чертежную доску и в конце концов придумал этот логотип.

Этот логотип очень, очень гладкий, он очень современный, а также очень простой, но очень сложный в мельчайших формах. Отсюда и родилась идея CSC. Я хотел язык, который произведет революцию в отрасли, и мы все это прекрасно знаем, учитывая первоначальный дизайн RPC, который не собирался работать, потому что ни один человек не стал бы делать все это для простого сценария вредоносного ПО. Как только логотип был готов, у меня начали появляться идеи, чего не хватает современным языкам программирования, а еще лучше, что такое синтаксис, который является моим, но также имеет смысл не только физически, но и математически. Синтаксис SkyLine на начальных этапах будет выглядеть примерно так.

import|"std"|

CLASS -> SkyLine_Class {
  MODULE --> SkyLine_Module {
      cause setup = function() {
        println("hello world");
      }
  };
};

cause Main = Func() {
  SkyLine_Class::SkyLine_Module->setup();
}

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

• Современный язык: SkyLine попытается быть современным, работая с различными модулями, классами и ключевыми словами, а также имея гораздо более подробную систему ошибок и чрезвычайно быстрый компилятор байт-кода.
• Язык безопасности: SkyLine будет одним из очень немногих и новейших языков программирования, посвященных кибербезопасности. Это было бы похоже на RPC, где RPC имел полноценную серверную часть, предназначенную для кибербезопасности на более низком уровне, но то же самое можно было бы сделать и с SkyLine на более высоком уровне.
• Настройка: современные языки программирования придерживаются одного стиля и не позволяют вам быть самим собой, SkyLine предоставит вам два варианта и возможность изменить свое синтаксическое дерево с помощью макросов. Эти два стиля будут использоваться так, как вы хотите, и будут короткими. Например, в функциях вы можете использовать ключевое слово return или просто отказаться от него и все равно получить тот же результат. Ниже приведен хороший пример этого

allow x = Func() {
  return (10 - 20 * 90 / 1000)
}

print(x())

// however the following function will still yield the same result 
// depending on its placement 

allow a = Func() {
  (10 - 20) 
  10 - 90
}

// the result from 10 - 90 will be returned from the function 
// where (10 - 20) will either be ignored or thrown to STDOUT on execution

• Система ошибок: SkyLine также будет иметь ОЧЕНЬ подробную систему ошибок с уникальными кодами ошибок, средствами проверки операторов, шагами проверки перед выполнением и даже даст вам возможность добавить новые ограничения на программу, такие как предотвращение использования пользовательского ввода или аргументов функции. или игнорирование ввода, отправленного из другого процесса.

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

Как SkyLine докажет, что это именно то, для чего он был разработан

SkyLine — это очень новый язык, на момент написания этой статьи он разрабатывался всего несколько недель, однако у разработчиков (у меня) есть многое в запасе, чтобы доказать, что этот язык может помочь в различных ситуациях. Вместо того, чтобы писать целую программу из 900 строк только для создания простого изображения GIF, BMP, JPG и т. д., SkyLine позволит вам сделать это за два. Алгоритмы, такие как функции отображения мира, основанные на алгоритме линейного преобразования, будут автоматизированы на серверной части. Геометрия, исчисление, предварительное исчисление, тригонометрия и линейная алгебра также будут важной частью горизонта, такой как вычисление средневзвешенных значений, решение очень специфических алгоритмов за секунды и многое другое. SkyLine также будет иметь несколько встроенных библиотек для цифровой криминалистики, что позволит вам вставлять изображения, обнаруживать зашифрованные строки в изображениях, извлекать и вставлять архивы в изображения, обнаруживать геоданные в изображениях или других типах файлов, а также позволяет вам проверять двоичные данные и дампы памяти. . Конечная цель Skyline не в том, чтобы быть языком программирования общего назначения, а скорее в том, чтобы он был направлен на развитие и кибербезопасность. Например

• Сетевые библиотеки
• встроенные HTTP-модули
• Лучше более безопасные встроенные
• Библиотеки шифрования
• Научно библиотеки
• Математические библиотеки
• Веб- и облачные библиотеки
• Библиотеки для пентестинга
• Библиотеки обратного проектирования

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

import 
use
include<>
carry
external
mod
load

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

• Carry: Carry, который используется так: «file.csc»| приостановит выполнение текущей программы и выполнит файл, указанный в ключевом слове переноса. Это не импорт, это не импорт содержимого этого файла.
• Регистрация: Регистрация импортируется, но для стандартных библиотек. Когда интерпретатор запускается и программа анализируется, в программе запускается среда, которая устанавливает переменные, циклы for, константы, функции и многое другое. Перед синтаксическим анализом программы на серверной части вызывается функция, называемая register, для «регистрации» или предварительной установки встроенных функций, таких как len(), push(), pop() и т. д., в среду. Теперь, поскольку стандартная библиотека будет очень большой, и мы не хотим использовать ключевое слово import для этого, мы будем использовать регистр, который сообщит интерпретатору и компилятору байт-кода, когда регистрировать функции стандартной библиотеки.
• Import, Include, Require All Импорт содержимого одного файла в другой просто работает по-разному. Import будет импортировать непосредственно из среды, в которой вы находитесь, include будет импортировать из локального корневого каталога CSC/SkyLine, а require будет импортировать из любого указанного или заданного пути.

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

Почему вы разрабатываете язык, даже если есть другие языки?

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

• они новые
• они современные
• они быстрые
• Их гораздо больше поддерживают
• Они гораздо более многословны
• Они гораздо более уникальны

Если бы все говорили, что не собираются что-то разрабатывать, потому что кто-то другой сделал это лучше, тогда языки программирования просто не существовали бы после ассемблера и C. Мы все разрабатываем программы по разным причинам, я разработал SkyLine, потому что я представлял, что он может помочь МНОЖЕСТВУ команд безопасности в процессе, и это может помочь МНОЖЕСТВУ людей в процессе разработки проектов. Конечно, язык экспериментальный, но важно то, что он личный для меня и ни для кого другого. Создание чего-то такого большого в одиночку с такой личной связью приносит гораздо больше, чем навыки и опыт, поскольку оно порождает связь и способность быть гибким в своем обучении. Конечно, опять же, вы можете сказать, что Python лучше уверен прямо сейчас. Будущее в какой-то степени непредсказуемо, особенно в этом смысле, поэтому совсем не помешает сделать свое собственное, поскольку даже если оно никогда не станет популярным или не изменит сообщество так, как я хочу, оно все равно стоило моего времени и дало мне гораздо больше опыта, чем люди, которые его игнорировали.

Чему вас учит создание собственного языка программирования?

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

• Креативность. Когда вы разрабатываете собственный язык программирования, требуются месяцы разработки, чтобы сделать его идеальным, особенно если вы хотите сделать его только своим дизайном. Если вы хотите хорошо провести время, делая его своим языком программирования, вы потратите много времени на размышления о многих вещах, таких как… how will types be defined? , will types be required before variable deceleration , will it be interpreted or compiled и о многих других вопросах, которые даже после того, как вы ответите на них, потребуют целую вечность для реализации. Как и стандартное программирование, оно требует больших умственных усилий и во всяком случае учит вас, как проявлять творческий подход и как работать с другим кодом.
• Терпение. Если что-то и сделало меня более терпеливым, так это развитие собственного языка. При разработке собственного языка программирования в 100 % случаев кодовые наборы, которые вы в конечном итоге разрабатываете, будут чрезвычайно продвинутыми и чрезвычайно сложными, особенно если вы работаете с такими языками, как Rust, C, C++ и другими. старые случаи golang Ассемблер. Работа со сложными базами кода, особенно при создании собственных типов данных, потребует большого терпения и научит вас правильному времени, чтобы просто встать и сделать перерыв, или правильному времени, чтобы протолкнуть это со здоровым мышлением. Этот вид навыков помогает даже за пределами мира разработки, потому что он помогает вам гораздо лучше управлять своим гневом и эмоциями в очень специфических ситуациях.
• Уважение. Многие люди привыкли жаловаться на язык программирования, а затем говорить о том, как легко было бы реализовать функцию, алгоритм или концепцию. гораздо больше уважения к разработчикам языка, даже если язык не был разработан наилучшим образом. В конце концов, этот язык был создан до того, как вы, скорее всего, были живы, и создан людьми, которые всю свою жизнь только мечтали об этом и даже почти месяцами просто пытались реализовать малейшую концепцию. Это заставляет вас уважать разработчиков языка и людей, которые тратят годы своей жизни на то, чтобы сделать что-то настолько удивительное, особенно если это было направлено на изменение мира или если это был эзотерический дизайн, такой как RPC или BrainF8ck.
• Математика. Если вы работаете над языком программирования в одиночку и у вас нет команды разработчиков, с вероятностью 9 из 10 вам придется разрабатывать всю библиотеку самостоятельно, включая математику. Если вы не знаете стандартные соотношения ( tan, cos, tan2, cos2, sin, acos, abs, asin, asing, atanh, cbrt, sqrt, cosh, dim, erf, erfc, FMA, SB, SCOS, SBI, POW , POW10, CMPLX) и многое другое из этого списка, пора учиться. Конечно, мы все можем просто автоматизировать серверную часть другого языка программирования, который мы используем, но когда этот язык станет самостоятельным, вам понадобится знать, как писать на этом языке и как писать эти алгоритмы, уравнения, отношения, измерения, формулы и т. д. Знание математики даже заранее будет довольно сложным, поэтому создание собственного языка даст вам невероятный опыт в математической сфере, особенно познакомит вас со всеми формами математики.
• Типы данных. О боже, если вы думали, что научиться использовать типы данных и работать с ними — это плохо, представьте, что вы можете сделать их самостоятельно. Когда вы пишете язык программирования, вам нужно многому научиться, и одна из главных вещей — заставить работать типы данных. Даже если язык не определяет их или требует, чтобы пользователь указал String, Bool или Int перед переменной, внутреннему коду все равно нужно знать, является ли строка целым числом или это просто логическое значение, что означает, что вам нужно сделайте свой собственный псевдоним для этих заданных типов данных. Изучение того, как делать это со структурами типов, позволяет вам так много узнать о типах данных и о том, как они работают, особенно когда вы добираетесь до булевой алгебры и некоторых операторов. Например, простой строковый тип данных может потребовать до 200 строк кода только для реализации в AST, Parser, Evaluator, Model List, Lexer и многих других из этого списка.
• Внутренности. Внутренности языка программирования должны существовать, потому что без них у вас просто будет ложный код, который не может и не будет работать, если вы не напишете для этого программу. Написание собственного языка программирования даст вам практический опыт работы с синтаксическими анализаторами, абстрактными синтаксическими деревьями (AST), оценщиками и даже в большинстве случаев (если язык интерпретируется) с тем, как виртуальная машина работает с компиляторами байт-кода и внутренностями виртуальных таблиц и токенов. . Когда вы получаете уровень модификации AST (макросы) и добираетесь до сути виртуальных машин, компиляторов байтового кода и стандартных компиляторов, вы понимаете, насколько сложной задачей является работа с виртуальной или аппаратной памятью и насколько это действительно раздражает. заставить его работать. Работа с этими типами систем дает вам целое дерево опыта работы с расширенными кодовыми наборами, типами данных, расширенными математическими операциями, арифметикой указателей и глубокой памятью, учитывая, что вы создаете свою виртуальную машину или компилятор с нуля, но даже в этом случае вам все равно нужно знать много о памяти и компьютере, чтобы иметь возможность работать с этими типами языков.

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

Заключение и резюме

Создание языка программирования — очень, очень раздражающий и утомительный процесс, для такой работы требуется много работы и глубокое понимание сложных наборов кодов. Однако, если вы новичок в этом опыте, не торопитесь. Создание языка программирования требует глубокого понимания, требует опыта, требует много времени и много усилий и творчества, даже если вы берете его из книг или журналов или даже используете чужой код, чтобы поэкспериментировать со своим! Если вы слишком расстроены, возможно, пришло время сделать глубокий вдох, осознать, что вы не можете продолжать дальше, успокоиться и попытаться вернуться позже с более сильным настроем, лучше понять концепцию и почему ваша реализация может работать, а может и не работать. В сегодняшней статье мы узнали, как и почему был разработан SkyLine, и почему я решил разработать язык, несмотря на то, что мне сказали, что он никогда не будет использоваться. Конечная цель этой статьи состояла в том, чтобы показать вам, как много значит этот язык для меня как разработчика, откуда он взялся, и попытаться лучше объяснить идею SkyLine изменить мир кибербезопасности к лучшему. Это может занять несколько лет, но как только это произойдет, у меня есть довольно хорошее предчувствие, что это будет использоваться для большого количества опыта и множества примеров программирования!

А пока — Абсолютно_Не_А_Хаксер ВЫХОДИТ!!

Не забудьте поддержать меня на всех моих страницах в социальных сетях и основных аккаунтах!

• Поддержите меня на гитхабе

ArkAngeL43 — Обзор

• Поддержите меня в инстаграме

https://www.instagram.com/Totally_Not_A_Haxxer

• Ссылки на маяки

https://www.beacons.ai/Totally_Not_A_Haxxer

• Кассовое приложение

Заплати мне через приложение Cash