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

Жертвам «слабой памяти» посвящается.

Заодно узнаете как можно вести разработку на Java хоть в чистом поле — в самолете, в поезде или на закрытом объекте, без подключения к интернету и документации.

Видео

На этот раз для большего угара помимо статьи было записано и видео, где показан весь процесс «полевой разработки» на Java, с одним только JDK:

Также ролик можно посмотреть на VK Video и Youtube.

Тестовое окружение

Для большей чистоты эксперимента был взят Live-образ Ubuntu Desktop 24.04.3 LTS, записан на флешку, флешка вставлена в один из рабочих ноутбуков, который затем с нее был загружен.

Таким образом получилась абсолютно чистая система, без средств разработки и с отключенной сетью.

Из инструментов у нас будет лишь текстовый редактор и JDK.

И все.

Что будем писать

Самое простое что можно написать в таких полевых условиях — реверс-шелл HTTP-сервер. На самом деле написать можно много чего, особенно если посмотреть в каталог demo внутри OpenJDK:

Здесь и далее скриншоты из другой системы (Manjaro), чтобы не заморачиваться с их перебрасыванием из Live-системы и добавлением в статью. Тем не менее на видео все описываемые в статье шаги и весь код вбиваются каноничным способом — полностью вручную, на чистой системе, загруженной с Live USB.

Демо

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

Так выглядит демо-проект Notepad, реализующий простейший текстовый редактор:

Так выглядит демо Metalworks, с простейшей реализацией мульти-оконной системы (MDI):

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

Все демо-проекты содержат исходный код в архивах src.zip и собираются без внешних зависимостей.

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

Ручная разработка

В ролике в записи показано как автор последовательно вводит и запускает в работу примерно такой код:

// разумеется я не помню названий абсолютно всех
// импортируемых классов, поэтому тут стоит '*'
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class MyWebServer {

static void handle(Socket s) {
// метод getId() устарел, поэтому его использование в
// последних версиях JDK выдает предупреждение
System.out.println("Thread: %d"
.formatted(Thread.currentThread().getId()));

// самое сложное место, которое удалось повторить на записи
// далеко не с первой попытки
try(PrintWriter out = new PrintWriter(s.getOutputStream());
BufferedReader in = new BufferedReader(
new InputStreamReader(s.getInputStream()));) {
// поскольку используется чтение и запись строк а не байт - читаем
// строку целиком, т.е. до символа \n
String l = in.readLine();
// тут просто показываем в консоль
System.out.println(l);
// этим простым способом читаем только строку запроса,
// которая идет первой, пропустив все заголовки
// \r\n (пустая строка) - признак завершения запроса
while (l==null || l.isEmpty() || "\r\n".equals(in.readLine()));

// тут мы 'в лоб' сравниваем строку HTTP-запроса целиком
// так она выглядит до работы парсера
if ("GET /test HTTP/1.1".equals(l)) {
// поскольку мы реагируем только на один url '/test'
// формируем ниже статичный ответ
String data = "Hello from alex0x08 at "+ new Date();
// так выглядят стандартные поля ответа в 'raw' виде, без обработки
out.println("HTTP/1.1 200 OK");
// 'close' дает указание браузеру разорвать соединение
// с сервером сразу после получения данных
out.println("Connection: close");
// поскольку мы отдаем строку - ставим MIME тип 'text/plain'
out.println("Content-Type: text/plain");
// опционально отдаем размер данных
out.println("Content-Length: " + data.length());
// пустая строка - признак начала блока с данными
out.println();
// отдаем сами данные
out.println(data);
} else {
// во всех остальных случаях формируем ответ 404
out.println("HTTP/1.1 404 Not Found");
out.println("Connection: close");
out.println();
}
// нужно обязательно вызывать поскольку PrintWriter кеширует данные
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
// в любом случае закрываем клиентский сокет
try {s.close();} catch (Exception ee) {}
}
}
// стартовый метод приложения
public static void main(String[] args) throws Exception {
System.out.println("Starting..");
// тоже сложное место, которое было непросто ввести по памяти
ExecutorService p = Executors.newFixedThreadPool(10);
// создание 'серверного' сокета, который будет прослушивать
// указанный порт
// поскольку хост не указан - будут прослушиваться все (0.0.0.0)
ServerSocket ss = new ServerSocket(8089);
// бесконечный цикл, который нужен тк метод accept() - блокирующий
// и выход из него произойдет после получения входящего подключения
while (true) {
// получен клиентский сокет
Socket s = ss.accept();
// запуск асинхронной обработки
p.execute(() -> handle(s));
}
}
}

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

Данный исходный код реализует простейший многопоточный веб-сервер на Java, который отвечает лишь на один URL /test и отдает заранее заданную строку с датой.

Как видите даже столь небольшого количества строк достаточно, чтобы можно было подключиться из современного браузера Chrome:

Компиляция выполняется как и в записи всего одной командой:

javac -cp . MyWebServer.java

После чего появится один единственный class-файл c совпадающим именем. Поскольку пакеты не использовались, для запуска достаточно указать в качестве classpath текущий каталог:

java -cp . MyWebServer

Но это все лирика и понты.

Когда кончается человеческая память

Разумеется невозможно запомнить абсолютно все и рано или поздно вы столкнетесь с названием метода или класса, которые надо где-то подсмотреть.

Для примера, автор при записи видео столкнулся с таким в двух местах:

длинные классы-обертки над потоками (stream) сокета и сложное название статичного метода, создающего экземпляр ExecutorService.

И то и другое получилось правильно ввести далеко не с первой попытки.

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

Невероятно но факт:

подсмотреть названия системных классов и методов можно.. в самом JDK!

Вот это поворот!

В последних версиях JDK появилась интересная утилита jimage, которая находится в каталоге bin (там же где и главные бинарники java и javac).

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

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

Команда для запуска:

jimage list $JAVA_HOME/lib/modules |less

Где переменная JAVA_HOME указывает на каталог с установленной JDK:

Так вы увидите названия всех системных классов, но что делать с методами?

Вытаскиваем сигнатуры методов

Тут тоже есть решение, поскольку эта же самая утилита позволяет распаковывать jmod-файлы в которых находятся системные классы JDK:

jimage extract --dir=/opt/src/tmp $JAVA_HOME/lib/modules

А еще одна утилита javap позволяет посмотреть метаданные class-файла, в том числе сигнатуры всех методов:

cd /opt/src/tmp/jre
javap java.base/java/nio/Bits.class

Так выглядит результат:

Вот этого уже с запасом хватит для полевой разработки в условиях крайнего Севера.

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

Исходники JRE

Если вам совсем повезет, в каталоге JDK/lib будет находиться файл src.zip, внутри которого будут исходники всех системных классов JRE:

«Повезет» — потому что также как и demo, этот файл часто удаляют ментейнеры дистрибутивов Linux, с переносом в отдельный пакет. Но разумеется если он присутствует, то поможет гораздо больше чем все приседания с javap.

В распакованном виде:

Внутри находится исходный код всех классов Java, используемых в JDK:

cat java.base/java/io/Bits.java |less

Для примера, так выглядит исходный код класса java.io.Bits, который мы просматривали выше с помощью javap:

Эпилог

Смысл такой «полевой разработки» — в первую очередь глумеж над джунами проверка реальных практических навыков, которые находятся в голове у программиста, а не где‑то в интернете. К сожалению ныне можно констатировать, что такие навыки являются большой редкостью и мало кто из кандидатов, которых я когда-либо собеседовал могли осилить написание хотя‑бы трети подобного кода.

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

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

Что получилось

Сделал браузерный симулятор (соответственно, скачивать и даже регистрироваться не надо). Назвал «Алгоритм Ершова» — в честь нашего академика Андрея Петровича Ершова (я сам из Академгородка, у нас это имя знаковое). Он говорил, что «программирование — вторая грамотность». А мне кажется, что понимание того, как это программирование физически работает на уровне железа — это тот самый базис, без которого никуда. Примерно как буквы в общей грамотности :)

По сути, это игра-головоломка. Вы начинаете с абсолютного нуля:

• Сначала просто соединяете проводами вентили И, ИЛИ, НЕ.
  

• Потом из этого собираете сумматоры и ячейки памяти.
  

• Шаг за шагом сложность растет, и в финале вы строите полноценный 8-битный процессор по гарвардской архитектуре. А потом еще и пишете для него код на ассемблере.
  

Зачем пишу сюда

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

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

Любой фидбек интересен — пишите прямо тут в комментах или в сообщения каналу https://t.me/ershovalgorithm.

Ну и буду дико благодарен, если просто кинете ссылку знакомым учителям информатики/схемотехники или тем, кто интересуется темой.

Ссылка на сам тренажер: https://ershovalgorithm.ru/

А потом производители клавиатур стали извращаться и даже на полноразмерных клавиатурах стали менять расположение кнопок как им вздумается! Зачем, бл...??? Найти стандартную клавиатуру из дешёвых уже не так просто, потому что блок PrintScreen-ScrollLock-Pause уехал в лево, F12 сместили, блок PgUp-Delete всё чаще стоит вертикально. На хрена так делать???

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

Эх, где мои 17 лет KBS-720 c железным днищем, недорогие, но приятные!

Можно чёрную! Можно плоскую(LCDS)! Но, чтобы все кнопки были на своих местах, без перестановок и укороченных бэкспейсов и шифтей и "ВК"!

[картинка KBS-ки, для примера, из глобальной сети]

Когда человек впервые видит раздельную клавиатуру, разговор почти всегда начинается с вопроса:
— На ней вообще можно работать?

Следом звучит второй:
— И зачем переучиваться, если обычная клавиатура и так выполняет свои функции?

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

Поэтому сравнивать особенно не с чем.

Первая неделя. Кажется, я разучился печатать

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

Большую часть жизни мы печатаем не потому, что помним расположение клавиш. За нас всё делает мышечная память. И вот эта память внезапно дает сбой. Пальцы едут туда, где кнопок уже нет. Руки на автомате пытаются соединить две половинки корпуса обратно, а большие пальцы вообще не понимают, почему теперь им тоже придется работать.

Появляется мысль: «Наверное, это была плохая идея».

Вторая неделя. Начинаешь замечать вещи, которых раньше не видел

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

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

Только теперь начинаешь задаваться вопросом: обязательно ли вообще так много двигать руками? Начинаешь отделять саму задачу от инструмента, которым она решается.

Третья неделя. Мозг начинает перестраиваться

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

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

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

Через месяц клавиатура больше не отвлекает

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

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

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

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

На обычной клавиатуре все пользуются примерно одним и тем же расположением клавиш.На раздельной же впервые задаешь себе вопрос: «Что именно я нажимаю чаще всего?».

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

Значит ли это, что обычная клавиатура плохая?

Нет.

Она справляется со своей задачей и остается универсальным решением для миллионов людей.

Однако после месяца с раздельной клавиатурой ты перестаешь воспринимать её как готовый продукт с неизменяемым набором кнопок, который обязан подходить всем. Это инструмент, который можно и нужно адаптировать под себя. Кто-то переносит стрелки, кто-то меняет логику цифр, кто-то создает отдельные слои под Photoshop или код. Клавиатура становится продолжением рабочего процесса её владельца.

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

Вместо этого у тебя появляются вопросы к стандартным:

• Почему клавиши расположены именно так, со смещением?

• Почему большие пальцы почти не используются?

• Почему стрелки вынесены в отдельный далекий блок?

• Почему ради базовых символов приходится сдвигать всю кисть?

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

И это, пожалуй, стало моим самым неожиданным открытием.

Если вам тоже интересно исследовать, почему клавиатуры устроены именно так, я веду телеграм-канал ergosplits.

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

• можно создать несколько зон;

• перетащить зону куда удобно;

• растянуть за угол;

• выбрать действие;

• поставить пресет;

• очистить всё и вернуться к обычной схеме.

Из действий есть листание вперёд/назад, меню, закладки, оглавление, яркость плюс/минус, TTS, выход из приложения и “ничего”.

“Ничего” оказалось не шуткой. Иногда реально нужна область экрана, которая не делает ничего. Например, если туда часто случайно попадаешь при чтении.

Отдельно пришлось решать пересечения.

Например, можно сделать большую зону “вперёд” почти на весь правый край, а поверх неё маленькую зону “меню” в углу. Тогда возникает вопрос: если тап попал сразу в обе зоны, кто победил?

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

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

В Compose зона могла начать перетаскиваться, потом интерфейс пересобирался, pointerInput перезапускался, и drag срывался прямо во время движения. Визуально это выглядело так, будто блок просто отлип от пальца.

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

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

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

Но тап-зоны сейчас, наверное, самая заметная штука именно в интерфейсе чтения.

MRead бесплатный, без рекламы. GitHub использую как страницу релизов: APK, changelog и контрольные суммы.

Скачать, посмотреть changelog и закинуть баг/идею удобнее всего через канал - там же все ссылки на сторы в закрепе:

https://t.me/mread_app

Отдельное спасибо всем, кто пишет баги, предлагает фичи и просто рассказывает, где неудобно. Большая часть правок появилась именно из такого фидбека.