Simple Made Easy — Rich Hickey (с русским переводом)

Original author: Rich Hickey
  • Translation
Всем привет!

Я сделал перевод и набил субтитры на знаменитый доклад Рича Хикки — Simple Made Easy (Простое сделать лёгким). Впервые на русском языке.

Доклад впервые был представлен в 2011 году на конференции Strange Loop.




О докладе:

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

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



Рич Хикки — создатель языка программирования Clojure, независимый разработчик ПО и консультант с 20-летним опытом работы в различных областях разработки ПО. Примерно 2,5 года в одиночку работал над Clojure, прежде чем кому-либо его показать.

UPD от 18.06.2020:
Субтитры были частично обновлены — исправлены неточности в переводе.



Посмотреть на Ютубе

Посмотреть здесь

Полный текст субтитров
1
00:00:04,923 --> 00:00:09,302
Привет!
Кто готов послушать про теорию категорий?

2
00:00:09,402 --> 00:00:15,009
Вы все ошиблись дверью.

3
00:00:16,927 --> 00:00:23,339
Этот разговор, я надеюсь,
кажется обманчиво очевидным.

4
00:00:25,032 --> 00:00:29,195
Одна из замечательных вещей на этой конференции,
что здесь довольно продвинутая публика.

5
00:00:29,195 --> 00:00:32,498
Многие из вас используют продвинутые технологии.
Многие из вас используют функциональное программирование.

6
00:00:32,598 --> 00:00:40,780
И вы возможно киваете, да, да, да, когда я это говорю.
И если что-то из этого знакомо, то замечательно.

7
00:00:40,880 --> 00:00:47,075
С другой стороны, я надеюсь, что вы уйдете
с этой встречи с некоторыми инструментами,

8
00:00:48,271 --> 00:00:55,668
которые сможете использовать в разговорах с другими людьми,
чтобы убедить их делать правильные вещи.

9
00:00:58,787 --> 00:01:05,730
Итак, я начну с обращения к авторитету.
Простота это необходимое условие для надежности.

10
00:01:06,095 --> 00:01:12,748
Я согласен не со всем, о чём говорил Дейкстра,
я думаю, он сильно заблуждался в доказательстве.

11
00:01:13,483 --> 00:01:15,642
Но мне кажется он прав в этом.

12
00:01:15,742 --> 00:01:20,726
Нам нужно создавать простые системы,
если мы хотим создавать хорошие системы.

13
00:01:20,826 --> 00:01:23,649
Я думаю, мы не достаточно фокусируемся на этом.

14
00:01:23,749 --> 00:01:25,269
Происхождение слова

15
00:01:25,369 --> 00:01:27,634
Я люблю происхождения слов.
Они страшно интересны.

16
00:01:27,734 --> 00:01:30,165
Одна из причин почему это интересно,

17
00:01:30,165 --> 00:01:35,181
потому что слова начинают означать то,
что мы соглашаемся, чтобы они значили.

18
00:01:35,281 --> 00:01:37,773
То, что обычно понимается как смысл слова,
это то, что оно означает.

19
00:01:37,873 --> 00:01:41,834
И часто интересно сказать, ну, я бы хотел;

20
00:01:41,934 --> 00:01:44,157
Я хотел бы вернуться к тому,
что они означают, и использовать этот смысл.

21
00:01:44,257 --> 00:01:47,186
И я думаю, что есть пара слов,
которые я собираюсь использовать в этой речи,

22
00:01:47,286 --> 00:01:51,530
и я хотел бы, чтобы вы ушли,
зная о происхождении этих слов

23
00:01:51,630 --> 00:01:55,164
и попытались использовать их более точно,
особенно когда речь идёт о программах.

24
00:01:57,136 --> 00:01:59,289
Итак, первое из слов — простота (simple).

25
00:02:00,256 --> 00:02:07,809
И корни этого слова sim и plex,
означают вложение или оплетка или скручивание.

26
00:02:07,909 --> 00:02:15,945
И это качество быть
единожды скрученным или сложенным.

27
00:02:16,045 --> 00:02:21,388
Как выглядит один поворот?
На самом деле это значит ни одного поворота.

28
00:02:21,488 --> 00:02:25,740
А противоположность этого слова — сложность (complex)

29
00:02:25,840 --> 00:02:29,627
которое означает сплетённые или
сложенные вместе.

30
00:02:31,802 --> 00:02:36,746
Размышляя о разработке ПО в терминах
вложенности, это главная мысль нашего разговора.

31
00:02:36,846 --> 00:02:43,010
Другое слово, которое мы часто используем
на замену простоте — легкость (easy).

32
00:02:43,726 --> 00:02:46,424
А происхождение у этого слова французское

33
00:02:46,524 --> 00:02:50,824
и последнее ответвление от этого происхождения
довольно спекулятивно, но я использую его сегодня

34
00:02:50,924 --> 00:02:53,238
оно очень хорошо подходит к сегодняшней речи

35
00:02:53,338 --> 00:02:57,513
оно произошло от
латинского корня слова adjacent

36
00:02:57,613 --> 00:03:02,191
которое означает лежащий рядом,
находящийся рядом.

37
00:03:02,291 --> 00:03:04,380
А противоположное слово — сложность (hard)

38
00:03:04,480 --> 00:03:06,689
Конечно корень слова hard
не имеет ничего общего с «лежащий рядом».

39
00:03:06,789 --> 00:03:08,261
Оно не значит лежащий далеко.

40
00:03:08,361 --> 00:03:16,778
Оно на самом деле означает
сильный или извилистый.

41
00:03:16,878 --> 00:03:18,378
Простота

42
00:03:18,478 --> 00:03:20,557
Если мы пытаемся применить
простоту к своей работе

43
00:03:20,657 --> 00:03:24,764
нам нужно начать
с концепции одного плетения

44
00:03:24,864 --> 00:03:28,685
И посмотреть на него с нескольких сторон

45
00:03:28,785 --> 00:03:30,862
Я думаю разговор о разных сторонах
был интересен в речи Эрика Мейера

46
00:03:30,962 --> 00:03:33,532
это определенно важная часть
работы над проектированием ПО.

47
00:03:33,632 --> 00:03:35,995
Если мы хотим взглянуть на простые вещи

48
00:03:36,095 --> 00:03:38,925
мы хотим взглянуть на определенные вещи.

49
00:03:39,025 --> 00:03:40,774
Они имеют одну функцию.

50
00:03:40,874 --> 00:03:44,090
Они о выполнении какой-то одной цели.

51
00:03:44,190 --> 00:03:52,523
Они могут быть об одном понятии,
таком как безопасность.

52
00:03:55,208 --> 00:03:58,704
И что-то вроде того, что они могут касаться

53
00:03:58,804 --> 00:04:01,595
конкретного аспекта проблемы,
которую вы пытаетесь решить

54
00:04:01,695 --> 00:04:05,143
И важная мысль в том, что когда
вы ищете что-то простое

55
00:04:05,596 --> 00:04:08,271
вы хотите, чтобы оно
фокусировалось на этих областях

56
00:04:09,519 --> 00:04:12,032
Вы не хотите, чтобы оно
комбинировало разные вещи.

57
00:04:12,132 --> 00:04:15,617
С другой стороны, мы не можем
слишком сильно фиксироваться на одной вещи

58
00:04:15,717 --> 00:04:21,554
В частности, простота не означает что-то одно.
Верно?

59
00:04:21,654 --> 00:04:26,084
Она не является интерфейсом
с одной операцией.

60
00:04:26,184 --> 00:04:32,772
Поэтому важно различать
мощность множества

61
00:04:32,872 --> 00:04:36,458
то есть количество вещей
от фактического перемежения этих вещей.

62
00:04:36,558 --> 00:04:40,459
Что важно, простота это не перемежение,

63
00:04:40,559 --> 00:04:45,637
это не одна какая-то вещь,
важно помнить об этом.

64
00:04:48,431 --> 00:04:51,456
Хорошо, другая важная вещь про простоту,

65
00:04:51,556 --> 00:04:55,833
то о чём мы только что говорили,
это перемежаются вещи или нет

66
00:04:57,360 --> 00:04:59,808
это объективная характеристика.

67
00:04:59,908 --> 00:05:04,314
Вы можете пойти и сами в этом убедиться.
Я не вижу никаких связей.

68
00:05:04,414 --> 00:05:06,141
Я не вижу нигде, где этот изгиб
был чем-то другим

69
00:05:06,241 --> 00:05:10,384
простота на самом деле
является объективным понятием.

70
00:05:11,870 --> 00:05:15,247
Это также очень важно при определении
разницы между простым и легким.

71
00:05:15,347 --> 00:05:16,396
Легкость

72
00:05:16,496 --> 00:05:19,010
Давайте посмотрим на легкость.

73
00:05:19,110 --> 00:05:22,346
Я думаю это понятие о близости
очень, очень классное.

74
00:05:22,446 --> 00:05:26,492
В частности, очевидно есть много примеров,
когда что-то может быть рядом.

75
00:05:26,592 --> 00:05:34,240
Есть в этом что-то от физического понятия.
Это что-то рядом.

76
00:05:34,340 --> 00:05:36,203
И я думаю вот откуда корень
этого слова происходит.

77
00:05:36,303 --> 00:05:39,342
Знаете, когда что-то легко получить,
потому что оно рядом.

78
00:05:39,342 --> 00:05:40,277
Оно не в соседнем городе.

79
00:05:40,359 --> 00:05:43,252
Мне не нужно садиться на лошадь,
чтобы добраться до этой вещи.

80
00:05:43,352 --> 00:05:46,232
У нас нет того же понятия физической близости
в нашем программном обеспечении

81
00:05:46,332 --> 00:05:48,103
но что-то подобное есть, знаете

82
00:05:48,203 --> 00:05:50,974
наш собственный жёсткий диск или
набор инструментов

83
00:05:51,074 --> 00:05:58,131
или способность делать вещи ближе,
устанавливая их и тому подобное.

84
00:05:58,231 --> 00:06:05,889
Второе понятие близости это нечто близкое
нашему пониманию или к нашему уровню навыков.

85
00:06:05,989 --> 00:06:12,287
И я не имею в виду, в этом случае, близко
по смыслу к нашему понимаю слова способность.

86
00:06:12,387 --> 00:06:15,075
Я имею в виду буквально близко к тому,
что мы уже знаем.

87
00:06:15,175 --> 00:06:19,216
Правильное слово в этом случае
быть знакомым.

88
00:06:21,866 --> 00:06:27,216
Я полагаю, что мы, все вместе,
увлечены этими двумя понятиями лёгкости.

89
00:06:27,316 --> 00:06:34,089
Мы так сильно вовлечены в эти два аспекта,
нас это чрезвычайно задевает.

90
00:06:34,189 --> 00:06:36,881
Всё о чём мы беспокоимся, могу ли я
получить это мгновенно

91
00:06:36,881 --> 00:06:38,766
и запустить за пять секунд?

92
00:06:38,745 --> 00:06:43,701
Это может быть что-то бесполезное, но всё,
что вас волнует, можете ли вы это получить.

93
00:06:43,801 --> 00:06:48,947
Вдобавок, мы зацикливаемся на этом: о,
я не могу, я не могу это прочитать.

94
00:06:51,071 --> 00:06:52,479
Я не могу читать на немецком.

95
00:06:52,579 --> 00:06:55,259
Означает ли это, что немецкий нечитаем?
Нет.

96
00:06:55,359 --> 00:06:57,513
Я не знаю немецкий.

97
00:06:59,167 --> 00:07:03,108
Понимаете, такой подход
определенно не помогает.

98
00:07:03,208 --> 00:07:07,673
В частности, если вы хотите, чтобы всё было
знакомым, вы никогда не выучите что-то новое,

99
00:07:07,673 --> 00:07:10,177
потому что у вас не будет
чего-то особо отличающегося

100
00:07:10,277 --> 00:07:13,170
от того, что вы уже знаете
и не отличающегося от уже знакомого.

101
00:07:14,580 --> 00:07:19,303
Есть третий аспект простоты,
о котором мы особо и не размышляем

102
00:07:19,403 --> 00:07:25,594
он станет дискуссионным, он о том,
что сейчас близко к нашим способностям.

103
00:07:25,694 --> 00:07:29,838
И мы не любим говорить об этом,
потому что нам становится неловко

104
00:07:29,938 --> 00:07:31,811
из-за того, о каких способностях мы говорим?

105
00:07:31,911 --> 00:07:35,915
Если мы говорим о простоте
в плане игры на скрипке или на пианино

106
00:07:36,015 --> 00:07:38,490
или о скалолазании или о чём-то подобном,

107
00:07:38,590 --> 00:07:43,489
я лично не чувствую себя плохо от того,
что не умею играть на скрипке хорошо,

108
00:07:43,589 --> 00:07:45,374
потому что я не умею играть
на скрипке совсем.

109
00:07:47,178 --> 00:07:48,276
Но работа, которой мы занимаемся

110
00:07:48,376 --> 00:07:51,668
это умозрительная работа, поэтому,
когда мы начинаем говорить о чем-то

111
00:07:51,768 --> 00:07:54,789
что находится за пределами наших возможностей,
ну, вы знаете

112
00:07:54,889 --> 00:07:57,095
это действительно
начинает давить на наше эго.

113
00:07:58,283 --> 00:08:05,205
Итак, вы знаете, из-за сочетания высокомерия и
небезопасности, мы никогда не говорим о том

114
00:08:05,305 --> 00:08:07,644
находится ли что-то вне наших возможностей.

115
00:08:07,744 --> 00:08:17,320
Это не так стыдно, потому что у нас нет
совершенно разных способностей в этой области.

116
00:08:17,420 --> 00:08:20,332
Последняя вещь, которую
я хочу сказать про лёгкость,

117
00:08:20,432 --> 00:08:26,447
лёгкость, в отличии от простоты,
это относительное понятие. Верно?

118
00:08:26,547 --> 00:08:29,510
Играть на скрипке и читать по-немецки
для меня действительно трудно.

119
00:08:29,610 --> 00:08:32,887
Для других легко,
некоторых других людей.

120
00:08:32,987 --> 00:08:38,110
В отличии от простоты, где мы можем
увидеть переплетения и чередования

121
00:08:38,210 --> 00:08:44,695
легко это всегда кому-то или трудно кому-то.
Это относительное понятие.

122
00:08:44,795 --> 00:08:46,815
Правда в том, что мы бросаемся этими понятиями,

123
00:08:46,915 --> 00:08:50,044
говоря мне нравится использовать эту технологию,
потому что она простая,

124
00:08:50,144 --> 00:08:52,113
а под простотой я имею ввиду легкость.

125
00:08:52,213 --> 00:08:56,378
А когда я говорю легкость, я имею ввиду,
что я уже знаком с чем-то похожим.

126
00:08:56,478 --> 00:08:58,892
В этом случае все понятия размываются
и мы никогда

127
00:08:58,892 --> 00:09:04,924
не сможем объективно обсудить
качество наших программ.

128
00:09:05,024 --> 00:09:06,370
Конструкция против артефакта

129
00:09:06,470 --> 00:09:19,472
В какой же области нам необходимо различать
эти два понятия — легкость и простота?

130
00:09:19,572 --> 00:09:22,607
Когда речь идёт о конструкциях и артефактах.

131
00:09:22,707 --> 00:09:25,226
Мы программируем с помощью конструкций.
У нас есть языки программирования.

132
00:09:25,326 --> 00:09:26,966
Мы используем определенные
библиотеки, и те вещи,

133
00:09:27,066 --> 00:09:32,453
которые сами по себе,
когда мы смотрим на них, например,

134
00:09:32,553 --> 00:09:34,099
когда мы смотрим на код, который мы пишем,

135
00:09:34,199 --> 00:09:36,499
имеют определенные характеристики
сами по себе.

136
00:09:36,599 --> 00:09:39,688
Но мы находимся в бизнесе артефактов.

137
00:09:39,788 --> 00:09:42,444
Мы не поставляем исходный код

138
00:09:42,544 --> 00:09:45,870
и пользователи не смотрят на наш код
и не говорят: «О, так здорово».

139
00:09:47,121 --> 00:09:47,459
Нет.

140
00:09:47,559 --> 00:09:51,891
Они запускают наши программы
и они работают длительное время.

141
00:09:51,991 --> 00:09:55,621
И на протяжении времени мы продолжаем работать
над нашим программным обеспечением.

142
00:09:55,721 --> 00:10:00,514
И всё в этом софте — запуск, производительность,

143
00:10:00,614 --> 00:10:06,620
способность изменяться — атрибуты артефактов,
а не оригинальных конструкций.

144
00:10:06,720 --> 00:10:14,201
Но снова, мы всё ещё так сильно фокусируемся
на нашем опыте использования конструкций.

145
00:10:14,301 --> 00:10:18,467
Посмотрите: Мне пришлось написать
всего 16 символов. Ух, ты! Здорово.

146
00:10:18,567 --> 00:10:20,656
Нет точек с запятой и прочих вещей.

147
00:10:20,756 --> 00:10:29,004
Это целое понятие — удобство программиста,
мы увлечены им, а не пользой, которую приносим.

148
00:10:29,104 --> 00:10:31,703
С другой стороны дела обстоят ещё хуже.

149
00:10:31,803 --> 00:10:34,977
Наши работодатели тоже увлечены этим. Верно?

150
00:10:35,077 --> 00:10:38,724
Эти два значения лёгкости, что они означают?

151
00:10:38,824 --> 00:10:41,874
Могу ли я привлечь другого программиста.

152
00:10:43,852 --> 00:10:47,313
И они смотрят на ваш исходный код,
и думают, что он выглядит знакомо.

153
00:10:49,853 --> 00:10:53,674
И они уже знают весь инструментарий.
Он под рукой.

154
00:10:53,774 --> 00:10:56,928
У них уже есть этот инструмент
в инструментарии. Они могут его прочитать.

155
00:10:57,158 --> 00:10:58,304
Я могу заменить вас.

156
00:10:58,392 --> 00:11:01,906
Это лёгкая задача, особенно если
я игнорирую третье понятие о лёгкости

157
00:11:03,483 --> 00:11:08,021
а именно может ли кто-нибудь понять ваш код,
потому что это на самом деле их не волнует.

158
00:11:08,121 --> 00:11:10,883
Они просто заботятся о том, чтобы кто-нибудь
мог сесть на ваше место и начал печатать.

159
00:11:12,939 --> 00:11:19,588
Ещё раз, многие владельцы бизнеса
фокусируются на первых двух аспектах лёгкости

160
00:11:19,821 --> 00:11:21,388
потому что это делает
программистов заменяемыми.

161
00:11:21,488 --> 00:11:26,026
Мы собираемся сопоставить это
с последствиями долгосрочного использования.

162
00:11:28,271 --> 00:11:30,190
Что значит придерживаться
таких принципов в долгосрочном периоде?

163
00:11:32,585 --> 00:11:35,842
А что там? Там вся суть. Правильно?

164
00:11:35,942 --> 00:11:41,432
Делает ли программа то, что должна?
Она высокого качества?

165
00:11:41,532 --> 00:11:43,172
Можем ли мы положиться на неё,
делая то, для чего она предназначалась?

166
00:11:43,272 --> 00:11:46,766
Можем ли мы исправить проблемы,
когда они появляются?

167
00:11:46,866 --> 00:11:49,669
И если появляются новые требования,
можем ли мы изменить программу?

168
00:11:49,769 --> 00:11:54,626
Эти вещи не имеют никакого отношения
к конструкциям, как мы описали их здесь

169
00:11:54,726 --> 00:12:00,880
или совсем небольшое, и имеют
большое отношение к атрибутам артефакта.

170
00:12:00,980 --> 00:12:06,692
Мы должны начать оценивать наши конструкции,
основываясь на артефактах

171
00:12:06,792 --> 00:12:13,188
а не на том как они выглядят
или ощущаются во время их создания.

172
00:12:14,155 --> 00:12:15,345
Ограничения

173
00:12:15,530 --> 00:12:17,052
Давайте поговорим немного об ограничениях.

174
00:12:17,152 --> 00:12:17,916
О, смотрите, оно движется.

175
00:12:19,760 --> 00:12:24,755
Это просто должно увести вас в такое состояние,
когда всё, что я говорю, кажется правдой.

176
00:12:27,802 --> 00:12:31,579
Потому что я не могу
использовать монады, чтобы сделать это.

177
00:12:35,578 --> 00:12:37,630
Этот материал довольно логичен, так?

178
00:12:37,730 --> 00:12:41,689
Как мы вообще можем сделать что-то надёжным,
если мы эту вещь не понимаем?

179
00:12:43,304 --> 00:12:44,910
Это очень, очень сложно.

180
00:12:45,984 --> 00:12:50,917
Я полагаю профессор Суссман привел отличный
аргумент, что придётся идти на компромисс.

181
00:12:51,017 --> 00:12:51,648
В будущем для некоторых систем,

182
00:12:51,748 --> 00:12:54,912
в связи с тем, что мы делаем их более гибкими
и расширяемыми и динамичными,

183
00:12:55,012 --> 00:13:05,907
нам придётся идти на компромисс в понимании
их поведения и в уверенности их корректности.

184
00:13:06,731 --> 00:13:11,056
Но для вещей, которые мы хотим понять,
и в корректности которых мы должны быть уверены,

185
00:13:11,156 --> 00:13:14,339
мы будем ограничены.
Мы будем ограничены в нашем понимании.

186
00:13:14,439 --> 00:13:16,151
А наше понимание очень ограничено, верно?

187
00:13:16,251 --> 00:13:19,764
Есть представление о том,
сколькими мячами вы можете жонглировать,

188
00:13:19,864 --> 00:13:21,556
или сколько вещей
вы можете держать в голове одновременно.

189
00:13:21,656 --> 00:13:24,250
Это конечное число, и оно очень мало, так?

190
00:13:24,350 --> 00:13:28,689
Мы можем учитывать только несколько вещей,
и, когда вещи переплетаются вместе,

191
00:13:28,789 --> 00:13:31,866
мы теряем способность
воспринимать их изолированно.

192
00:13:31,966 --> 00:13:35,767
Каждый раз, когда я извлекаю
новую часть программы

193
00:13:35,867 --> 00:13:38,848
мне нужно осмыслить её,
а она прикреплена к другой части

194
00:13:38,948 --> 00:13:40,654
Я должен положить эту другую часть себе в голову

195
00:13:40,754 --> 00:13:43,183
потому что я не могу думать
об одной части в отрыве от другой.

196
00:13:43,283 --> 00:13:45,171
Так ведут себя вещи,
когда они переплетены.

197
00:13:45,271 --> 00:13:48,620
Каждое переплетение добавляет эту ношу,

198
00:13:48,720 --> 00:13:52,973
и эта ноша является своего рода комбинаторной
в отношении количества вещей

199
00:13:53,073 --> 00:13:54,723
которые мы можем учитывать.

200
00:13:54,823 --> 00:13:59,773
По сути эта сложность, а под сложностью
я понимаю это сплетение вещей вместе,

201
00:13:59,873 --> 00:14:03,621
ограничивает нашу способность
в понимании наших систем.

202
00:14:07,271 --> 00:14:08,376
Изменение

203
00:14:09,164 --> 00:14:10,597
Как мы изменяем наш софт?

204
00:14:10,697 --> 00:14:15,699
Похоже я сегодня слышал в одном выступлении,
что agile и экстремальное программирование

205
00:14:15,799 --> 00:14:23,656
показали, что рефакторинг и тесты позволяют
нам вносить изменения с нулевым воздействием.

206
00:14:23,756 --> 00:14:28,736
Я никогда этого не знал.
Я всё ещё этого не знаю.

207
00:14:28,836 --> 00:14:33,091
Это на самом деле не то, что нужно знать.
Это чушь.

208
00:14:33,191 --> 00:14:39,290
Верно? Если вы собираетесь
изменять программу вам нужно проанализировать,

209
00:14:39,390 --> 00:14:41,828
что она делает и принять решение
о том, что она должна делать.

210
00:14:41,928 --> 00:14:46,605
Понимаете, как минимум вам нужно сказать:
«В чём воздействие потенциальных изменений?»

211
00:14:47,432 --> 00:14:52,763
И на какие части программы мне нужно
перейти, чтобы осуществить изменения?

212
00:14:53,898 --> 00:14:59,188
Знаете, я не переживаю если вы используете XP
или agile или что-либо ещё.

213
00:14:59,288 --> 00:15:02,843
Вам не обойти тот факт, что если вы
не можете рассуждать о вашей программе

214
00:15:02,943 --> 00:15:04,078
вы не сможете принять эти решения.

215
00:15:05,186 --> 00:15:09,378
Но я хочу прояснить, потому что многие люди,
как только они слышат слова,

216
00:15:09,478 --> 00:15:10,708
о необходимости рассуждений, они говорят:

217
00:15:10,808 --> 00:15:13,796
«О, Боже мой! Вы говорите, что мы должны
быть санкционировать программы?»

218
00:15:13,896 --> 00:15:16,875
Я в это не верю.
Я не считаю, что это объективно.

219
00:15:16,975 --> 00:15:20,438
Я лишь говорю про неформальные рассуждения,
такие же, которые мы применяем каждый день,

220
00:15:20,538 --> 00:15:22,116
когда решаем что делать.

221
00:15:22,216 --> 00:15:26,261
Мы не берем теорию категорий
и не говорим «Ууу»,

222
00:15:26,361 --> 00:15:31,854
вы знаете. Мы на самом деле
можем рассуждать без неё. Слава Богу.

223
00:15:32,372 --> 00:15:32,859
Отладка

224
00:15:32,959 --> 00:15:36,200
Что по поводу другой стороны? Есть две вещи,
которые вы делаете с вашей программой.

225
00:15:36,300 --> 00:15:37,815
Одна — вы добавляете новые возможности.

226
00:15:37,915 --> 00:15:42,510
Другая — вы исправляете те,
которые вы сделали не очень хорошо.

227
00:15:43,078 --> 00:15:48,446
И мне нравится задавать этот вопрос: что верно
для каждой ошибки, найденной в продакшене?

228
00:15:49,156 --> 00:15:50,596
Ответ аудитории: Кто-то её написал.

229
00:15:50,696 --> 00:15:51,859
Она была кем-то написана. Да.

230
00:15:52,958 --> 00:15:58,092
Что ещё более интересно:
она прошла проверку типов.

231
00:15:58,192 --> 00:16:00,029
Что ещё она сделала?

232
00:16:01,023 --> 00:16:05,962
Она прошла все тесты.
Да. Что теперь вам нужно сделать?

233
00:16:08,838 --> 00:16:13,232
Я считаю, что мы в мире, как я его называю
оградительного программирования.

234
00:16:14,747 --> 00:16:17,334
Грустно говорить это.

235
00:16:17,434 --> 00:16:19,360
Мы такие: Я могу вносить изменения,
потому что у меня есть тесты.

236
00:16:20,141 --> 00:16:21,032
Кто так делает?

237
00:16:21,132 --> 00:16:23,724
Кто водит машину,
стукаясь об ограждения, говоря:

238
00:16:23,824 --> 00:16:32,768
«Вау! Я рад, что у меня есть эти ограждения,
иначе я никогда бы не приехал вовремя.»

239
00:16:33,974 --> 00:16:39,517
И установленные ограждения
помогают вам добраться до места?

240
00:16:40,014 --> 00:16:41,745
Вроде, ограждения направляют вас?

241
00:16:41,845 --> 00:16:43,957
Нет. Ограждения повсюду.

242
00:16:44,057 --> 00:16:47,554
Они не направляют вашу машину
в какое-то конкретное направление.

243
00:16:48,645 --> 00:16:52,281
Ещё раз, нам нужно иметь возможность
думать о нашей программе.

244
00:16:52,381 --> 00:16:53,148
Это становится критически важно.

245
00:16:53,248 --> 00:16:56,684
Все наши ограждения подводят нас.
У нас будет эта проблема.

246
00:16:56,784 --> 00:16:59,188
Нам нужно уметь рассуждать
о нашей программе.

247
00:16:59,288 --> 00:17:03,154
Скажем вроде этого: Ну, вы знаете, что?
Я думаю, потому что, может быть,

248
00:17:03,254 --> 00:17:04,901
если это не слишком сложно, я смогу сказать:

249
00:17:05,001 --> 00:17:09,940
«Я знаю, с помощью заурядной логики,
этого не может быть в этой части программы.

250
00:17:10,040 --> 00:17:13,491
Оно должно быть в другой части программы,
и позвольте мне сначала посмотреть там».

251
00:17:14,415 --> 00:17:15,162
Скорость разработки

252
00:17:15,262 --> 00:17:20,275
Теперь все конечно же начнут стонать: "
Но у меня есть скорость. Я использую agile.

253
00:17:21,353 --> 00:17:26,212
Понимаете, эти простые вещи делают мою
жизнь хорошей, ведь у меня высокая скорость.

254
00:17:27,135 --> 00:17:33,545
Какой бегун может бежать с максимальной
скоростью с самого начала гонки?

255
00:17:34,853 --> 00:17:35,752
Ответ аудитории: Спринтер.

256
00:17:35,755 --> 00:17:40,216
Верно, только тот, который бежит
на очень короткие дистанции. Верно?

257
00:17:43,138 --> 00:17:47,666
Но конечно, мы программисты, мы умнее бегунов,
очевидно из-за того,

258
00:17:47,766 --> 00:17:51,115
что мы знаем как исправить эту проблему,
верно?

259
00:17:51,215 --> 00:18:03,398
Мы просто стреляем из стартового пистолета
каждые сто метров и зовём это новым спринтом.

260
00:18:03,498 --> 00:18:07,778
Я не знаю, почему они ещё до этого
не догадались, но ладно.

261
00:18:08,409 --> 00:18:14,745
Это моя точка зрения, основанная на опыте,
если вы игнорируете сложность, вы замедляетесь.

262
00:18:14,845 --> 00:18:17,610
Вы неизменно будете замедляться
на длительной дистанции.

263
00:18:18,476 --> 00:18:22,393
Конечно, если вы делаете что-то на
короткой дистанции, вам ничего этого не нужно.

264
00:18:22,493 --> 00:18:25,430
Вы можете писать код в виде единиц и нулей.

265
00:18:25,530 --> 00:18:28,313
И это мой действительно научный график.

266
00:18:28,413 --> 00:18:35,735
Вы заметили, что ни на одной из осей нет чисел,
потому что я только что все это выдумал.

267
00:18:35,835 --> 00:18:41,945
Это экспоненциальный граф, он показывает,
что если вы фокусируетесь на легкости

268
00:18:42,045 --> 00:18:46,200
и игнорируете простоту, я не говорю, что
одновременно следить за обоими параметрами нельзя.

269
00:18:46,300 --> 00:18:47,005
Это было бы замечательно.

270
00:18:47,105 --> 00:18:51,789
Но если вы фокусируетесь на легкости, то сможете
побежать так быстро, как возможно с самого начала.

271
00:18:51,889 --> 00:18:55,050
Но не важно какую технологию вы используете,
или какую длину спринта вы бежите

272
00:18:55,150 --> 00:18:56,594
или какие стартовые пистолеты у вас есть,

273
00:18:56,765 --> 00:18:58,504
сложность, в конце концов, убьёт вас.

274
00:18:58,604 --> 00:19:02,092
Она убьёт вас в том плане, что
каждый спринт будет выполняться медленнее.

275
00:19:02,192 --> 00:19:05,403
Большинство спринтов будут состоять из полной
переделки вещей, которые вы уже сделали.

276
00:19:06,251 --> 00:19:10,411
И в результате вы не продвигаетесь вперёд
каким-либо существенным образом.

277
00:19:10,511 --> 00:19:12,493
Теперь, если вы начинаете с того,
что фокусируетесь на простоте,

278
00:19:12,593 --> 00:19:15,960
почему вы не можете бежать так быстро
как возможно с самого начала?

279
00:19:17,659 --> 00:19:20,638
потому что некоторые инструменты, которые просты,
на самом деле настолько же легки в использовании,

280
00:19:20,738 --> 00:19:22,147
как другие инструменты, которые не просты.

281
00:19:22,247 --> 00:19:24,517
Почему же тогда вы не можете бежать быстро?

282
00:19:26,241 --> 00:19:26,897
Вам приходится думать.

283
00:19:26,997 --> 00:19:30,822
Вы должны, на самом деле, провести
некоторую работу по упрощению проблемы

284
00:19:30,922 --> 00:19:33,606
прежде чем начать, и это даст вам импульс.

285
00:19:36,288 --> 00:19:43,220
Одна из проблем я полагаю в этой головоломке, что
некоторые вещи, которые легки, на самом деле сложны.

286
00:19:45,778 --> 00:19:52,086
Есть куча конструкций, которые создают
сложные артефакты, которые очень кратко описаны.

287
00:19:52,186 --> 00:19:56,150
Некоторые вещи, которые очень опасно
использовать, так просто описать.

288
00:19:56,250 --> 00:19:58,649
Они кажутся невероятно знакомыми, так?

289
00:19:58,749 --> 00:20:02,339
Если вы пришли из ООП, то вам
знакомо множество сложных вещей.

290
00:20:02,439 --> 00:20:05,219
Они чрезвычайно доступны. Верно?

291
00:20:06,571 --> 00:20:07,595
Их легко использовать.

292
00:20:07,695 --> 00:20:10,662
На самом деле, по всем параметрам,
стандартным параметрам,

293
00:20:10,762 --> 00:20:13,292
вы бы посмотрели на них и сказали,
что это легко.

294
00:20:14,755 --> 00:20:17,122
Но мы не беспокоимся об этом. Так?

295
00:20:17,222 --> 00:20:19,249
Ещё раз, пользователи не смотрят
на наши программы,

296
00:20:19,349 --> 00:20:23,529
и их особо не заботит как хорошо
мы провели время, когда их писали.

297
00:20:24,537 --> 00:20:29,906
Беспокоит их то, что программа делает,
и если она работает хорошо,

298
00:20:30,006 --> 00:20:35,763
это будет связано с тем, были ли
выходные данные этих конструкций простыми.

299
00:20:35,863 --> 00:20:37,832
Другими словами, какую сложность
они принесли?

300
00:20:38,201 --> 00:20:44,603
Когда случается сложность, мы будем называть
её случайная сложность. Верно?

301
00:20:44,703 --> 00:20:46,374
Она не была частью того,
что просили пользователи.

302
00:20:46,474 --> 00:20:49,362
Мы выбрали инструмент.
У него было сколько-то своей сложности.

303
00:20:49,462 --> 00:20:51,386
Она случайна для этой проблемы.

304
00:20:51,486 --> 00:20:59,438
Я не добавил сюда определение, но случайность
по-латински означает — «по вашей вине».

305
00:21:02,733 --> 00:21:05,006
И это так, и я думаю, что вы
действительно должны спросить себя

306
00:21:05,106 --> 00:21:07,308
вы программируете с помощью ткацкого станка?

307
00:21:07,408 --> 00:21:11,087
Знаете, у нас замечательное время.
Вы бросаете этот челнок взад и вперед.

308
00:21:11,187 --> 00:21:16,293
И то, что выходит с другой стороны,
это запутанное месиво.

309
00:21:16,393 --> 00:21:19,708
Оно может выглядеть мило,
но у вас есть эта проблема.

310
00:21:19,808 --> 00:21:26,464
В чём проблема?
Проблема в вязаном зАмке. Так?

311
00:21:26,564 --> 00:21:28,064
Преимущества простоты

312
00:21:28,164 --> 00:21:34,370
Какие преимущества
у нас есть от наличия простоты?

313
00:21:34,470 --> 00:21:36,900
Мы получаем легкость понимания.
Это своего рода определение.

314
00:21:37,000 --> 00:21:42,220
Я утверждаю, что мы получаем лёгкость
изменений и более простую отладку.

315
00:21:42,320 --> 00:21:48,864
Из этого вытекают и другие преимущества
на вторичном уровне: повышенная гибкость.

316
00:21:48,964 --> 00:21:51,160
И когда мы будем больше говорить
о модульности и разбиении вещей на части,

317
00:21:51,260 --> 00:21:52,691
мы увидим, к чему это приведёт.

318
00:21:53,993 --> 00:22:00,832
Понравилась возможность менять направление
развития или перемещать вещи, верно?

319
00:22:00,932 --> 00:22:04,142
По мере того, как мы делаем вещи проще,
мы получаем больше независимости от решений,

320
00:22:04,242 --> 00:22:08,893
потому что они не чередуются, поэтому
я могу принять решение о местоположении.

321
00:22:08,993 --> 00:22:12,963
Это ортогонально решению
по поводу производительности.

322
00:22:13,063 --> 00:22:18,411
И я действительно хочу, знаете ли, задать
вопрос, сторонникам agile или как пожелаете:

323
00:22:18,511 --> 00:22:22,735
можно ли, имея тестовый набор
и инструменты для рефакторинга,

324
00:22:22,835 --> 00:22:29,027
внести изменения в вязаный замок
быстрее, чем в замок Лего?

325
00:22:30,072 --> 00:22:33,038
Ни за что.
Это совершенно не связанные вещи.

326
00:22:35,755 --> 00:22:36,528
Делая вещи проще

327
00:22:36,628 --> 00:22:37,842
Так как же нам всё упростить?

328
00:22:37,942 --> 00:22:43,094
Предположительно, суть не в том,
чтобы оплакивать их софтверный кризис, так?

329
00:22:43,194 --> 00:22:44,553
Что мы можем предпринять,
чтобы сделать вещи легче?

330
00:22:44,653 --> 00:22:46,509
Мы посмотрим на те части,
те аспекты, делающие вещи легче.

331
00:22:46,609 --> 00:22:48,588
Есть аспект местоположения.

332
00:22:48,688 --> 00:22:53,236
Держа вещи под рукой, помещая их в наш
инструментарий, это относительно просто.

333
00:22:53,336 --> 00:22:55,533
Мы просто устанавливаем их.

334
00:22:55,633 --> 00:22:57,890
Может это немного сложнее,
потому что нам нужен кто-то,

335
00:22:57,990 --> 00:22:59,469
кто скажет, что можно ими пользоваться.

336
00:22:59,569 --> 00:23:03,948
С другой стороны как мне
сделать что-то знакомым, верно?

337
00:23:04,048 --> 00:23:07,105
Может я никогда не видел этого раньше.
Этому нужно учиться.

338
00:23:07,205 --> 00:23:09,518
Мне приходится идти и брать книгу,
проходить туториал,

339
00:23:09,618 --> 00:23:12,358
просить кого-то объяснить мне.
Может самому попробовать.

340
00:23:12,458 --> 00:23:15,306
Мы проходим через оба аспекта.
Мы проходим.

341
00:23:15,406 --> 00:23:18,942
Мы устанавливаем. Мы изучаем.
Всё в наших руках.

342
00:23:19,042 --> 00:23:24,349
Есть ещё одна сторона — умственные способности.

343
00:23:24,449 --> 00:23:33,961
И о ней всегда сложно разговаривать,
потому что мы можем изучить множество вещей.

344
00:23:34,061 --> 00:23:36,549
На самом деле
мы не станем намного умнее.

345
00:23:36,649 --> 00:23:41,425
Мы не продвигаемся,
мы не продвигаемся в познании сложности.

346
00:23:41,525 --> 00:23:45,415
Чтобы продвинуться в
понимании нам нужно упрощать вещи.

347
00:23:45,515 --> 00:23:50,151
Но правда не в том,
что есть эти крутые, светлые головы,

348
00:23:50,251 --> 00:23:53,715
которые могут делать потрясающие вещи,
где все остальные застревают,

349
00:23:53,815 --> 00:23:57,380
здесь аналогия с жонглированием
очень подходит.

350
00:23:57,480 --> 00:24:00,597
Средний жонглёр может
управляться с тремя мячами.

351
00:24:00,697 --> 00:24:06,400
Самый лучший жонглер в мире управляется
с девятью мячами или с двенадцатью.

352
00:24:06,500 --> 00:24:12,426
Они не справятся с двадцатью или с сотней.
Мы все очень ограничены.

353
00:24:12,526 --> 00:24:15,888
По сравнению со сложностью,
которую мы можем создать,

354
00:24:15,988 --> 00:24:19,938
мы все статистически находимся в одной
точке нашей способности понять это,

355
00:24:20,038 --> 00:24:21,599
что не очень хорошо.

356
00:24:21,699 --> 00:24:24,825
Нам придётся упрощать вещи,
чтобы их понять.

357
00:24:24,925 --> 00:24:28,263
И поскольку мы можем жонглировать небольшим
количеством мячей, вы должны принять решение.

358
00:24:28,363 --> 00:24:32,920
Сколько из этих мячей будут
представлять случайную сложность,

359
00:24:33,020 --> 00:24:35,068
а сколько — сложность вашей проблемы?

360
00:24:35,168 --> 00:24:37,293
Сколько лишних мячей?

361
00:24:37,393 --> 00:24:38,484
Вы хотите, чтобы кто-то бросал вам мячи,

362
00:24:38,584 --> 00:24:39,969
которые вы должны попытаться
включить в вашу программу?

363
00:24:40,069 --> 00:24:41,116
О, используйте этот инструмент.

364
00:24:41,216 --> 00:24:45,894
И вы такие: «вау», понимаете,
«больше вещей». Кто хочет этим заниматься?

365
00:24:45,994 --> 00:24:50,367
Скобки сложны!

366
00:24:50,467 --> 00:24:53,576
Давайте посмотрим правде в глаза.

367
00:24:55,032 --> 00:24:59,391
Я был по другую сторону этого
недовольства и мне это нравится.

368
00:24:59,491 --> 00:25:01,009
Мы можем разобраться с этим очень быстро,

369
00:25:01,109 --> 00:25:06,973
проблемы нет — это утверждение не имеет никакого
отношения к реальному использованию.

370
00:25:07,073 --> 00:25:10,677
Утверждение, что скобки сложны
основано только на опыте программистов.

371
00:25:10,777 --> 00:25:13,058
Итак, скобки сложны. Верно?

372
00:25:13,158 --> 00:25:16,587
Они не под рукой для большинства людей,
которые не использовали их по-другому.

373
00:25:16,687 --> 00:25:22,463
Что это означает? У них нет редактора,
который знает что делать,

374
00:25:22,563 --> 00:25:25,418
понимаете, расставляет скобки
или структурно перемещает блоки,

375
00:25:25,518 --> 00:25:28,642
или у них есть один редактор, но они не запускали
режим, который позволяет это сделать.

376
00:25:28,742 --> 00:25:30,625
Полностью доступно, верно?

377
00:25:30,725 --> 00:25:32,977
Они не под рукой, они не распространены.

378
00:25:33,077 --> 00:25:38,894
В том смысле, что все видели скобки, но
не видели их по другую сторону метода.

379
00:25:43,307 --> 00:25:46,812
Я думаю это безумие!

380
00:25:50,722 --> 00:25:55,772
Но, я полагаю, это ваша ответственность,
исправить эти две вещи,

381
00:25:55,872 --> 00:25:57,851
как пользователь,
как потенциальный пользователь.

382
00:25:57,951 --> 00:26:00,728
Вам придётся сделать это.
Но мы можем копнуть глубже.

383
00:26:00,828 --> 00:26:01,770
Давайте посмотрим на третью вещь.

384
00:26:01,870 --> 00:26:03,823
Действительно ли вы дали
мне что-то простое?

385
00:26:03,923 --> 00:26:07,812
Язык построенный на скобках прост?

386
00:26:07,912 --> 00:26:15,796
Я имею ввиду, свободен ли он от
перемежения и сплетения? Ответ нет. Верно?

387
00:26:15,896 --> 00:26:21,630
Common LISP и Scheme не просты
в этом смысле, в использовании скобок,

388
00:26:21,730 --> 00:26:25,925
они перегружены использованием скобок.

389
00:26:26,025 --> 00:26:31,264
Скобки обрамляют вызовы.
Они обрамляют композиции.

390
00:26:31,364 --> 00:26:33,580
Обрамляют структуры данных.

391
00:26:33,680 --> 00:26:39,628
И эта перегрузка — вид сложности
по умолчанию, как данность. Верно?

392
00:26:39,728 --> 00:26:43,890
И даже если вы действительно побеспокоились
и настроили свой редактор и выучили,

393
00:26:43,990 --> 00:26:50,393
что скобки идут с другой стороны от оператора,
всё ещё это обоснованное недовольство.

394
00:26:50,493 --> 00:26:54,004
Теперь, конечно, все с лёгкостью
говорили, что это трудно,

395
00:26:54,104 --> 00:26:56,134
это сложно, и они использовали
эти слова очень слабо.

396
00:26:56,234 --> 00:26:59,631
Это было трудно по нескольким причинам,
которые можно решить,

397
00:26:59,731 --> 00:27:03,694
и это было не просто
по вине проектировщика языка,

398
00:27:03,794 --> 00:27:05,810
а именно из-за того,
что язык был перегружен скобками.

399
00:27:05,910 --> 00:27:09,592
Мы можем это исправить. Так?
Мы можем добавить ещё одну структуру данных.

400
00:27:09,692 --> 00:27:13,109
От того, что добавится новая структура
данных LISP не перестанет быть LISP'ом.

401
00:27:13,209 --> 00:27:15,841
это всё равно язык определённый в терминах
своих собственных структур данных.

402
00:27:15,941 --> 00:27:20,914
Но имея больше структур данных,
мы можем избавиться от этой перегрузки,

403
00:27:23,154 --> 00:27:28,945
и теперь проблема на ваших плечах,
потому что простота вернулась в конструкцию,

404
00:27:29,045 --> 00:27:32,390
и теперь всё знакомо, всё решаемо.

405
00:27:32,490 --> 00:27:37,541
Лисперы знают ценность всех вещей,
но плату — ни одной. Алан Перлис.

406
00:27:37,641 --> 00:27:46,025
Это был старый подкоп под программистов
на LISP'ах. Я не вполне понимаю о чём он.

407
00:27:46,125 --> 00:27:48,073
Полагаю это что-то связанное
с производительностью.

408
00:27:48,173 --> 00:27:52,053
Лисперы, они съели всю память,
сделали все расчёты,

409
00:27:52,153 --> 00:27:54,155
это было настоящим обжорством.

410
00:27:54,255 --> 00:27:58,960
Лисперы в то время были абсолютными
обжорами по отношению к железу.

411
00:27:59,060 --> 00:28:03,888
Они знали ценность всех этих
объектов, их динамическую природу.

412
00:28:03,988 --> 00:28:09,001
Это всё замечательно. Это ценные вещи,
но была плата производительностью.

413
00:28:09,101 --> 00:28:13,857
Я хотел бы взять всю эту фразу и применить
её ко всем нам прямо сейчас.

414
00:28:13,957 --> 00:28:18,581
Как программисты, мы смотрим на все эти вещи,
и я прямо вижу.

415
00:28:18,681 --> 00:28:20,193
Понимаете, читая Hacker News
или что угодно.

416
00:28:20,293 --> 00:28:22,647
Типа, о, смотрите; за эти вещи
приходится платить. О, отлично.

417
00:28:22,747 --> 00:28:24,176
Я так и собираюсь поступить.

418
00:28:24,276 --> 00:28:29,142
Это здорово. Это прекрасно.
Так короче.

419
00:28:29,242 --> 00:28:35,710
Вы никогда не услышите в разговорах:
был ли компромисс? Есть ли недостатки?

420
00:28:35,810 --> 00:28:37,982
Есть ли что-то плохое,
что приходит вместе с этим?

421
00:28:38,082 --> 00:28:39,249
Никогда. Ничего подобного.

422
00:28:39,349 --> 00:28:41,407
Кажется мы все смотрим только на выгоды.

423
00:28:41,507 --> 00:28:47,858
Как программисты мы все смотрим только на выгоду,
мы не обращаем внимание на побочные продукты.

424
00:28:51,213 --> 00:28:52,797
Что в вашем инструментарии?

425
00:28:52,897 --> 00:29:01,220
У меня есть две колонки. Одна
показывает сложность, вторая — простоту.

426
00:29:01,320 --> 00:29:04,988
Колонка простоты всего лишь
означает, что вещи там попроще.

427
00:29:05,088 --> 00:29:08,400
Это не значит, что в ней
все вещи абсолютно простые.

428
00:29:08,500 --> 00:29:18,112
Я не пометил какие из них плохие,
а какие хорошие. Я оставляю это вам.

429
00:29:21,622 --> 00:29:25,128
Какие вещи сложны, а какие являются
простыми заменами для них?

430
00:29:25,228 --> 00:29:28,145
Я собираюсь в этом разобраться, я не буду
объяснять почему они сложны,

431
00:29:28,245 --> 00:29:30,151
но скажу, что состояния и объекты — сложны,

432
00:29:30,251 --> 00:29:35,866
а значения — просты и могут
заменить их во многих случаях.

433
00:29:35,966 --> 00:29:39,890
Методы — сложны, а функции — просты.

434
00:29:39,990 --> 00:29:41,608
Пространство имён — просто.

435
00:29:41,708 --> 00:29:46,296
Причина по которой методы здесь,
потому что часто пространство методов,

436
00:29:46,396 --> 00:29:52,274
класса или чего угодно является миниатюрным,
очень плохим пространством имен.

437
00:29:52,374 --> 00:30:01,372
Vars сложны и переменные сложны.
Управляемые ссылки тоже сложны, но они проще.

438
00:30:01,472 --> 00:30:07,813
Наследование, switch-утверждения,
паттерн-матчинг они все сложны,

439
00:30:07,913 --> 00:30:11,312
а полиморфизм по запросу прост.

440
00:30:11,412 --> 00:30:14,561
Теперь вспомните суть простоты.

441
00:30:14,661 --> 00:30:21,371
Суть простоты в незапутанности,
в несвязности с чем-либо ещё.

442
00:30:21,471 --> 00:30:23,752
Она не в том, чтобы заранее
знать, что это такое.

443
00:30:23,852 --> 00:30:26,658
Простота не в том, чтобы
заранее знать что это такое.

444
00:30:28,163 --> 00:30:31,151
Синтаксис сложен. Данные просты.

445
00:30:33,835 --> 00:30:37,514
Императивные циклы, даже свёртки,
которые кажутся чем-то вроде высшего уровня,

446
00:30:37,614 --> 00:30:40,365
всё ещё имеют подтекст,
который связывает две вещи вместе,

447
00:30:40,465 --> 00:30:42,589
тогда как набор функций проще.

448
00:30:42,689 --> 00:30:47,021
Акторы сложны, а очереди проще.

449
00:30:47,121 --> 00:30:52,965
ORM сложен, а манипуляция данными
декларативно проще.

450
00:30:53,065 --> 00:31:00,436
Даже Эрик сказал об этом в своей речи.
Сказал очень быстро под конец.

451
00:31:00,536 --> 00:31:06,336
Ах, да, согласованность в конечном счёте
очень трудна для программистов.

452
00:31:07,602 --> 00:31:12,855
Условия сложны определённым образом,
а правила могут быть проще.

453
00:31:15,412 --> 00:31:17,568
Неконсистентность очень сложна.

454
00:31:17,668 --> 00:31:21,684
Это почти определение сложности, потому что
консистентность означает оставаться вместе,

455
00:31:21,784 --> 00:31:24,144
таким образом
неконсистентность значит быть порознь.

456
00:31:24,244 --> 00:31:28,318
Это значит взять разрозненные вещи и
попытаться думать о всех них одновременно.

457
00:31:28,418 --> 00:31:30,964
Это в принципе сложно сделать.

458
00:31:30,964 --> 00:31:32,838
И каждый, кто пытался пользоваться системой,

459
00:31:32,938 --> 00:31:34,345
которая в конечном счёте согласована,
знает об этом.

460
00:31:34,445 --> 00:31:37,651
Сплетение

461
00:31:37,751 --> 00:31:43,627
Ладно. Есть одно клёвое слово,
называется сплетение. Обнаружил его.

462
00:31:43,727 --> 00:31:47,149
Я люблю его. Оно значит перемежаться,
переплетаться или заплетаться.

463
00:31:48,554 --> 00:31:51,952
Я хочу начать разговор о том,
что делает наши программы плохими.

464
00:31:52,052 --> 00:31:54,791
И я не хочу сказать
заплетёнными или переплетёнными,

465
00:31:54,891 --> 00:31:58,473
потому что они не имеют хорошего\плохого
смысла, который есть у сплетения.

466
00:31:58,573 --> 00:32:02,110
Сплетение это очевидно плохо.
Согласны?

467
00:32:02,210 --> 00:32:06,676
Оно считается устаревшим, но нет
запрета на его повторное использование,

468
00:32:06,776 --> 00:32:09,730
так что я собираюсь
его использовать до конца разговора.

469
00:32:09,830 --> 00:32:13,876
Что вы знаете о сплетении?
Это плохо. Не делайте так.

470
00:32:13,976 --> 00:32:20,347
Вот откуда приходит сложность:
сплетённость.

471
00:32:21,106 --> 00:32:22,445
Всё очень просто.

472
00:32:25,477 --> 00:32:28,693
Это то, чего вы должны
избегать в первую очередь.

473
00:32:28,793 --> 00:32:33,568
Посмотрите на эту диаграмму.
Посмотрите на верхнюю. Посмотрите на нижнюю.

474
00:32:33,668 --> 00:32:37,049
Понимаете? На них изображено
одно и то же, в точности.

475
00:32:37,149 --> 00:32:43,829
Те же полоски. Что произошло?
Они переплелись.

476
00:32:43,929 --> 00:32:50,181
И теперь трудно понять нижнюю диаграмму
глядя на верхнюю, но это одно и то же.

477
00:32:50,281 --> 00:32:54,005
Вы делаете так постоянно.
Вы можете создать программу сотней способов.

478
00:32:54,105 --> 00:32:55,605
Некоторые из них изображены здесь.
Здесь все прямые.

479
00:32:55,705 --> 00:33:00,131
Вы смотрите на них.
Говорите, здесь четыре строчки кода. Так?

480
00:33:00,231 --> 00:33:02,231
Затем вы можете написать
четыре строчки на другом языке

481
00:33:02,331 --> 00:33:04,040
или с использованием других конструкций
и, в конце концов,

482
00:33:04,140 --> 00:33:07,974
перед вами этот узел, теперь
вам придётся жить с ним.

483
00:33:08,074 --> 00:33:09,045
Композиция

484
00:33:09,145 --> 00:33:12,170
Итак сплетение означает
скручивание вместе.

485
00:33:12,270 --> 00:33:17,421
А композиция значит размещение вместе.
Нам это известно, так?

486
00:33:17,521 --> 00:33:18,696
Все продолжают объяснять нам это.

487
00:33:18,796 --> 00:33:22,026
Мы хотим создать композиционные системы.
Мы просто хотим поместить вещи вместе,

488
00:33:22,126 --> 00:33:26,073
что замечательно, и
я думаю не будет возражений. Так?

489
00:33:26,173 --> 00:33:30,929
Составление простых компонентов,
простых в этом отношении,

490
00:33:31,029 --> 00:33:33,909
это то, как мы пишем
надежное программное обеспечение.

491
00:33:36,409 --> 00:33:37,245
Модульность и простота

492
00:33:37,345 --> 00:33:41,154
Это просто, верно? Всё,
что нам нужно сделать — все это знают.

493
00:33:41,254 --> 00:33:42,988
Я здесь просто говорю вам,
что вы и так знаете.

494
00:33:43,088 --> 00:33:45,654
Мы создаём простые системы,
делая их модульными, так?

495
00:33:47,524 --> 00:33:49,929
Закончили.
Я где-то на полпути в своей речи.

496
00:33:50,029 --> 00:33:54,956
Я даже не знаю, дойду ли я до конца.
Это так просто. Вот так. В этом вся суть.

497
00:33:56,342 --> 00:34:02,064
Нет, очевидно не в этом суть.
Кто видел компоненты с такими параметрами?

498
00:34:04,407 --> 00:34:08,154
Я подниму свою руку дважды, т.к. недостаточно
людей подняли свои. Это смешно. Верно?

499
00:34:08,254 --> 00:34:08,969
Что происходит?

500
00:34:09,069 --> 00:34:13,028
Вы можете создавать модульный софт
со всеми взаимосвязями между компонентами.

501
00:34:13,128 --> 00:34:17,411
Они могут не вызывать друг друга,
но они полностью переплетены.

502
00:34:20,148 --> 00:34:25,071
Мы знаем как разрешить эту проблему. Она не
имеет никакого отношения к этим двум вещам.

503
00:34:25,171 --> 00:34:28,213
Она имеет отношение к тому,
о чём могут думать эти две вещи,

504
00:34:28,313 --> 00:34:30,341
если вы хотите действительно их очеловечить.

505
00:34:30,441 --> 00:34:34,933
И что мы хотим сделать, чтобы вещи делали
то, что мы хотим и только то, что мы хотим?

506
00:34:36,359 --> 00:34:37,842
Абстракции.

507
00:34:37,942 --> 00:34:43,216
Я не знаю получилось ли хорошо это показать.
Этот пунктирный белый кубик Лего сверху.

508
00:34:43,316 --> 00:34:45,966
Только этим мы хотим их ограничить,

509
00:34:46,066 --> 00:34:48,561
потому что теперь синий не знает
ничего про жёлтого,

510
00:34:48,661 --> 00:34:52,098
а жёлтый — про синего,
и они оба становятся простыми.

511
00:34:54,693 --> 00:34:58,851
Очень важно, чтобы вы не связывали
простоту с разделением и расслоением.

512
00:34:58,951 --> 00:35:02,340
Они не подразумевают этого.
Они активируются благодаря простоте.

513
00:35:02,440 --> 00:35:03,964
Если вы создаёте простые компоненты,

514
00:35:04,064 --> 00:35:09,135
вы можете разделить их
по горизонтали и расслоить по вертикали.

515
00:35:09,235 --> 00:35:14,314
Но вы также можете сделать это со сложными
вещами, и вы не получите никакой выгоды.

516
00:35:14,414 --> 00:35:17,166
И поэтому я бы посоветовал
вам быть особенно осторожными,

517
00:35:17,266 --> 00:35:21,377
чтобы не быть одураченными
организацией кода.

518
00:35:21,477 --> 00:35:26,774
Есть куча библиотек, которые говорят:
смотрите, разные классы, отдельные классы.

519
00:35:26,874 --> 00:35:29,469
Они вызывают друг друга
таким чудесным образом, верно?

520
00:35:29,569 --> 00:35:32,046
Потом вы выходите в поле и
вы такие «о, Господи!»

521
00:35:32,146 --> 00:35:37,863
Эта вещь предполагает, что та вещь никогда
не возвращает число 17. Что это вообще такое?

522
00:35:37,963 --> 00:35:40,010
Состояние никогда не бывает простым.

523
00:35:41,166 --> 00:35:45,197
Я хочу сказать вам, что состояние
это здорово. Я люблю состояние.

524
00:35:45,297 --> 00:35:52,523
Я не функциональный парень. Вместо этого
скажу: у меня было так, и это отстой.

525
00:35:52,623 --> 00:35:57,503
Я годами писал на C++, понимаете,
как супергерой,

526
00:35:57,603 --> 00:35:59,032
программирование с учетом состояния.

527
00:35:59,132 --> 00:36:02,541
Это совсем не весело.
Это не здорово.

528
00:36:03,785 --> 00:36:05,551
Оно никогда не бывает простым.

529
00:36:05,651 --> 00:36:07,668
Наличие состояния в вашей программе
никогда не бывает простым,

530
00:36:07,768 --> 00:36:12,821
потому что оно имеет фундаментальное сплетение,
которое отражается на артефактах.

531
00:36:12,921 --> 00:36:15,320
Оно связывает значение и время.

532
00:36:15,420 --> 00:36:19,566
У вас нет возможности
получить значение в отрыве от времени.

533
00:36:19,666 --> 00:36:24,612
А иногда даже совсем нет возможности
получить значение ни в каком виде.

534
00:36:24,712 --> 00:36:29,248
Но снова, это отличный пример.
Это просто. Оно абсолютно знакомо.

535
00:36:29,348 --> 00:36:35,579
Под рукой. Оно во всех языках программирования.
Это так легко. Эта сложность так проста.

536
00:36:38,301 --> 00:36:39,595
Вы не сможете избавиться от него.

537
00:36:39,695 --> 00:36:43,820
У меня есть модульность. Этот оператор
присваивания находится внутри метода.

538
00:36:43,920 --> 00:36:47,466
Если каждый раз при вызове этого метода
с одними и теми же параметрами,

539
00:36:47,566 --> 00:36:49,547
вы получаете разный результат,
угадайте, что произойдёт?

540
00:36:50,401 --> 00:36:52,425
Эта сложность просто протечёт.

541
00:36:52,525 --> 00:36:54,334
Не важно, что вы не можете
видеть эту переменную.

542
00:36:54,434 --> 00:36:57,374
Если вещь, которая оборачивает
что-то имеет состояние,

543
00:36:57,474 --> 00:36:58,740
и вещь, которая оборачивает что-то ещё,
тоже имеет состояние,

544
00:36:58,840 --> 00:37:01,586
я имею в виду, что каждый раз,
когда вы задаете один и тот же вопрос,

545
00:37:01,686 --> 00:37:06,016
вы получаете разный ответ, у вас
есть эта сложность, и это похоже на яд.

546
00:37:06,116 --> 00:37:11,008
Это все равно, что бросить темное зелье в вазу.

547
00:37:11,108 --> 00:37:12,952
Всё растечётся повсюду.

548
00:37:13,052 --> 00:37:15,265
Единственный раз, когда вы действительно
можете, вы знаете, избавиться от состояния,

549
00:37:15,365 --> 00:37:16,892
это когда вы помещаете его внутрь чего-то,

550
00:37:16,992 --> 00:37:19,971
что способно представить
функциональный интерфейс наружу,

551
00:37:20,071 --> 00:37:22,572
настоящий функциональный интерфейс:
что на входе, то и на выходе.

552
00:37:23,560 --> 00:37:28,573
Вы не можете облегчить работу с состоянием
через обычную организацию кода.

553
00:37:29,698 --> 00:37:32,298
И обратите внимание, в частности,
я не говорил о параллелизме здесь.

554
00:37:32,398 --> 00:37:35,955
Речь не о параллелизме.
Это не имеет ничего общего с параллелизмом.

555
00:37:36,055 --> 00:37:38,728
Речь идет о вашей способности
понимать вашу программу.

556
00:37:38,828 --> 00:37:41,508
Ваша программа с этим сталкивалась.
Она однопоточная. Она не работает.

557
00:37:41,608 --> 00:37:44,675
Все тесты пройдены.
Проверка типов прошла успешно.

558
00:37:44,775 --> 00:37:49,366
Размышляете, что случилось. Если она полна
переменных, с чего вы собираетесь начать?

559
00:37:51,309 --> 00:37:56,011
Воссоздать состояние, которое было на клиенте,
когда все стало плохо.

560
00:37:56,111 --> 00:37:59,759
Это будет легко?
Нет!

561
00:37:59,859 --> 00:38:02,926
Не все ссылки\переменные одинаковые.

562
00:38:03,026 --> 00:38:03,803
Но мы исправим это, так?

563
00:38:03,903 --> 00:38:06,199
Ваш язык, ваш новый,
сияющий язык имеет что-то,

564
00:38:06,299 --> 00:38:10,811
что называется переменной
или в нём есть ссылки.

565
00:38:10,911 --> 00:38:14,472
Ни одна из этих конструкций
не упрощает состояние.

566
00:38:14,572 --> 00:38:16,407
Это во-первых, главная мысль.

567
00:38:16,507 --> 00:38:17,779
Я не хочу сказать так даже
про конструкции в Clojure.

568
00:38:17,879 --> 00:38:20,373
Они не делают состояние простым в том
смысле, о котором я говорю,

569
00:38:20,473 --> 00:38:24,049
по природе простым.
Но они не то же самое, что переменные.

570
00:38:24,149 --> 00:38:26,976
Они предупреждают вас, когда появляется
состояние, и это замечательно.

571
00:38:27,076 --> 00:38:28,999
Большинство людей, использующие язык,

572
00:38:29,099 --> 00:38:31,745
в котором мутабельность
не даётся по умолчанию,

573
00:38:31,845 --> 00:38:33,324
и вы должны приложить все усилия,
чтобы получить её,

574
00:38:33,424 --> 00:38:35,589
обнаруживают, что программы,
которые вы в конечном итоге пишете,

575
00:38:35,689 --> 00:38:39,328
имеют значительно,
на порядки, меньше состояний,

576
00:38:39,428 --> 00:38:40,227
чем в противоположном случае,

577
00:38:40,327 --> 00:38:42,741
потому что программе с самого начала
не нужны все остальные состояния.

578
00:38:42,841 --> 00:38:44,713
Так что это действительно здорово.

579
00:38:44,813 --> 00:38:51,720
Я назову ссылки в Clojure и Haskell как
особенно выдающиеся в решении этого вопроса,

580
00:38:51,820 --> 00:38:54,633
поскольку они компонуют
значения и время.

581
00:38:54,733 --> 00:38:57,334
Есть на самом деле маленькие конструкции,
которые делают две вещи.

582
00:38:57,434 --> 00:39:01,935
У них есть некоторая абстракция над временем
и способность извлекать значения.

583
00:39:03,738 --> 00:39:09,138
Это действительно важно,
потому что это ваш путь обратно к простоте.

584
00:39:09,238 --> 00:39:11,708
Если у меня есть способ выйти
из этой ситуации и получить значение,

585
00:39:11,808 --> 00:39:12,759
я могу продолжить свою программу.

586
00:39:12,859 --> 00:39:15,001
Если мне нужно передать
эту переменную кому-то другому

587
00:39:15,101 --> 00:39:19,171
или ссылку чему-то, что будет находить
переменную каждый раз разными способами,

588
00:39:19,271 --> 00:39:21,353
я отравляю остальную часть моей системы.

589
00:39:21,453 --> 00:39:26,937
Так что посмотрите на переменные в вашем
языке и спросите, делают ли они то же самое.

590
00:39:28,453 --> 00:39:30,708
Сложность инструментария
Давайте посмотрим, почему всё сложно.

591
00:39:30,808 --> 00:39:34,704
Состояние, о котором мы уже говорили.
Оно сплетает всё, к чему прикасается.

592
00:39:34,804 --> 00:39:39,305
Объекты сплетают состояние,
определение и значение.

593
00:39:39,405 --> 00:39:43,259
Они смешивают эти три вещи так,
что вы не можете вытащить части.

594
00:39:44,107 --> 00:39:49,157
Методы сплетают функции и
состояние, верно?

595
00:39:49,257 --> 00:39:52,530
Кроме того, в некоторых языках
они связывают пространства имен.

596
00:39:52,630 --> 00:39:54,470
Отнаследовались от двух вещей в Java,

597
00:39:54,570 --> 00:39:57,364
каждая из которых
имеет метод с одинаковым именем и…

598
00:39:57,804 --> 00:39:59,240
Так не работает.

599
00:39:59,340 --> 00:40:05,864
Синтаксис связывает смысл и порядок
часто в сильно однонаправленном виде.

600
00:40:06,954 --> 00:40:12,288
Профессор Суссман сделал отличное
замечание о данных и синтаксисе,

601
00:40:12,388 --> 00:40:14,594
и это абсолютная правда.

602
00:40:14,694 --> 00:40:18,261
Мне всё равно, насколько сильно вы
любите синтаксис вашего любимого языка.

603
00:40:18,361 --> 00:40:20,746
Он уступает данным во всех отношениях.

604
00:40:20,846 --> 00:40:26,536
Наследование связывает типы.
Эти две вещи связаны.

605
00:40:26,636 --> 00:40:32,006
Вот что это значит: наследование, сплетение.
Это его определение.

606
00:40:32,106 --> 00:40:38,809
Switch-утверждения и матчинг,
они сплетают множество пар,

607
00:40:38,909 --> 00:40:41,700
которые собираются что-то делать
и что происходит

608
00:40:41,800 --> 00:40:47,439
они делают это в одном месте одним способом.
Это очень плохо.

609
00:40:47,539 --> 00:40:53,628
Переменные, опять же, сплетают значения и
время, часто неразрывно,

610
00:40:53,728 --> 00:40:55,287
поэтому вы не можете получить значение.

611
00:40:55,387 --> 00:40:58,773
Вчера во время основного выступления
мы увидели фотографию

612
00:40:58,873 --> 00:41:05,875
этой удивительной памяти, где вы можете
разыменовать ссылку и получить объект.

613
00:41:05,975 --> 00:41:08,576
Я хочу получить один из этих компьютеров.

614
00:41:08,676 --> 00:41:10,952
Вы когда-нибудь использовали
один из этих компьютеров?

615
00:41:11,052 --> 00:41:14,523
Я не могу получить его.
Я позвонил в Apple, и они такие, пфф, нет.

616
00:41:14,623 --> 00:41:15,944
Единственное, что вы можете
получить из адреса ячейки памяти,

617
00:41:16,044 --> 00:41:20,744
это слово, скаляр, то, что все высмеивали.

618
00:41:20,844 --> 00:41:24,995
Восстановление составного объекта по
адресу — это не то, что делают компьютеры,

619
00:41:25,095 --> 00:41:26,838
ни один из тех, что у нас есть.

620
00:41:26,938 --> 00:41:29,424
Переменные имеют ту же проблему.

621
00:41:29,524 --> 00:41:34,633
Вы не можете восстановить составную мутабельную
вещь при помощи одного лишь разыменования.

622
00:41:36,372 --> 00:41:40,894
Циклы и свёртки: циклы довольно
очевидно сплетают то,

623
00:41:40,994 --> 00:41:42,197
что вы делаете и то,
как вы это делаете.

624
00:41:42,297 --> 00:41:44,628
Свёртка немного более утончённая вещь,

625
00:41:44,728 --> 00:41:47,195
потому что кажется, что это хорошо,
что кто-то другой заботится об этом.

626
00:41:47,295 --> 00:41:51,768
Но свёртка подразумевает определенный
порядок вещей, слева направо.

627
00:41:51,868 --> 00:42:00,949
Акторы сплетают то, что будет
сделано и того, кто это делает.

628
00:42:03,263 --> 00:42:06,608
Профессор Суссман сказал, что все
эти разговоры имеют аббревиатуры,

629
00:42:06,708 --> 00:42:08,605
и я не могу изменить свои
слайды во времени,

630
00:42:08,705 --> 00:42:14,235
поэтому объектно-реляционное отображение,
о, Боже мой, сплетение продолжается.

631
00:42:15,030 --> 00:42:18,598
Вы даже не можете начать говорить
о том, как это плохо, верно?

632
00:42:18,698 --> 00:42:25,110
И, вы знаете, если вы собираетесь
использовать принцип двойственности,

633
00:42:25,210 --> 00:42:27,442
какова двойственность у значения?

634
00:42:28,241 --> 00:42:30,740
Это со-значение?
Что такое со-значение?

635
00:42:31,322 --> 00:42:36,777
Это неконсистентная вещь.
Кому это нужно?

636
00:42:36,877 --> 00:42:40,360
Условные операторы, думаю, интересны.
Это своего рода более передовая область.

637
00:42:40,460 --> 00:42:43,390
У нас есть несколько правил о том,
что должны делать наши программы.

638
00:42:43,490 --> 00:42:45,292
Это разбросано по всей программе.

639
00:42:48,610 --> 00:42:49,698
Можем ли мы это исправить,

640
00:42:49,798 --> 00:42:53,966
потому что это сплетено со структурой
программы и устройством программы.

641
00:42:55,393 --> 00:42:58,007
Инструментарий простоты

642
00:42:58,107 --> 00:43:00,454
Хорошо, что если вы запомните
две вещи из этого разговора,

643
00:43:00,554 --> 00:43:04,133
одна из них будет разницей между
словами простота и лёгкость.

644
00:43:04,233 --> 00:43:11,906
Другая, я надеюсь, будет тем фактом, что мы
можем создавать точно такие же программы,

645
00:43:12,006 --> 00:43:15,456
которые мы создаем прямо сейчас,
с помощью этих сложных инструментов

646
00:43:15,556 --> 00:43:19,365
с существенно более
простыми инструментами.

647
00:43:19,465 --> 00:43:22,310
Я писал на C ++ в течение
длительного времени.

648
00:43:22,410 --> 00:43:23,848
Я писал на Java. Писал на C#.

649
00:43:23,948 --> 00:43:27,012
Я знаю, как создавать
большие системы на этих языках,

650
00:43:27,112 --> 00:43:31,088
и я абсолютно уверен,
что вам не нужна вся эта сложность.

651
00:43:31,188 --> 00:43:36,046
Вы можете написать сложную систему
с существенно более простыми инструментами,

652
00:43:36,146 --> 00:43:38,381
что означает, что вы будете
сосредоточены на системе,

653
00:43:38,481 --> 00:43:41,147
на том, что она должна делать,
а не на том месиве,

654
00:43:41,247 --> 00:43:43,703
которое вытекает из конструкций,
которые вы используете.

655
00:43:43,803 --> 00:43:47,678
Так что я бы хотел сказать,
что первый шаг к упрощению жизни

656
00:43:47,778 --> 00:43:49,636
это просто выбрать более простые вещи.

657
00:43:49,736 --> 00:43:53,114
Поэтому, если вам нужны значения,
обычно вы можете их получить.

658
00:43:53,214 --> 00:43:55,051
У большинства языков есть
что-то вроде значений.

659
00:43:55,151 --> 00:44:00,720
Final или val, вы знаете,
давайте объявим что-то иммутабельным.

660
00:44:00,820 --> 00:44:02,941
Вам действительно нужно
найти персистентные коллекции,

661
00:44:03,041 --> 00:44:05,210
потому что во многих языках

662
00:44:05,604 --> 00:44:09,160
сложно получить агрегатные величины
которые являются значениями.

663
00:44:09,260 --> 00:44:11,334
Вы должны найти хорошую библиотеку
для этого или использовать язык,

664
00:44:11,434 --> 00:44:13,342
в котором это используется по умолчанию.

665
00:44:17,580 --> 00:44:19,876
Функции есть в большинстве языков.
Слава Богу.

666
00:44:19,976 --> 00:44:24,599
Если вы не знаете, что они такое,
они как методы без состояния.

667
00:44:24,699 --> 00:44:27,467
Пространства имен — это то, что язык
действительно должен уметь делать и

668
00:44:27,567 --> 00:44:30,814
к сожалению, в большинстве случаев
они сделаны не очень хорошо.

669
00:44:31,387 --> 00:44:34,233
Данные: Прошу вас!
Мы программисты.

670
00:44:34,333 --> 00:44:36,997
Предположительно мы пишем
программы по обработке данных.

671
00:44:37,097 --> 00:44:39,129
Всегда есть программы,
в которых нет данных.

672
00:44:39,229 --> 00:44:43,606
У них есть все эти конструкции, которыми мы
обкладываем данные и помещаем поверх них.

673
00:44:43,706 --> 00:44:45,783
Данные на самом деле очень просты.

674
00:44:45,883 --> 00:44:49,684
Нет какого-то огромного
разнообразия видов данных.

675
00:44:49,784 --> 00:44:53,917
Есть словари. Есть множества.
Есть линейные, последовательные данные.

676
00:44:54,017 --> 00:44:57,174
Существует не так много
других категорий данных.

677
00:44:57,274 --> 00:45:02,066
Мы создаем сотни тысяч вариантов,
не имеющих ничего общего с сутью вещей,

678
00:45:02,166 --> 00:45:05,068
и затрудняем написание программ,
которые манипулируют сутью вещей.

679
00:45:05,168 --> 00:45:10,404
Мы должны просто манипулировать сутью вещей.
Это не сложно. Это проще.

680
00:45:10,504 --> 00:45:12,414
То же самое с коммуникацией.

681
00:45:12,514 --> 00:45:18,821
Разве мы все не рады, что не используем
метод Unix для общения в Интернете?

682
00:45:21,457 --> 00:45:23,311
Любая произвольная командная строка

683
00:45:23,411 --> 00:45:25,511
может быть списком
аргументов для вашей программы,

684
00:45:25,611 --> 00:45:28,204
а любой произвольный набор символов
может быть результатом выполнения.

685
00:45:28,304 --> 00:45:31,233
Давайте все напишем парсеры.

686
00:45:31,333 --> 00:45:35,069
Нет ведь, я имею ввиду, что это проблема.
Это источник сложности.

687
00:45:35,169 --> 00:45:37,131
Мы можем избавиться от неё.
Просто используйте данные.

688
00:45:37,231 --> 00:45:40,332
Я думаю, самая важная вещь,
самая желанная вещь,

689
00:45:40,432 --> 00:45:42,777
только для посвящённых;
это трудно понять,

690
00:45:42,877 --> 00:45:44,172
но, ребята, когда она у вас есть,

691
00:45:44,272 --> 00:45:49,091
ваша жизнь абсолютно, полностью изменится
это полиморфизм по запросу.

692
00:45:49,191 --> 00:45:55,095
Протоколы в Clojure и классы типов в Haskell
и подобные конструкции.

693
00:45:55,195 --> 00:45:59,342
Дают вам возможность самостоятельно сказать — у меня есть структуры данных

694
00:45:59,442 --> 00:46:04,720
у меня есть определения наборов
функций, и я могу соединить их вместе,

695
00:46:04,820 --> 00:46:07,682
это три независимых операции.

696
00:46:07,782 --> 00:46:11,887
Другими словами, генерализация
не связана с чем-то конкретным.

697
00:46:11,987 --> 00:46:13,714
Она доступна по запросу.

698
00:46:13,814 --> 00:46:17,477
Я не знаю множества библиотек для языков,
в которых с этим проблемы.

699
00:46:17,577 --> 00:46:19,930
Я уже говорил об управлении
ссылками и о том, как их получить.

700
00:46:20,030 --> 00:46:24,096
Может быть, вы можете использовать
замыкания из разных языков платформы Java.

701
00:46:24,196 --> 00:46:25,397
Функции для работы с множестом
вы можете получить из библиотек.

702
00:46:25,497 --> 00:46:29,880
Очереди можно получить из библиотек.
Вам не нужен специальный язык общения.

703
00:46:29,980 --> 00:46:33,387
Наконец, вы можете получить декларативное
манипулирование данными с помощью SQL

704
00:46:33,487 --> 00:46:36,064
или изучения SQL, наконец-то уже.

705
00:46:36,164 --> 00:46:40,575
Или чего-то вроде LINQ или
чего-то вроде Datalog.

706
00:46:40,675 --> 00:46:43,149
Я думаю, что эти последние
пару вещей сложнее.

707
00:46:43,249 --> 00:46:45,542
Думаю, в настоящее время у нас
не так много способов

708
00:46:45,642 --> 00:46:47,552
хорошо интегрировать их в наши языки.

709
00:46:48,298 --> 00:46:50,496
LINQ — попытка сделать это.

710
00:46:50,596 --> 00:46:53,939
Правила, системы декларативных
правил, вместо того, чтобы

711
00:46:54,039 --> 00:46:56,821
встраивать кучу условных
выражений непосредственно

712
00:46:56,921 --> 00:46:59,332
в наш язык в каждой точке
принятия решения,

713
00:46:59,432 --> 00:47:02,974
было бы здорово собрать эти вещи
и поместить в какое-то одно место.

714
00:47:03,074 --> 00:47:05,282
Вы можете получить системы
правил из библиотек,

715
00:47:05,382 --> 00:47:07,024
или вы можете использовать
такие языки, как Prolog.

716
00:47:07,124 --> 00:47:10,642
Если вы хотите консистентности,
вам нужно использовать транзакции,

717
00:47:10,742 --> 00:47:12,237
и вам нужно использовать значения.

718
00:47:13,149 --> 00:47:16,413
Есть причины, по которым вам, возможно,
придётся выйти из этого списка,

719
00:47:16,513 --> 00:47:19,751
но, ребята, нет никаких причин,
по которым вы не должны начинать с него.

720
00:47:19,851 --> 00:47:23,710
Сложность окружения

721
00:47:23,810 --> 00:47:25,562
Есть источник сложности,
с которым действительно трудно иметь дело,

722
00:47:25,662 --> 00:47:27,842
и не по вашей вине.

723
00:47:27,942 --> 00:47:30,415
Я называю это сложностью окружения.

724
00:47:30,515 --> 00:47:33,467
Наши программы в конечном итоге работают
на машинах рядом с другими программами,

725
00:47:33,567 --> 00:47:39,475
рядом с другими частями самих себя,
и они соперничают;

726
00:47:39,575 --> 00:47:43,188
они соперничают за ресурсы:
память, такты процессора и тому подобное.

727
00:47:43,288 --> 00:47:46,771
Все борются за ресурсы.
Это врождённая сложность.

728
00:47:46,871 --> 00:47:49,902
Врождённая это по-латыни значит
«не по вашей вине».

729
00:47:51,297 --> 00:47:54,107
В области реализации и,
нет, это не является частью проблемы,

730
00:47:54,207 --> 00:47:56,205
но является частью реализации.

731
00:47:56,305 --> 00:47:57,753
Вы не можете вернуться к
клиенту и сказать,

732
00:47:57,853 --> 00:47:59,952
что то, что он хотел, не очень хорошо,

733
00:48:00,052 --> 00:48:02,610
потому что у меня проблемы с GC
(Garbage Collector / сборщик мусора).

734
00:48:02,710 --> 00:48:05,777
Но проблемы с GC и тому подобное,
они вступают в игру.

735
00:48:05,877 --> 00:48:08,883
Там не так много хороших решений.
Вы можете использовать сегментацию.

736
00:48:08,983 --> 00:48:10,914
Вы можете сказать, что это ваша память,
это ваша память, это ваша память,

737
00:48:11,014 --> 00:48:13,450
это ваш процессор, а это ваш процессор.

738
00:48:13,550 --> 00:48:16,906
Это огромная растрата, верно,
потому что вы заранее аллоцируете ресурсы.

739
00:48:17,006 --> 00:48:19,603
Вы не используете все возможности.
У вас нет динамической природы.

740
00:48:19,703 --> 00:48:22,029
Но проблема, с которой, я думаю,
мы сталкиваемся,

741
00:48:22,129 --> 00:48:23,741
и на данный момент у меня
нет решения, состоит в том,

742
00:48:23,841 --> 00:48:27,907
что решения вокруг этих
вещей не сочетаются.

743
00:48:28,007 --> 00:48:30,757
Если все скажут:
«Я просто установлю свой пул потоков,

744
00:48:30,857 --> 00:48:33,272
чтобы он был такого-то размера»,
вы знаете, конечно.

745
00:48:33,372 --> 00:48:35,258
Сколько раз вы можете
сделать это в одной программе?

746
00:48:36,459 --> 00:48:39,141
Не много, чтобы она всё еще работала.

747
00:48:39,241 --> 00:48:44,448
Так что, к сожалению, многие подобные вещи,
разбивая вашу программу на части

748
00:48:44,548 --> 00:48:48,840
и принимая индивидуальные решения,
на самом деле не делают вещи проще.

749
00:48:48,940 --> 00:48:53,039
Они усложняют ситуацию, потому что
это решение должно приниматься кем-то,

750
00:48:53,139 --> 00:48:54,936
кто обладает лучшей информацией.

751
00:48:55,036 --> 00:48:58,037
И я не думаю, что у нас
есть много хороших источников

752
00:48:58,137 --> 00:49:02,812
для организации этих решений
в отдельных местах в наших системах.

753
00:49:02,912 --> 00:49:10,078
Программирование, лишенное всех его существенных
несоответствий сводится, не больше и не меньше,
к очень эффективному мышлению и избеганию
неуправляемой сложности, к очень сильному
разделению ваших многочисленных проблем.

754
00:49:10,490 --> 00:49:12,708
Это длиннющая цитата.
В целом в ней говорится, что

755
00:49:12,808 --> 00:49:16,487
программирование это не про печатание.
Оно про размышления.

756
00:49:16,587 --> 00:49:18,695
Дальше пойдём быстрее.

757
00:49:18,895 --> 00:49:22,828
Абстракция для простоты
Как мы проектируем простые вещи для себя?

758
00:49:22,928 --> 00:49:26,252
Итак, первая часть упрощения состоит в том,
чтобы просто выбрать конструкции,

759
00:49:26,352 --> 00:49:28,263
которые имеют простые производные объекты.

760
00:49:28,363 --> 00:49:30,201
Но иногда нам приходится
писать собственные конструкции,

761
00:49:30,301 --> 00:49:32,580
так как же абстрагироваться,
чтобы сделать вещи проще?

762
00:49:33,565 --> 00:49:37,570
Абстракция, ещё раз, вот реальное
определение, а не выдуманное.

763
00:49:37,670 --> 00:49:43,122
Это значит что-то утаить. И, в частности,
утаить от физической природы чего-либо.

764
00:49:44,250 --> 00:49:47,223
Я хочу, чтобы мы видели отличие
от того, что иногда

765
00:49:47,323 --> 00:49:50,762
люди используют термин очень грубо,
просто имея ввиду «скрывать вещи».

766
00:49:50,862 --> 00:49:55,345
Это не абстракция,
и это определение не поможет вам.

767
00:49:56,014 --> 00:50:00,472
Есть два — вы знаете, я не могу
полностью объяснить, как это делается.

768
00:50:00,572 --> 00:50:03,364
Это действительно работа по
проектированию, но один из подходов,

769
00:50:03,464 --> 00:50:05,646
который вы можете использовать:
кто, что, когда, где, почему и как.

770
00:50:05,746 --> 00:50:08,601
Если вы просто пройдёте через всё это
и посмотрите на всё,

771
00:50:08,701 --> 00:50:11,597
что вы хотите сделать, и скажете:
«Что есть аспект кого? Что есть аспект чего?»

772
00:50:11,697 --> 00:50:14,530
Это может помочь вам разбить
программу на части.

773
00:50:14,630 --> 00:50:18,116
Другое дело — поддерживать
такой подход, который гласит:

774
00:50:18,216 --> 00:50:20,347
«Я не знаю, я не хочу знать».

775
00:50:20,447 --> 00:50:24,577
Однажды я так и сказал во время курса C++,
который я преподавал,

776
00:50:24,677 --> 00:50:26,177
один из студентов сделал мне рубашку.

777
00:50:27,852 --> 00:50:32,981
Это была диаграмма Буча,
потому что у нас не было униформы тогда.

778
00:50:33,081 --> 00:50:35,163
И каждая строчка
только об этом и говорила.

779
00:50:35,263 --> 00:50:38,687
Это то, что вы хотите сделать.
Вы действительно просто не хотите знать.

780
00:50:38,787 --> 00:50:44,384
Итак что есть «что»? Что значит операция?
Что означает «чего мы хотим достичь?»

781
00:50:44,484 --> 00:50:49,481
Мы собираемся создавать абстракции,
беря функции и, в частности,

782
00:50:49,581 --> 00:50:51,834
наборы функций и присваивая им имена.

783
00:50:51,934 --> 00:50:55,952
В частности — вы собираетесь использовать
то, что позволяет использовать ваш язык.

784
00:50:56,052 --> 00:50:59,504
Если у вас есть только интерфейсы,
вы будете использовать их.

785
00:50:59,604 --> 00:51:03,377
Если у вас есть протоколы или
классы типов, вы будете использовать их.

786
00:51:03,477 --> 00:51:05,433
Все эти вещи находятся в категории вещей,

787
00:51:05,533 --> 00:51:09,055
которые вы используете для создания
наборов функций, которые будут абстракциями.

788
00:51:09,155 --> 00:51:11,656
И это действительно
наборы спецификаций функций.

789
00:51:11,756 --> 00:51:16,065
Сегодня я хотел бы подчеркнуть,
что они должны быть очень маленькими,

790
00:51:16,165 --> 00:51:19,341
намного меньше, чем мы обычно видим.

791
00:51:19,441 --> 00:51:23,319
Интерфейсы в Java громадны,
и причина их громадности в том,

792
00:51:23,419 --> 00:51:26,225
что в Java нет объединяющих типов,
поэтому неудобно говорить,

793
00:51:26,325 --> 00:51:30,796
что эта функция принимает, вы знаете,
что-то, что делает то и то и это.

794
00:51:30,896 --> 00:51:34,379
Вы должны сделать этот и тот и тот интерфейсы,
поэтому мы видим эти гигантские интерфейсы.

795
00:51:34,479 --> 00:51:36,941
И с этими гигантскими
интерфейсами, дело в том,

796
00:51:37,041 --> 00:51:39,276
что разбить программы намного сложнее,

797
00:51:39,376 --> 00:51:42,710
поэтому вы будете представлять их
с помощью своих полиморфных конструкций.

798
00:51:42,810 --> 00:51:45,332
Это спецификации, верно?

799
00:51:45,432 --> 00:51:47,296
Они на самом деле не реализации.

800
00:51:47,396 --> 00:51:51,749
Они должны использовать только значения
и другие абстракции в своих определениях.

801
00:51:51,849 --> 00:51:54,880
Итак, вы собираетесь определить
интерфейсы или классы типов,

802
00:51:54,980 --> 00:51:59,923
которые принимают только интерфейсы и
классы типов или значения и возвращают их.

803
00:52:00,023 --> 00:52:02,413
И самая большая проблема,
с которой вы сталкиваетесь,

804
00:52:02,513 --> 00:52:04,331
если вы сплетаетесь с «как».

805
00:52:04,431 --> 00:52:07,402
Вы можете сплестись с «как»
заклинивая их вместе, говоря,

806
00:52:07,502 --> 00:52:10,068
что это просто конкретная
функция вместо интерфейса,

807
00:52:10,168 --> 00:52:12,427
или вот конкретный класс
вместо интерфейса.

808
00:52:12,527 --> 00:52:17,492
Также вы можете сплестись с «как»
более тонко, добавляя семантику функции,

809
00:52:17,592 --> 00:52:22,127
диктующую как это должно быть сделано.
Свёртка является примером этого.

810
00:52:25,397 --> 00:52:27,746
Строгое разделение «что» и «как»
является ключом

811
00:52:27,846 --> 00:52:30,007
к перекладыванию проблемы
«как» на кого-то ещё.

812
00:52:30,107 --> 00:52:34,590
Если вы сделали это очень хорошо, вы можете
переложить проблему «как» на чужие плечи.

813
00:52:34,690 --> 00:52:37,432
Вы можете сказать: движок базы данных,
вы придумали «как» его сделать

814
00:52:37,532 --> 00:52:39,287
или логический движок, вы придумали
«как» использовать его для поиска.

815
00:52:39,387 --> 00:52:40,974
Мне не нужно этого знать.

816
00:52:41,727 --> 00:52:45,991
«Кто» это про данные или сущности. Это то,
чем наши абстракции будут соединены,

817
00:52:46,091 --> 00:52:48,329
чтобы в конце концов зависеть от того,
как ваши технологии работают.

818
00:52:48,429 --> 00:52:53,543
Вы хотите создать компоненты
из подкомпонентов в стиле прямых инъекций.

819
00:52:53,643 --> 00:52:55,926
Вы не хотите, например,
жестко связывать подкомпоненты.

820
00:52:56,026 --> 00:52:59,179
Вы хотите, насколько это возможно,
использовать их в качестве аргументов,

821
00:52:59,279 --> 00:53:03,670
потому что это даст вам большую программную
гибкость в том, как вы строите системы.

822
00:53:04,699 --> 00:53:07,360
Вероятно, у вас должно быть
гораздо больше подкомпонентов, чем есть,

823
00:53:07,460 --> 00:53:10,138
поэтому нужно гораздо
меньше интерфейсов, чем у вас есть,

824
00:53:10,238 --> 00:53:12,334
и вы хотите иметь больше подкомпонентов,
чем обычно,

825
00:53:12,434 --> 00:53:14,206
потому что обычно у вас их нет.

826
00:53:14,306 --> 00:53:15,753
А потом, может быть,
у вас есть один подкомпонент,

827
00:53:15,853 --> 00:53:17,424
когда вы решите, о, мне нужно отдать
на откуп направление развития.

828
00:53:17,524 --> 00:53:20,525
Если вы говорите, что это работа, и я выполнил:
«кто», «что», «когда», «где», «почему»,

829
00:53:20,625 --> 00:53:23,655
и нашел пять компонентов,
не расстраивайтесь.

830
00:53:23,755 --> 00:53:27,035
Это отлично.
Вы сильно от этого выиграли.

831
00:53:27,807 --> 00:53:29,984
Вы знаете, разделите
направление развития и прочие вещи.

832
00:53:30,084 --> 00:53:35,165
И то, о чем вы должны быть предупреждены,
когда строите систему,

833
00:53:35,265 --> 00:53:38,523
обозначение вещей, начиная с подкомпонентов
— это любая из таких вещей — 834
00:53:38,623 --> 00:53:41,195
работая с жёлтым, думая о синем,
работая с синим, думая о жёлтом,

835
00:53:41,295 --> 00:53:46,046
скрытые зависимости деталей это то,
чего вам нужно избегать.

836
00:53:46,146 --> 00:53:48,868
Как происходят события,
это фактически код реализации,

837
00:53:48,968 --> 00:53:50,815
работа по выполнению операций.

838
00:53:50,915 --> 00:53:55,570
Вы хотите точно соединить эти вещи вместе,
используя полиморфные конструкции.

839
00:53:55,670 --> 00:53:57,386
Это самая мощная вещь.

840
00:53:57,486 --> 00:53:59,155
Да, вы можете использовать
switch-утверждения.

841
00:53:59,255 --> 00:54:01,949
Вы можете использовать паттерн-матчинг.
Но всё это сбивает с толку.

842
00:54:02,049 --> 00:54:06,783
Если вы используете одну из этих систем,
у вас есть политика в сторону полиморфизма,

843
00:54:06,883 --> 00:54:11,789
и это действительно сильно,
особенно если это рантайм-полиморфизм.

844
00:54:11,889 --> 00:54:14,238
Но даже если это не так,
это лучше, чем ничего.

845
00:54:15,810 --> 00:54:20,151
И снова, остерегайтесь абстракций,
которые каким-то изощренным образом

846
00:54:20,251 --> 00:54:22,536
диктуют как должно быть,
потому что, если это так,

847
00:54:22,636 --> 00:54:25,204
то вы пригвождаете человека,
который работает над реализацией.

848
00:54:25,253 --> 00:54:26,474
Вы связываете ему руки.

849
00:54:26,574 --> 00:54:30,156
Таким образом, чем более декларативные
вещи, тем лучше они работают.

850
00:54:30,256 --> 00:54:34,176
«Как» это что-то вроде фундамента,
верно?

851
00:54:34,276 --> 00:54:35,158
Не смешивайте «как» ни с чем другим.

852
00:54:35,258 --> 00:54:39,585
Все эти реализации должны быть
как можно более обособленными.

853
00:54:40,117 --> 00:54:46,776
Когда и где, это довольно просто. Я думаю,
что вы просто должны избегать этого.

854
00:54:46,876 --> 00:54:52,540
Я вижу, что это случайно происходит,
в основном,

855
00:54:52,640 --> 00:54:54,140
когда люди проектируют системы
с напрямую связанными объектами.

856
00:54:54,240 --> 00:54:57,683
Так что, если вы знаете,
что ваша программа спроектирована так,

857
00:54:57,783 --> 00:55:00,630
что эта штука имеет дело с
операциями ввода,

858
00:55:00,730 --> 00:55:03,443
а затем эта штука должна
выполнить следующую часть работы.

859
00:55:03,543 --> 00:55:09,358
Ну, если А вызывает Б,
вы просто их сплели. Правильно?

860
00:55:09,458 --> 00:55:14,436
И теперь у вас появляются «когда» и «где»,
потому что теперь A должна знать «где» Б

861
00:55:14,536 --> 00:55:19,602
и когда это происходит,
всякий раз A делает это.

862
00:55:20,583 --> 00:55:24,674
Воткните очередь (queue) туда. Очереди — способ избавиться от этой проблемы.

863
00:55:24,774 --> 00:55:27,976
Если вы не используете очереди широко,
вам следует.

864
00:55:28,076 --> 00:55:32,074
Вы должны начать прямо сейчас,
сразу после этого разговора.

865
00:55:32,174 --> 00:55:35,754
И затем есть часть «почему».
Это своего рода политика и правила.

866
00:55:35,854 --> 00:55:41,815
Я думаю, что это трудно для нас. Мы обычно
помещаем такие вещи по всему приложению.

867
00:55:41,915 --> 00:55:44,591
Теперь, если вам когда-нибудь
придётся поговорить с клиентом о том,

868
00:55:44,691 --> 00:55:49,102
что делает приложение, очень трудно сидеть
с ним в исходном коде и смотреть на него.

869
00:55:49,202 --> 00:55:51,636
Теперь, если у вас есть
одна из этих систем тестирования,

870
00:55:51,736 --> 00:55:54,112
которая позволяет вам писать английские
строки, чтобы клиент мог на них взглянуть,

871
00:55:54,212 --> 00:55:55,577
это просто глупо.

872
00:55:55,677 --> 00:55:57,960
У вас должен быть код,
который выполняет ту работу,

873
00:55:58,060 --> 00:55:59,046
на которую кто-то может взглянуть,

874
00:55:59,146 --> 00:56:03,315
а это значит попытаться, вы знаете,
выложить этот материал куда-то наружу.

875
00:56:03,415 --> 00:56:05,543
Попробуйте найти декларативную систему
или систему правил,

876
00:56:05,643 --> 00:56:07,296
которая позволит вам выполнять
эту работу.

877
00:56:07,396 --> 00:56:11,982
Последняя часть это информация:
она проста.

878
00:56:12,082 --> 00:56:17,092
Единственное, что вы можете сделать
с информацией, это разрушить ее.

879
00:56:17,192 --> 00:56:20,571
Не делайте этого! Правильно?
Не делайте этого.

880
00:56:20,671 --> 00:56:22,465
Я имею в виду, у нас есть объекты.

881
00:56:22,565 --> 00:56:25,083
Объекты были созданы для
инкапсуляции устройств ввода-вывода,

882
00:56:25,183 --> 00:56:27,652
есть монитор, но я не могу, например,
прикоснуться к монитору,

883
00:56:27,752 --> 00:56:28,827
поэтому у меня есть объект.

884
00:56:28,927 --> 00:56:30,789
Мышь. Я не могу коснуться мыши,
поэтому есть объект.

885
00:56:30,889 --> 00:56:32,724
Это всё, для чего они хороши.

886
00:56:32,824 --> 00:56:35,134
Они никогда не должны были
применяться к информации.

887
00:56:35,234 --> 00:56:38,188
А мы применяем их к информации,
это просто неправильно.

888
00:56:38,288 --> 00:56:41,643
Это не правильно. Но теперь я могу
назвать причину, почему это неправильно.

889
00:56:41,743 --> 00:56:43,995
Это неправильно, потому что это сложно.

890
00:56:44,900 --> 00:56:47,769
В частности, это разрушает
вашу способность

891
00:56:47,869 --> 00:56:49,893
создавать обобщённые штуки для
манипулирования данными.

892
00:56:49,993 --> 00:56:54,902
Если вы оставите данные в покое,
вы сможете создавать вещи,

893
00:56:55,002 --> 00:56:58,337
которые будут манипулировать данными, и
вы сможете использовать их повсеместно,

894
00:56:58,437 --> 00:57:00,557
и как только вы узнаёте, что они корректны,
ваша работа окончена.

895
00:57:00,657 --> 00:57:03,410
Другая вещь, которая тоже
относится к ORM, заключается в том,

896
00:57:03,510 --> 00:57:05,602
что она связывает вашу логику
с репрезентативными вещами,

897
00:57:05,702 --> 00:57:08,815
которые снова связывают,
сплетают, перемежают.

898
00:57:08,915 --> 00:57:11,415
Так что представляйте данные как данные.

899
00:57:11,515 --> 00:57:13,927
Пожалуйста, начните использовать
словари и множества напрямую.

900
00:57:14,027 --> 00:57:17,794
Не думайте, что должны создать новый класс,
потому что у вас есть новая информация.

901
00:57:17,894 --> 00:57:19,167
Это просто глупо.

902
00:57:19,267 --> 00:57:24,898
Простота не является целью в искусстве, но человек,
достигший простоты, понимает реальный смысл вещей.

903
00:57:24,998 --> 00:57:28,257
Последний пункт, мы выбираем простые
инструменты. Мы пишем простые вещи.

904
00:57:28,357 --> 00:57:30,265
И тогда иногда мы должны
упростить чужие вещи.

905
00:57:30,365 --> 00:57:33,997
В частности, нам, возможно, придётся
упростить проблемное место в коде

906
00:57:34,097 --> 00:57:35,910
или какой-то код,
который кто-то написал.

907
00:57:36,010 --> 00:57:39,039
Это тема для отдельного разговора,
в которую я сейчас не буду вдаваться.

908
00:57:39,139 --> 00:57:42,978
Но работа по сути похожа
на распутывание, верно?

909
00:57:43,078 --> 00:57:46,107
Мы знаем что это сложно.
Код запутанный.

910
00:57:46,207 --> 00:57:49,865
Так что нам нужно сделать?
Нам нужно как-то распутать его.

911
00:57:49,965 --> 00:57:55,592
Вам придётся пройти через это. Вам нужно
сначала выяснить, куда он тянется.

912
00:57:55,692 --> 00:58:01,585
Вы должны будете проследить за всем вокруг
и в конечном счете пометить всё.

913
00:58:01,685 --> 00:58:04,906
Это начало. Это примерно
то, на что похож этот процесс.

914
00:58:05,006 --> 00:58:09,184
Но опять же, это отдельный разговор, чтобы
попытаться поговорить об упрощении.

915
00:58:09,284 --> 00:58:12,991
Хорошо, я собираюсь завершить
парой слайдов.

916
00:58:13,916 --> 00:58:16,136
Суть заключается в простоте выбора.

917
00:58:16,236 --> 00:58:18,979
Это ваша вина, если у вас
нет простой системы.

918
00:58:19,079 --> 00:58:22,875
И я думаю, что у нас есть
культура сложности.

919
00:58:22,975 --> 00:58:25,144
В той степени, в которой мы все
продолжаем использовать эти инструменты,

920
00:58:25,244 --> 00:58:28,193
которые имеют сложные результаты,
мы просто в колее.

921
00:58:28,293 --> 00:58:31,885
Мы просто закапываемся глубже.
И мы должны выбраться из этой колеи.

922
00:58:31,985 --> 00:58:33,397
Но опять же, как я уже сказал,
если вы уже говорите:

923
00:58:33,497 --> 00:58:36,266
«Я знаю это. Я верю вам.
Я уже использую что-то получше.

924
00:58:36,366 --> 00:58:37,956
Я уже использовал весь этот
правый столбец»,

925
00:58:38,056 --> 00:58:42,708
тогда, надеюсь, этот разговор даст вам основу
для разговора с кем-то, кто не верит вам.

926
00:58:42,808 --> 00:58:47,978
Поговорим о простоте против сложности.
Придётся выбирать.

927
00:58:48,078 --> 00:58:50,226
Потребуется постоянная бдительность.

928
00:58:50,326 --> 00:58:52,619
Мы уже видели, что защитные
ограждения не дают простоты.

929
00:58:52,719 --> 00:58:53,970
Они действительно не помогают
нам в этом.

930
00:58:56,065 --> 00:58:57,865
Потребуется чувствительность и
осторожность.

931
00:58:57,965 --> 00:59:01,972
Ваши ощущения, что простота равна
легкости использования, не верны.

932
00:59:02,072 --> 00:59:05,519
Они просто не верны. Правильно? Мы
увидели определения простоты и лёгкости.

933
00:59:05,619 --> 00:59:09,953
Это совершенно разные вещи.
Легко не значит просто.

934
00:59:10,053 --> 00:59:14,127
Вы должны начать развивать
чувствительность вокруг запутанности.

935
00:59:14,355 --> 00:59:17,026
Это то, что вы должны иметь — иметь радар по обнаружению запутанности.

936
00:59:17,126 --> 00:59:19,226
Вам будет достаточно взглянуть на
какое-нибудь ПО и сказать:

937
00:59:19,326 --> 00:59:22,186
Эй! Знаете, сказать не то, что вам не
нравятся имена, которые в нём использовали,

938
00:59:22,286 --> 00:59:26,304
форма кода или отсутствие точки с запятой.
Это тоже важно.

939
00:59:26,404 --> 00:59:29,262
Но вы начнёте видеть сплетения.

940
00:59:29,362 --> 00:59:31,953
Вы будете видеть взаимосвязи между вещами,
которые могли бы быть независимыми.

941
00:59:32,053 --> 00:59:34,435
Вот где вы получите
наибольшую производительность.

942
00:59:34,535 --> 00:59:39,750
Все инструменты надёжности, которые
у вас есть, они не о простоте,

943
00:59:39,850 --> 00:59:42,092
они все вторичны.

944
00:59:43,009 --> 00:59:51,966
Они просто не касаются сути этой проблемы.
Это защитные сети, но не более того.

945
00:59:52,066 --> 00:59:57,169
Итак, как нам сделать простоту легкой?

946
00:59:57,269 --> 01:00:03,908
Мы собираемся выбрать конструкции
с более простыми артефактами,

947
01:00:04,008 --> 01:00:07,310
и избегать конструкций,
которые имеют сложные артефакты.

948
01:00:07,410 --> 01:00:11,664
Это артефакты.
Это не авторская работа.

949
01:00:11,764 --> 01:00:14,820
Как только вы вступите в спор с кем-то,
что мы должны использовать то-то...,

950
01:00:14,920 --> 01:00:19,592
разобраться с этим потому что…
Они думают, что форма кода

951
01:00:19,692 --> 01:00:25,336
который они пишут, не зависит от этих добавок.
Вам с этим придётся жить.

952
01:00:25,436 --> 01:00:28,846
Мы попытаемся создать абстракции,
основанные на простоте.

953
01:00:28,946 --> 01:00:36,405
Мы собираемся потратить немного времени
на упрощение, прежде чем начнём.

954
01:00:36,505 --> 01:00:41,819
И осознаем что, когда мы упрощаем вещи,
мы часто получаем больше вещей.

955
01:00:41,919 --> 01:00:44,545
Простота не в том, чтобы считать.

956
01:00:44,645 --> 01:00:48,856
Я бы предпочёл, чтобы больше вещей
было подвешено красиво, прямо,

957
01:00:48,956 --> 01:00:53,946
не скрученных вместе,
чем просто пара вещей, связанных узлом.

958
01:00:54,046 --> 01:00:56,750
И прекрасный факт про
хранение вещей раздельно — 959
01:00:56,850 --> 01:00:58,566
у вас будет гораздо больше возможностей
по их изменению,

960
01:00:58,666 --> 01:01:00,946
и я думаю, что в этом
и есть преимущества.

961
01:01:01,046 --> 01:01:09,298
Считаю, что это важный момент, и надеюсь,
что каждый сможет применить это на практике

962
01:01:09,398 --> 01:01:13,280
или использовать как инструмент,
чтобы убедить кого-то другого сделать это.

963
01:01:13,380 --> 01:01:16,503
Простота есть высочайшая сложность.

964
01:01:16,603 --> 01:01:21,817
Скажите это, когда кто-то попытается
продать вам сложную систему типов.

965
01:01:22,214 --> 01:01:26,051
Автор перевода и субтитров:
Константин Проскурня — t.me/ProsWeb
AdBlock has stolen the banner, but banners are not teeth — they will be back

More
Ads

Comments 1

    +1

    Спасибо, это очень важный перевод!
    Как в начале говорит Рич Хикки — обманчиво простой.

    Only users with full accounts can post comments. Log in, please.