company_banner

Разработка сервера браузерной игры… как учебная дисциплина

    В середине прошлого лета на программерскую рассылку отдела клиентских игр Mail.Ru Group пришло письмо – «Объявлен конкурс на позицию преподавателя курса Java в нашем совместном проекте с МГТУ им. Н. Э. Баумана». Как программист и сотрудник отдела я это письмо тоже получил. Как выпускник физтеха, а в прошлом преподаватель и научный работник, решил откликнуться.
    Так для меня началась история работы преподавателем в Технопарке. Собственно об этом (о работе, о Технопарке, о своем курсе и о студентах) я и хочу вам рассказать.

    Демотиватор, посвященный обсуждению курса Java *
    (*) Демотиватор был сделан на основе записи презентации курса «Углубленное программирование на Java» на выступлении «1 год Технопарка» и получил первое место на закрытом конкурсе демотиваторов.

    Задача статьи

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


    История создания курса

    Я ответил на письмо из рассылки. Придумать и прочитать курс по теме своей основной работы — это возможность одновременно получить опыт преподавания, лучше узнать язык программирования, по- новому взглянуть на себя и свою работу, и, вдобавок, заработать денег. Через пару дней мне написал руководитель Технопарка и предложил обсудить проект курса.
    Подробно о Технопарке я здесь писать не буду — есть отличная статья руководителя Технопарка Дмитрия Волошина.
    Полное название дисциплины курса, который мне предстояло прочесть, звучало так: «Углубленное программирование на Java». Это полугодовой курс для студентов, которые успешно прошли первый семестр обучения в Технопарке. К началу курса у студентов уже должны быть основные знания в области программирования и небольшой опыт разработки на каком-либо языке высокого уровня.
    Мне предстояло подготовить материал для 9 лекций и 6 семинаров (по 4 академических часа на каждое занятие). Курс должен был стать частью общей программы по подготовке web-разработчиков и системных архитекторов.
    Я был свободен в выборе тем и материалов, мог подготовить любой курс, соответствующий названию. Единственным обязательным условием была практическая направленность курса. То есть студенты должны были не просто прослушать теоретический материал, но и сделать ряд практических работ — например, решить задачи, похожие на те, которые решаем мы сами.
    Как я уже писал, я сотрудник отдела разработки клиентских компьютерных игр. Я участвовал в работе над проектом Аллоды Онлайн и сейчас работаю в серверной команде нового проекта SkyForge. Я пишу игры. Точнее, я пишу на Java серверную часть онлайновой игры. Мне надо подготовить курс для студентов, который был бы практически ориентирован на решение проблем, похожих на мои рабочие.
    Сформулировав свою задачу таким образом, я понял, какой курс нам нужен. Это должен быть курс, в процессе изучения которого студенты напишут на Java свой игровой сервер.
    Это курс по Java? Да. Это практический курс? Да. По моей работе? Да! Начальные условия соблюдены. Можно начинать разработку программы.
    Основную работу по подготовке курса я провел сам, но конечно, над многими вопросами я думал не один. Описывая результаты коллективной работы (обсуждений с руководством, коллегами, студентами) я буду писать «мы».

    Разработка курса

    Я начал работать над программой. Первая сложность, которая сразу бросалась в глаза — сервер бесполезен без клиента. Можно написать «божественный сервер», но, если к нему никто не сможет обратиться, ценность его будет невелика, и писать его будет не интересно. Писать свой клиент, тем более на Java, не было ни желания, ни времени. Решение, в общем-то, тоже бросалось в глаза. В качестве клиента можно использовать браузер. И написать сервер для браузерной игры. По той архитектуре, которую я опишу ниже, с точки зрения сервера разницы в том, какой клиент использовать, нет вообще никакой.
    Вторая сложность с подбором материалов была в том, чтобы найти баланс: их должно быть достаточно для создания законченного проекта, но при этом не слишком много, чтобы работу можно было выполнить за отведенное время. За 4 месяца, которые длится курс, студенты должны выполнить работу, равнозначную работе по разработке небольших браузерных и/или социальных игр. Насколько я знаком с такого рода разработками, весь цикл создания подобных игр у команды из 3-4 человек занимает 1-2 месяца. Но в разработке участвуют профессионалы (в большей или меньшей степени), и работают они full-time. А большинство студентов, с которыми нужно было работать мне, опыта разработки не имеют (здесь не важно на каком языке, важно, что нет опыта создания проектов). Вдобавок, кроме моего курса у них 2 курса Технопарка и еще неизвестно сколько курсов МГТУ.
    Мы решили, что для достижения наших задач нужно придерживаться ряда правил.
    • Все практические задания по разработке кода должны складываться в один проект. Ни одна строка кода не должна быть написана просто для тренировки
    • Для задач, не связанных непосредственно с курсом, мы используем сторонние библиотеки.
    • Студентов объединяем в группы по 3-4 человека. Одна группа разрабатывает один проект. Оценку за практическую работу получает вся группа.

    В результате в программу вошли следующие темы:
    1. История и особенности языка Java. Платформа Java. Java editions. Сборщик мусора. Сравнение Java и С++. Наследование в Java. Ключевые слова: interface, class, enum, extends, implements.
    2. class Object и class Class<?>. Классы «обертки» простых типов. Generics. Типизация. Iterator и Iterable. Обзор коллекций Java. Класс Collections. Многопоточность. Processes and Threads. Interface Runnable. class Thread. sleep(), interrupt(), join(). Потоки с точки зрения процессора. Прерывание. Java memory model. Volatile. Критические секции. Synchronization. Мьютексы. Семафоры. Monitor. Проблемы многопоточного доступа к данным. Atomic Variables. Deadlock. wait() и notify().
    3. Описание проблемы взаимодействия потоков. Задача — взаимодействие потоков Frontend и AccountService. Плюсы решения задачи через два потока. Способы взаимодействия потоков. Concurrent collections. Основная идея взаимодействия потоков через сообщения. MessageSystem — объект для обмена данными. Address и Abonent. Аналогия с почтой. Message — иерархия наследования сообщений. AddressService.
    4. Организация кода. Проблема циклических зависимостей. Решение циклических зависимостей через интерфейсы. Архитектура сервера. Разбор модулей сервера и их взаимодействия. Игровая механика. Диаграмма взаимодействия модулей игровой механики и фронтенда. Репликация. Примеры игровых механик.
    5. Виды тестирования. Unit-тестирование. Функциональное тестирование. Нагрузочное тестирование. Практики тестирования. JUnit. Selenium. Анализируемые параметры. GC. Виды GC. Параметры GC. Принципиальное устройство GC.
    6. Singleton и Context. Events, подписка на события. Callback. Анонимные классы. Random. Работа со временем и датой. Unix time. Locale. Подписка на время. I/O Streams. Потоки байт и потоки символов. Дерево наследования потоков. Файловые потоки. Безопасность закрытия потоков. File. VFS. Примеры кода.
    7. Сериализация/десериализация. Interface Serializable, transient поля, serialVersionUID. Reflection. Роль reflection в сериализации. Class<T>. Field, Method, Constructor. Пример ReflectionHelper-а. Factory method pattern. SAX и DOM парсеры. Восстановление объекта по XML-файлу. Ресурсы. Использование ReflectionHelper для десериализации ресурсов. Роль ресурсов в игровом сервере. ResourceFactory.
    8. Шаблон работы с базой. DataSet, DAO, Manager, Executor. JDBC API. Database driver. Connection. Statement. ResultSet. Executing SQL statement. Модуль для работы с базой данных. Dependency Injection.
    9. Annotation. Object Relational Mapping. Hibernate.


    Подробнее программу Технопарка вы можете посмотреть здесь.

    Напомню, что полное название курса — «Углубленное программирование на Java». Поэтому право на резкий переход от первого занятия с Hello World к многопоточности на втором занятии у меня было. В аннотации к курсу мы написали, что для успешного восприятия студентам необходимо знакомство с базовыми понятиями в Java. Что из этого получится, можно было узнать только на практике.

    Требования к слушателям курса

    Из трех слов, составляющих название курса («Java», «программирование» и «углубленное»), слово «углубленное» — самое неоднозначное. Если бы курс назывался «Введение в Java», было бы понятно, о чем рассказывать. «Углубленное» означает, что слушатели уже знакомы с программированием — причем не просто на языке высокого уровня, а именно с программированием на Java. Мы решили, что студенты уже должны знать следующее:
    • примитивные типы, переполнение
    • объекты, классы, наследование, инкапсуляция, полиморфизм
    • область видимости переменных, статические переменные
    • ветвления и циклы
    • преобразования примитивных типов
    • интерфейсы, реализация интерфейса
    • операторы, порядок выполнения операторов
    • стек, куча
    • модификаторы видимости (private, protected, public)

    В Технопарке учатся студенты второго—пятого курсов различных факультетов МГТУ. К моему курсу они подошли после первого семестра обучения. Проверку на мотивацию они прошли; все, кто не обладал базовыми знаниями, базовые знания получили. Среди студентов были и те, кто уже пишет на Java и зарабатывает этим деньги, и те, кто до курса на Java вообще ничего не писал.
    В результате часть слушателей на первой практической работе в первый раз написала «Hello world», а другая часть решила, что без шаблонизаторов и HTTP-сессий разрабатывать не интересно. По результатам первых двух занятий я решил, что правильно будет не ограничивать студентов, и разрешил использовать любые библиотеки, которые им известны. А к середине курса и вовсе разрешил писать свою Frontend-ную часть, то есть всю работу сервера с браузером организовать так, как им удобнее. При этом те, кто опыта работы на Java до этого не имел, могли продолжать учиться по моей программе. Использование дополнительных знаний на оценку не влияло.

    Особенности чтения курса в Технопарке

    Технопарк — дело добровольное. В том смысле, что мы не берем со студентов платы за обучение, не подписываем никаких контрактов и не обязываем посещать наши занятия — у студентов должна быть заинтересованность в посещении лекций и семинаров. Это должно быть их собственным желанием. А значит, сами занятия должны быть в первую очередь интересными. Если студент заинтересован происходящим, материал лекции он тоже запомнит и, скорее всего, придет на следующее занятие. Мы решили, что сделать не просто курс по Java, а курс по разработке игр — мало. Лекция в нашем понимании должна быть в некотором роде шоу. В первую очередь это отразилось в иллюстрациях к учебным материалам. Ниже — три примера из лекций:


    Матрешки-Бэтмены – иллюстрация к теме «Шаблон Decorator в Java I/O»,

    Обход дерева – иллюстрация к теме «Работа с XML-документами»

    Вуки на слайде с большим количеством кода — чтобы глазу было на чем отдохнуть

    Кроме слайдов, для привлечения внимания оказалось очень полезным задавать аудитории неожиданные вопросы. Например, «Кто помнит расстояние от Земли до Луны? Если у нас сервер с базами на Луне, какая будет минимальная задержка при записи в базу?». Или «Кто играл в корейские онлайновые игры? Вы можете объяснить термин ВКР?».
    Позитивно на восприятии сказывается и упоминание названий и игровых терминов, которые студенты не ожидают услышать в университете.

    Архитектура учебного сервера и практическая работа

    Не все, что я написал о курсе до этого, может быть понятно с точки зрения преподавания теории по языку Java. Если ограничиться только прочтением лекций по приведенной выше программе, смысл многих разбираемых в курсе вопросов останется неясным. Например, зачем нам многопоточность на второй лекции, зачем нагрузочное тестирование на пятой, и почему аннотации только в конце курса? Эта странность будет понятна, если рассмотреть курс со стороны домашних заданий и практической работы.
    Начну с описания задачи. Предлагаемый для разработки учебный сервер состоит из 8 модулей:



    Подробно о каждом модуле:
    1. main — зависит от всех остальных модулей. Содержит функцию main(). Создает все остальные модули в момент старта сервера. Запускает frontend, dbService и gameMechanics в отдельных потоках. Инициализирует библиотеку Jetty, передает в Jetty ссылку на frontend.
    2. Frontend — это одновременно и handler для событий Jetty (через браузер пользователь передает запрос в Jetty, Jetty вызывает handle у Frontend), и служба, живущая в собственном потоке. Frontend хранит только те данные о пользователях, которые нужны для создания страницы и пересылки ее обратно в браузер. Все расчеты происходят в потоке gameMechanics. Задача фронтенда — принять запрос от пользователя, передать его в нужную службу и отдать пользователю страницу (в асинхронном режиме).
    3. dbService — сервис связи сервера с базой данных. Живет в отдельном потоке, держит коннект к базе. Обрабатывает запросы остальных модулей и возвращает им ответы. dbSerivice может быть несколько, каждый в своем потоке.
    4. gameMechanics — служба сервера, в которой происходят все игровые события. Игровой мир живет в этом потоке. Для всех остальных сервисов это просто черный ящик. Разные игры, написанные студентами, должны отличаться только игровой механикой. Игровая механика обсчитывает все события и отправляет реплику на Frontend.
    5. messageSystem — общий для всех потоков объект, через который происходит обмен данными между потоками. Содержит по одной очереди сообщений для каждого потока. Желающий обратиться к другому потоку должен положить в соответствующую очередь специальный объект – сообщение. Получатель достанет это сообщение из очереди и обработает его в удобное для себя время. Результатом обработки может стать отправка ответного сообщения.
    6. resourceSustem — singleton, который позволяет всем службам обратиться к файлам с параметрам работы сервера (ресурсам). Подробнее о ресурсах вы можете почитать здесь.
    7. Утилиты – набор служб и хелперов для работы со временем, случайными числами и логами.
    8. base – набор интерфейсов и базовых классов всех служб.

    Вы можете сравнить архитектуру учебного сервера с архитектурой сервера Аллодов. Заимствование не полное, но очевидно, что мы всячески старались им подражать.
    Теперь о том, в какой последовательности мы все это писали. Работа была разбита на 6 семинаров:
    1. «Hello World», знакомство с Eclipse, знакомство с Jetty. Запуск web-сервера на localhost:8080, который возвращает страницу с «Hello Server!». Запоминание пользователя либо через сессии Jetty, либо через hidden поля на форме. Создание страницы, которая запрашивает саму себя раз в T миллисекунд.
    2. Запуск Frontend в отдельном потоке. Подсчёт из этого потока количества обращений, которые пришли к серверу со стороны пользователя. Запуск в отдельном потоке прототипа dbService (который пока к базе не обращается, а только имитирует обращение через кэш в памяти). Написание messageSystem для взаимодействия этих потоков через сообщения.
    3. Начало работы над игровой механикой. Студенты решают, какую игру они будут писать, и начинают разработку логики. Создание модуля gameMechanics в отдельном потоке, пересылка сообщений от Frontend к механике и обратно. Тестирование уже написанных модулей. Разработка unit-тестов и функциональных тестов.
    4. Создание утилит для работы со временем и случайными числами (если они нужны для механики). Создание модуля для работы с файловой системой. Перенос всех параметров из кода сервера в файлы (ресурсы).
    5. Работа с базами данных. Превращение «поддельного» dbService в настоящий.
    6. Завершение работы и защита сервера.

    Семинары проходили очень живо. Я и мой ассистент бегали между студентами, отвечали на массу вопросов разной степени сложности. Студенты показывали друг другу свои решения. Мы разбирали общие для всех проблемы и трудности. Некоторые из вопросов были действительно интересными, и мое желание «узнать в процессе преподавания о себе и о Java что-то новое» было удовлетворено полностью.
    Подход, при котором студент от состояния «ничего не писал на Java» за месяц переходит в состояние «написал web-сервер, который работает в 3 потока», может показаться жестким. Однако, как показывает практика, именно он работает лучше всего.

    Результаты первого семестра

    Большинство студентов предложенную выше программу освоили. Проблемы с восприятием материала были на третьей лекции, к концу которой мы разбирали взаимодействие потоков через систему обмена сообщениями. Сейчас я прочел эту же лекцию второму потоку студентов. И теперь мне кажется, что проблемы были не столько с восприятием, сколько с моими способностями объяснить материал. Повторное чтение курса, насколько я могу судить по степени остекленения глаз студентов, проходит гораздо продуктивнее.
    Почти на всех лекциях я показывал свой код и показывал, как он работает. В результате, даже если студент что-то не понимал на лекции, он мог просмотреть ее в записи и скопировать сложные участки кода. Исходники своего кода я не раздавал, и, как следствие, даже при заимствовании кода из лекции этот код надо было, как минимум, переписать.
    Главным результатом первого семестра я считаю доказанную студентами возможность написать за отведенное время проект web-севера по предложенной мной архитектуре. До защиты сервера дошли шесть групп из десяти. Три группы из шести подошли к задаче творчески и, кроме реализации всех модулей сервера, разработали интересную игровую механику.
    Ну и, конечно, опрос студентов после завершения курса:


    Экзамен и билеты

    Экзамен сдавали только те студенты, которые не смогли вовремя выполнить практическую работу. Мы решили, что это теоретики, и что они, возможно, смогут добиться признания в роли архитекторов. Чтобы получить отличную оценку, надо было ответить на 3 вопроса, случайным образом взятых из двух одинаковых наборов по 49 вопросов в каждом. Вариант, при котором студент вытащит два одинаковых вопроса, мы не стали отбрасывать. В этом случае он должен был отвечать на один и тот же вопрос дважды. Правда, таких счастливчиков на экзамене не было.
    Для полного представления о курсе привожу список вопросов:
    1. История и особенности языка Java.
    2. Платформа Java. Java Editions. GC, JVM, JDK, JRE. Bytecode.
    3. Правила наименований пакетов, классов, переменных и методов. Запуск Java-приложений
    4. class Object и class Class<?>. Основные методы этих классов.
    5. Простые типы в Java. Классы «обертки» простых типов.
    6. Generic programming в Java. Создание своих шаблонных классов и методов.
    7. Коллекции в Java. Iterator, Iterable.
    8. Processes и Threads.
    9. Interface Runnable. class Thread. Методы start() и run().
    10. Методы класса Thread: sleep(), interrupt(), join().
    11. Ключевые слова volatile и synchronized. Синхронизированные методы и выражения.
    12. Проблемы многопоточного доступа к данным. Race condition. Deadlock.
    13. Методы класса Object: wait(), notify() и notifyAll().
    14. Плюсы и минусы многопоточных приложений.
    15. Способы взаимодействия потоков.
    16. java.util.concurrent.
    17. MessageSystem. Address и Abonent.
    18. Распределение классов по пакетам. Циклические зависимости между пакетами.
    19. Архитектура игрового сервера. Схема зависимостей модулей.
    20. Процесс работы игрового сервера, репликация.
    21. Виды тестирования.
    22. GC. Виды GC. Параметры GC.
    23. Работа со случайными числами.
    24. Паттерны проектирования: Singleton и Context.
    25. Events. Подписка на события.
    26. Передача функции в библиотеку. Callback.
    27. Анонимные классы.
    28. Работа со временем и датой. Unix time. Locale.
    29. I/O Streams. Потоки байтов и потоки символов.
    30. Исключения: Throwable, Error, Exception, try, catch, finally.
    31. Сериализация/десериализация. Interface Serializable.
    32. Ключевое слово transient. Причины использования transient при сериализации.
    33. Reflection. Роль reflection в сериализации.
    34. Шаблон проектирования Factory method.
    35. SAX-парсер.
    36. DOM-парсер.
    37. Ресурсная система сервера.
    38. JDBC API.
    39. class Connection из JDBC API. Задачи, которые решает Connection.
    40. Dependency Injection. Использование при работе с базами данных.
    41. class Statement из JDBC API. Задачи, которые решает Statement.
    42. class ResultSet из JDBC API. Обработка ответа от базы.
    43. DataSet (элемент ORM).
    44. DAO (элемент ORM).
    45. Annotation. Использование аннотаций. Создание собственных аннотаций.
    46. Object Relational Mapping.
    47. Frontend — роль в составе сервера.
    48. Game Mechanics — роль в составе сервера.
    49. Database Service — роль в составе сервера.


    Заключение

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

    Благодарности

    В работе над статьей и курсом мне помогали:
    Александр Акбашев – QA сервера проекта SkyForge, аспирант МГТУ и мой ассистент в Технопарке.
    Дмитрий Волошин – директор отдела исследований и образования Mail.Ru Group.
    Сергей Загурский – руководитель команды сервера проекта SkyForge.
    Тимур Бухараев – руководитель web-команды проекта SkyForge.
    Mail.ru Group
    999,92
    Строим Интернет
    Поделиться публикацией

    Похожие публикации

    Комментарии 43

    • НЛО прилетело и опубликовало эту надпись здесь
        +1
        Он скорее в ужасе схватился за голову при виде такого кода.
          0
          Следующая за демонстрацией работы этого кода задача была — сделать так, чтобы потоки написали в лог свои сообщения строго в порядке нумерации (1,2,3...). Для этого надо было использовать wait() и notifyAll(). У вас есть решение этой задачи?
            0
            Можно вместо wait() и notifyAll() воспользоваться синхронизаторами — это намного эффективнее. CountDownLatch, CyclicBarrier, Exchanger, Semaphore — выбирай, как говорится, любой на вкус и под задачу.
              0
              Можно, но у нас задача — рассказать студентам о Java весело и доступно.
                0
                Теперь понятно, почему ява тормозит!
                  0
                  Имхо, решение с CountDownLatch намного веселее и доступней, чем wait/notify.
            +2
            И правда! StringBuilder тут не нужен.
            Я о нем как раз рассказывал до этого и в примере с кодом он остался.
            Сейчас поправлю.

            Этот код — пример того, что последовательность запуска потоков не определена.
            Собственно эта неопределенность и привела вуки в замешательство.

            Код демонстрационный, поэтому может быть избыточен.
              0
              Пример не у Эндрю Тролсен взят?
                0
                Нет.
                Пример как идея: «показать, что потоки могут быть запущены в произвольном порядке» вроде ни у кого заимствовать не надо. В любом языке с поддержкой потоков такой пример, мне кажется, обязательно надо на лекции показывать.
                Пример как код… А что Тролсен про Java писал? Я только про C# знаю.
                  0
                  Нет про Java не слышал, в книге о C# есть почти такой же пример! ))
                  +1
                  Если тема многопоточности всем так интересна, там еще один пример был:

                  public class ThreadInterference extends Thread {
                  	private static final int HandredMillion = 100000000;
                  	private static int i = 0;
                  	private static int j = 0;
                  	public void run(){
                  		while( j < HandredMillion ){
                  			i++;
                  			synchronized (this) {
                  				j++;
                  			}
                  		}		
                  	}
                  	
                  	public static void example(){
                  		Thread first = new ThreadInterference();
                  		first.start();
                  		Thread second = new ThreadInterference();
                  		second.start();
                  		
                  		try {
                  			first.join();
                  		} catch (InterruptedException e) {
                  			e.printStackTrace();
                  		}
                  		
                  		System.out.println("j: " + j + " i: " + i);
                  	}	
                  }
                  
                  


                    +5
                    Hundred
                      0
                      А можно поинтересоваться, что именно вы этим примером иллюстрируете? Меня больше всего смущает то, что lock у потоков не общий, т.е. хоть j и будет в итоге равно сто миллионов (или сто миллионов и один при некоторых таймингах), но общее количество итараций все равно будет больше ста миллионов.
                        0
                        Конечное значение i может быть как больше так и меньше ста миллионов.
                    0
                    Можно ещё дополнить, что в указанном примере приведены классические «гонки».
                  +6
                  А можно будет где-нибудь почитать этот курс?
                    +1
                    Да-да, было бы очень здорово прочитать такой замечательный по описанию курс.
                      +1
                      Дык читайте, если есть такое желание. Вот автор уже прочитал. И Вы почитайте! Я уверен, что есть много вузов, в которых с удовольствием бы этот курс послушали. :)
                        0
                        На данный момент в свободном доступе есть только программа курса.
                        В этом семестре мы записываем лекции на видео и летом эти записи будут доступны всем, а не только студентам Технопарка.
                        Книги по курсу пока нет. Все наши курсы авторские. Материал собран из массы различных источников.
                        Не исключено, что мы выпустим сборник работ по нашим лекциям когда наберем достаточно материала и опыта.
                          0
                          Я бы посмотрел. Игры давняя мечта (Но я же джава программист! КАКИЕ ИГРЫ!). Надеюсь будет пост на хабре о появлении записей в общем доступе? Или может вы в онлайн вещаете?
                            +1
                            Будет.
                              +1
                              Не могу плюсовать. Не хватает силы. Я глянул видео, на которое ссылка, очень понравилось. Вот бы у нас во всех универах так преподавали. Эх.
                                0
                                May the Force be with you
                            +2
                            Нотч смотрит на вас с удивлением.
                              –2
                              Играл я в мк. Это мнение только укрепило почему то.
                            0
                            Дополню Виталия: мы готовим видеозаписи всех лекций и, отдельно, SCORM-курс (видео-модули по 15 минут с промежуточным тестированием). Если все пойдет удачно, то летом появится этот курс в формате e-learning.
                          0
                          Я когда только начинал тыкать яву и C#, я всегда писал «некий абстрактный игровой сервер для игр типа MUD». Ооочень помогает изучить платформу: и работа с потоками, и работа с сетью, работа с файлами, разбор как подключать библиотеки и что делать дальше, сигналы(C#), генерики и так далее. Я теперь всегда, когда делать нечего, а попрограммировать хочется ради программирования, пишу что-нибудь в этом роде. Пусть никто никогда не увидит, пусть не имеет ценности, но опыта дает не мало.
                            0
                            У меня в курс сеть не уместилась. Очень хотел сделать не многопоточный, а многопроцессный сервер. И под MessageSystem положить еще и сетевой уровень, чтобы сообщения передавать между абонентами на разных машинах.
                            На лекциях рассказать успею. Написать не успеем.
                              0
                              Да, оказалось, что никто из моих студентов в MUD не играл. Рассказывал истории из своего опыта.
                                0
                                Д уж, я бы с удовольствием, конечно, послушал такую лекцию. Хотя профессионально я и работаю совсем в другой области, но для общего развития эти темы очень интересные и необходимые, имхо.

                                Что касается меня, я выбирал MUD именно из-за отсутствия необходимости реализовывать клиент — даже для «браузерки» нужно что-нибудь да и сверстать, а тут — телнет. Красота
                              • НЛО прилетело и опубликовало эту надпись здесь
                                  0
                                  Ну, мне иногда хочется пописать именно что абстрактные фабрики синглтонов. Некие странные никому не нужные вещи. Выразить, т.к. сказать, себя. А баг-репортов от кастомеров мне хватает и на работе. Я ее тоже люблю, и люблю то, чем занимаюсь на работе, но и ради разнообразия надо как-то отвлекаться от кастомеров, от баг-репортов, от пользователей.
                                0
                                1. Как обстоят дела со смежными вопросами, с которыми в любом случае придется столкнуться при Java-разработке, но при этом Java по сути не является. Навскидку это минимум maven, системы контроля версий, реляционная модель базы данных, основы протокола HTTP и т.п. Это входит в программу курса или остается на самостоятельное обучение?
                                2. Есть ли идеи добавить в обучение симуляцию реального процесса разработки, например, таск/баг-трекинг, ревью кода, continues integration, группы тестирования и аналитики (хотя бы в примитивном виде), планы и дедлайны, agile-методологии и пр.?
                                  0
                                  1. Мой курс — курс второго семестра Технопарка. На первом семестре студенты изучали web технологии, алгоритмы и структуры данных и C++. Полная программа Технопарка здесь.
                                  То есть подготовка по web, алгоритмам и языкам высокого уровня у них к началу изучения курса уже есть.
                                  Параллельно с Java студенты изучают курс по базам данных и нагрузке.
                                  К тому моменту как мы подходим к работе с базами из Java, курс по базам уже практически закончен.
                                  2. Мы как раз думаем об изменении формата курса в еще большую сторону от теории к практике.
                                  По моей задумке к концу семестра студенты должны сделать работу, которую можно будет показывать как прототип инвестору. А опыт разработки, полученный при ее написании, позволит считать группу студентов — коллективом разработчиков.
                                  Как будут результаты — напишу.
                                  –1
                                  Для полноты картины, рассказали бы, как передается изображение с сервера в браузер.
                                    0
                                    Не совсем понял предложение.
                                    Механизм передачи? То есть то, как по сети в браузер уходит статика сайта? Об этом у студентов был курс web технологий.
                                    То как отдавать статику? Статику можно отдавать из Jetty. Об этом я студентам рассказал.
                                      0
                                      Я имел ввиду, в каком формате изображение передается (передавать всю картинку на каждый кадр ведь накладно) и каким плагином оно в браузере воспроизводится.
                                        0
                                        кхм… Вы в курсе, что такое браузерные игры?
                                          0
                                          Абсолютно не в курсе.
                                          0
                                          Север формирует на каждый «кадр» html страницу. В минимальном варианте всю, в нормальном через ajax только нужный участок. Это текст который получает браузер и интерпретирует его. В тексте есть ссылки на картинки. Картинки неизменны (например это иконки танков или роботов). Эти картинки мы тоже можем отдавать из сервера как статику страницы.
                                          Никаких плагинов для этого не нужно. Нужен браузер с поддержкой javascript: о)
                                            0
                                            Как интересно… И что, из отдельных картинок можно cформировать качественное изображение? Танк едет, он же поворачивается, и фон меняется.

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

                                    Самое читаемое