Опыт обучения школьников программированию

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

    Но еще интереснее оказалась часть проекта, ориентированная на работу со школьниками. Я принимаю непосредственное участие именно в этой части, поэтому хочу рассказать о ней.

    Проблема школьного обучения программированию


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

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

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

    Методика И. Р. Дединского

    Поиск методик преподавания, отличных от современных школьных шаблонов, вывел нас на замечательного, увлеченнейшего человека — Илью Рудольфовича Дединского. Он работает старшим преподавателем в московском Физтехе (МФТИ) плюс учителем в физматшколе, и добивается со школьниками потрясающих успехов — его ученики уже в 9-11 классе пишут программы, по сложности соответствующие 3-4 курсу технического вуза (!) — компиляторы, трехмерные движки, моделируют физические процессы, осознанно работая с проектами значительно большего объема, чем можно ожидать даже от студентов. Причем, что важно, Илья Рудольфович добивается таких результатов регулярно. Это не звезды, это обычные ученики (правда, из физматшколы). Как говорит он сам, «методику нужно судить по середнякам». «Звезды» будут всегда, отстающие, увы — тоже. Уровень же, достигнутый основной частью группы — вот истинный показатель качества применяемой методики и работы учителя. Примеры достижений его учеников приведены на сайте Ильи Рудольфовича, в частности, это работа десятиклассника Ивана Шаповалова Платформа для машинно-независимого исполнения программного кода с возможностью JIT-компиляции и коллективная работа Леонида Столярова (9 класс), Федора Петряйкина (9 класс) и Никиты Уварова (7 класс) Платформа для автоматной многоагентной системы в стиле 3D-Action.

    Мне довелось встретиться с Ильей Рудольфовичем, пообщаться с ним лично, послушать рассказ о его методике «из первых рук». Взяв ее за основу, мы разработали собственный вариант его программы обучения, основанный на тех же принципах. К сожалению, использовать оригинальную методику Ильи Рудольфовича для нас очень сложно в силу нехватки педагогического опыта. Вполне вероятно, что мы пока не оценили всех её преимуществ и возможностей, поскольку Илья Рудольфович оттачивает свою программу обучения не один год. Полагаю, что с опытом придет понимание, что можно улучшить в нашей программе. Но, как вы понимаете, программа обучения — не та вещь, которую можно бездумно копировать, её нужно понять на собственном опыте. Ниже изложены принципы, которые положены в основу нашей программы обучения, как я их понимаю и применяю в своей практике (с оригинальным изложением принципов авторской методики вы можете ознакомиться на сайте И.Р. Дединского в разделе «Основные материалы»):

    1. «Учить только хорошему». Дети должны сразу, с первого занятия видеть перед собой правильные, хорошие цели и правильные, хорошие примеры. Если не обратить внимания на какие-то вещи (например, форматирование кода), пустить их на самотек, дети сделают это так, как «поймут» сами. Впоследствии их придется переучивать, а это всегда намного менее продуктивно, чем учить правильно с самого начала. Поэтому на первом же занятии дети узнают, как правильно пользоваться пробелами и отступами, и почему важны пустые строки, разбивающие программу на логические фрагменты. С первых же занятий вводится понятие качества имен, и от детей требуется использовать понятные имена для переменных и функций.
    2. «Учить программированию, а не языку». Все понятия, даваемые детям, выводятся как инструмент решения проблемы. Даже не совсем так: сначала формулируется проблема, дается возможность её «пощупать», попробовать решить имеющимися средствами (в качестве домашнего задания или вместе с преподавателем в классе). Например, мы умеем рисовать на экране домик (у нас уже есть такая функция). Давайте нарисуем на экране 5 домиков друг за другом. Задачу, безусловно, можно решить, вызвав функцию 5 раз. Но, проверяя технологию, мы задаем вопросы: а если надо будет 10 домиков? 50? 100? А если 4? А если столько, сколько поместится на экране? Или столько, сколько введет пользователь программы? Затем детям предлагается обсудить, как можно было бы решить эту проблему, и обычно они сами, с некоторой помощью преподавателя, формулируют с той или иной степенью приближения идею цикла. Лишь только затем рассказывается синтаксис оператора цикла в выбранном для обучения языке программирования.

    Последовательность задач


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

    Одна из проблем современного школьника, даже математически образованного, иллюзия компетентности в работе с компьютером (все знают, как скачать музыку или установить Skype) и одновременно страх и неуверенность перед программированием («это сложно, мне никогда не понять»). Поэтому для снятия этого страха на первом же занятии детям предлагается поиграть в деловую игру, которая на первый взгляд не имеет отношения ни к компьютерам, ни к программированию1. В ходе игры участники воображают себя владельцами рекламного агентства, в которое приходит некий заказчик (преподаватель) и хочет заказать рекламный баннер. Но какой именно, не объясняет, ссылаясь на усталость, и предлагает задавать ему вопросы, из ответов на которые и будет составлен контракт. Такое вот завуалированное обсуждение ТЗ. На все вопросы о деньгах, установке баннера, разрешениях на установку и прочем успокаивает: «Это не проблема. Деньги есть, разрешения есть, не первый раз такую рекламу вешаем, рабочие уже вызваны». Подвох в том, что баннер нужен завтра, а его размер — 100 на 400 метров. Что же он с ним таким огромным будет делать?

    Зачем нужен баннер (монолог вредного заказчика)

    «Понимаете, я владелец крупной торговой сети «Чайник анлимитед». Мы продаем любую посуду — от коллекционных чашечек тончайшего фарфора до металлических чайничков. Вот недавно продали в Эмираты сервиз… миллионов за 50, из платины. Сейчас переговоры с Китаем на крупные поставки недорогой посуды. Так вот, я открываю магазин в вашем городе, и так получилось, что совершенно забыл про рекламу. Помощник заболел, а у меня из головы вылетело. Дату открытия сдвинуть не могу — все распланировано, заказано, будет ущерб для репутации… Я, честно говоря, сегодня с этим вопросом был у ваших конкурентов, мы много говорили, пили чай, все было очень мило, но… в последний момент они сказали, что у них какие-то сложности, и заказ они не возьмут. И я пришел к вам. В общем, нужен баннер. Хотя бы один. Я немного устал от разговора у ваших конкурентов, поэтому не хотел бы снова излагать детали заказа, и поэтому давайте так — если вы что-то хотите спросить или уточнить, то спрашивайте, и это и составит текст нашего договора.»

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

    Кто же это сделает?

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

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

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

    Программа на псевдокоде
    Включи библиотеку (включи в свою голову знания из нее о том как рисовать)
    
    Главная работа
    Начало
      Установи холст 100 400
    
      Установи цвет красный
      Линия 25 300 75 300
      Линия 25 300 50 100
      Линия 50 100 75 300
    
      Установи цвет зеленый
      Окружность 65 200 40
    
      Установи цвет синий
      Линия 40 180 20 80
    
      Вернуть результат
    Конец

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

    Программа на C++
    #include "TXLib.h"
    
    int main()
    {
      txCreateWindow(100, 400);
      
      txSetColor(TX_RED);
      txLine(25, 300, 75, 300);
      txLine(25, 300, 50, 100);
      txLine(50, 100, 75, 300);
    
      txSetColor(TX_GREEN);
      txCircle(65, 200, 40);
      
      txSetColor(TX_BLUE);
      txLine(40, 180, 20, 80);
    
      return 0;
    }
    

    Библиотека TXLib.h (TX означает «тупой художник») разработана Ильей Рудольфовичем и предоставляет простой API для рисования различных рисунков, работающий под Win32. Подробнее с ней можно ознакомиться на его сайте.

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

    Кратко о дальнейшем обучении

    Домашним заданием после этого занятия является написание программы, рисующую несколько героев будущего мультфильма. Функция main сразу распухает до 50-100 строк, а у некоторых увлеченных учеников и больше. Поэтому на втором же занятии вводим понятие «функция» — пока без параметров, вида void DrawMan(),— и таким образом разбиваем программу на части. Для часто использующихся цветов вводим понятие «константа» и называем появляющиеся в программе константы понятным образом. Упор делается именно на понятность имен функций и констант. Фактически, это занятие о группировке кода и именовании.

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

    После этого пробуем сделать анимацию — движущиеся объекты, простейший «мультик». Вводим понятие «цикл» (и здесь же локальные переменные). Опять упор на понятные имена переменных, на отступы в цикле. Пишем цикл, в котором рисуются персонажи мультика. Уже на этом этапе дети начинают рисовать достаточно сложные и эффектные сцены: например, у одного из моих учеников был нарисован домик, над которым «пролетало» солнце от восхода до заката, затем луна. Цвет всего рисунка менялся в зависимости от положения солнца (луны) на небе. Словами это описать непросто, но выглядело весьма эффектно.

    Когда у функций становится ну очень много параметров, вводится понятие «структура», и объекты мультфильма описываются в виде структур. Снова делается упор на понятность имен структур и их полей, на логичность группировки данных в структуры.

    Затем обсуждается возможность использовать написанный код повторно, для создания другого мультика с теми же персонажами. Вводится понятие «библиотека» (на этом этапе все складывается в один .h файл, раздельной компиляции не вводим, так как это весьма трудно для понимания всеми начинающими). Предлагается оформить функции в библиотеку, использовать её самим в программе, документировать, снабдить примерами работы с ней и дать пользоваться товарищам. Товарищи же, получив чужую библиотеку, пробуют её использовать и пишут рецензию, по итогам которой выпускается новая версия библиотеки (фактически, это выпуск SDK и peer review).

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

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

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

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

    Итог


    Я занимаюсь со школьниками по этой программе примерно один учебный год (с прошлого октября). Режим занятий — 2 раза в неделю, одно занятие — 3 академических часа (120 минут, включая десятиминутный перерыв). Группа разновозрастная, от 8 до 11 класса. Но результатом я могу гордиться — дети действительно научились решать задачи самостоятельно. Уверен, что мои ученики 8-9 класса школьные разделы по программированию 10-11 класса пройдут с легкостью. Последний раз, когда было дано задание написать программу «Угадай число» (компьютер загадывает, игрок угадывает по принципу «больше-меньше» — двоичный поиск) все справились с ней самостоятельно. Я просто ходил и наблюдал, как дети итеративно накручивают функционал — почти все начали с главной проверки (if на совпадение/больше/меньше), потом «обернули» её в цикл, потом начали добавлять «украшения». В результате, после нескольких замечаний, получился код, за который мне никак не стыдно. Разумеется, это далеко не самая сложная задача, которую ученики способны решить, но этот пример оказался для меня очень показательным, поскольку дал возможность увидеть самостоятельную работу с начала и до конца за один урок.

    Могу сказать, что, по моему мнению, взятая нами за основу методика обучения И. Р. Дединского, — это большой прогресс в области обучения детей программированию. Она подводит базу под процесс обучения, позволяет систематизировать его, заинтересовать детей, показать им, что программирование — это очень интересно, позволяет дать детям больше знаний и навыков в области программирования, чем традиционная школьная программа. Но хочу отметить, что эта методика предъявляет немалые требования к преподавателю. Многие не всегда осознаваемые нюансы (например, выбор преподавателем чересчур абстрактного имени для функции или переменной ради сокращения записей, или введение глобальных переменных для «упрощения» объяснения работы функций) имеют далеко идущие неприятные последствия, которые нужно хорошо осознавать. Преподаватель должен обладать опытом практического программирования, чтобы внятно объяснить, почему нужно делать именно так, а не иначе, и очень желательно на примерах из практики (а не через запреты без объяснений). Он должен уметь быстро разбираться в коде учеников, оценить его состояние и последствия его развития, представить себе, мог ли подобный фрагмент кода быть использован в реальном проекте. Допустим, оставленная неинициализированной переменная: на учебной машине она не всегда приводит к ошибке, но при смене компилятора/версии компилятора/версии ОС/фазы луны может приводить к неопределенному поведению программы. Неудачные имена переменных, нарушение стиля: почему здесь все с большой буквы, а тут с маленькой? почему здесь «верблюжий» стиль, а здесь через подчеркивание? —вот некоторые из «мелочей», из которых складывается не только функционально рабочий, но и чистый, правильный, профессиональный код, и на это преподаватель должен обращать особое внимание. К сожалению, без практического опыта этот навык приобрести довольно сложно. Практический опыт, кроме того, хороший аргумент. При объяснениях я часто использую пример «… и улетели вы в отпуск на Таити. А тут — бац, ошибка в вашем модуле! Коллеги в панике, разобраться в вашем коде быстро не могут, вас срочно отзывают из отпуска —и вот вы прямо в пляжных шортах оказываетесь на рабочем месте». Немного преувеличено, конечно, но суть передает.

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

    Ссылки


    Сайт Ильи Рудольфовича
    Библиотека TXLIb
    Документация на TXLib
    Презентация Дединского по методике преподавания (pdf)
    Доклад Дединского «Аналитический подход к довузовскому преподаванию программирования»
    Учебные программы (pdf)


    1 Игра «Вредный заказчик» и последующая за ней «Звонок тупому художнику» заимствованы из программы И. Р. Дединского практически полностью. (Назад к тексту)
    Поделиться публикацией
    Реклама помогает поддерживать и развивать наши сервисы

    Подробнее
    Реклама
    Комментарии 164
    • –15
      Плюсы? Детям как первый язык?
      • +16
        Почему нет? Тем более плюсов там нет в примере, чистый С. Да если бы был — учат же не языку, а программированию. А это разные вещи.
        • –3
          ИМХО, идеальный вариант, сам начинал на псевдокоде, но по настоящему удовольствие стал получать когда стал в старших классах писать программы на C++. Они короче, быстрее пишутся и проще для понимания.
          • –12
            Но пожалуй сейчас актуальнее брать первым языком JavaScript.
            • +4
              Увы, не подходит в первую очередь из-за отсутствия статической типизации, см. мой ответ ниже.
              • –9
                C JavaScript легко найти подработку после уроков, вакансий полно. А проект на C++ ещё найти надо.
                Без статической типизации вполне можно жить, почему она так важна для обучения — неясно.
                • +7
                  Вы серьезно? Подработка для школьников? Это же даже не студенты, их знаний и навыков не хватит на серьезный проект, даже в рамках «подработки». В каком джаваскрипт-проекте сейчас обходится без jQuery, node.js или какого-то подобного фреймворка? Предлагаете учить школьников еще и этому?

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

                  Мы и так в Си наступили на несколько неочевидных ошибок, связанных с преобразованием типов (наподобие применения abs к double), боюсь с JS это было бы намного страшнее.
                  • +1
                    Фреймворки — это отдельная тема. Аналогично я могу спросить будете ли вы рассказывать про Boost?
                    Что касается школьников, вы их недооцениваете.
                    В идеале вылавливанием ошибок должны заниматься тесты, а не компилятор.
                    • +3
                      Не буду. Но и не буду предлагать участвовать в реальном проекте, поскольку там обязательно найдется STL, Boost, Qt, Gtk или еще какая-нибудь библиотека. После второго года обучения, возможно, дети с этим справятся, после первого — нет.

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

                      Но начинать обучение нужно с обучения программированию, основ. И джаваскрипт для этого далеко не самый подходящий язык.
                    • 0
                      Сам школьник, часто принимаю заказы от студентов сделать курсовые по программированию(в основном программированию графики на OpenGL ). Вполне нормальная подработка, что скажете?
                      • 0
                        Извините, в каком вы классе и сколько времени уже изучаете программирование?
                        • 0
                          Перешел в 10. Изучаю именно программирование около 4 -5 лет, около 2ух именно OpenGL. Естественно, пока изучал графику, за одно и познал некоторые элементы линейной алгебры, такие как матрицы, так что математическая база у меня несколько выше, чем та, что дают по школьной программе.
                          • +2
                            Вот вы и ответили на свой вопрос. А в начале обсуждения речь шла о том, чтобы изучать JS в качестве первого языка, под предлогом того что «C JavaScript легко найти подработку после уроков». Я и ответил что о подработке раньше чем через 2-3 года занятий говорить рано (не считая особо выдающихся учеников). Ваш пример только подтверждает мои слова.
                            • 0
                              Мм, действительно, извиняюсь. Просто я изначально не понял, что речь идет именно о подработке СРАЗУ после уроков(быть может это потому, что звучит это крайне нелепо).
                            • 0
                              Ситуация один в один, коллега :-)
                              А по поводу статьи: все верно, на уроках ИВТ учат не применению полученных знаний на практике, но синтаксису языка, что от реальности очень далеко. При этом учат штампованным алгоритмам, не разрешая отступать от них ни на шаг, даже в именах переменных.
                        • 0
                          Так сложилось что в следующем году я буду преподавать веб-программирование школьникам. Естественно там будут тонны JavaScript на клиенте и сервере. Эти школьники с пятого класса играются с роботами лего и Arduino. Юный техник возрожден. Но информатика у них будет только с 10 класса, а они в восьмом ) И что делать? Я буду учить по мотивам курса Startup Engineering чтобы они могли продвигать свои поделки.
                  • 0
                    Я за плюсы, но только если дети его действительно осиливают. Все таки это не на Бейсике квадраты с окружностями заливать. Может Си лучше для начала?
                    • +1
                      Ну по сути первый год обучения там и есть Си. Плюсы если и возникают, то только в виде небольшого синтаксического сахара к сишным конструкциям.
                    • +1
                      Лично у меня вышло как-то наоборот: в 7-8 классе, когда изучали псевдокод, я ни черта не понимал и все списывал. Как дело дошло до реального языка — я стал, без преувеличения, лучшим в классе и начал самообучение языку.
                    • +13
                      Да. На самом деле в начале обучения обходимся в основном Си, элементы «плюсов» появляются значительно позже.

                      А какие на самом деле еще варианты? Обучение начинается с процедурного программирования, поэтому Java, C# и прочие OO-языки, где без объекта простейшей программы не напишешь не подходят. К тому же в них достаточно «магии», наподобие сборщика мусора — это тоже плохо. Значит нужен процедурный язык. Нужна статическая типизация — это полностью укладывается в принцип «учить хорошему». Из чего выбирать? Паскаль и Си — ИМХО больше кандидатов нет.

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

                      Как показывает практика, Си нормально воспринимается детьми, он не настолько сложен. Точнее — из него можно выделить подмножество достаточно простых конструкций и пользоваться ими, оставив «дебри», такие как шаблоны, множественное наследование и т.п. на будущее.
                      • +1
                        Нас в своё время именно на Паскале обучали. Turbo Pascal, даже не Object. Не скажу, что он мне нравится, но основы алгоритмизации на нём очень хорошо изучать. Если бы начали сразу с Си, то может и был другой эффект, не знаю. По крайней мере, опыт изучения разных языков всегда пригодится.
                        • 0
                          Ну по крайней мере большинство современных языков Си-подобны. Тот же C#, Java, Javascript — после изучения Си их синтаксис покажется знакомым. А вот синтаксис Паскаля — увы, отдельно от всего остального. В «свое время» он был эффективным средством обучения, сейчас — увы.

                          А основы алгоритмизации можно и на Си очень хорошо преподать. А кое-какие структуры данных, те же списки — даже проще чем на Паскале (по крайней мере мне указатели в Паскале всегда казались какими-то странными).
                          • +4
                            «одним из design goals при разработке Паскаля была возможность LL(1)-разбора — т.е. автоматом, который видит только один следующий символ текста. Большинство «живых языков» в LL не укладываются: например, в Си на int может начинаться объявление либо переменной, либо функции, и мы не может отличить одно от другого, пока не дочитаем строку до конца.»
                            habrahabr.ru/post/99466/

                            Это к слову о странности.
                            • 0
                              Пытался обучить человека Си. Сразу взрывается мозг при попытке понять что такое &, * и прочая магия. А без & сложно понять даже как ввести данные с консоли.

                              Не думали про GoLang? Язык не особо популярен, но живее того де паскаля, за ним гугл.
                              • 0
                                Если начинать с консоли — да, сложности будут. Но с ними можно справиться, если на первом этапе сказать «сейчас делай так, потом разберем подробнее что это за конструкция». Поэтому мы до консоли добираемся где-то во втором семестре, рассматриваем printf, scanf. А первый семестр построен целиком на рисовании через TXLib, там нет таких сложностей, все достаточно несложно и логично.

                                GoLang я, к сожалению, не знаю, поэтому не рассматривал. Учить нужно на том языке, который знаешь сам.
                                • 0
                                  Когда приходится начинать с консоли (при переучивании первокурсников с Паскаля на Си), то объясняю так: когда scanf воспримет число с клавиатуры, он должен знать, куда его положить. Передать ему просто «х» — означает передать значение «х», а это ему бесполезно. Надо передать информацию, где находится переменная «х», где она лежит в памяти, какой у нее адрес. Как узнать этот адрес? Для этого есть оператор "&". &x — «адрес того места, где лежит переменная х». Поэтому когда на улице подходит гопник и спрашивает, с какого вы района, то он всего лишь применяет к вам оператор & :) Зная адрес, scanf закинет (запишет) туда значение. Кстати, термин «адрес» понятнее начинающим, чем «указатель», и второй я ввожу как синоним первого.

                                  Вообще-то, конечно, лучше создать ситуацию, в которой очень хочется, чтобы функция меняла значение параметра. Например, напишем простейшее моделирование движения шарика по экрану с отскоком от стенок. Если говорить кратко, то отскок там будет выглядеть как vx = -vx или vy = -vy под условиями. Таких случаев будет 4 (не надо сокращать до двух:) ), и если рефлексы обучаемого правильно развиты, он захочет выделить эту физику в функцию. Реализовав ее, увидим, что шарик стоит на месте. Тут как раз очень удобно объяснить, что при вызове функции значения переменных скопируются и драматически проиграть эту ситуацию с листочками, на которых написаны значения — в конце «исполнения» листочки-копии с обновленными значениями торжественно разрываются и выбрасываются. Чтобы отменить копирование, надо передать не значение-копию, а информацию о месте, где лежит листочек-оригинал, т.е. его адрес. Далее см. объяснение выше. (Плюс есть еще пара аллегорий на тему копирования и указателей, которые придумались за время таких объяснений.)

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

                                  • 0
                                    Понятные объяснения, но мне кажется вы недооцениваете сложнось преподавания школьникам. Я использовал эти сравнения, но все равно пришлось про указатели повторять несколько раз разными словами, в том числе рисовать на доске таблицу «адрес — значение».

                                    Отличие между использование return и указателя на самом деле ввести просто: если функция модифицирует свой параметр — передаем указатель, если вычисляет что-то новое — используем return.
                                    • 0
                                      Если школьникам, то я ввожу это только вторым (основным) способом. Многое зависит от подробностей «игр» с листочками и используемых метафор, от умения читать декларации (plain-style, Yoda-style). Т.е., практически, это и есть повторение разными словами и даже способами. Это нормально, ведь ученик здесь впервые встречается с понятием явной косвенности в программировании, с которым он в других областях привык работать неявно. Кроме того, он впервые знакомится с базовыми понятиями архитектуры (адрес). Плюс, поняв концепцию, ему далее надо не запутаться в обозначениях. :)

                                      Рисовать таблицу на доске или фрагмент оперативной памяти — очень и очень правильное занятие!

                                      Про возврат значения я имел в виду не объяснение как таковое, а формирующиеся привычки. Если ученик не привык явно возвращать значение функции, он имеет тенденцию не пользоваться return (даже если он знает, что это такое), а передавать переменную по указателю. Часто это сочетается с неразборчивостью форм передачи переменной (проще говоря, он все начинает передавать по указателю, ему так проще, т.к. не надо тщательно продумывать о роли переменных) — далее это ведет к спутанности логики и неудачной архитектуре. Синтаксический сахар в виде ссылок здесь приводит к синтаксическому «диабету» и провоцирует эту спутанность, т.к. не надо думать даже о синтаксисе. Склонность некоторых паскалистов передавать параметры как var (через ссылки) имеет ту же природу.
                                      • 0
                                        А на примере какой задачи вы вводите return и как она встраивается в программу? Я не увидел возможности дать возврат значения во время обучения анимации, поэтому в моем курсе они оказались перепутаны — сначала указатели, потом return.
                                        • 0
                                          В задаче движения шарика можно ввести препятствия, это превращает (управляемую) анимацию в простую игру. Столкновение с препятствием или другим шариком можно рассчитывать по теореме Пифагора, это достаточно муторная запись, чтобы возникла мотивация сделать функцию с возвращаемым значением (про hypot не рассказываем). Если дети не знают теоремы Пифагора, то можно работать через txGetPixel, но тогда их потребуется несколько, чтобы учесть размеры объектов — это тоже мотивация для рефакторинга с выделением кода в функцию.

                                          При дальнейшем развитии игры возникает желание сделать главное меню программы с пунктами «игра», «выход» и т.д., а это проверки на нажатия мышки в прямоугольник (опять функция с return-ом). Кроме того, функции игры часто полезно возвращать значение {проиграл, выиграл, прервал игру, что-то еще} для какой-либо индикации или действий в главном меню (например, break из цикла или rerurn из main).
                                          • 0
                                            У меня так и получилось, когда начали делать игру. Но ведь сначала делается движение (указатели) и только потом проверка на столкновения (return). А в комментарии выше, вы пишете что указатели нужно давать до return.
                                            • 0
                                              Имхо совсем необязательно в одном занятии делать прототип движущихся шариков с физикой, прописанной в прямо цикле движения, и рефакторинг кода с выделением функции (и указателями). Можно сначала рассмотреть препятствия и return. Хотя в принципе, если группа сильная и уверенность в ней есть, можно return давать и после указателей. Главное, чтобы произошло не вытеснение одного метода передачи результата другим, а грамотная расстановка акцентов. В слабой группе это не всегда просто дается, и тогда я не рискую и разношу методы по времени. (Возможно, я выше был слишком категоричен в вопросе о последовательности.)
                                • +3
                                  Сложность перехода с паскаля на си, все-таки, преувеличена, немного. Но я считаю, что язык должен выбирать преподаватель, си, значит си, джава-скрипт, значит джаваскрипт, лишь бы он смог этот язык объяснить ученикам.
                                  • 0
                                    Сложнее обратный переход :)
                              • –1
                                Имхо, разумеется, но популярность языка здесь неважна. Паскаль проще с точки зрения понимания и отладки, поэтому при обучении программированию будет проще сконцентрироваться на алгоритме и задаче, а не сайд-эффектах языка и их отладке.
                                • +3
                                  Важна, если воспринимать обучение не как изолированный процесс, а как часть системы. Наша программа обучения ориентирована на практику и использовать язык, который не имеет большого практического применения, я не вижу смысла. Рано или поздно мы упремся в ограничения языка (или экосистемы, например, не сможем найти нужную библиотеку) и что тогда? Говорить детям «мы вас тут учили не совсем правильно, давайте быстренько выучим Си и дальше будем писать на нем»? ИМХО — не вариант.
                                  • +2
                                    Что значит «учили неправильно»? Вы же говорили, что учите детей именно программировать.

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

                                      Ссылку просмотрел, сразу могу сказать что автор настроен к Си предвзято. Он говорит что не может понятно объяснить «Hello, world!». Сравните с моим примером — программа подлиннее чем «Hello, world!» и тем не менее с ней особых проблем не возникает, нужно только подобрать правильные слова, не бросаться в дебри, наподобие «директива макропроцессора», «возвращемый тип данных» и прочие:

                                      #include <stdio.h> //включили (include) в программу модуль ввода-вывода
                                      
                                      int main() //начало главного (main) фрагмента программы
                                      { //начало
                                        printf("Hello, world!\n"); //напечатать (print) на экран строку
                                        return 0; //вернуть количество ошибок - ошибок нет, возвращаем 0
                                      } //конец
                                      


                                      Так что я с автором не согласен, на Си вполне можно (и даже нужно) учить программированию, наша практика это подтверждает.
                                      • 0
                                        Почему нельзя менять язык? Можете посчитать сами сколько раз язык менялся у меня в школе habrahabr.ru/post/136272/#comment_4537012, и ничего, очень даже полезно это оказалось.
                                        • 0
                                          Менять язык можно, но я считаю это контрпродуктивным. Время потраченное на смену языка, на изучение новых конструкций — по сути потрачено неэффективно.

                                          Вот простой пример. В Паскале
                                          if a=b then

                                          В Си:
                                          if (a==b) {

                                          Маленькая разница между = и ==, а сколько проблем. Некоторые из моих учеников (10 класс) параллельно учили Паскаль в школе. Путаница между = и == случалась регулярно.
                                • +3
                                  Python?
                                  • 0
                                    И опять же, динамическая типизация. Хотя язык отличный, ему можно и нужно обучать, но после того, как основы программирования заложены.
                                    • 0
                                      Она динамическая, но сильная в отличии от JS или PHP.
                                      • 0
                                        Akela_wolf В питоне начиная с 3.5 есть type hints это уже зачатки статической типизации, до этого похожая возможность была в виде отдельной тулзы mypy.
                                    • +1
                                      Питон или Руби.
                                      Оба — красивые языки, прививающие любовь к хорошему коду.
                                      • +2
                                        Нужна статическая типизация — это полностью укладывается в принцип «учить хорошему».

                                        Чем плоха динамическая типизация?
                                        • –1
                                          Тем что при использовании динамической типизации очень легко наделать ошибок, которые проявятся только в рантайме и которые начинающему сложно находить.
                                          • +2
                                            Да ладно. Мы сейчас говорим о коде, где ошибка проявляется один раз на тысячу запусков или почти гарантированно на каждом запуске (в учебных проектах почти всегда так)?

                                            Я не вижу большой разницы между ситуациями:
                                            1) Компилятор говорит, что у меня ошибка такая-то в такой-то строке.
                                            2) Я запускаю код, и он вываливается в дебаггер с сообщением об ошибке такой-то в такой-то строке.
                                            • 0
                                              Даже в статически-типизированном Си у моих учеников случилась ошибка, проявлявшаяся не на каждом запуске (неинициализированная переменная).
                                              Но пусть она даже появляется каждый раз — проблема не в том, что программа остановится (это хорошо если остановится). Она может работать неправильно, выдавая чудные результаты и искать такую ошибку может быть достаточно сложно (повторюсь, даже ошибка округления в результате преобразования double -> int была достаточно проблемной для поиска). А если остановится — место где она остановится может быть достаточно далеко от места где сделана ошибка (даже в другой функции, даже не по стеку вызовов). Опять же начинающему находить такие проблемы очень непросто.
                                              • +3
                                                Ха, ну так видите — дело не в типизации, а в языке. Вот в C# программа с неинициализированной переменной не откомпилируется.

                                                Я думаю, что вы в целом несправедливо проводите разграничение по линии типизации.

                                                Да, C — язык со статической типизацией, но его типизация позволяет выполнять дивнейшие фортели.
                                                В то время как более современные языки с динамической типизацией могут быть гораздо строже к выполняемым конструкциям.
                                                Всё зависит от конкретного языка.
                                                • 0
                                                  В таком случае, считайте меня сторонником статической типизации (каковым я и являюсь) :) С моей точки зрения у статической типизации больше плюсов, особенно в учебных целях.

                                                  В идеале я бы выбрал язык с более строгой типизацией, чем Си, тот же Java, например. Но с ними другие проблемы. Поэтому приходится идти на компромисс.
                                                  • 0
                                                    Проблему Java вы озвучили — объектно-ориентированность, но реальные эксперименты (Кэя или Парнаса, упоминал...) её опровергают.
                                                    • 0
                                                      Не знаком с этими экспериментами. Но из моей практики — объект это далеко не самая простая для понимания вещь, особенно когда доходит до полиморфизма, даже студенты не все это хорошо понимают.

                                                      А использовать объекты как контейнеры для статических методов — значит по сути не использовать их вообще.
                                                      • 0
                                                        Ну, просто Java — язык агрессивно объектный, надо взять что-то менее заставляющее принудительно пользоваться объектами.

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

                                                        Например, в C есть массивы, но нет ассоциативных массивов. А ведь с точки зрения логики в чём разница? Там сопоставляют структуру целочисленному индексу, а здесь один объект другому. Словарь, телефонный справочник.

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

                                                        Если программирование — это структуры данных и алгоритмы, то в C всё очень скверно со структурами данных, и если уж изучать программирование на примере C, то параллельно надо читать отдельную книжку по структурам.
                                                        • +1
                                                          Так в этом его преимущество! Когда будем изучать структуры данных, дети должны будут сами написать тот же ассоциативный массив (map), поймут как он работает, ощутят его особенности «на собственной шкуре», а не просто подключат библиотеку. В обучении должно быть минимум «магии», ученики должны понимать как устроено то что они используют.

                                                          Кстати, в Си ассоциативных массивов нет не потому что «авторы не удосужились добавить», а потому что работать с численными индексами — естественно для компьютера (адресная арифметика), а с сопоставлением «объект-объект» — нет. В первом случае алгоритмы тривиальны, во втором — увы, нет.

                                                          Обратите внимание, в C++ тоже нет ассоциативных массивов, они в STL, но не в самом языке.
                                                          • 0
                                                            Мы вступаем на очень тонкий лёд. Безусловно, они должны понимать, как работает структура данных, но реализовывать всё самим — а где та грань? Почему бы им самим не реализовать, например, функцию синуса — или вы тоже их это заставляете? Я думаю, что любой человек должен прежде всего знать наперечёт все базовые структуры данных, а их реализация — вопрос уже следующий.

                                                            Ученики всё равно не могут всё знать. Вот спросите, как в компьютере вычисляется логарифм или квадратный корень — уверен, далеко не все ответят.

                                                            По поводу «удосужились — не удосужились» — вот в Паскале есть встроенные операции со множествами, а в Си нет. Не удосужились :)

                                                            В C++ ассоциативные массивы есть. Я не знаю, что такое STL (dumb mode on) — если вы заглянете в Стандарт C++, то увидите там упоминание std::map наряду с std::max(), например, а слова STL вы не увидите нигде. То, что исторически map взят из библиотеки STL, не имеет никакого значения. Я тоже могу сказать, что в C нет поддержки файлов — она есть в stdio.h.
                                                            • 0
                                                              Синус вычислять, конечно, не заставляю. Хотя если кто-то захочет — мешать не буду, это полезный опыт.

                                                              Но с моей точки зрения нужно знать структуры данных и принципы их реализации. Иначе вопросы «почему в списке время доступа к произвольному элементу O(n), а в массиве O(1)? А почему в дереве O(log n)?» будут ставить в тупик. А чтобы понять принципы реализации нужно их реализовать на практике.

                                                              Это промышленный программист не может позволить себе изобретать велосипед, в целях обучения собственные велосипеды необходимы.
                                                              • 0
                                                                Конечно, поддерживаю. Но в общем-то всё это вопрос нюансов.

                                                                Рассмотрим вот такую простую задачу: с клавиатуры вводится массив чисел (число-enter-число-enter...), пока не будет введён нуль. Далее этот массив каким-то образом обрабатывается.

                                                                В чистом C эта банальщина реализуется очень трудно (т.к. нет автоматически растущих массивов). Получается, либо надо выделять фиксированный блок на N элементов (чему мы учим детей??? этому чудовищному стилю, где возможен buffer overflow?), либо реализовывать поведение наподобие того, что есть в std::vector.

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

                                                                Таким образом, получается, что дети не учатся выбирать наиболее эффективную структуру данных для своей задачи. Если реализация тоже ложится на их плечи, конечно, будет выбрано наиболее простое решение. Да ё-моё, я сам почти всегда пишу std::map, даже если правильнее было бы взять хэш-таблицу, но как стандарт она появилась только в C++11.
                                        • 0
                                          Если следовать основной мысли подхода, а именно учить не языку, а решению задач, то я предлагаю Scheme. Сам я начинал с С. Так вот, для того что б начать программировать на С, нужно хоть базово знать архитектуру процессора и основы организации памяти в компьютере.
                                          • –2
                                            Lisp-подобный синтаксис начинающим? В качестве первого языка? На второе занятие придет половина группы, на третье — один человек.
                                            • 0
                                              Ну это же стереотип. Для мелких заданий очень даже удачный синтаксис.
                                              • 0
                                                А для чего-то более-менее крупного? Хотя бы квадратное уравнение решить — в скобках не запутаетесь?
                                                • 0
                                                  Математические вычисления действительно в лиспе выглядят не очень красиво. Но не одних только вычислениях мир сошёлся. Если брать для примеры программ для вашего ТХ, то лисп тоже будет весьма простым выглядеть.
                                                  • 0
                                                    Ну так это же только примеры. Начинается анимация — начинаются вычисления. Делаем игру — тоже вычисления, логика. Хотя бы даже проверить попадание точки в прямоугольник:
                                                    struct Rect {
                                                      int leftPos;
                                                      int topPos;
                                                      int width;
                                                      int height;
                                                    }
                                                    
                                                    bool isInside(Rect rect, int x, int y)
                                                    {
                                                      bool xInside = (x >= rect.leftPos) && (x <= rect.leftPos + rect.width);
                                                      bool yInside = (y >= rect.topPos) && (y <= rect.topPos + rect.height);
                                                      return xInside && yInside;
                                                    }
                                                    

                                                    А как это будет выглядеть на лиспе?
                                                    • 0
                                                      На кложуре это может выглядеть так:
                                                      Объявление прямоугольника
                                                      (def rect {:leftPos 1
                                                                 :topPos  2
                                                                 :width   3
                                                                 :height  4})
                                                      

                                                      Функция проверки принадлежности
                                                      (defn inside? [rect x y]
                                                        (let [{:keys [leftPos topPos width height]} rect
                                                              x-inside? (<= leftPos x (+ leftPos width))
                                                              y-inside? (<= topPos y (+ topPos height))]
                                                          (and x-inside? y-inside?)))
                                                      

                                                      В принципе не особо и страшнее получилось.
                                                      • 0
                                                        На Scheme:

                                                        (define (left-pos rect) (car rect))
                                                        (define (top-pos rect) (cadr rect))
                                                        (define (width rect) (caddr rect))
                                                        (define (height rect) (cadddr rect))
                                                        
                                                        (define (in? x low hi)
                                                          (and (>= x low) (<= x hi)))
                                                                                 
                                                        (define (inside? rect x y) 
                                                          (and
                                                           (in? x (left-pos rect) (+ (left-pos rect) (width rect)))
                                                           (in? y (top-pos rect) (+ (top-pos rect) (height rect)))))
                                                        
                                                        (inside? (list 0 0 30 40) 20 30)
                                                        
                                                    • 0
                                                      Вот решение квадратного уравнения.

                                                      (define (discriminant a b c)
                                                        (- (* b b) (* 4 a c)))
                                                      
                                                      (define (solve a b c)
                                                        (let ((d (discriminant a b c)))
                                                          (cond ((< d 0) (error "уравнение не имеет действительных корней"))
                                                                ((= d 0) (- (/ b (* 2 a))))
                                                                (else (list (/ (+ (- b) (sqrt d)) (* 2 a)) 
                                                                            (/ (- (- b) (sqrt d)) (* 2 a)))))))
                                                      
                                                      (solve 1 8 7)
                                                      

                                                      Разве все так ужасно выглядит?
                                                      • 0
                                                        7 скобок подряд — да, это ужасно.
                                                        • 0
                                                          Если оценивать программу по числу скобок, то да. Но мне кажется это не совсем разумный критерий.
                                                          • +1
                                                            А как вам такой критерий:
                                                            На математическую запись этого решения не похоже вообще
                                                            • 0
                                                              Этот критерий мне больше нравится. Нет претензии «много скобочек — некрасиво». Я уже говорил, что на лиспах средние и сложные арифметические операции выглядят не очень красиво. К счастью не так уж часто приходится их использовать.
                                              • +2
                                                Си как и Паскаль — морально устаревшие языки, которые тянут за собой огромный багаж не самых красивых архитектурных решений, дырок, да и просто ненужностей (для современного мира). Для нас, состоявшихся программистов, это не проблема — если понимаешь суть, можно писать хоть на Паскале, хоть на Коболе. Работа есть работа.

                                                Использовать же его для обучения детей — это значит объявить последние 35 лет развития IT технологий потерянными. Дескать, ничего за эти годы достойного не появилось. Это крайне печальная и несправедливая позиция. Скажем, со времён Паскаля даже его непосредственный автор сочинил Модулу, Модулу-2, Оберон и Оберон-2 — вероятно, считая их более совершенными языками.

                                                Детям нужно давать язык, на котором писать легко и приятно. Да, рано или поздно нужно изучить C, чтобы понимать внутреннее устройство компьютера и знать, что почём, что сложение целых и сложение строк — далеко не одно и то же. Но если ребёнку надо выполнить десяток базовых операций над строками, и мы для этой цели предлагаем strcpy(), strcat() и иже с ними — это форменное издевательство.

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

                                                Я бы сам детей учил либо на C#, либо на Питоне. Из старья — рассмотрел бы даже QuickBasic, всяко проще Паскаля. А MS вообще вон придумала SmallBasic для детей — совсем неплохо. По поводу «объектной ориентированности» — кто-то из патриархов (то ли Кэй, то ли Парнас) писал, что дети прекрасно осваивают объекты, и ничего страшного в них нет.
                                                • 0
                                                  Учить на «чистом» Си может быть не самое лучше решение. Но Си + учебная библиотека (в роли которой TXLib) превращается в мощный инструмент. Не хотите издеваться над детьми с функциями вида strcpy, strcmp. stricmp и подобными — напишите несложную библиотеку, которая все это скроет от них.

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

                                                    По-моему, моя первая компьютерная программа была чем-то вроде:

                                                    INPUT name$
                                                    PRINT «Hello, »; name$; "!"

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

                                                    TXLib — хорошо, но в любом упомянутом мной языке тоже есть хорошие библиотеки.
                                                    • 0
                                                      Всему одновременно научить нельзя. Чему учить и в какой последовательности — это определяет программа обучения. Конечно, она подбирается под возможности языка, так что выбери мы другой язык — произошло бы тоже самое «простые и прикольные вещи скрыты лишь потому, что конкретный язык этого не позволяет». Увы, нет языков одинаково хорошо справляющихся с любой задачей.
                                                • 0
                                                  А как Вы отнесетесь к Scala (Kojo)?
                                                  Статически типизирован, поддерживает разные стили, доступны библиотеки Java.
                                                  Есть REPL — на мой взгляд важно для обучения.
                                                • +1
                                                  Я дико жалею, что в школе нас пичкали фигней… интересно как жизнь повернулась бы… т.к. программинг привлек внимание только к 20 годам, хотя до этого я его обходил стороной
                                                  • 0
                                                    Я тоже компьютеры увидел в 23, вместе с программируемыми калькуляторами.
                                                    В институте программировали только в тетрадях.
                                                    И ничего, программист :-)
                                                    • 0
                                                      Ну «ничего» это… Представьте сколько времени можно было бы сэкономить… я например сначала в ФизТехе учился, щас заканчиваю дизайнерский =)) и главное: хочу связать жизнь с программингом — если бы в школе что-то было иначе возможно не пришлось бы терять столько лет чтобы найти себя)
                                                      • 0
                                                        Познание других областей знаний тоже полезно. Можно говорить со специалистами на их языке.
                                                        Может, судьба такая — физику визуализировать :-)
                                                • +19
                                                  Преподаватель должен обладать опытом практического программирования

                                                  Это должно быть первой фразой в любой статье такого рода. Извините, наболело.
                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                    • –28
                                                      email — для старперов, все давно пользуются контактом =)
                                                      • 0
                                                        Из всех моих знакомых ИТшников, только десяток знакомых из киевского Фидо есть в одноклассниках.
                                                        Во вконтакте из ИТшников всего пару человек, зато в скайпе и фейсбуке есть и активно общаются почти все.

                                                        Так что очень зависит от окружения, имхо
                                                        • +8
                                                          Только ситхи возводят все в абсолют.
                                                    • 0
                                                      но не учат намного более важному умению — применять их для решения возникающих на практике задач

                                                      к сожалению, это не только к программированию относится и не только к школе, но и к ВУЗу
                                                      • +2
                                                        При моих попытках учить людей программированию самым сложным всегда было дать понятие переменной. Отсылка к аналогичному понятию в математике и/или физике скорее мешала, чем помогала. Приходилось опускаться до уровня чуть ли не ассемблера, рассказывать об организации памяти (линейное пространство, прямая и косвенная адресация и т. п.) причем «на пальцах», без примеров кода.

                                                        Как у вас вводится? Читал рассказ ожидая этого момента, но очень вскользь затронуто.
                                                        • 0
                                                          С понятием «переменная» каких-то проблем не было. Вводил я его очень просто — вот в программе у нас есть число (литерал). Хорошее такое число, но у него есть недостаток — оно постоянное, а нам нужно его менять. Мы ему можем дать имя (константа), но все равно не сможем менять значение, константа это просто понятное имя для числа. Дальше обсуждение как эту проблему решить. Собственно к этому моменту дети уже понимают разницу между именем и значением, говорят — вот было бы хорошо менять значение константы, а это и есть переменная.

                                                          Больше проблем было с указателями. Вот тут пришлось рисовать на доске схему организации памяти, рассказывать адресацию и прочее. В итоге дети почти без подсказок дошли до случая «указатель на указатель» :)
                                                          • +4
                                                            А я объяснял переменные так:
                                                            У вас есть коробочка с надписью на ней «Имя(Name)», вторая коробочка с надписью «Количество лет (Age)», и т.д.
                                                            А значения — это листочки с текстом, которые мы кладем в коробки.
                                                            Присваивание — это ксерокопирование листочка со значением, затем кладем копию в нужную коробку.

                                                            А указатели — еще проще:
                                                            Вот есть человек — это объект.
                                                            А есть его телефонный номер — это его указатель.
                                                            С помощью телефонного номера мы можем звонить человеку, отдавть ему команды или что-то у него спрашивать.
                                                            Листок с телефонным номером можно отксерокопировать сколько угодно раз и хранить в любом количестве коробок.
                                                            • 0
                                                              Так хорошо объяснять в Java или C#. А у них C, где указатель обычно не адресует объект, а используется для всяких трюков типа передачи массива в функцию, прохода по строке, тут же арифметика указателей приплетается, надо объяснять, в чём разница между указателями на разные типы и т.п.
                                                              • 0
                                                                Адресную арифметику детям не рассказываем. Даже массивы прекрасно даются без адресной арифметики. Указатель адресует что-то (целое число, дробное число, структуру и т.д.)
                                                          • +2
                                                            Я на своих занятиях ввожу на нескольких примерах:
                                                            Коробка, куда можно положить что-то. На коробке написано иия. Сразу с указанием того, что в отличие от вещей данные копируются.
                                                            Второй пример — флешка. На флешку влезает 1 файл. На флешке написано имя.
                                                            Но это почти не требуется, понятие буквенных обозначений знакомо из математики.

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

                                                            Типизация:
                                                            Напоминаю им про пример с коробкой. Но коробки для велосипеда и мячика разного размера и формы.

                                                            Указатели:
                                                            Напоминаю им про пример с коробкой-ка переменной. Прошу представить, что все вещи у нас лежат на складе. Склад представляет собой много квадратов, пронумерованных по порядку начиная с 0. Коробка занимает несколько соседних квадратов.
                                                            Есть коробка с нарисованной буквой А, внутри нее бумажка с адресом квадрата, на котором мой велосипед.
                                                            Выделение памяти, освобождение — запись в амбарной книге у кладовщика. И так далее по всем понятиям, связанных с адресной арифметикой.
                                                            • 0
                                                              Нам в университете в курсе логического программирования рассказывали, что ни в коем случае нельзя проводить аналогию между переменной в математике и переменной в императивных языках. В математике переменная не имеет никакого конкретного значения (даже наоборот), а в том же C++ переменная всегда имеет вполне конкретное значение (если инициализирована, конечно). Математическую переменную можно сравнить с переменной в Прологе, но никак не в императивных языках.
                                                              • 0
                                                                Я до этого дошел опытным путем. Теперь не привожу, просто рассказываю про память и что имя переменной это адрес памяти, в которой храниться какое-то значение (в некотором диапазоне), но одно и только одно.
                                                            • +1
                                                              Очень интересно! Спасибо!
                                                              А можете подробнее рассказать о своей программе? На сколько рассчитан курс обучения, какие темы подымаете? В чем проявляется недостатки вузовского образования по программированию?
                                                              • +1
                                                                Про программу нужно рассказывать отдельным постом. Курс планируется на два года, может быть в будущем мы его скорректируем.

                                                                Если кратко: первый семестр осваиваемся с рисованием мультика (функции, циклы, структуры, собственная библиотека функций, документирование и прочее). Под конец первого семестра, в начале второго, делаем игру (взаимодействие с клавиатурой, ветвления, указатели, массивы, освоение работы с достаточно большим проектом). Ближе к концу второго семестра меняем тему, начинаем рисовать графики математических функций, здесь знакомимся с указателями на функции.
                                                                Второй год начнем с синтаксического разбора арифметического выражения, затем элементы объектного программирования. Попробуем сделать универсальный построитель графиков, способный обработать введенную пользователем комбинацию элементарных функций. Дальше запланирована возня с графическим интерфейсом — окна, виджеты и прочее, углубление знаний и навыков в ООП. Но, как известно, ни один план не выдерживает столкновения с реальностью, посмотрим как будет дальше. На второй год, кстати, планируем знакомство с mercurial и его практическое использование для командной работы.

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

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

                                                                  И только потом уже имеет смысл рассказывать про бранчи и прочие операции, сложнее чем hg ci / hg up
                                                                  • +2
                                                                    Чтобы осознать пользу от подобной системы хорошо бы потерять исходники разочек :) Тогда больше не захочется.

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

                                                                    А на второй год ввести подобное становится достаточно просто — после знакомства с системой контроля версий учитель принимает только тот код, который лежит в репозитории.
                                                                    • 0
                                                                      Ну так вполне же можно спровоцировать ситуацию, когда исходники «потеряются» :) Лучше обжечься на чем-то простом, чем потом потерять месяц работы из-за ерунды :)

                                                                      Ведь для начала можно даже не объяснять сути VCS. Например по началу результаты каждого урока складывать в отдельную папочку на дропбоксе, а потом перейти к тому что это неудобно, легко запутаться и т. д. и предложить делать коммит. Но это уже конечно сильно зависит от специфики.
                                                              • 0
                                                                тема интересная

                                                                хотелось бы узнать как устроенно рабочее место для школьника: какой софт используется, где хранится код?
                                                                • 0
                                                                  Код хранится в dropbox. У каждого школьника свой аккаунт, с которым они могут работать как в классе так и дома.

                                                                  В качестве IDE используем Geany, но, вероятно, будем что-то менять к новому учебному году — инсталляция на домашний компьютер даже при наличии подробных инструкций превратилась в натуральный квест. Компилятор — gcc.

                                                                  Документация к библиотеке генерируется с помощью doxygen. Плюс браузер, чтобы залезть в интернет при необходимости.

                                                                  Собственно пока все, никакого другого софта не использовалось. На второй год будем изучать mercurial и bitbucket или аналогичный сервис.
                                                                  • 0
                                                                    Тема интересная, я веду факультатив «основы программирования» 1 курс
                                                                    У студентов кроме меня, есть основной курс программирования

                                                                    Пришел к тому, что потребовал от студентов разжиться ноутбуками
                                                                    (Работа каждый раз с новым компьютером в новой аудитории — вводила их в ступор)

                                                                    Среда программирования: vs2010 express
                                                                    (12 — не пошла, не смогли поставить)

                                                                    Свой код я раздавал через github.com/BloodJohn/console_app
                                                                    (Можно скачать архив через web и распаковать прямо на занятии)

                                                                    Еще одна проблема, с которой я столкнулся — никто не учит терминологии.
                                                                    (Очень помогло, когда я расписал в комментариях, что именно происходит в каждой строчке кода)

                                                                    У студентов был натуральный ужас, когда первый раз рассказывал про параметры/аргументы и объявление/реализацию функций.
                                                                    С указателями и строчками было чуть проще.
                                                                    • 0
                                                                      У нас проще — домашние директории пользователей хранятся на сервере, то есть влогинившись с любого компьютера под своей учеткой школьник видит свои файлы и настройки. Плюс дропбокс для синхронизации между домашним компьютером и классом. Так что этой проблемы практически нет.
                                                                • 0
                                                                  в школе учат не решению проблем с помощью программирования, не разработке программ, а лишь языку программирования как таковому


                                                                  Вы знаете, это очень повезет, если хотя бы так.
                                                                  Знакомая год назад показывала мне свою тетрадку по информатике (училась она в одном из довольно известных лицеев Москвы, 9й класс).
                                                                  Суть в том, что вела предмет пожилая женщина, точно за 65, и преподавала она так называемое программирование.

                                                                  Смысл был в следующем — компьютеры при обучении не использовались принципиально.
                                                                  Все занятия проходили на доске/в тетрадках, обучали их какому-то русскоязычному псевдокоду (то ли такой действительно существует и используется для обучения, то ли это изобретение этой самой учительницы). На доске она писала и пыталась объяснять конструкции вроде:
                                                                  Если а=б то
                                                                  а:=c
                                                                  Конец если


                                                                  Что-то между русским языком и паскалем. Сейчас могу уже ошибаться, но конструкции там были не хилые.
                                                                  После чего ученикам в качестве домашнего задания задавали написать рабочую программу на этом псевдо-языке в тетради.
                                                                  Тетради сдавались ей на проверку. Плюс нужно было еще какой-то устный тест сдать ей. Естественно, никто не мог этого сделать, и все ходили к ней пересдавать до конца года по нескольку раз на тройку.
                                                                  Я когда эти «лекции» и «домашние задания» (точнее, попытки их решить) увидел, чуть не упал.
                                                                  • 0
                                                                    Вероятно нечто вроде этого
                                                                    Проц Старт()
                                                                        Вывод 'Здравствуй, мир!'
                                                                    Кон Проц
                                                                    

                                                                    Называется Рапира В обиходе «русский паскаль» В конце 80-х- начале 90-х его массово в школах давали, афаик (в нашей давали точно :)
                                                                    • 0
                                                                      В ЕГЭ по информатике до сих пор приводятся куски кода на школьном алгоритмическом (правда они дублируются на нормальных языках).
                                                                    • 0
                                                                      Есть ЛКШ (летняя омпьютерная школа), в которой не плохо учат программмированию. Объем знаний огромный и превышает бинпоиск). Вот ссылка на учебные параллели и их программы.
                                                                      • +1
                                                                        Не стоит думать что все чему научились дети — это только бинарный поиск. Это был просто пример хорошей самостоятельной работы.
                                                                        • 0
                                                                          Я так и не думаю. Просто я этим занимался гораздо раньше, чем 9-11 класс. Я рисовал в бейсике классе в 5-том. Поэтому в возрасте 9-11 класс остается больше времени для изучения более продвинутых алгоритмов. Я думаю надо этому класса с 5 — 7 учить.
                                                                      • 0
                                                                        Мне интересно следующее: а как у обучаемых с английским? Ведь тот же компилятор выводит сообщение об ошибке не на русском языке. Не мешает ли это обучению?
                                                                        • 0
                                                                          Большинство изучают в школе английский. Конечно, недостаточной уровень знания языка мешает, приходится переводить, объяснять. Но сообщения об ошибках довольно типичны, ученики довольно быстро начинают в них ориентироваться самостоятельно.
                                                                        • 0
                                                                          Мне кажется, что наибольшего успеха можно достичь, начиная обучать учеников 8-9 класса — в дальнейшем обучаемость снижается.


                                                                          Я обучаю школьников программированию более 7 лет (в системе доп. образования детей). Контингент был с 4-го по 11 класс. Мои выводы для общей массы детей (не берем случаев одаренности):
                                                                          1) Учить детей младше 8-го класса чему-то более сложному, чем Logo и HTML не стоит. У них еще нет жизненного опыта, чтобы вполне осозновать, зачем это надо. Кроме того, они в принципе не могут понять сложные логические конструкции. Их мозг еще привян к наглядности и им сложно рассуждать абстрактно.
                                                                          2) Восьмиклассники справляются с основами программирования. Это возраст, когда надо начинать знакомить с каким-либо языком программирования. Подготовка простых проектов помогает обучению, сложных и объемных — только мешает и путает ученика, способна заварить кашу в голове ученика. Обучение основано на многократном повторении: решаем много аналогичных задач.
                                                                          3) Учащиеся 10-го класса намного быстрее осваивают программирование по сравнению с 8-м классом, даже если до этого они с ним не были особо знакомы. Это факт. То что с 8-ми классником я прохожу за 3 месяца, с десятиклассником — за 1 месяц. Десятиклассник легко видит аналогию, легко перекладывает опыт решения прошлой задачи на новую, легко обобщает.
                                                                          • 0
                                                                            Примеры проектов, которые делают подростки: younglinux.info/projects
                                                                            Большинство из тех, что там перечислены, занимали призовые места на всероссийской конференции «Шаг в будущее».
                                                                          • +2
                                                                            его ученики уже в 9-11 классе пишут программы, по сложности соответствующие 3-4 курсу технического вуза (!) — компиляторы


                                                                            Было бы интересно посмотреть на компилятор, написанный 11-тиклассником. На сайте Дединского вижу разбор выражений методом рекурсивного спуска от второкурсника и попытку восьмиклассника сделать трансляцию автоматов на Visio в С.
                                                                            Что -то мне все-таки кажется, что от правильной расстановки пробелов и игры «Угадай число» до 3D-движков дистанции огромного размера.
                                                                              • 0
                                                                                Вот, почти сходу на его сайте нашлось: Платформа для машинно-независимого исполнения программного кода с возможностью JIT-компиляции


                                                                                Это очень круто (остальные проекты тоже, наверняка хороши, просто я в этих опенглях не разбираюсь)).
                                                                                Ну, соответсвенно возникает вопрос сколько в этом успехе от методики, а сколько от таланта ученика (который очевиден).
                                                                                Ок, рассказали мы ученикам про пробелы, отступы и пустые строки, напугали страшными последствиями ошибки в модуле, но опыт показывает, что теперь ученики могут самостоятельно писать «Угадай число». Как до JIT-компиляторов-то доскочить, в чем секрет?
                                                                                Вот как думаете, у ваших учеников результат воспроизведется, будут они динамические анализаторы C++ в старших классах писать?
                                                                                • 0
                                                                                  Что я могу сказать кроме банального «поживем — увидим»? Среди моих учеников тоже есть способные ребята, которые стремятся развиваться дальше. Главное — у них есть интерес, есть стремление, я думаю что секрет в этом. Если есть желание развиваться, если желание учиться программированию встречает содействие со стороны учителя, если учитель направляет развитие так, чтобы оно было максимально продуктивным, то результат не заставит себя долго ждать. Если ученик заинтересуется какой-то проблемой, пусть даже сложной, такой как JIT-компилятор, а учитель поможет ему разобраться в ней, то это уже полдела.

                                                                                  Я делаю акцент в первую очередь на том, чтобы «научить хорошему», не только отступам и пробелам, но и более сложным вещам. Я выделил «отступы и пробелы» как наиболее очевидные вещи, которые, тем не менее, часто упускают. Точно также есть «хорошее» и «плохое» в ООП, например, и я тоже буду стараться учить детей «хорошему», правильной иерархии классов, отделению интерфейса от реализации, принципам SOLID и т.п.

                                                                                  Возможно, что с первой группой сверхвыдающихся результатов не будет (хотя вполне достойные — будут обязательно), но мы же только начинаем наш проект.
                                                                              • +1
                                                                                В свободное время пытаюсь разрабатывать учебный язык программирования (подход похож на C#)

                                                                                Прошу оценить понятность примеров исходного кода для детей ( подробнее примеры — pl2-rainbow.livejournal.com/3570.html, подход — habrahabr.ru/qa/39571/ )

                                                                                В каком возрасте дети «потянут» такие простейшие примеры (наиболее способные и в среднем)?

                                                                                Пустой файл

                                                                                code source=pl2 name=example1
                                                                                    namespace start \ начальное знакомство с языком программирования PL2 \
                                                                                    {
                                                                                    }
                                                                                /code
                                                                                
                                                                                


                                                                                Вывод Hello, world

                                                                                code source=pl2 name=example2
                                                                                    using user.OS.IO; // взаимодействие пользователя с компьютером средствами операционной системы
                                                                                    using pl2.translator.system; // взаимодействие с транслятором
                                                                                
                                                                                    namespace start \ начальное знакомство с языком программирования PL2 \
                                                                                    {
                                                                                        class Example2 \ класс для проверки работоспособности транслятора \
                                                                                        {
                                                                                            static void main \ программа для запуска средствами операционной системы \
                                                                                               (String arguments \параметры командной строки выполняемого файла\ [])
                                                                                            {
                                                                                                String string_for_out \ строка для вывода \
                                                                                                   := "Здравствуй, мир!";
                                                                                
                                                                                                Console.write_line(string_for_out);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                /code
                                                                                
                                                                                


                                                                                Hallo, world с наворотами

                                                                                code source=text name=example_3_text
                                                                                Пример выводимого текста:
                                                                                Здравствуй, мир!
                                                                                /code 
                                                                                 
                                                                                code source=pl2 name=example3
                                                                                    using numbers;
                                                                                    using user.OS.IO;
                                                                                    namespace start
                                                                                    {
                                                                                        class Example3 \ третий пример начального уровня \
                                                                                        {
                                                                                            String example_text = source.example_3_text; // получаем строку исходников в переменную
                                                                                
                                                                                            static void main \ основная функция исполнения третьего примера начального уровня \
                                                                                               ( String aruments \ одномерный массив строк после имени исполняемого файла при запуске программы \
                                                                                                           []
                                                                                               )
                                                                                            {
                                                                                                numbers.Integer counter \ индексатор для перечисления параметров \;
                                                                                                numbers.Integer parameters_count \ количество переданных параметров при вызове исполняемого файла \;
                                                                                                parameters_count = arguments.lenght();
                                                                                                Console.write_line(example_text);
                                                                                                if (parameters_count > 0)
                                                                                                    for (counter := 0 ; counter < parameters_count ; ++counter)
                                                                                                        Console.write_line(arguments[counter]);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                /code
                                                                                
                                                                                


                                                                                Hallo, world с наворотами на русском

                                                                                код метод=text имя=текст_примера_4
                                                                                Пример выводимого текста:
                                                                                Здравствуй, мир!
                                                                                /код 
                                                                                 
                                                                                код метод=pl2 имя=пример4
                                                                                    использовать числа;
                                                                                    использовать пользователь.ОС.ВВ;
                                                                                    пространство начало
                                                                                    {
                                                                                        класс Пример4 \ четвертый пример начального уровня \
                                                                                        {
                                                                                            Строка текст_примера := исходный.текст_примера_4; // получаем строку исходников в переменную
                                                                                
                                                                                            статичное пустое главное \ основная функция исполнения четвертого примера начального уровня \
                                                                                               ( Строка аргументы \ одномерный массив строк после имени исполняемого файла при запуске программы \
                                                                                                           []
                                                                                               )
                                                                                            {
                                                                                                числа.Целое перечислитель \ индексатор для перечисления параметров \;
                                                                                                числа.Целое количество_параметров \ количество переданных параметров при вызове исполняемого файла \;
                                                                                                количество_параметров := аргументы.количество();
                                                                                                Терминал.вывести_строку(текст_примера);
                                                                                                если (количество_параметров > 0)
                                                                                                    для (перечислитель := 0 ; перечислитель < количество_параметров ; ++ перечислитель )
                                                                                                        Консоль.вывести_строку(аргументы[перечислитель]);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                /код
                                                                                


                                                                                В перспективе предполагается выделение следующих областей видимости (по habrahabr.ru/post/176249/ )

                                                                                functional — Функциональное — для разделов, использующих функциональное программирование.
                                                                                aspect — Аспектное — для интерфесов и аспектов. Для методов могут указываться необходимые свойства и дополнения, используемые перед методом (before), после метода (after) и при выполнении каждого оператора (invariant)
                                                                                predicate — Логическое — соответствует Булевым переменным, доказательству теорем, Аристотелевкой логике, работе с запросами SQL, LINQ или простейшим операциям Prolog.
                                                                                controller — Управляющее — соответствует контроллеру (Controller) модели MVC
                                                                                publish — Изменяемое — соответствует представлению (View) для модели MVC
                                                                                public — Соединяющее — соответствует модели базы данных (Model) модели MVC
                                                                                protected — Защищенное — внутренние элементы класса
                                                                                private — Внутреннее — скрытые элементы класса
                                                                                local — Блоковые — переменные методов и блоков
                                                                                • 0
                                                                                  Так почему не использовать реальный язык? раз уж так все похоже.
                                                                                  • 0
                                                                                    Уже не похоже :-) Вчера додумал оператор цикла ( pl2-rainbow.livejournal.com/3833.html?view=14073#t14073 )

                                                                                    loop [explicit] [метка]
                                                                                    {
                                                                                        for <[тип] переменная [ := инициализатор]>;
                                                                                        in <контейнер>;
                                                                                        while <условие, при котором цикл продолжает итерации>; 
                                                                                        next <оператор итерации>;
                                                                                        where <условие выполнения тела цикла>
                                                                                    
                                                                                        ...
                                                                                        continue;
                                                                                        break [метка блока];
                                                                                    }
                                                                                    


                                                                                    Здесь:
                                                                                    loop — оператор начала цикла
                                                                                    explicit — цикл исполняется хотя бы один раз, проверка условия выхода из цикла перед первым проходом не выполняется
                                                                                    for — список переменных цикла и их инициализация
                                                                                    in — контейнер, из которого выбираются элементы при проходе по циклу
                                                                                    while — условие, при котором цикл продолжает итерации
                                                                                    next — команды, выполняемые после итерации
                                                                                    where — условие для выполнения тела цикла
                                                                                    continue — оператор досрочного перехода к следующей итерации
                                                                                    break — оператор досрочного выхода из текущего или указанного цикла
                                                                                    • 0
                                                                                      Излишне сложно и многословно. Я бы на таком языке писать не стал, тем более использовать его для обучения.
                                                                                      • 0
                                                                                        Попробую показать минимальный вариант

                                                                                        code source=pl2 name=example3
                                                                                            using user.OS.IO;
                                                                                        
                                                                                            namespace start
                                                                                            {
                                                                                                class Example6
                                                                                                {
                                                                                                    static void main( String aruments[])
                                                                                                    {
                                                                                                        Console.write_line("Hallo, world!");
                                                                                                        loop{
                                                                                                            for argument;
                                                                                                            in arguments;
                                                                                        
                                                                                                            Console.write_line(argument);
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        /code
                                                                                        


                                                                                        Для переменной цикла подразумевается автоматическое определение типа. Как со сложностью данного примера?
                                                                                        • +1
                                                                                          Очень высокая

                                                                                          1. В чем смысл обрамления code /code? В файле может быть что-то кроме кода? Почему тогда не фигурными скобками, как везде?
                                                                                          code {
                                                                                          }
                                                                                          2. В чем смысл source и name?
                                                                                          3. using — ладно, пусть будет. Хотя иерархия настораживает.
                                                                                          4. namespace — для простых задач совершенно не нужен.
                                                                                          5. class — ага, у нас все классы. То есть чтобы обучать детей нужно сначала объяснить что такое класс?
                                                                                          6. статический метод. Так класс тут, оказывается не нужен — он просто контейнер статического метода. Что мешаешь отказаться от класса в данном случае вообще?
                                                                                          7. В чем смысл слова loop? Почему слова for и прочие считаются подчиненными относительно loop? Почему тело цикла отнесено на один уровень с for… in ...? Почему конструкция for… in… разбита на две строки, разделенные точкой с запятой, как будто это независимые конструкции? Почему после in стоит точка с запятой, как будто это независимая конструкция, относительно тела цикла?

                                                                                          Если профессиональному программисту это объяснить можно (хоть это и нелогично с моей точки зрения), то ученику — точно нет. Объяснения сведутся к «понимаешь, это магия».
                                                                                          • 0
                                                                                            1. В чем смысл обрамления code /code?
                                                                                            Предлагаю, что в этом же файле могут храниться другие ресурсы: комментарии, SQL, HTML, BNF для описания компилятора, многострочный текст и т.д. Каждый раздел может проверять отдельный анализатор. Импорт текста в строчную переменную программы продемонстрирован в примерах 3 и 4.
                                                                                            Раздел code не является частью синтаксиса PL2, а для того, чтобы не заморачиваться с тегами XML, HTML выбраны простые текстовые ключевые слова метаанализатора
                                                                                            2. В чем смысл source и name?
                                                                                            source задает режим проверки данного раздела.
                                                                                            name позволяет обратиться к блоку по внутреннему экземпляру файла времени компиляции source. Это напоминает метаслово __FILE__ C.
                                                                                            3. using — ладно, пусть будет. Хотя иерархия настораживает.
                                                                                            Необходимые ссылки можно передавать компилятору через настройки в командной строке.
                                                                                            по иерархии: думаю, что класс Console лучше хранить в пространствах пользователя, в отличии от пространства потоков OS.IO
                                                                                            4. namespace — для простых задач совершенно не нужен.
                                                                                            можно ввести ключевое слово program для простейших программ из одного класса
                                                                                            5. class — ага, у нас все классы. То есть чтобы обучать детей нужно сначала объяснить что такое класс?
                                                                                            Для использования Console.write_line что то объяснять придется
                                                                                            6. статический метод. Так класс тут, оказывается не нужен — он просто контейнер статического метода. Что мешаешь отказаться от класса в данном случае вообще?
                                                                                            да, при использовании program эту часть можно убрать.
                                                                                            7. В чем смысл слова loop?
                                                                                            это единственный оператор цикла
                                                                                            Почему слова for и прочие считаются подчиненными относительно loop?
                                                                                            для указания конкретных параметров цикла. Используются только те параметры, которые необходимы из вышеприведенного описания оператора цикла. Все параметры цикла описываются в его начале.
                                                                                            Почему тело цикла отнесено на один уровень с forin ...?
                                                                                            это не операторы, это объявления для цикла loop
                                                                                            Почему конструкция forin… разбита на две строки, разделенные точкой с запятой, как будто это независимые конструкции?
                                                                                            Они и независимы, за исключением того, что с ключевым словом in не может использоваться ключевое слово next. Конкретные разрешенные сочетания надо будет выделить в отдельные блоки описания языка

                                                                                            Почему после in стоит точка с запятой, как будто это независимая конструкция, относительно тела цикла?
                                                                                            А чего их все в одну строку пихать? А читать, на мой взгляд, будет легче.

                                                                                            Спасибо. Ключевое слово program придется задействовать :-)
                                                                                            • +1
                                                                                              :) у вас есть жесткий интерес к разработке языков, но причем тут бедные детишки?
                                                                                              скажу иначе. если ваша цель — сделать из первокласника — второкласника, то это одна задача. если ваша цель сделать из 10тиклассника 11классника — это другое. если из первоклассника за 10 лет 11ка — это тоже совсем другой вариант. ваш язык уже очень похож на то, что вы пытаетесь сделать из технического студента — академика. Т.е. одно дело — решать задачу по обучению ребенка и в рамках этой задачи разработать какой-то наипростейший минимальный подходящий для этого язык, а другое — выдумать sql#
                                                                                      • 0
                                                                                        После некоторых раздумий ключевое слово in заменено на ключевое слово from
                                                                                    • +1
                                                                                      Слишком многословно все. Если такие дети могут понять что такое static void и namespace то можно сразу и С# показывать.
                                                                                      Я бы наверно начал с питона. Hello world is just print 'Hello, world!'
                                                                                      • 0
                                                                                        Компилятор для write(«Hello, world») из одного оператора write с компилятором в .COM я уже писал.
                                                                                        Я считаю, что программа должна быть читаемой с возможностью наращивания сложности и модульным подходом.
                                                                                        А
                                                                                        echo "Hallo, world!"
                                                                                        или
                                                                                         MsgBox "Hallo, world!"

                                                                                        дети написать и сейчас замечательно могут :-)
                                                                                      • +1
                                                                                        На первый взгляд — очень сложные конструкции. С какой целью разрабатывается этот учебный язык? Если не начинать обучение на нем (а в этом мало смысла — конструкции слишком громоздкие и излишне академические), то какой в нем смысл далее? Если дети освоили программирование на Си или Паскале, то смогут дальше перейти на другой язык при необходимости. Какое место должен будет занять ваш язык в системе обучения?

                                                                                        Пока у меня складывается ощущение что вы пытаетесь сделать язык «все в одном»: функциональное программирование, логическое, аспектное и т.д. ИМХО, это плохая идея, учебный язык должен быть простым и сосредоточенным на цели именно обучения, даже в ущерб строгости синтаксиса. Например, в Паскале наиболее часто используемые функции вынесены в модуль System, который неявно подключается к каждой программе. В Си такого нет, любой заголовочный файл нужно подключать явно.
                                                                                        • –1
                                                                                          С какой целью разрабатывается этот учебный язык?
                                                                                          Одно из положений — Компилятор языка использует стандартные ключевые слова на английском языке, но включает опцию расширения для каскадированного включения в таблицу лексем синонимов на национальных языках народов России. В результате, дети могут писать программы на своем естественном языке, а переводом занимается компилятор. При этом преподаватель может проверить листинг на любом из промежуточных языков (русский, английский) ( pl2-rainbow.livejournal.com/301.html).
                                                                                          Если не начинать обучение на нем (а в этом мало смысла — конструкции слишком громоздкие и излишне академические), то какой в нем смысл далее?
                                                                                          Попробую еще уменьшить размер примера сверху:

                                                                                          code source=pl2 name=example6
                                                                                              program( String aruments[] )
                                                                                              {
                                                                                                  Console.write_line("Hallo, world!");
                                                                                                  loop
                                                                                                  {
                                                                                                      for integer argument_number := 0;
                                                                                                      while argument_number < arguments.length()
                                                                                                      next ++argument_number;                   
                                                                                          
                                                                                                      Console.write_line(arguments[argument_number]);
                                                                                                  }
                                                                                              }
                                                                                          /code


                                                                                          Если дети освоили программирование на Си или Паскале, то смогут дальше перейти на другой язык при необходимости.
                                                                                          Да, императивные языки так изучили миллионы.
                                                                                          Какое место должен будет занять ваш язык в системе обучения?
                                                                                          Ознакомить с основными возможными способами программирования.
                                                                                          Пока у меня складывается ощущение что вы пытаетесь сделать язык «все в одном»: функциональное программирование, логическое, аспектное и т.д.
                                                                                          Да, именно на это я и целюсь (правда, медленно)
                                                                                          ИМХО, это плохая идея, учебный язык должен быть простым и сосредоточенным на цели именно обучения, даже в ущерб строгости синтаксиса.
                                                                                          На мой взгляд, это должен быть больше язык для чтения чужих программ. Но желательно, чтобы он плохо, но решал типичные примеры из каждого вида программирования.
                                                                                      • +3
                                                                                        У меня отец, научный сотрудник, большой опыт программирования, когда вышел на пенсию, устроился учителем информатики.

                                                                                        То, какой там поставлен курс, по его мнению, вообще в принципе нельзя научить детей программированию…
                                                                                        Он отошел от учебника и стал рассказывать по своему. Оценок он не ставил, так как пока оценивать было не чего…
                                                                                        К концу четверти дети стали что-то понимать… А вот, в конце года его уволили…
                                                                                        • +4
                                                                                          Если его выпуск чему-то научился, то задачу он выполнил на все сто!
                                                                                          • 0
                                                                                            не думаю, что на все 100
                                                                                            он просто их не успел ничему научить, но некоторых сумел научить немного думать…
                                                                                          • 0
                                                                                            Увы, система образования сопротивляется изменениям и это не здоровый консерватизм. Нам проще, а вот с внедрением подобной методики в школах будет куда больше бюрократии :(
                                                                                            • 0
                                                                                              видимо он в какой-то мере подставил школьников, да еще и непедагогично, опустив министерство образования в их глазах, им ведь когда-то экзамены сдавать — это же реальный мир. при таком альтруизме лучше было бы вести кружок или на продленке правильные знания передавать.
                                                                                              • 0
                                                                                                думаю, что те кто хоть что-то соображают, то сдадут все экзамены на отлично,
                                                                                                и не только выпускные, но и Вузовские.
                                                                                                а кому учеба не нужно — тот получит своё. Это было везде и всегда.