Posted:
Июл 11, 2023
Comments:
0 Comments

Изменение кода программы: Изменение кода программы во время ее выполнения на примере Common Lisp / Хабр

Изменение кода программы во время ее выполнения на примере Common Lisp / Хабр

Введение


По моему скромному мнению, Lisp — жемчужина среди языков функционального программирования. Несмотря на то, что это один из первых в истории (1958 год) высокоуровневых языков, он по сей день не перестает удивлять. Мне кажется, он настолько обогнал свое время, что его час еще только готовится прийти.

Так давайте попытаемся написать программу, которую проблематично будет создать на других языках. Как следует из названия статьи, эта программа будет редактировать собственный код по мере своего выполнения. Для ее создания я использую Common Lisp, а точнее его интерпретатор SBCL.

Примечание: если вы возьмете чистый SBCL, то у него есть свойство не флашить поток stdio после каждого вывода, я сам пользуюсь SBCL через Emacs и Slime, там этой проблемы нет. Адекватного решения пока не нашел.

Каким образом?


Lisp обладает замечательными свойствами, среди которых хочется отметить очень простой синтаксис и однородность кода. Самое классное то, что любой код на Lisp является данными для него же, и многие данные могут являться кодом. В частности, это дает возможность писать автоаппликативные (применимые сами к себе) и авторепликативные (воспроизводящие себя) функции. Чуть-чуть о них написано здесь; информация в свою очередь взята из книги «Мир Лиспа» (Э. Хювёнен, И. Сеппянен) том 1, страница 280. Например, квайн, который является одновременно и автоаппликативной, и авторепликативной функцией, записывается так:

((lambda (x) (list x (list 'quote x))) 
	'(lambda (x) (list x (list 'quote x))))


При интерпретации, естественно, выводит себя же.

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

Командный процессор


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

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

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

(defun start-program ()
	'(lambda (program) 
		(princ "$> ") 
		(let ((input (read)))
			(when (listp input)
				(let ((command (car input)))
					(cond
						((eq command 'code)  ; если команда = code,
							(setf program 	 ; то обновим программу
								(funcall     ; результатом того, что ввел пользовтаель
									(eval (list 'lambda '(program input) (cadr input))) 
								program input) 
							)
						)
						(t (format t "Unknown command ~A ~%" command))
					)
				)
			)
			program
		)
	)
)


Наш начальный код мало чего умеет. Он выводит приглашение для пользователя, считывает с клавиатуры s-выражение, если оно список, то первый элемент — имя команды, остальные — ее аргументы. Командный процессор «из коробки» умеет обрабатывать только одну единственную команду «code». Эта команда берет свой первый аргумент и создает из него лямда-функцию, применяемую к program и input. Зачем так сложно? Потому что eval делает свои грязные делишки в нулевом лексическом окружении, а значит локальные переменные program и input нам не доступны, хотя могут потребоваться. Нужно найти способ их передать внутрь eval; ничего лучше лямды с параметрами мне в голову не пришло. Не исключаю, что есть и более изящные способы. Результат внутреннего eval присваивается переменной program. Вообще можно было б просто присвоить program остаток от input, но в этом случае мы не сможем исполнять дополнительные функции при использовании команды code. О них чуть позже.

Следующая функция main организует цикл работы программы. Вся магия таится именно в ней.

(defun main ()
	(let ((program (start-program))) ; задаем начальную программу
		; цикл, пока программа не пустая, т.е. не nil
		(loop while program do 
			; своеобразный try - catch, увеличивает стабильность программы, 
			; если итерация дает ошибочный код
			(handler-case 
				; присвоим переменной program результат выполнения фукции, 
			        ; содержащейся в переменной program с параметром program
				(setf program (funcall (eval program) program))
				; в случае ошибки, сообщим о ней
				(error (c1) (format t "Error! ~A~%" c1) )
			)
		)
	)
)


Итак, цикл идет, пока программа (переменная program) не пуста. Программа же на нулевой итерации — результат функции start-program, а на ненулевой итерации мы присваиваем ей (переменной program) результат выполнения функции, содержащейся в ней (переменная program), с параметром program (опять она же). Это не тавтология, и важно понять как оно работает, прежде чем двигаться дальше. Разобрались? Теперь запускаем в

REPL

-е main и видим приглашение:

CL-USER> (main)
$>


Можно творить. Если надоест и захочется назад в

REPL

, достаточно выполнить нашу единственную пока команду code в параметром nil. Она заменит исходный текст на nil, и цикл воспримет это как условие завершения. Но мы, конечно, не будем пока этого делать. Отныне все команды вводятся уже в нашу работающую программу. Я буду часто опускать «$> » для удобства копирования.

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

(code
	'(lambda (program)
		(princ "$> ") 
		(let ((input (read)))
			(when (listp input)
				(let ((command (car input)))
					(cond
						((eq command 'code) 
						    (setf program 
						        (funcall 
						            (eval (list 'lambda '(program input) (cadr input))) 
						         program input)))
						((eq command 'eval) (eval (cadr input))) ; НОВОЕ
						(t (format t "Unknown command ~A ~%" command))
					)
				)
			)
			program
		)
	)
)


Возможно, оно выдаст STYLE-WARNING, это не страшно. Проверим:

$> (eval (print (+ 3 2)))
5 $>


Вуаля, работает!

Приправим систему с помощью трех функций (rsubs, rrem, rins). rsubs (Recursive substitution) заменяет рекурсивно старую форму (первый параметр old) на новую (второй параметр new) в форме (третий параметр form). rrem (Recursive remove) удаляет форму (первый параметр what) из формы (второй параметр form) тоже рекурсивно. Наконец, rins (Recursive insert) вставляет рядом в формой (первый параметр where) форму (второй параметр what) в форме (третий параметр form), причем если указан ключ :before t, то вставка выполняется перед формой where, иначе — после нее. Придется выполнить три команды.

Посмотреть три команды

(eval 
	(defun rsubs (old new form)
		(cond
			((atom form) (if (equal form old) new form))
			((equal form old) new)
			(t (loop for el in form collect (rsubs old new el)))
		)
	)
)
(eval 
	(defun rrem (what form)
		(cond
			((atom form) (if (equal what form) nil form))
			(t (loop for el in form 
				if (not (equal what el))
				collect (if (listp el) (rrem what el) el)
			))
		)
	)
)
(eval
	(defun rins (where what form &key before)
		(cond 
			((atom form) form)
			(t (loop for el in form append 
				(if (equal el where) 
					(if before (list what el) (list el what))
					(if (listp el) 
						(list (rins where what el :before before))
						(list el)
					)
				)
			))
		)
	)
)


Уже можно добавлять новые команды в наш процессор более красивым способом, как раз благодаря тому, что code не просто замещает код на свой аргумент, а предварительно исполняет его. Добавим команду view, которая выведет нам содержание переменной program. Весьма полезная команда для отслеживания изменений кода. Как видно, здесь происходит вставка нового кода после атома cond.

(code (rins 'cond '((eq command 'view) (progn (format t "---code---") (print program) (terpri))) program))


Тестируем, должно получиться что-то вроде этого:

Пример вывода команды (view)

$> (view)
---code---
(LAMBDA (PROGRAM)
  (PRINC "$> ")
  (LET ((INPUT (READ)))
    (WHEN (LISTP INPUT)
      (LET ((COMMAND (CAR INPUT)))
        (COND
         ((EQ COMMAND 'VIEW)
          (PROGN (FORMAT T "---code---") (PRINT PROGRAM) (TERPRI)))
         ((EQ COMMAND 'CODE)
          (SETF PROGRAM
                  (FUNCALL
                   (EVAL (LIST 'LAMBDA '(PROGRAM INPUT) (CADR INPUT)))
                   PROGRAM INPUT)))
         ((EQ COMMAND 'EVAL) (EVAL (CADR INPUT)))
         (T (FORMAT T "Unknown command ~A ~%" COMMAND)))))
    PROGRAM)) 
$>


Отлично! Теперь нам несложно добавить команду, которая будет добавлять команды. Ну, как иначе это назвать? Синтаксис команды будет таков: (add-cmd имя-новой-команды что-она-будет-делать). Но тут нас ожидает пикантная ситуация. В предыдущий раз мы вставляли код новой команды после атома cond, потому что это было проще всего. Имя это распространенное, и если в тексте появится еще одно его упоминание, то вставка будет выполнена и там, что нарушит работу тех частей, которые мы не собирались трогать. Решить эту проблему можно многими способами, например, ввести уникальный маркер и вставлять новые команды после него. Маркер будет представлять собой невыполнимое условие, которое мы добавим после cond:

(code (rins 'cond '((eq t nil) 'secret-marker) program))


Готово. Теперь будем передавать в rins местоположение вставки с помощью данного маркера. Громоздкость маркера ничего не значит, ведь мы создадим команду, которая будет его знать, и нам будет уже необязательно его помнить. Кстати, нельзя, чтобы код команды add-cmd использовал определение маркера, иначе rins найдет и поломает его. Можно попытаться обмануть rins, исказив маркер, но гораздо проще просто вынести в отдельную внешнюю функцию (rins по ним не ищет). Функция add-command-to-program принимает первым параметром программу program и возвращает ее обновленной, дополнив ее новой командой command, выполняющей действие action:

(eval
	(defun add-command-to-program (program command action)
		(rins '((eq t nil) 'secret-marker) ; после маркера   
			`((eq command ',command) ,action) ; применим квазицитирование
			program
		)
	)
)


Собственно создаем команду add-cmd.

(code 
	(rins '((eq t nil) 'secret-marker) 		; вставляем после маркера следующее
		`((eq command 'add-cmd)     	; имя новой команды add-cmd
			(setf program (add-command-to-program program (cadr input) (caddr input)))
		 ) 
		program
	)
)


Замечательно! Теперь нет ничего проще, чем добавить новые команды (две последние из них лучше пока не запускать):

(add-cmd hi (princ "Hi, "))
(add-cmd quit (setf program nil))
(add-cmd reset (setf program (start-program)))


Более полезными окажутся возможности по сохранению в файл программы и последующей загрузки ее из файла. Определим соответствующие команды save и load:

(add-cmd save (with-open-file (stream (cadr input) :direction :output :if-exists :overwrite :if-does-not-exist :create) (print program stream)))
(add-cmd load (setf program (with-open-file (stream (cadr input)) (read stream))))


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

$> (save "1.txt")
$> (load "1.txt")
Кастомизация


Для разнообразия займемся кастомизацией нашего диалога. Например, добавим забавные приветствия функцией:

(eval
	(defun greeting ()
		(let 
			((sentences (vector
				"My life for Ner'zhul.  "
				"I wish only to serve. "
				"Thy bidding, master? "
				"Where shall my blood be spilled? "
				"I bow to your will. "
			)))
			(elt sentences (random (length sentences)))
		)
	)
)


Теперь применим их в командном процессоре:

(code (rsubs '"$> " '(greeting) program))


Получится нечто вроде:

I bow to your will. (hi)
Hi, I wish only to serve.


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

(code (rsubs '(read) '(read-from-string (concatenate 'string "(" (read-line) ")")) program))


Результат:

Thy bidding, master? hi
Hi, Where shall my blood be spilled?


Давайте напоследок еще раз взглянем на код:

Окончательный результат

Thy bidding, master? view
---code---
(LAMBDA (PROGRAM)
  (PRINC (GREETING))
  (LET ((INPUT
         (READ-FROM-STRING (CONCATENATE 'STRING "(" (READ-LINE) ")"))))
    (WHEN (LISTP INPUT)
      (LET ((COMMAND (CAR INPUT)))
        (COND ((EQ T NIL) 'SECRET-MARKER)
              ((EQ COMMAND 'LOAD)
               (SETF PROGRAM
                       (WITH-OPEN-FILE (STREAM (CADR INPUT))
                         (READ STREAM))))
              ((EQ COMMAND 'SAVE)
               (WITH-OPEN-FILE
                   (STREAM (CADR INPUT) :DIRECTION :OUTPUT :IF-EXISTS
                    :OVERWRITE :IF-DOES-NOT-EXIST :CREATE)
                 (PRINT PROGRAM STREAM)))
              ((EQ COMMAND 'RESET) (SETF PROGRAM (START-PROGRAM)))
              ((EQ COMMAND 'QUIT) (SETF PROGRAM NIL))
              ((EQ COMMAND 'HI) (PRINC "Hi, "))
              ((EQ COMMAND 'ADD-CMD)
               (SETF PROGRAM
                       (ADD-COMMAND-TO-PROGRAM PROGRAM (CADR INPUT)
                                               (CADDR INPUT))))
              ((EQ COMMAND 'VIEW)
               (PROGN (FORMAT T "---code---") (PRINT PROGRAM) (TERPRI)))
              ((EQ COMMAND 'CODE)
               (SETF PROGRAM
                       (FUNCALL
                        (EVAL
                         (LIST 'LAMBDA '(PROGRAM INPUT) (CADR INPUT)))
                        PROGRAM INPUT)))
              ((EQ COMMAND 'EVAL) (EVAL (CADR INPUT)))
              (T (FORMAT T "Unknown command ~A ~%" COMMAND)))))
    PROGRAM)) 
My life for Ner'zhul.


С этой штукой можно развлекаться сколько угодно! Но на сегодня хватит.

Как изменить код программы без исходника? Несколько способов

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

Решение воздействовать на код программы в отсутствие ее исходного кода случается довольно часто и в основном этому предшествуют 2 основные причины:

  • вы потеряли исходный код;

  • его у вас никогда и не было, но хотите доработать какую-то программу.

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

В общем, «в таком положении» — без отсутствия исходного кода — вероятность, что что-то получится, невысокая, но она есть. А раз есть вероятность, значит, можно пробовать.

 

Как изменить код программы без исходников?

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

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

Декомпиляцию возможно осуществить при помощи специализированных программ:

  1. VB Decompiler;

  2. ReFox;

  3. DeDe;

  4. EMS Source Rescuer;

  5. PEID;

  6. и др.

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

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

 

Как изменить код программы без декомпиляции?

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

В качестве вспомогательного инструмента в этом случае будут программы OllyDbg и Ida PRO.

 

Заключение

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

  • используя декомпилятор;

  • изучая ассемблер.

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

Как редактировать исходный код программы — Сообщество — Форумы SitePoint

realfreetv

1

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

фелгалл

2

Первое, что вам нужно, это исходный код.

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

Сумасшедший банан

3

редактировать исходники ПО без исходников? как отредактировать .exe или установленное программное обеспечение? или создавать, редактировать и компилировать, как при создании программного обеспечения?

реалфритв

4

Сумасшедший банан:

редактировать исходник sw без исходника? как отредактировать . exe или установленное программное обеспечение? или создавать, редактировать и компилировать, как при создании программного обеспечения?

Редактировать исходный код программного обеспечения с доступным исходным кодом. На самом деле я купил искомое с правами собственности, и я хотел бы отредактировать графику и ссылки, указывающие на сайт продавца. То есть; редактировать файл .exe

реалфритв

5

Фелгалл:

Первое, что вам нужно, это исходный код.

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

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

фелгалл

6

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

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

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

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

Сумасшедший банан

7

ну… вы МОЖЕТЕ отредактировать .EXE, но для этого потребуются некоторые навыки работы с HEX и языком ассемблера (и во многих случаях с распаковкой и упаковкой). Вам также может понадобиться сравнить и записать новую контрольную сумму после редактирования, если вы добавили в нее больше, чем содержалось в исходном .EXE.

Если у вас есть время и навыки, вы можете переписать все приложение. Но если у вас нет этого знания, как сказал Фелгалл; — не редактируется.

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

AlexDawson

8

RealFreeTV:

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

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

RealFreeTV:

Редактировать исходный код программного обеспечения с доступным исходным кодом. На самом деле я купил искомое с правами собственности, и я хотел бы отредактировать графику и ссылки, указывающие на сайт продавца. То есть; редактировать файл .exe

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

реалфритв:

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

?

Проверьте расширения файлов, затем загуглите расширение файла, и он скажет вам, с каким продуктом он связан… например, если это vbp / vb, это будет Visual Basic, если это cpp / c, это будет C++… или если вы хотите быть действительно ленивым, то спросите разработчика или проверьте веб-сайт, на котором размещен исходный код, он должен сказать

Сумасшедший банан:

ну… вы МОЖЕТЕ отредактировать .EXE, но для этого потребуются некоторые навыки работы с HEX и языком ассемблера (и во многих случаях с распаковкой и упаковкой).

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

Сумасшедший банан

9

Алекс Доусон:

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

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

В любом случае, если он сидит только с .exe, и купил его без исходников, то может и забыть об этом .
Что он может сделать, так это запросить его источник, откуда он его купил, и посмотреть, что произойдет, и работать оттуда…

система

Закрыто

10

«Хороший код легко изменить» — мой новый первый принцип программирования

← Вернуться на главную страницу блога

Методы разработки

Автор: Аарон Кинг

5 декабря 2018 г.

Хороший код легко изменить.

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

Хороший код — это код, который легко изменить.

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

1. Требования изменятся.

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

2. Быстрая смена лежит в основе программного обеспечения.

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

3. Правильность не так важна.

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

4. Остальные принципы обычно сводятся к изменчивости.

Разделение задач, абстракция, слабая связанность, запрет на повторение — все это шаблоны, облегчающие изменение кода. В общем, они гарантируют, что любое изменение, которое вам нужно сделать, будет (в основном) ограничено одним компонентом.

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

Следите за нашими последними сообщениями.

Мы ежемесячно будем присылать наши последние советы, знания и тематические исследования от Atomic braintrust.

Похожие сообщения

Расскажите нам о своем проекте

Мы хотели бы поговорить с вами о вашем следующем замечательном проекте по программному обеспечению.

This entry was posted in Семантическое ядро