500 слов в минуту без подготовки



    Обычная скорость чтения на русском языке составляет 120—180 слов в минуту. С помощью долгих тренировок можно повысить её где-то до 600 слов в минуту. Совсем недавно небольшой стартап из Бостона представил новую технологию под названием Spritz.

    Мне удалось без подготовки читать со скоростью 500 слов в минуту. Разработчики утверждают, что можно достигнуть 1000; без ущерба для смысла. Более того, утверждается, что использование Spritz также увеличивает скорость чтения обычных текстов.

    Вероятно, теперь можно ожидать появления устройств с крошечными экранами, которые составят конкуренцию традиционным электронным книгам. Очень рекомендую ознакомиться с демкой на сайте.
    Метки:
    Поделиться публикацией
    Похожие публикации
    Комментарии 272
    • НЛО прилетело и опубликовало эту надпись здесь
      • +9
        Наверху на сайте находится демка. Нужно на неё кликнуть. У меня по-русски скорость была выше; там можно выбирать язык.
        • НЛО прилетело и опубликовало эту надпись здесь
          • +34
            Один раз моргнул — пара страниц мимо… Пока оно не будет с датчиком, который фиксирует моргание бесполезная штука.
            • +8
              Сейчас половина самсунгов с датчиками глаз выходит. (правда работают они через задницу, зато какой потенциал!)
            • +6
              Обратная сторона — напряжение для глаза. Смотреть не моргая очень вредно.
              • 0
                Немного погоняв демку — опровергаю: даже на 500 успеваю моргнуть, правда делаю это специально, но на восприятие не влияет.
                • +3
                  Погоняйте час, два часа. Восприятие изменится и появится дискомфорт в глазах.
                  • +1
                    Да, глазки побаливают.

                    Сомнительно также то, что не нужно двигать глазами при чтении. Так могут и глазные мышцы атрофироваться. Хотя, если делать зарядку для глаз…
                    • +6
                      С чего это они атрофируются, если изначально человеческий организм не предназначен для чтения? Занимайтесь спортом, ходите по улице, смотрите по сторонам, а не только сидите за мониторами. Тогда и глаза будут тренироваться) Хотя долю сомнения, в будущем глазных мышц, вы мне заронили в голову. Но с другой стороны обычно чтение тоже атрофирует зрение, согласитесь?
                      • +2
                        Не совсем атрофируются. Появляется спазм, жёсткая фиксация мышц, который сложно снять. По собственному опыту получил такую бяку (и как следствие небольшую близорукость) пару месяцев читая с экрана в супер-проге для чтения книг. Сравнил с обычным чтением с экрана. Вот тут и осознал как важны эти микродвижения вправо-влево, вверх-вниз. Эти движения напоминают зарядку для глаз совсем не случайно. Но для сохранения зрения, лучшее упражнение всё-таки вблизь-вдаль.
                        • +4
                          Но для сохранения зрения, лучшее упражнение всё-таки вблизь-вдаль.
                          Джордж Лукас — великий человек! Ещё с 1977 года он начал заботиться о ваших глазах и выпустил уже шесть специальных тренажёров для чтения вблизь-вдаль (под кодовым названием «Звёздные войны»).
                          • +1
                            Я согласен с Вами — микродвижения глаз необходимы. Однако, есть простое решение данной проблемы: перемещать форму со словами по экрану. Т.е. она сама переодически перемещается, так чтобы Ваши глаза меняли своё положение.
                            • +1
                              Писали уже, что достаточно просто водить головой немного, их стороны в сторону, при этом смотря во дну точку.
                        • +3
                          Разработчики технологии в разделе FAQs пишут, что по их данным глаза не атрофируются из-за микродвижений. Правда приводят и фото:
                          Подопытный
                          image
                          • +4
                            Если очень хочется двигать глазами, то можно просто двигать головой. Мало того, можно качаться на стуле, тогда и расстояние до текста будет меняться :D
                            • +1
                              Приятное с полезным!

                              Камин, кресло-качалка, плед и хорошая книга… на 1000wps.
                      • 0
                        Надо добавить в программу функцию, которая заставляла бы читателя моргать каждые десять секунд (кажется именно столько надо, чтобы глазам было комфортно).

                        Можно каждые десять секунд останавливать показ слов и демонстрировать моргающий глаз, что напоминало бы пользователю о том, что надо моргнуть. Со временем это должно войти в привычку и функцию можно отключить.
                      • 0
                        Задумывался об этом, пока читал демку на дефолтной скорости. Когда пробовал читать на максимальнм (500) моргал чаще специально, чтобы опробовать каково оно. Вывод для себя я сделал такой: науч. издат я таким способом читать не стану, а вот повод начаьт читать худ. лит-ру теперь есть (обычно я пока читаю про цветочки думаю про код и перечитываю одно и то же по 5 раз) — читать художку так удобнее, даже если вы «проморгали» 2-5 слов, это несильно мешает понимать текст (так же как и при чтении по «диагонали»)
                        • +1
                          А почему не сделать Tap to read?
                          • +4
                            Тапнул, моргнул, дальше читать? Контролировать ещё и каждое моргание «вручную», нет уж, спасибо.
                            • +1
                              Tap to read, tap to stop. Ну или удерживание пальца в определённой области, чтобы продолжать воспроизведение текста.
                              • 0
                                Подумают, что вы террорист: едет человек в метро, держит палец на кнопке, и смотрит в одну точку, еще и губами шевелит иногда.
                                • +1
                                  на такой скорости не точно шевеление губами, а речевой центр подавляется.
                          • +5
                            Надо научиться моргать поочерёдно. Только не забыть ведущий глаз переключать.
                          • 0
                            Согласен, немного укачивает. Возможно с непривычки.
                          • –1
                            Как там язык менять?
                            • +3
                              клик по флагу
                              • +5
                                Блин, понял — это на главной можно язык менять, а я был на какой-то другой
                        • +11
                          Писал когда-то подобное, для себя, на десктопе. Читается действительно быстрее, но требует высокой концентрации, поэтому надолго не хватает, и подходит не для всех текстов. Для новостных лент — пожалуйста, для художественной литературы — вряд-ли. Впрочем, это общие проблемы все подобных техник быстрого чтения.
                          Для гуглогласов с их малоразмерным экранчиком — весьма уместна.
                          • 0
                            Аналогично писал для своей старенькой нокии e52. Среди всего прочего, считаю, что самым удобным для меня оказалось не мелькание слов, а добавление их в колонку, где последняя появляется на месте предыдущей, а предыдущая сползает вверх (как в консоли =)
                            • +10
                              Метод старый, помнится, на ZX Spectrum себе такую штуку делал. Предел восприятия был — 3 кадра на слово, что, при частоте 50HZ на телевизоре давало… (150 кадров на 50 слов, 150 кадров — это 3 секунды, 50 * 20 = 1000)… 1000 слов в минуту. Но 4 кадра на слово было гораздо комфортнее — 750 слов в минуту. Так первые 4 тома «Хроник Амбера» проглотил за несколько часов.
                              • +3
                                И как? Были ли какие-то дискомфортные ощущения описанные в комментариях выше, усталость глаз?
                                • +1
                                  Усталость глаз если и была, то исключительно из-за ЭЛТ-монитора с 50hz развёрткой. Особых потерь смысла во время прочтения — не заметил, напротив, очень увлекательно было. (Перечитывал потом с бумаги с такими же позитивными ощущениями как и в первый раз).
                                  • +2
                                    Я тоже так прочитал несколько книжек. Запоминается намного лучше. Вначале не успеваешь читать, минут через десять ты уже не читаешь, а информация «заливается» в твой мозг. Как будто проглотил что-то и ты уже это знаешь.
                                    • –1
                                      А не страдает восприятие атмосферы художественного произведения? Для меня идеальное погружение это когда хороший чтец и качественная аудиозапись.
                                      • +1
                                        аудиокниги слушать не могу, слишком медленный поток информации для меня.
                            • 0
                              Вот, кстати, хотел в ту же степь высказаться.

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

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

                              Тут ниже пишут, что читали на подобной штуке худ. лит… Не знаю, кому как. По мне — так это — убийство для художественной литературы. Так позволить себе читать может только школьник, которому надо срочно «осилить» большой роман. Удовольствия мало…
                            • +62
                              Круто, только после того, как я попробовал все скорости и оторвал взгляд от прямоугольника, он у меня «отпечатался» на сетчатке и еще какое-то время был виден его инвертированный силуэт. Но сама задумка очень понравилась.
                              • +27
                                Подтверждаю. Вожу сейчас взглядом по комментариям а поверх них пляшет «отпечатавшийся» прямоугольник.
                                • 0
                                  Если поиграете прямо сейчас в Guitar Hero, osu!, Stepmania, у вас такой же эффект будет. Со временем привыкните, и такого не будет.
                                  • +1
                                    От GH только стены ползать начинают, а osu! вроде никаких эффектов не даёт.
                                  • 0
                                    Есть программы читалки, там фон делаешь нейтрального цвета, а слова выводишь в центре. Все это разворачиваешь в полный экран и наслаждаешься. У меня лично глаза не уставали. Просто не надо пялиться в экран, а так, полуоткрытыми… откинуться на кресле и погрузиться в книгу.
                                  • 0
                                    На самом деле просто не нужно фиксировать взгляд. Специально проверил на 500 словах в минуту и на русском, и на английском. Если расслабиться, то можно спокойно перемещать взгляд в районе центра прямоугольника и моргать. Главное чтобы слово попадало в поле зрения ( не совсем на периферию, а ближе к центру), тогда мозг схватывает даже на боковом зрении и воспринимает смысл.
                                    • 0
                                      Тут ничего удивительного или необычного это утомление зрительного анализатора. Поглядите с полминуты на красный экран и потом всё будет сине-зеленым.
                                    • +4
                                      Попробовал. При моем скудном знании английского — 250 слов в минуту осилил. Впечатляет.
                                      • +36
                                        Я один такой, кто читает не отдельными словами, а целыми предложениями/абзацами?
                                        • +9
                                          Поддерживаю. Если просто много читать, то со временем начинаешь читать целыми предложениями. Если абзацы не сложные и не нужно вчитываться в них, то основная мысль становится понятна практически с первого взгляда.
                                          • НЛО прилетело и опубликовало эту надпись здесь
                                            • +3
                                              Не один. Скорость 500 слов в минуту впечатляет конечно, но на чтение одной страницы с сайта этим Шпритцем уходит как-то уж очень много времени — без него быстрее, да и ещё этот прямоугольник, глаза устают через несколько минут.
                                              • +2
                                                Да почти все так читают. Не осознают просто. При чтении читается как минимум три строки одновременно. Пока взгляд бежит по строке идет повторное дочитывание предыдущей и уже немного считана следующая. Именно поэтому так важна правильная ширина колонок в которые сверстан текст. И правильно сверстанный текст легко читается.
                                                • +10
                                                  Так вот, почему программисты «по-своему» понимают мои ТЗ. Они их читают абзацами!
                                                  • 0
                                                    Вот-вот. Я ниже написал об этом :) Программа ценна, чтобы заставить себя читать скушный сухой текст внимательно
                                                  • 0
                                                    Вот вы, кстати, задели одно важное применение этой штуки, по-моему. Для таких как вы (и я), кто привык проглатывать скучный текст предложениями она неоценимо полезна в том случае, когда надо вчитаться в каждое слово. Попробуйте, например, прочесть какое-нибудь унылое лицензионное соглашение сперва просто глазами, а затем — через эту программу. Второй раз отложится больше и лучше.
                                                  • 0
                                                    Возможно, это будет круто работать для субтитров на небольших экранах, где две строки из 10 слов читать не всегда удобно. Попробовал демку на русском и на английском — очень большое желание прочесть этим способом материал побольше, чем пресс-релиз. Есть где, кто-нибудь знает?
                                                    • +1
                                                      Думал у них на странице через DevTools текст подменить и почитать что-то, но там формат дурацкий — с указанием пауз и длительностей показа каждого слова, просто текст не вставишь.
                                                      • +2
                                                        Зайдите в блог, там наверху справа есть волшебная кнопочка.
                                                        • +4
                                                          Снизу есть ссылка на похожий сервис: www.spreeder.com/
                                                          • 0
                                                            Спасибо. Залил ему одну из своих статей.
                                                            Оказалось что не каждый текст хорошо воспринимается таким образом.
                                                            Например, следующий кусок не воспринялся вообще, хотя его писал я сам и он неплохо воспринимается в тексте:
                                                            Разработали, оттестировали на рабочей машине, на тестовом сервере, выкатили на продакшен и… ничего. Программа данные не качает, молчит, а через некоторое время валится с ошибкой.


                                                            Наверное, дело в том, что в этом предложении мало связи между словами, что важно для методики.
                                                            Похоже тексты для нее нужно будет специально готовить.
                                                        • +3
                                                          С первого раза прочитал на скорости 500 слов в минуту без проблем. Считаю технологию революционной, но требующей доработки: незнакомые слова буду тормозить восприятие, и в какой-то момент времени можно будет потерять смысл предложения.
                                                          Желательно, еще, иметь кнопку паузы, ползунок замедления показа, и, возможно, чуть ниже виджета — оригинал текста, с выделением прочитанных слов. Мне лично довольно часто приходится возвращаться к целым абзацам которые я уже прочитал, для переосмысления, переваривания информации, так сказать.
                                                          • НЛО прилетело и опубликовало эту надпись здесь
                                                            • 0
                                                              Похоже, но опять неправильное позиционирование слов.
                                                          • +23
                                                            Бесперспективная технология.
                                                            0. исключает распознавание груп слов
                                                            1. невозможен возврат к прочитанному
                                                            2. нельзя даже на миг отвлечься
                                                            3. много времени идет на одно- двобуквенные слова
                                                            4. необходимость дополнительного софта
                                                            5.… очень уж устойчивый стереотип чтения у людей
                                                            • +3
                                                              Прикрутить к этому ползунок замедления скорости с возможностью отматывать назад и проблемы 1 и 2 решатся. Технология перспективная, просто нужно дорабатывать и дорабатывать.
                                                              • 0
                                                                Поздновато свой коммент отправил. Абсолютно с Вами согласен
                                                                • +4
                                                                  Извините, но, видимо я читаю как-то не так как вы. Чтение — это процесс, который не должен сопровождаться постоянной необходимостью отвлекаться на регулировку скорости, на поиск момента возврата (а при подобной технологии это довольно сложно, говорю уверенно, так как сам читал с маленького 2" экрана).
                                                                  Страничный режим книг придуман не просто так, он тысячелетиями отрабатывался. Именно возможность иметь перед глазами достаточно большой запас прочитанного материала, и материала который нужно прочитать позволяет делать это очень скоро, с пониманием, и без «белых пятен». Это такой себе «кэш».

                                                                  … нда, и еще одно — при чтении мозг одни слова, которые он очень часто использует распознает запоминает/суммирует в предложение за сотые секунды, а другие, которые очень редкие (тем более которые видит в первый раз ) он переваривает дай бог чтобы за секунды.
                                                                  • +3
                                                                    Я думаю, что при прочтении средней длины текстов, отвлекаться придется не часто.

                                                                    В таком режиме, как предлагают авторы, долго читать не получится. Просто потому, что требуется намного более серьезная концентрация, чем при обычном чтении. Художественную литературу так читать – только удовольствие портить. Если же ограничить размер читаемых таким образом текстов, то становится уже не так критично то, что иногда придется вернуться назад. Например, прочитать таким образом пришедший вам e-mail может быть весьма удобно (если там чистый текст, а не html). Пробежаться по списку новостей или по их тексту тоже. Или если вам по какой-то причине надо за короткое время ознакомиться с содержанием относительно простого для понимания текста – это тоже идеальный вариант.

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

                                                                    А вот про запас прочитанного материала – это вы про вдумчивое чтение. Если текст легкий, то запас прочитанного материала роли не играет никакой. Но и про «очень скоро» в таком случае говорить странно. Почему-то вы не разделяете разное чтение в своем понимании. Сравните вот чтение короткого смс сообщения за 2 секунды и чтение серьезной технической литературы, например. Ясно, что в первом случае технология идеальна — можно минимизировать время на совершение такого простого действия просто до невообразимо ничтожного, в то время как какие бы вы методики чтения не применяли, вряд ли сможете без ущерба для понимания быстрее проштудировать томик Кнута.

                                                                    Про слова — для родного языка, имхо, это роли не играет. Если вы много читаете, то очень редко будете встречать такие слова.
                                                                    • 0
                                                                      Страничный режим книг придуман не просто так, он тысячелетиями отрабатывался.
                                                                      Сомневаюсь, что страничный режим был придуман ради удобства чтения. Скорее ради удобства упаковки и хранения текста компактными кирпичиками книг.
                                                                      Но в остальном я с вами согласен — сам часто читаю «по диагонали», но по многу раз возвращаюсь к некоторым местам, иногда даже на несколько страниц назад.
                                                                      Способ чтения из метода хорошо подойдёт для рекламы бьющей прямо в мозг :)
                                                                      • +1
                                                                        > Чтение — это процесс, который не должен сопровождаться постоянной необходимостью отвлекаться на регулировку скорости, на поиск момента возврата…
                                                                        Почему не должен? Перелистыванием страниц он должен сопровождаться?

                                                                        >… на поиск момента возврата (а при подобной технологии это довольно сложно, говорю уверенно, так как сам читал с маленького 2" экрана).
                                                                        На странице книги точку возврата найти труднее, т.к. область поиска больше.

                                                                        > Страничный режим книг придуман не просто так, он тысячелетиями отрабатывался.
                                                                        Древними мудрецами, знания которых современное поколение утратило?

                                                                        > Это такой себе «кэш».
                                                                        Т.е., если книгу закрыть (отключиться от кэша), всё только что прочитанное забудется?
                                                                        • 0
                                                                          Хм, для себя открыл режим скроллинга текста, то есть когда непрерывная лента текста ползёт снизу вверх, сам читаю лёжа на диване по 3-5 часов, листать страницы в таком случае не особо удобно, скорость скроллинга выставляю чуть меньше чем моя скорость чтения, тогда есть возможность и перечитать побыстрому кусок, и навигация глазами по странице, правда по началу стены как от GH ползали, но потом привык.
                                                                      • 0
                                                                        Не поспорить, но тут ситуация как с самсунговский смартфоном с изогнутым экраном: они первые выпустили, а LG уже сделали удобнее. Может позже сделают движущуюся строку или две строки. С регулировкой скорости, может с сенсором пальца, при удержании которого на гаджете «страницы» листаются. В общем идея перспективная, но пока сырая и не признанная
                                                                        • 0
                                                                          Насчёт движущейся строки не соглашусь, бесперспективно. А вот отображать не одно слово, а несколько — это да, самое то!
                                                                        • +1
                                                                          Пункт 3 можно доработать: если в тексте предварительно корректно расставить неразрывные пробелы около союзов, частиц и предлогов etc, то их можно будет демонстрировать вместе со словами, к которым они относятся. Например, вместо
                                                                          500
                                                                          слов
                                                                          в
                                                                          минуту
                                                                          без
                                                                          подготовки
                                                                          было бы выведено
                                                                          500 слов
                                                                          в минуту
                                                                          без подготовки
                                                                          но это лишь в том случае, если подобное «улучшение» не снизит показатели в целом.
                                                                          • +2
                                                                            удивительно, но первый вариант я прочитал проще и быстрее, чем второй с неразрывными пробелами.
                                                                            • 0
                                                                              Возможно, потому, что во втором случае, мозгу приходится сопоставлять с известными ему смысловыми значениями не единичные слова, а комбинации из слов (т.е. высчитывать смысл каждой комбинации в реальном времени).
                                                                              • 0
                                                                                Ну так я и говорю, что лишь в том случае, если это действительно будет продуктивно. А Вы, позвольте поинтересоваться, как их читали: просто переводя взгляд со строчки на строчку, или через шприцеподобный интерфейс?
                                                                                • 0
                                                                                  Первый блок читаю разом, т.е. без перевода глаза на строчку или даже слова.
                                                                                  А второй приходится вчитываться в каждую строчку
                                                                                  • 0
                                                                                    Для чистоты эксперимента неплохо бы их построчно прочесть, без контекста. Кстати, где-то в комментариях была ссылка на подобное приложение, там как раз с предлогами и частицами слова подаются — никакого дискомфорта не заметил.
                                                                            • 0
                                                                              0. не исключает
                                                                              1. возможен
                                                                              2. можно
                                                                              3. одно- двобуквенные слова можно выводить с большей скоростью
                                                                              4. технология была бы перспективнее, если бы реализовывалась без софта?
                                                                              5.… а ещё этот стериотип является очень ненавистным
                                                                              • 0
                                                                                у них слова и так с разной скоростью выводятся.
                                                                            • +6
                                                                              А смотреть постоянно в одну точку — не вредно ли для глаз? Когда читаем, мы же водим глазами и вправо-влево, и вверх-вниз, мышцы работают
                                                                              • +16
                                                                                Как по мне, у всех этих техник супер-скорочтения есть 1 большой минус — «прочитав» 5-10 предложений, вы даже не вспомните что там было в первом.

                                                                                p.s. Прошу прощения, промазал и ответил на Ваш комментарий)
                                                                                • +2
                                                                                  К этому привыкаешь, причем довольно быстро. Но, вы правы, нормальные техники скорочтения направлены как на скорость чтения текста, так и на расширение восприятия прочитанного. Практикуется комплексный подход. Сейчас провел маленький эксперимент, прочел первую главу «Гадких лебедей» Стругацких данным методом и набросал кратенькое изложение. После чего перечитал обычным способом. К изложению добавить было нечего, это конспект состоящий из фактов. Имеем классику «научившись скорочтению, я потерял, для себя, художественную литературу»
                                                                                • 0
                                                                                  В FAQ написано, что не страшно. Плюс глаза всегда совершают микродвижения. Но, конечно, это ничего не доказывает.
                                                                                  • 0
                                                                                    Как человек со зрением -13, малость изучивший этот вопрос, не соглашусь. Глаза здорового человека совершают, постоянно автоматически «сканируя» объект, периодически возвращаясь к недорассмотренным участкам. Это всё происходит рефлекторно.
                                                                                    У близоруких людей этот рефлекс теряется, так как они постоянно неосознанно всматриваются в плохо видимый объект. В результате в спокойном состоянии глаз не «гуляет», а часто направлен в одну точку. И приходится эту «сканирующую разминку» делать сознательно.
                                                                                    Поэтому я не рекомендовал бы без дополнительного изучения последствий этот метод скорочтения близоруким людям. По себе могу сказать, легко читается 500 русский и английский, но некоторая напряженность в мышцах появляется.
                                                                                    И если для человека с нормальным зрением такое поведение глаза нетипично и легко проходит, то при миопии просто усугубляется нехорошее состояние, которое и без того присутствует всегда.
                                                                                  • +3
                                                                                    Меня больше смущает мерцание, на 500 словах в минуту глаза начинают побаливать как после паршивого 3D.
                                                                                    • +1
                                                                                      Можете вертеть головой влево-вправо и наклонять вверх-вниз удерживая взгляд на мелькающих словах — вот и будут вам движения глаз :)
                                                                                    • +3
                                                                                      Это жёсткая атака на мозг!
                                                                                      • +20
                                                                                        Куда торопиться-то?

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

                                                                                        А такой метод чтения позволяет быстро читать только пустые водные тексты, которые и читать-то не нужно.
                                                                                        • +9
                                                                                          Для комментов хорошо подходит :)
                                                                                          • +4
                                                                                            Совершенно с вами согласен.
                                                                                            40% литературы, которую я читаю — для души. Сел в кресло, налил кружечку чая и погрузился в другой мир.
                                                                                            40% литературы, которую я читаю — техническая. Которую нужно читать вдумчиво, возвращаясь порой на пару абзацев назад.
                                                                                            20% литературы, которую я читаю или скорее, общего текста — это новостные ленты, соц. сети и тому подобное. Как правило подобным занимаюсь, когда просто хочется отключиться и \\посчолкать\\ по картинкам и почитать небольшие абзацы текста.

                                                                                            Единственную нишу вижу в лице студентов, которые во время сессии из-за нехватки времени, пытаются запихнуть в голову как можно больше пройденого материала. Хотя и тут большой минус — одно дело прочитать с большой скоростью, а другое запомнить. После пары минут такой скорости чтения, половина информации будет напрочь забываться.
                                                                                            Все равно, что с большим феерверком — классно и обалденно выглядит и общее впечатление запоминается, ка ки возможно пару самых ярких моментов. А вот описать последовательность сменяющихся цветовых гам и узоров — не получится.
                                                                                            • +1
                                                                                              Мой список «к чтению» пополняется быстрее, чем что-то из него выбывает. Я бы не отказался, от любого способа читать больше, за тот же период времени без потери смысла, качества и эмоциональности.
                                                                                              • 0
                                                                                                Я думаю это подойдет идеально для чего-то короткого типа смс, или чата.
                                                                                              • +11
                                                                                                А как же удовольствие от чтения? Читать так, конечно, можно, но это неприятно, другое дело, когда перед сном, после насыщенного рабочего дня, берешь какую нить приятную книжечку, и полчасика почитать…
                                                                                                • +3
                                                                                                  Мне понравилось — реально быстро, 500 слов в минуту дались элементарно!
                                                                                                  • +2
                                                                                                    500 и мои глаза болят.
                                                                                                    • +1
                                                                                                      500 и мне мало успеваю отвлекаться… И да что заметил нужно расслабится и тогда понимаешь что ещё быстрее можешь читать и глаза не болят.
                                                                                                      • 0
                                                                                                        Аналогично, расслабленные и слегка расфокуссированные глаза только помогают. Моргать успеваю.
                                                                                                      • 0
                                                                                                        Аналогично. У меня так глаза не болели, когда я играл несколько часов на ноутбуке с не самым лучшим монитором.
                                                                                                      • +3
                                                                                                        Странно что страницу www.spritzinc.com/press/ оставили без внимания — там не работает.
                                                                                                        А вообще вспомнился отличный фильм «Джонни Мнемоник»
                                                                                                        • +9
                                                                                                          Хм, по-моему ничего особенного, просто форсируется скорость чтения, так можно делать и без этого приложения. Казаться правда будет, что ты не читаешь, а сканируешь текст на наличие какой-либо мысли. Не думаю, что подойдет для нормального чтения, только если, действительно не тренировать этот навык, но зачем?

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

                                                                                                          Сомнительно.
                                                                                                          • –2
                                                                                                            Вы только представьте, как студенты в ночь перед экзаменом рады будут такой технологии. Очень полезно как раз для таких случаев — когда нужно быстро просканировать большой объем текста без иллюстраций, не сильно вдумываясь.
                                                                                                            • +1
                                                                                                              Понимаю, ну а толку? Мне как-то думается, что экзамен сдать это не сильно поможет.
                                                                                                              • +1
                                                                                                                Смотря какой. Ведь всё прочитанное таким образом «отпечатывается» в мозгу. Если текст не очень глубокий и нужно лишь общее понимание, то таким способом вполне можно значительно ускорить восприятие информации.

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

                                                                                                                Так что такой технологии можно найти реальные применения.
                                                                                                                • +5
                                                                                                                  Ну на каком-нибудь Гарри Поттере — я и без этой технологии выжму из себя 800-1000 слов в минуту не сильно напрягаясь. А вот например Ландау-Лифшица первый раз я бы не стал читать даже на 250, да там хоть бы на 120 себя порадовать.
                                                                                                                  • +2
                                                                                                                    Да, представил как бы выглядел учебник по матану с кучей формул в таком виде – сцену из матрицы напомнило. :) Но я же не о том. Неужели, тексты по гуманитарным наукам никогда не читали?
                                                                                                                    • 0
                                                                                                                      Ну почему же, читал. Историю без цифр аналогично читаю быстро. А вот если это учебник по международному праву — то, я думаю, не только у меня вытечет мозг через уши от такой скорости.

                                                                                                                      P.S. Согласитесь, такой способ подходит только для поверхностного, легкого чтения.
                                                                                                              • 0
                                                                                                                Для студента куда бОльшая проблема — понять и потом ещё выучить, а не просто прочитать, это уж можете мне поверить.
                                                                                                            • +2
                                                                                                              500 без проблем читается. Но достаточно на секунду отвлечься — смысл потерян, и назад дороги нет.
                                                                                                              Ну и никакого удовольствия :(
                                                                                                              • +1
                                                                                                                Вопрос реализации. Представьте специально подготовленную таким образом книгу, где по абзацам расставлены коэфициенты скорости, абзацы с большим количеством часто встречаемых слов идут быстрее, с редкими словами — медленнее. А перед началом чтения вас спрашивают что-то в духе «знаете ли вы значения слова „рекреация“? А „рекуперация“ И так по всем словам книги с распространенностью ниже определенного процента. Соответственно абзацы со словами, которые вы не знаете будут идти медленнее, возможно даже со сносками.
                                                                                                                А еще пауза, кнопки „вернуться на Х секунд назад“, „показать этот абзац в классическом виде“ и т.д. Тут показали просто идею, ничего больше.
                                                                                                                При грамотной реализации это может быть очень круто. По крайней мере я бы книгу в таком виде, как минимум попробовать.
                                                                                                              • +1
                                                                                                                Убираются возвраты глазами ( регрессии). Это то, что реально замедляет скорость чтения.
                                                                                                                Т.е. таким образом можно избавиться как минимум от одного недостатка, многим мешающего начать быстро читать.
                                                                                                                • +2
                                                                                                                  Есть еще недостаток «потеря концентрации» против которого может помочь. Так что я считаю это интересным тренажером.
                                                                                                                • 0
                                                                                                                  Я так понял готовой реализации под тот же Android на данный момент нет? :(
                                                                                                                  • +1
                                                                                                                    Включил немецкий (владею им хорошо) и охренел! Двух- и трёхсоставные слова в немецком иногда даже просто на бумаге прочитать сложно, а тут оно за несколько миллисекунд проскакивает :)
                                                                                                                    После пары пробных заходов смотрю на белый фон хабрахабра, а там прямоугольная тень в глазу отпечаталась в том месте, куда смотришь (около 2ух минут была!)
                                                                                                                    • +3
                                                                                                                      Так на андроиде давно нечто подобное есть: Speed Book.Reader.
                                                                                                                      Давно это приложение не использовал, но на сколько я помню как оно работает — не заметил отличий от того, что предлагает Spritz.
                                                                                                                      • +3
                                                                                                                        Спасибо за ссылку. К сожалению, Speed Book Reader не совсем правильно позициониурет слова и не умеет разбивать длинные, но тоже неплохо.
                                                                                                                        • +3
                                                                                                                          А по какому принципу подсвечены буквы?
                                                                                                                          • +3
                                                                                                                            В зависимости от длины слова есть точка, по которой слово распознается мозгом: как только эта точка находится через микроосциляции (саккады) глаза, вы «узнаете» слово. Если уменьшить время на поиск этой точки (подсветив и выровняв все слова по ней), слова распознаются намного быстрее — за счет этого все и работает.

                                                                                                                            Это как с курсивом: мы не считаем палочки и на слога не раскладываем каждое слово, а воспринимаем сразу в совокупности (при условии, что мы хорошо знаем это слово).

                                                                                                                            • +2
                                                                                                                              Я, не считая палочки, только «лилии» и «слышишь» смог прочитать. Меня можно вылечить?
                                                                                                                              • +1
                                                                                                                                лилии, дымишь, дышишь,
                                                                                                                                лишишься, слышишь,
                                                                                                                                шиншиллы, ишемия.

                                                                                                                                Но в последней строке «н» и «е» специально испорчены.
                                                                                                                                • 0
                                                                                                                                  Нет, прочел то все слова, но для пбольшинства пришлось считать палочки. Скорее всего, в реальных текстах, выручил бы контекст, а в такой подаче довольно сложно «узнать» такое слово целиком.
                                                                                                                              • +3
                                                                                                                                Что легче читается?
                                                                                                                                • +6
                                                                                                                                  В данном случае третий вариант легче читается, но где вариант с вертикальным расположением?
                                                                                                                                  • 0
                                                                                                                                    Столбцами с пометками, кажется, читается легче… Причем смысл тоже воспринимается, но только после прочтения последнего столбца.
                                                                                                                                    • +11
                                                                                                                                      Задумался над тем, что значит
                                                                                                                                      В точка, как микроосциляции Если точки ней, за

                                                                                                                                      Потом только понял, что Вы поломали основное преимущество от позиционирования слов.
                                                                                                                                  • +11
                                                                                                                                    Отвечу вас исходным кодом, взятым из библиотеки на сайте:
                                                                                                                                    switch (wordLength) {
                                                                                                                                    		case 1:
                                                                                                                                    			bestLetter = 0; // first
                                                                                                                                    			break;
                                                                                                                                    		case 2:
                                                                                                                                    		case 3:
                                                                                                                                    		case 4:
                                                                                                                                    		case 5:
                                                                                                                                    			bestLetter = 1; // second
                                                                                                                                    			break;
                                                                                                                                    		case 6:
                                                                                                                                    		case 7:
                                                                                                                                    		case 8:
                                                                                                                                    		case 9:
                                                                                                                                    			bestLetter = 2; // third
                                                                                                                                    			break;
                                                                                                                                    		case 10:
                                                                                                                                    		case 11:
                                                                                                                                    		case 12:
                                                                                                                                    		case 13:
                                                                                                                                    			bestLetter = 3; // fourth
                                                                                                                                    			break;
                                                                                                                                    		default:
                                                                                                                                    			bestLetter = 4; // fifth
                                                                                                                                    		};
                                                                                                                                    

                                                                                                                                    • 0
                                                                                                                                      Взял и всю «технологию» расскрыл.
                                                                                                                                      • +1
                                                                                                                                        Спасибо, кстати, было уже записался на «SDK for Web Usage», а тут вы с разоблачением. За несколько минут набросал маленький тестик (результат в браузерной консоли).

                                                                                                                                        *Ну и «раскрыл», конечно же.
                                                                                                                                        • 0
                                                                                                                                          Она патентована же, значит не скрывается по определению.
                                                                                                                                          • 0
                                                                                                                                            Да это такой неумелый скарказм с моей стороны. Вроде бы оно ещё patent pending, да и сама технология, основанная, в большей степени, на одном switch'e сильно притянута за уши.
                                                                                                                                    • –2
                                                                                                                                      Подсчитав примерчик выше, подсвечиваются центральные буквы если число букв нечетное, и левая буква от центра, если четное
                                                                                                                                  • 0
                                                                                                                                    Более того, есть еще одно приложение, схожее по функциональности Autoreader 3D. Пробовал их оба, правда давно это было, поэтому не смогу сейчас сказать почему предпочел именно его, но среди фишек последней есть возможность чтение текста в 3D (стерео-пара, если я правильно называю этот эффект). 4" экран телефона не слишком удобен для такого режима — возможно, потому у меня и не получилось самому опробовать 3D (хотя, по правде говоря, не слишком то и старался), — но на экране планшета, думаю, это будет возможно. Плюс возможность плавного изменения текста протягиванием по вертикали вдоль экрана или качелькой громкости.
                                                                                                                                    В статье заявлена средняя скорость чтения 120-180 слов в минуту. Не знал, поэтому и считал (по крайней мере, для себя) минимально удобной скорость в 250 слов/минуту, но сейчас без принуждения читаю на скорости 400. После прочтения статьи попробовал на 500. Хмм, приемлемо. Тут у меня скорее было психологическое ограничение, чем чисто физическое по распознаванию текста
                                                                                                                                  • +1
                                                                                                                                    Я 250 не успеваю. При этом видя всю страницу, читаю я гораздо быстрее.
                                                                                                                                    • +3
                                                                                                                                      Человек читает плохо, а они вместо того, чтобы пожалеть — минусуют. :)
                                                                                                                                    • 0
                                                                                                                                      Ничего мега нового в этом нет, летом ещё в апсторе натыкался на несколько приложений с такой же техникой чтения, причем в них можно было регулировать кол-во слов одновременно показываемых на экране.
                                                                                                                                      • +3
                                                                                                                                        А как же старое доброе чтение по диагонали? Обычно сначала быстро просматриваю статью, чтобы понять, интересна ли она, а потом читаю подряд. Думаю, многие поступают примерно так же. С этой технологией такое исключено: или читай все, или не читай вообще. Ну и всегда бывает нужна возможность остановиться на каком-то абзаце, перечитать или вернуться выше по тексту. Пока непонятно, чем будут заменены эти привычные механизмы чтения и восприятия текстовой информации в целом.
                                                                                                                                        • +6
                                                                                                                                          ИМХО этот способ подойдёт для вывода информации на малогабаритные девайсы. Например сообщение на умные часы: нажал кнопку, оно выпулило небольшой текст со скоростью 500 слов, и по времени чтение смс-ки будет равнозначно просто взгляду на часы.
                                                                                                                                          • +1
                                                                                                                                            Можно сделать навигацию как в sublime2 (document map) и подсвечивать там текущую позицию, а при перемотке показывать «обычным строчным» способом текст.
                                                                                                                                          • 0
                                                                                                                                            Вообще, так можно было бы тренироваться распознавать язык, который ищучаешь, постепенно наращивая темпы. Я вот английский на 500 включил (в блоге) — все не успеваю, но образы в уме появляются
                                                                                                                                            • 0
                                                                                                                                              Очень круто, но там написано «patent pending» и мне кажется, что все сторонние реализации в читалках на андроиде или хотя бы в виде расширений для браузера будут быстренько выпиливать. А за свое решение, применяемое для чего-то кроме личных целей они будут просить денег. PS: 500 слов вполне можно успеть.
                                                                                                                                              • 0
                                                                                                                                                Обещают предоставлять API, вот тут есть немного подробностей. Если <10к пользователей в месяц — можно попробовать получить бесплатную персональную лицензию, остальным — за денежку.
                                                                                                                                                • 0
                                                                                                                                                  Я к тому, что если сйечас создать расширение для браузера или юзерскрипт, который рисует слова точно так же на любой странице, то им это не понравится.

                                                                                                                                                  Просто в форме расширения для браузера/читалки это было бы более удобно, но понятно, что они на лицензиях планируют заработать.
                                                                                                                                                  • 0
                                                                                                                                                    Софтпатенты дейстуют только в США, Канаде, Южной Корее и Японии. Во всем остальном цивилизованном мире они запрещены. Если вы не будете распространять софт в этих четырех странах (а на практике, скорее всего, даже в двух, потому что у меня есть подоздения, что в Японии и Корее патент не регистрировали), то больших проблем не будет. Другое дело, что в суд все равно могут подать и на защиту придется потратить время и средства.
                                                                                                                                                    • 0
                                                                                                                                                      К слову, могут ли они вообще подать в какой-либо суд, если я в России, а компания здесь не зарегистрирована?
                                                                                                                                              • +1
                                                                                                                                                Ничего революционного не вижу — www.spreeder.com
                                                                                                                                                Добавили немного плюшек вроде разной паузы и выделения буквы. Я что то упустил?
                                                                                                                                                • +2
                                                                                                                                                  В технике из топика выровняли слово так, что глазом водить не надо.

                                                                                                                                                  А вообще я попробовал загнать в сервис кусок рассказа, и полностью обломался на диалогах.
                                                                                                                                                  — Они не воспринимаются! — Сказал Н.
                                                                                                                                                  — Да, действительно. — Ответил К.
                                                                                                                                                  • 0
                                                                                                                                                    Текст который я когда-то давно читал и помню о чем речь — воспринимаю без проблем на 1200. Новый текст — на 800, быстрее если нет редких длинных слов вроде «вечнозеленые» — глаз просто не успевает их поймать. Впрочем, возможно зависит от автора — Стругацкие читаются гораздо быстрее Брэдбери.
                                                                                                                                                    Мне показалось, что неплохой возможностью улучшить систему будет определение времени показа по частоте и длине слова.
                                                                                                                                                  • +1
                                                                                                                                                    Идеально для чтения твитера. Даже если пропустил пару твитов — ничего страшного. Пойду на кикстартер с устройством для чтения твитов — берём пейджер, переделываем под приём твитов и вуаля!

                                                                                                                                                    Подумал. Ещё на айподе читать было бы удобно. Его джойстиком можно регулировать скорость.
                                                                                                                                                    • +13
                                                                                                                                                      Не знаю, правильно ли я понял концепцию, но вот:

                                                                                                                                                      #!/bin/bash
                                                                                                                                                      # $1 - считываемый файл
                                                                                                                                                      # $2 - скорость (около 0.2 достаточно комфортно)
                                                                                                                                                      data=`cat $1`
                                                                                                                                                      for i in $data; do
                                                                                                                                                        clear
                                                                                                                                                        printf "  %s" $i
                                                                                                                                                        sleep $2
                                                                                                                                                      done
                                                                                                                                                      
                                                                                                                                                      • +4
                                                                                                                                                        На Java — с паузой и слайдером для скорости:
                                                                                                                                                        Скрытый текст
                                                                                                                                                        package x.mvmn.speedread;
                                                                                                                                                        
                                                                                                                                                        import java.awt.BorderLayout;
                                                                                                                                                        import java.awt.event.ActionEvent;
                                                                                                                                                        import java.awt.event.ActionListener;
                                                                                                                                                        import java.io.BufferedReader;
                                                                                                                                                        import java.io.File;
                                                                                                                                                        import java.io.FileReader;
                                                                                                                                                        import java.util.Arrays;
                                                                                                                                                        import java.util.Iterator;
                                                                                                                                                        import java.util.LinkedList;
                                                                                                                                                        import java.util.List;
                                                                                                                                                        
                                                                                                                                                        import javax.swing.BorderFactory;
                                                                                                                                                        import javax.swing.JButton;
                                                                                                                                                        import javax.swing.JFileChooser;
                                                                                                                                                        import javax.swing.JFrame;
                                                                                                                                                        import javax.swing.JLabel;
                                                                                                                                                        import javax.swing.JOptionPane;
                                                                                                                                                        import javax.swing.JSlider;
                                                                                                                                                        import javax.swing.SwingUtilities;
                                                                                                                                                        
                                                                                                                                                        public class SpeedRead {
                                                                                                                                                        	private final JFrame mainWindow;
                                                                                                                                                        	private final JLabel label;
                                                                                                                                                        	private final List<String> words = new LinkedList<String>();
                                                                                                                                                        	private static volatile boolean PAUSE = false;
                                                                                                                                                        	private final JSlider delaySelectSlider = new JSlider(JSlider.HORIZONTAL, 0, 500, 100);
                                                                                                                                                        
                                                                                                                                                        	public static void main(String[] args) throws Exception {
                                                                                                                                                        		JFileChooser fileChooser = new JFileChooser();
                                                                                                                                                        		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                                                                                                                                                        		if (JFileChooser.APPROVE_OPTION == fileChooser.showOpenDialog(null)) {
                                                                                                                                                        			new SpeedRead(fileChooser.getSelectedFile());
                                                                                                                                                        		}
                                                                                                                                                        	}
                                                                                                                                                        
                                                                                                                                                        	public SpeedRead(final File selectedFile) {
                                                                                                                                                        		mainWindow = new JFrame(selectedFile.getName());
                                                                                                                                                        		mainWindow.getContentPane().setLayout(new BorderLayout());
                                                                                                                                                        		mainWindow.getContentPane().add(delaySelectSlider, BorderLayout.NORTH);
                                                                                                                                                        		label = new JLabel("", JLabel.CENTER);
                                                                                                                                                        		label.setBorder(BorderFactory.createEmptyBorder(100, 100, 100, 100));
                                                                                                                                                        		label.setFont(label.getFont().deriveFont(50f));
                                                                                                                                                        		mainWindow.getContentPane().add(label, BorderLayout.CENTER);
                                                                                                                                                        		{
                                                                                                                                                        			JButton pauseBtn = new JButton("Pause");
                                                                                                                                                        			mainWindow.getContentPane().add(pauseBtn, BorderLayout.SOUTH);
                                                                                                                                                        
                                                                                                                                                        			pauseBtn.addActionListener(new ActionListener() {
                                                                                                                                                        				Override
                                                                                                                                                        				public void actionPerformed(ActionEvent e) {
                                                                                                                                                        					SpeedRead.PAUSE = !SpeedRead.PAUSE;
                                                                                                                                                        				}
                                                                                                                                                        			});
                                                                                                                                                        		}
                                                                                                                                                        		label.setText("Supercalifragilisticexpialidocious");
                                                                                                                                                        		mainWindow.pack();
                                                                                                                                                        		label.setText("Reading file " + selectedFile.getName());
                                                                                                                                                        		mainWindow.setVisible(true);
                                                                                                                                                        
                                                                                                                                                        		new Thread() {
                                                                                                                                                        			public void run() {
                                                                                                                                                        				BufferedReader reader = null;
                                                                                                                                                        				try {
                                                                                                                                                        					reader = new BufferedReader(new FileReader(selectedFile));
                                                                                                                                                        					String line = reader.readLine();
                                                                                                                                                        					while (line != null) {
                                                                                                                                                        						words.addAll(Arrays.asList(line.split(" ")));
                                                                                                                                                        						line = reader.readLine();
                                                                                                                                                        					}
                                                                                                                                                        				} catch (Exception e) {
                                                                                                                                                        					JOptionPane.showMessageDialog(mainWindow, e.getClass().getName() + " " + e.getMessage(), "Error reading file", JOptionPane.ERROR_MESSAGE);
                                                                                                                                                        				} finally {
                                                                                                                                                        					try {
                                                                                                                                                        						if (reader != null) {
                                                                                                                                                        							reader.close();
                                                                                                                                                        						}
                                                                                                                                                        					} catch (Exception e) {
                                                                                                                                                        					}
                                                                                                                                                        				}
                                                                                                                                                        				Iterator<String> iter = words.iterator();
                                                                                                                                                        				while (iter.hasNext()) {
                                                                                                                                                        					while (PAUSE) {
                                                                                                                                                        						try {
                                                                                                                                                        							Thread.sleep(100);
                                                                                                                                                        						} catch (Exception e) {
                                                                                                                                                        						}
                                                                                                                                                        						Thread.yield();
                                                                                                                                                        					}
                                                                                                                                                        					final String next = iter.next();
                                                                                                                                                        					try {
                                                                                                                                                        						SwingUtilities.invokeAndWait(new Runnable() {
                                                                                                                                                        							Override
                                                                                                                                                        							public void run() {
                                                                                                                                                        								label.setText(next);
                                                                                                                                                        							}
                                                                                                                                                        						});
                                                                                                                                                        					} catch (Exception e) {
                                                                                                                                                        					}
                                                                                                                                                        					try {
                                                                                                                                                        						Thread.sleep(delaySelectSlider.getValue());
                                                                                                                                                        					} catch (Exception e) {
                                                                                                                                                        					}
                                                                                                                                                        				}
                                                                                                                                                        			}
                                                                                                                                                        		}.start();
                                                                                                                                                        
                                                                                                                                                        	}
                                                                                                                                                        }
                                                                                                                                                        

                                                                                                                                                        • +5
                                                                                                                                                          Почему меня, как пользователя Override, не увековечат в коде? (
                                                                                                                                                          • +3
                                                                                                                                                            Ему повезло — он увековечен в спецификации (-:
                                                                                                                                                            • 0
                                                                                                                                                              Регрессия, однако. Этот баг я когда-то репортил и его, вроде как, исправляли.
                                                                                                                                                              Есть ещё товарищь с ником
                                                                                                                                                              @catch


                                                                                                                                                              Как всё интересно… А @catch-то не хайлайтится вообще )
                                                                                                                                                            • +1
                                                                                                                                                              Версия с центровкой и подсветкой буквы
                                                                                                                                                              Скрытый текст
                                                                                                                                                              package x.mvmn.speedread;
                                                                                                                                                              
                                                                                                                                                              import java.awt.BorderLayout;
                                                                                                                                                              import java.awt.Color;
                                                                                                                                                              import java.awt.Font;
                                                                                                                                                              import java.awt.event.ActionEvent;
                                                                                                                                                              import java.awt.event.ActionListener;
                                                                                                                                                              import java.io.BufferedReader;
                                                                                                                                                              import java.io.File;
                                                                                                                                                              import java.io.FileReader;
                                                                                                                                                              import java.util.Arrays;
                                                                                                                                                              import java.util.Iterator;
                                                                                                                                                              import java.util.LinkedList;
                                                                                                                                                              import java.util.List;
                                                                                                                                                              import java.util.regex.Matcher;
                                                                                                                                                              import java.util.regex.Pattern;
                                                                                                                                                              
                                                                                                                                                              import javax.swing.BorderFactory;
                                                                                                                                                              import javax.swing.JButton;
                                                                                                                                                              import javax.swing.JFileChooser;
                                                                                                                                                              import javax.swing.JFrame;
                                                                                                                                                              import javax.swing.JLabel;
                                                                                                                                                              import javax.swing.JOptionPane;
                                                                                                                                                              import javax.swing.JPanel;
                                                                                                                                                              import javax.swing.JSlider;
                                                                                                                                                              import javax.swing.JSplitPane;
                                                                                                                                                              import javax.swing.SwingUtilities;
                                                                                                                                                              
                                                                                                                                                              public class SpeedRead {
                                                                                                                                                              	private final JFrame mainWindow;
                                                                                                                                                              	private final JLabel labelOne;
                                                                                                                                                              	private final JLabel labelTwo;
                                                                                                                                                              	private final JLabel labelThree;
                                                                                                                                                              	private final List<String> words = new LinkedList<String>();
                                                                                                                                                              	private static volatile boolean PAUSE = false;
                                                                                                                                                              	private final JSlider delaySelectSlider = new JSlider(JSlider.HORIZONTAL, 0, 500, 100);
                                                                                                                                                              
                                                                                                                                                              	public static void main(String[] args) throws Exception {
                                                                                                                                                              		JFileChooser fileChooser = new JFileChooser();
                                                                                                                                                              		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                                                                                                                                                              		if (JFileChooser.APPROVE_OPTION == fileChooser.showOpenDialog(null)) {
                                                                                                                                                              			new SpeedRead(fileChooser.getSelectedFile());
                                                                                                                                                              		}
                                                                                                                                                              	}
                                                                                                                                                              
                                                                                                                                                              	public SpeedRead(final File selectedFile) {
                                                                                                                                                              		mainWindow = new JFrame(selectedFile.getName());
                                                                                                                                                              		mainWindow.getContentPane().setLayout(new BorderLayout());
                                                                                                                                                              		mainWindow.getContentPane().add(delaySelectSlider, BorderLayout.NORTH);
                                                                                                                                                              		labelOne = new JLabel("", JLabel.RIGHT);
                                                                                                                                                              		labelTwo = new JLabel("", JLabel.CENTER);
                                                                                                                                                              		labelThree = new JLabel("", JLabel.LEFT);
                                                                                                                                                              
                                                                                                                                                              		// GroupLayout layout = new GroupLayout(labelPanel);
                                                                                                                                                              		Font font = new Font(Font.MONOSPACED, labelOne.getFont().getStyle(), 50);
                                                                                                                                                              		labelOne.setFont(font);
                                                                                                                                                              		labelTwo.setFont(font);
                                                                                                                                                              		labelThree.setFont(font);
                                                                                                                                                              		labelOne.setText("Supe");
                                                                                                                                                              		labelTwo.setText("r");
                                                                                                                                                              		labelThree.setText("califragilisticexpialidocious");
                                                                                                                                                              		labelOne.setMaximumSize(labelOne.getPreferredSize());
                                                                                                                                                              		labelOne.setMinimumSize(labelOne.getPreferredSize());
                                                                                                                                                              		labelTwo.setMaximumSize(labelTwo.getPreferredSize());
                                                                                                                                                              		labelTwo.setMinimumSize(labelTwo.getPreferredSize());
                                                                                                                                                              		labelThree.setMaximumSize(labelThree.getPreferredSize());
                                                                                                                                                              		labelThree.setMinimumSize(labelThree.getPreferredSize());
                                                                                                                                                              		labelTwo.setForeground(Color.RED);
                                                                                                                                                              
                                                                                                                                                              		JPanel rightLabelPanel = new JPanel(new BorderLayout());
                                                                                                                                                              		JPanel rightLabelSubPanel = new JPanel();
                                                                                                                                                              		rightLabelSubPanel.add(labelTwo);
                                                                                                                                                              		rightLabelSubPanel.add(labelThree);
                                                                                                                                                              		rightLabelPanel.add(rightLabelSubPanel, BorderLayout.WEST);
                                                                                                                                                              
                                                                                                                                                              		JSplitPane labelPanel = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, false, labelOne, rightLabelPanel);
                                                                                                                                                              		labelPanel.setDividerSize(0);
                                                                                                                                                              		labelPanel.setBorder(BorderFactory.createEmptyBorder(100, 100, 100, 100));
                                                                                                                                                              
                                                                                                                                                              		mainWindow.getContentPane().add(labelPanel, BorderLayout.CENTER);
                                                                                                                                                              		{
                                                                                                                                                              			JButton pauseBtn = new JButton("Pause");
                                                                                                                                                              			mainWindow.getContentPane().add(pauseBtn, BorderLayout.SOUTH);
                                                                                                                                                              
                                                                                                                                                              			pauseBtn.addActionListener(new ActionListener() {
                                                                                                                                                              				public void actionPerformed(ActionEvent e) {
                                                                                                                                                              					SpeedRead.PAUSE = !SpeedRead.PAUSE;
                                                                                                                                                              				}
                                                                                                                                                              			});
                                                                                                                                                              		}
                                                                                                                                                              		mainWindow.pack();
                                                                                                                                                              		labelOne.setText("");
                                                                                                                                                              		labelTwo.setText("");
                                                                                                                                                              		labelThree.setText("Reading file " + selectedFile.getName());
                                                                                                                                                              		mainWindow.setVisible(true);
                                                                                                                                                              
                                                                                                                                                              		new Thread() {
                                                                                                                                                              			public void run() {
                                                                                                                                                              				BufferedReader reader = null;
                                                                                                                                                              				try {
                                                                                                                                                              					reader = new BufferedReader(new FileReader(selectedFile));
                                                                                                                                                              					String line = reader.readLine();
                                                                                                                                                              					while (line != null) {
                                                                                                                                                              						words.addAll(Arrays.asList(line.split(" ")));
                                                                                                                                                              						line = reader.readLine();
                                                                                                                                                              					}
                                                                                                                                                              				} catch (Exception e) {
                                                                                                                                                              					JOptionPane.showMessageDialog(mainWindow, e.getClass().getName() + " " + e.getMessage(), "Error reading file", JOptionPane.ERROR_MESSAGE);
                                                                                                                                                              				} finally {
                                                                                                                                                              					try {
                                                                                                                                                              						if (reader != null) {
                                                                                                                                                              							reader.close();
                                                                                                                                                              						}
                                                                                                                                                              					} catch (Exception e) {
                                                                                                                                                              					}
                                                                                                                                                              				}
                                                                                                                                                              				Iterator<String> iter = words.iterator();
                                                                                                                                                              				while (iter.hasNext()) {
                                                                                                                                                              					while (PAUSE) {
                                                                                                                                                              						try {
                                                                                                                                                              							Thread.sleep(100);
                                                                                                                                                              						} catch (Exception e) {
                                                                                                                                                              						}
                                                                                                                                                              						Thread.yield();
                                                                                                                                                              					}
                                                                                                                                                              					final String next = iter.next();
                                                                                                                                                              					try {
                                                                                                                                                              						SwingUtilities.invokeAndWait(new Runnable() {
                                                                                                                                                              							Override
                                                                                                                                                              							public void run() {
                                                                                                                                                              								int hl = getHighlightedCharIndex(next);
                                                                                                                                                              								if (hl < 0) {
                                                                                                                                                              									labelOne.setText("");
                                                                                                                                                              									labelTwo.setText("");
                                                                                                                                                              									labelThree.setText(next);
                                                                                                                                                              								} else {
                                                                                                                                                              									labelOne.setText(next.substring(0, hl));
                                                                                                                                                              									labelTwo.setText(next.substring(hl, hl + 1));
                                                                                                                                                              									labelThree.setText(next.substring(hl + 1));
                                                                                                                                                              								}
                                                                                                                                                              							}
                                                                                                                                                              						});
                                                                                                                                                              					} catch (Exception e) {
                                                                                                                                                              					}
                                                                                                                                                              					try {
                                                                                                                                                              						Thread.sleep(delaySelectSlider.getValue());
                                                                                                                                                              					} catch (Exception e) {
                                                                                                                                                              					}
                                                                                                                                                              				}
                                                                                                                                                              			}
                                                                                                                                                              		}.start();
                                                                                                                                                              	}
                                                                                                                                                              
                                                                                                                                                              	private static Pattern LETTER = Pattern.compile("[\\p{L}'`\\-]+($|[^\\p{L}'`\\-])");
                                                                                                                                                              
                                                                                                                                                              	private int getHighlightedCharIndex(String text) {
                                                                                                                                                              		int result = -1;
                                                                                                                                                              		if (text != null) {
                                                                                                                                                              			Matcher matcher = LETTER.matcher(text);
                                                                                                                                                              			if (matcher.find()) {
                                                                                                                                                              				int indexOfFirstLetter = matcher.start();
                                                                                                                                                              				int indexOfLastLetter = matcher.end();
                                                                                                                                                              				int length = indexOfLastLetter - indexOfFirstLetter - 1;
                                                                                                                                                              				result = indexOfFirstLetter + getHighlightedCharIndex(length);
                                                                                                                                                              			}
                                                                                                                                                              		}
                                                                                                                                                              		return result;
                                                                                                                                                              	}
                                                                                                                                                              
                                                                                                                                                              	private int getHighlightedCharIndex(int wordLength) {
                                                                                                                                                              		int bestLetter = 0;
                                                                                                                                                              		switch (wordLength) {
                                                                                                                                                              			case 0:
                                                                                                                                                              			case 1:
                                                                                                                                                              				bestLetter = 0; // first
                                                                                                                                                              			break;
                                                                                                                                                              			case 2:
                                                                                                                                                              			case 3:
                                                                                                                                                              			case 4:
                                                                                                                                                              			case 5:
                                                                                                                                                              				bestLetter = 1; // second
                                                                                                                                                              			break;
                                                                                                                                                              			case 6:
                                                                                                                                                              			case 7:
                                                                                                                                                              			case 8:
                                                                                                                                                              			case 9:
                                                                                                                                                              				bestLetter = 2; // third
                                                                                                                                                              			break;
                                                                                                                                                              			case 10:
                                                                                                                                                              			case 11:
                                                                                                                                                              			case 12:
                                                                                                                                                              			case 13:
                                                                                                                                                              				bestLetter = 3; // fourth
                                                                                                                                                              			break;
                                                                                                                                                              			default:
                                                                                                                                                              				bestLetter = 4; // fifth
                                                                                                                                                              		}
                                                                                                                                                              		return bestLetter;
                                                                                                                                                              	}
                                                                                                                                                              }

                                                                                                                                                            • +1
                                                                                                                                                              Даёшь неделю «скорочтения в 30 строк»!
                                                                                                                                                              • 0
                                                                                                                                                                Override вызвало даже из кода.
                                                                                                                                                                Промазал ответом.
                                                                                                                                                            • +1
                                                                                                                                                              Не оставляет времени на подумать и оценить информацию.
                                                                                                                                                              В моем случае — только для читания художественной литературы, но зачем она нужна с такой скоростью?

                                                                                                                                                              Для меня сомнительная фигня.

                                                                                                                                                              Но возможно что неплохая технология для изучения/тренировки языков методом зомбирования :)
                                                                                                                                                              • –3
                                                                                                                                                                А слабо им получить справку что это безопасно для мозга/глаз для абсолютно всех людей во всех ситуациях и в долгосрочной перспективе?