Введение в прикладное программирование под GNU/Linux

Это конспект, который я готовил для доклада на конференции, проводившейся местным университетом совместно с нашей LUG. Доклад «для самых маленьких», так что профессионалам просьба не жаловаться на поверхностность и обзорность.

Аудитория

Эта статья расчитана на два вида читателей. Во-первых, это люди, имеющие опыт программирования под MS Windows, но не имеющие такого опыта под GNU/Linux. Во-вторых, это люди, не имеющие опыта программирования вовсе. Однако, я предполагаю, что читатель в общем знаком с общепринятой в программировании терминологией, и ему не нужно объяснять, например, что такое «программа», «функция», «компилятор» или «отладка».

Средства разработки

Я буду рассматривать разработку с использованием тех средств, которые являются наиболее «родными» для GNU/Linux. К ним относятся:

• Язык программирования C

• Командная оболочка bash

• Текстовые редакторы Vim и Emacs

• Компилятор GCC

• Отладчик GDB

• Утилита для сборки проекта GNU make

• Система управления версиями Git

• Оконная система X11

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

Языки программирования

Наиболее «родным» языком программирования для GNU/Linux является C. Это обусловлено следующими факторами:

• GNU/Linux заимствует многие идеи (практически, идеологию) операционной системы UNIX;

• Операционная система UNIX была написана на языке C (собственно, этот язык создавался именно для написания этой ОС);

• Соответственно, ядро Linux и системное окружение GNU написаны тоже на C.

Ниже я буду рассматривать разработку с использованием языка C. Однако, этот выбор не является догмой. Другими популярными при разработке под GNU/Linux языками являются C++, Python, Perl. Конечно, могут использоваться и любые другие языки.

Среда разработки

В течение последних двух десятилетий очень широкое распространение получили т.н. IDE — интегрированные среды разработки. Такая среда включает в себя текстовый редактор, компилятор, отладчик, средства сборки проекта и мн.др. Такие среды есть и под GNU/Linux (наиболее популярны Eclipse, NetBeans, IDEA, KDevelop, Anjuta). Однако, история разработки под UNIX-подобные системы показывает, что IDE не являются не только единственным, но и наиболее эффективным средством разработки. Практически, правильный ответ на вопрос «какая самая лучшая IDE под GNU/Linux» — это «GNU/Linux это и есть IDE».

Часто можно встретить мнение, что большой проект без IDE разрабатывать невозможно. Это мнение легко опровергается. Первые версии UNIX писались даже не в Vim (его тогда ещё не было), а в Ed. Это так называемый «построчный» текстовый редактор, в котором вы можете редактировать за раз только одну строку текста. Весь файл на экране не отображается. В случае с UNIX по-другому и быть не могло — у разработчиков не было никаких экранов, а общение с системой осуществлялось при помощи телетайпов. Современное ядро Linux пишется в основном в редакторах Emacs и Vim.

Многие утилиты UNIX вызывают «текстовый редактор по умолчанию». Команда, запускающая текстовый редактор по умолчанию, берётся из переменной окружения $EDITOR. Некоторые утилиты смотрят сначала в переменную $VISUAL, и, лишь если она не установлена, в переменную $EDITOR. Это исторически сложившееся поведение: к старым компьютерам зачастую не было подключено никакого дисплея, а только телетайп, поэтому запускать экранный (визуальный) редактор смысла не было. В современных дистрибутивах обычно по умолчанию оказывается EDITOR=vi или EDITOR=nano. Указать использование другого редактора для одной команды можно так:

EDITOR=emacs some-command

Чтобы использовать нужный редактор по умолчанию всегда, нужно добавить в файл ~/.profile строчку типа

export EDITOR=emacs

Исторически сложилось так, что «настоящими» текстовыми редакторами для программистов являются только Vim и Emacs (просто из-за того, что у них самая долгая история развития именно в качестве текстовых редакторов для программистов). Остальные редакторы находятся в положении догоняющих.

Командная оболочка

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

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

ОС семейств DOS и Windows заимствовали некоторые функции командной оболочки из UNIX, однако их авторы пошли на существенные упрощения, из-за чего функционал COMMAND.COM и cmd.exe получился сильно урезанным. PowerShell вполне на уровне, но работает существенно по-другому.

В рамках этой статьи я ограничусь использованием командной оболочки bash (как наиболее распространённой и используемой по умолчанию в большинстве дистрибутивов) для запуска компилятора и других средств разработки. Хороший обзор использования командной оболочки можно найти, например, в известной книге [kernigan_pike].

Документация

Все средства разработки и библиотеки в GNU/Linux обычно довольно хорошо документированы. Традиционно для документации используется специальный формат и утилита для его просмотра — man. Документация в системе делится на несколько разделов:

1. Команды пользователя (например, ls, gcc или man)

2. Системные вызовы — API ядра ОС

3. Библиотечные функции

4. Драйвера и т.п

5. Форматы файлов

6. Игры и т.п

7. Различные обзоры подсистем

8. Команды, используемые для системного администрирования

Для вызова раздела документации по имени нужно указать это имя при вызове команды man (например, man ls). Иногда разделы с одинаковым названием есть сразу в нескольких разделах документации документации. Указать конкретный раздел можно при вызове man (например, man 3 printf).

Более подробную информацию о справочной системе man см. в man man.

Утилиты системного окружения GNU часто используют для документации формат info. См., например, info Coreutils.

Компилятор

Сейчас существует много компиляторов языка C, более-менее совместимых с различными стандартами. Тем не менее, пока что в среде GNU/Linux наиболее применимым остаётся компилятор C, входящий в комплект GNU Compilers Collection (GCC). Этот компилятор, кроме стандарта C, поддерживает некоторое количество расширений стандарта. Эти расширения, в частности, широко используются в исходных текстах ядра Linux. В последнее время появляются компиляторы, способные скомпилировать ядро Linux (например, llvm-clang, или EKO).

Компилятор GCC запускается из командной оболочки командой вида

gcc [OPTIONS] program.c

где program.c — имя входного файла. Кроме того, по стандарту POSIX, компилятор может быть запущен командой cc program.c (cc — от "C compiler").

При обычном запуске компилятор пытается создать исполняемый файл. По умолчанию, выходной файл называется a.out (такое название осталось от древних версий UNIX). Другое название можно задать с помощью опции компилятора -o, например,

gcc -o program program.c

При сборке программы из нескольких модулей компилятору можно подавать на вход несколько исходных файлов или файлов объектного кода, например,

gcc -o program main.c module1.o module2.o …

Чтобы только скомпилировать один исходный файл в объектный код (не пытаясь собрать исполняемый файл), нужно дать команду вида

gcc -c module.c

(имя выходного файла по умолчанию будет module.o).

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

Статическая библиотека в UNIX-подобных системах представляет собой архив (старинного формата ar), включающий набор объектных файлов. Такой архив создаётся командой вида

ar r libsomething.a module1.o module2.o …

Имена файлов библиотек традиционно начинаются с префикса lib.

Динамически загружаемая библиотека представляет собой объектный файл специального формата (расчитанного на динамическую загрузку). Такая библиотека создаётся командой вида

gcc -shared -o libsomething.so module1.c module2.c …

Для использования библиотеки при сборке программы её нужно указать компилятору при помощи опции -l, например

gcc -o program -lm program.c

(здесь будет использоваться файл библиотеки libm.so, префикс lib компилятор подставляет по умолчанию). По умолчанию компилятор собирает программу, использующую динамические библиотеки. Если нужно использовать статические версии библиотек, компилятору нужно указать опцию -static.

Подробную информацию об опциях gcc см. в man gcc.

Hello, world!

Считается, что традиция начинать изучение языка программирования с написания программы, выводящей строку "Hello, world!", пошла с книги Кернигана и Ричи "Язык C" [kernigan_richie]. В случае с языком C эта программа выглядит следующим образом:

#include <stdio.h>

int main(int argc, char* argv[]) {
printf("Hello world!\n");
return 0; 
}

Чтобы запустить эту программу, этот текст нужно записать в файл с именем, скажем, hello.c, и из директории, в которой расположен этот файл, дать команду вида

gcc -o hello hello.c

Впрочем, в случае такой простой программы достаточно дать команду

make hello

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

./hello

Порядок сборки

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

На входе компилятор имеет в общем случае набор файлов с исходными текстами. Перед началом собственно компиляции эти файлы обрабатываются т.н. препроцессором (программа cpp). Главная функция этой программы — выполнение директив вида #include . Встретив такую директиву, препроцессор вставляет содержимое указанного файла (в данном случае, stdio.h) на место этой директивы. Препроцессор понимает ещё некоторые директивы, но сейчас на них останавливаться я не буду.

После препроцессора выполняется собственно компиляция. Из исходных файлов на этом этапе получаются т.н. объектные файлы. Это файлы, содержащие исполняемый машинный код, но ещё не готовые для запуска. Главное, чего в них недостаёт — это адреса вызываемых библиотечных функций. Например, код функции printf() содержится в библиотеке libc. А в объектном файле содержится только имя этой функции. Кроме того, объектный файл содержит имена всех объявленных в нём функций.

Объектные файлы, а также используемые библиотеки подаются на вход компоновщику (программа ld). Компоновщик ищет все вызываемые из различных объектных файлов функции (по именам) в объектных файлах и в библиотеках. Если все функции найдены, то компоновщик собирает собственно исполняемый файл. При этом имена вызываемых функций заменяются на конкретные адреса памяти. В случае использования динамической библиотеки имя используемой функции остаётся, и к нему добавляется имя файла динамической библиотеки, в которой при запуске программы нужно будет искать эту функцию.

Собственно программа gcc представляет собой так называемый драйвер (driver). Она запускает упомянутые выше программы (или только некоторые из них, в зависимости от опций), чтобы получить исполняемый файл.

Второй пример: решение квадратных уравнений

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

#include <stdio.h>
#include <math.h>

/* solve: calculate roots of square equation.
* a, b, c are coefficients in equation.
* Roots would be stored at x1, x2.
* Return value: count of real roots.
*/
int solve(double a, double b, double c,
        double* x1, double* x2) {
double D = b*b - 4*a*c;
double sqrtD;

if (D > 0) {
  sqrtD = sqrt(D);
  *x1 = (-b - sqrtD)/(2.0 * a);
  *x2 = (-b + sqrtD)/(2.0 * a);
  return 2;
} else if (D < 0)
  return 0;
  else {
    *x1 = -b/(2.0*a);
    return 1;
  }
}

int main (int argc, char* argv[]) {
double a,b,c;
double x1, x2;
int roots_count;

// Input coefficients
printf("A: ");
scanf("%lf", &a);
printf("B: ");
scanf("%lf", &b);
printf("C: ");
scanf("%lf", &c);

// Solve the equation
roots_count = solve(a,b,c, &x1, &x2);

// Output results
switch (roots_count) {
  case 0:
    printf("No (real) roots.\n");
    break;
  case 1:
    printf("One root: %0.4lf\n", x1);
    break;
  case 2:
    printf("Two roots: %0.4lf and %0.4lf\n",
           x1, x2);
    break;
}

return 0;
}

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

gcc -o square square.c

Но на этот раз мы получим ошибку примерно такого вида:

/tmp/cc6RNFIi.o: In function `solve': square.c:(.text+0x6d): undefined reference to `sqrt' collect2: ld returned 1 exit status

В чём здесь дело? Ясно, что компилятору почему-то не понравился вызов функции sqrt(). Причём, он жалуется уже не на файл исходного кода, а на объектный файл (вот этот cc6RNFIi.o). Это означает, что исходный файл благополучно скомпилировался, а проблемы возникли на стадии компоновки (что можно видеть и по упоминанию в тексте ошибки программы ld — это стандартный в GNU/Linux компоновщик). Компоновщик не смог найти функцию sqrt(). В данном случае, это произошло из-за того, что эта функция содержится в библиотеке libm, а мы не просили компилятор использовать её. Чтобы избавиться от этой ошибки, нам нужно изменить команду компиляции на следующую:

gcc -o square -lm square.c

Такая команда должна отработать без ошибок и создать исполняемый файл square.

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

square: square.c         $(CC) -o $@ -lm $<

Теперь собрать исполняемый файл можно просто дав команду make. Как это работает?

Make

Утилита make предназначена для сборки программ (хотя может использоваться для автоматизации многих других похожих задач). Она читает файл с именем Makefile и видит в нём набор правил. Каждое правило определяет три вещи: цель (goal, т.е. то, что нужно собрать), список исходных файлов и набор команд, которые нужно выполнить, чтобы собрать цель из исходных файлов. В примере выше, square — это имя цели, square.c — единственный в данном случае исходный файл (если их несколько, они перечисляются через пробел), а вторая строчка — команда. В команде могут использоваться переменные. Некоторые из переменных имеют специальное значение. В частности, в любом правиле $@ обозначает имя цели, а $< — первый исходный файл. Переменная $(CC) указывает на компилятор C, используемый в системе по умолчанию (в большинстве случаев это gcc, но бывает и что-нибудь другое).

В имени цели и списке исходных файлов может использоваться подстановочный символ %. Например, такое правило:

%.o: %.c   $(CC) -c $<

обозначает, что файлы с именем, заканчивающимся на .o, нужно собирать из соответствующих файлов с суффиксом .c.

Кроме того, make заранее знает некоторое количество правил по умолчанию. Среди них есть упомянутое в последнем примере, а также правило

%: %.c   $(CC) -o $@ $<

Благодаря этому правилу, в примере с «Hello, world!» просто команда make hello запускала cc -o hello hello.c.

По набору правил make составляет граф зависимостей целей друг от друга и от исходных файлов, и выполняет только те команды, которые нужны для сборки цели, указанной в командной строке. Если не указано никаких целей, то собирается первая цель, описанная в Makefile.

Более подробную информацию об этой утилите см., например, в man make.

Управление версиями

Для управления версиями исходного кода может использоваться любая VCS. Однако, раз уж мы говорим о GNU/Linux, рассмотрим вкратце систему, используемую для разработки ядра Linux: git. По git существует довольно обширная документация, в т.ч. и на русском языке. См. например, мою статью [vcs_git] или известную серию статей [los-t_git].

Для начала использования git нужно создать репозиторий — хранилище для версий файлов. Это делается командой

git init

Теперь можно добавлять файлы в репозиторий. Но нам не нужно отслеживать версии некоторых файлов, а именно: объектных файлов и исполняемых файлов. Чтобы сразу исключить их из рассмотрения git, напишем файл .gitignore следующего содержания:

*.o square hello

Теперь команда

git add .

добавит в репозиторий все файлы в текущей директории, кроме упомянутых в файле .gitignore. После этого можно делать коммит командой

git commit

По этой команде откроется текстовый редактор по умолчанию. Тут нужно будет написать комментарий к коммиту. В данном случае достаточно строчки типа «Initial commit».

Отладка

Для отладки в Linux используется отладчик gdb. Но сначала, для того, чтобы программу было удобно отлаживать, её нужно скомпилировать с опцией -g. Сейчас нам достаточно изменить Makefile, приведя его к виду

square: square.c         $(CC) -o $@ -lm -g $<

и пересобрать программу.

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

Отладка запускается командой вида

gdb ./square

Если отлаживаемой программе нужно передать какие-то опции командной строки, их можно указать здесь же:

gdb ./some-program -a -b

При запуске отладчика появляется приглашение командной строки вида:

GNU gdb (GDB) 7.2-ubuntu Copyright (C) 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later  This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.  Type "show copying" and "show warranty" for details. This GDB was configured as "i686-linux-gnu". For bug reporting instructions, please see: ... Reading symbols from /home/portnov/LUG/src/square...done. (gdb)

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

К наиболее часто используемым командам относятся:

list

Напечатать очередной кусок исходника (печатается 10 строк). Можно указать конкретные номера строк после имени команды, например l 10,15.

run

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

break

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

next

Выполнить одну строку программы.

print

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

display

Добавить выражение к списку постоянно отображаемых. Значения этих выражений будут показываться после исполнения каждой команды. Рядом с каждым выражением печатается его номер в списке. Удалить выражение из списка можно командой undisplay с номером выражения.

quit

Выход из отладчика.

Более подробную информацию по GDB см. в man gdb.

Оконная система X11

Исторически в UNIX не было и не могло быть никакой графической среды, потому что не было графических дисплеев. Графическая среда для UNIX появилась примерно тогда, когда появились распространённые графические дисплеи: в 1984. Сначала она называлась W (от Window), затем её усовершенствовали и назвали следующей буквой алфавита — X, следующая версия называлась X2… Сейчас имеем X11.

X11 представляет собой, прежде всего, сетевой протокол поверх TCP/IP и UDP/IP. У протокола есть клиент и есть сервер. Клиент посылает последовательность запросов вида «нарисуй мне окошко», «нарисуй на нём кнопочку», а сервер их исполняет. Один из главных принципов X11 — «определять механизмы, а не политики». Протокол предоставляет возможность, скажем, рисовать окошки, а как именно они будут отображаться — не определяет.

Наиболее распространённым X-сервером сейчас является Xorg (http://x.org); всё ещё жив XFree86; под Windows актуален Xming; выпускаются аппаратные X-серверы — комплекты «монитор + клавиатура + мышка», в которых поддержка серверной функциональности X11 реализована аппаратно — такие комплекты используются в качестве графических терминалов.

Протокол X11, в отличие от, скажем, HTTP, является бинарным, а не текстовым — это сделано из соображений экономии пропускной способности сетевого соединения и простоты разбора запросов сервером. Но это усложняет создание клиентов этого протокола: собирать замысловатые бинарные X11-запросы заведомо сложнее, чем, например, текстовые HTTP-запросы. Поэтому для написания X-клиентов используются специальные библиотеки функций, формирующих и отправляющих серверу X-запросы. Наиболее распространена библиотека libX11. Более современным вариантом является libxcb.

Запросы X11 весьма низкоуровневые. Например, чтобы реализовать функциональность кнопки, нужно нарисовать в окне прямоугольник, написать в нём текст, ждать в цикле нажатия кнопки мыши, и при каждом нажатии проверять, где щёлкнули — внутри прямоугольника или вне него. Поэтому стали появляться так называемые тулкиты — библиотеки, являющиеся высокоуровневыми обёртками над libX11.

Исторически первым тулкитом был Athena3D. Потом были Motif и Tk. Сейчас наиболее распространены GTK+ и Qt (Qt, строго говоря, представляет собой не X11-тулкит, а многоцелевой кроссплатформенный набор библиотек, который может использоваться в качестве X11-тулкита).

Hello, world на GTK+

В качестве примера рассмотрим следующую программу. Она показывает окно с одной кнопкой. При нажатии на эту кнопку появляется сообщение «Hello, world».

#include <gtk/gtk.h>

// This function displays message dialog.
// main_window parameter should be set to parent window of the dialog.
void message_box (GtkWindow* main_window, gchar *message) {
  GtkWidget *dialog, *label, *content_area;
 
  // Create a dialog
  dialog = gtk_dialog_new_with_buttons ("Message",
                                        main_window,
                                        GTK_DIALOG_DESTROY_WITH_PARENT,
                                        GTK_STOCK_OK,
                                        GTK_RESPONSE_NONE,
                                        NULL);
  // Create a label
  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
  label = gtk_label_new (message);
 
  // On "response" signal (it's called when user clicks a button in
  // the dialog), destroy the dialog.
  g_signal_connect_swapped (dialog,
                            "response",
                            G_CALLBACK (gtk_widget_destroy),
                            dialog);
 
  // Add a label
  gtk_container_add (GTK_CONTAINER (content_area), label);
  // Show the dialog
  gtk_widget_show_all (dialog);
}

// Callback for delete-event signal
static gboolean delete_event( GtkWidget *widget,
                             GdkEvent  *event,
                             gpointer   data )
{
 // If return TRUE, window will not be closed.
 // This may be used to preven closing window in some situations.
   return FALSE;
}

// Callback for destroy signal
static void destroy( GtkWidget *widget,
                    gpointer   data )
{
 // End main GTK+ event loop
   gtk_main_quit ();
}

// Callback for button click
static void hello ( GtkWidget *widget,
                   gpointer  data )
{
 // "data" parameter represents main window here
 message_box(GTK_WINDOW(data), "Hello, world!");
}

int main( int   argc,
         char *argv[] )
{
   GtkWidget *window;
   GtkWidget *button;
  
   // Init GTK+
   gtk_init (&argc, &argv);
  
   // Create main window
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  
   // Set up callbacks for some signals
   g_signal_connect (window, "delete-event",
        G_CALLBACK (delete_event), NULL);
  
   g_signal_connect (window, "destroy",
        G_CALLBACK (destroy), NULL);
  
   // Set window borders width
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
  
   // Create labeled button
   button = gtk_button_new_with_label ("Hello World");
  
   // Set up callback for "clicked" signal of the button.
   // Pass main window as second parameter.
   g_signal_connect (button, "clicked", G_CALLBACK (hello), (gpointer)window);
  
   // Pack the button into window
   gtk_container_add (GTK_CONTAINER (window), button);
  
   // Show the button
   gtk_widget_show (button);
  
   // Show the window
   gtk_widget_show (window);
  
   // Run main GTK+ event loop.
   gtk_main ();
  
   return 0;
}

Собирается эта программа командой вида

gcc -o gtk-hello $(pkg-config --cflags gtk+-2.0) $(pkg-config --libs gtk+-2.0) gtk-hello.c

GTK+ — довольно сложно устроенный набор библиотек, поэтому, чтобы не указывать все нужные библиотеки и опции компилятора вручную, мы используем здесь программу pkg-config, которая печатает опции компилятора, нужные для использования GTK+.

Дополнительная литература

[raymond] Реймонд, Эрик С. Искусство программирования для UNIX. — Пер. с англ. — М.: Издательский дом «Вильямс», 2005. — 544с., ил.

[kernigan_pike] Керниган Б., Пайк Р. UNIX. Программное окружене. — Пер с англ. — СПб: Символ-Плюс, 2003. — 416с., ил.

[kernigan_richie] Керниган Б., Ритчи Д. Язык программирования C. — Пер. с англ. — Москва: Вильямс, 2006. — 304 с.

[vcs_git] Портнов И. Системы контроля версий. Git. URL: http://iportnov.blogspot.com/2008/06/git.html

[los-t_git] Los-t. Git guts (серия статей в ЖЖ). URL: http://los-t.livejournal.com/tags/git+guts

Доклад по Python: часть III

9. Функциональное программирование.

ФП не является "родной" парадигмой для Питона. В частности, в Питоне нет оптимизации хвостовой рекурсии (создатель языка недавно подтвердил, что и не будет), что делает практически невозможным программирование в характерном для ФП рекурсивном стиле.

Однако некоторые элементы ФП могут быть использованы в Питоне очень эффективно. В частности, выше мы видели примеры применения конструкции lambda. Эта конструкция создает анонимную функцию, а точнее - замыкание (то есть создаваемая функция "запоминает" значения внешних переменных в момент создания). Классический пример использования замыканий:

def add(x,y):
 return x+y

inc = lambda x: add(x,1)

def incrementer(n):
 return lambda x: add(x,n)

inc(3)   # выдаст 4

f = incrementer(3)

f(5)      # выдаст 8.

Другие типичные конструкции, позаимствованные из функциональных языков - это стандартные функции map,filter,zip и специальная форма, называемая списочным сокращением (list comprehension).

Функция map(f,list) возвращает список значений, полученный применением функции f к каждому элементу списка list. Пример:

>>> def sqr(x):
...   return x*x
...
>>> map(sqr,[1,2,3])
[1, 4, 9]

Функция filter(p,list) возвращает список из только тех элементов списка list, для которых функция p возвращает истину. Пример:

>>> def even(n):
...   return n%2 == 0
...
>>> filter(even,[1,2,3,4,5,6])
[2, 4, 6]

Функция zip принимает два (или больше) списка и возвращает список пар (кортежей), составленных из соответствующих элементов списков:

>>> zip([1,2,3,4],["A","B","C","D"],['x','y','z','t'])
[(1, 'A', 'x'), (2, 'B', 'y'), (3, 'C', 'z'), (4, 'D', 't')]

List comprehensions позволяют одной строкой создать списки по какому-нибудь правилу:

>>> [x*x for x in [1,2,3,4,5]]
[1, 4, 9, 16, 25]

Можно тут же отбирать нужные элементы списка:

>>> [x*x for x in [1,2,3,4,5] if even(x)]
[4, 16]

Можно перебирать одновременно несколько последовательностей:

>>> l = [1,2,3,4,5]
>>> [x*y for x in l for y in l]
[1, 2, 3, 4, 5, 2, 4, 6, 8, 10, 3, 6, 9, 12, 15, 4, 8, 12, 16, 20, 5, 10, 15, 20, 25]

10. Декораторы.

Декораторы - это одна из самых мощных особенностей Питона (особенно в сочетании с интроспекцией). В простейшем случае декоратор - это функция, принимающая в качестве аргумента функцию и возвращающая новую функцию.

Применяются декораторы так:

@decor
def f(x,y):
...

и это эквивалентно такой записи:

def f(x,y):
...
f = decor(f)

Классический пример использования декораторов - это отслеживание вызовов функции:

def trace(func):
name = func.func_name                                                   # имя переданной функции
def wrapper(*args,**kwargs):                                          # создаем новую функцию
 print "Function called: %s(%s,%s)" % (name,args,kwargs)
 result = func(*args,**kwargs)                                        # вызываем исходную функцию
 print "Function %s returned %s" % (name,result)
 return result
return wrapper                                                                 # возвращаем созданную функцию

@trace
def f(x,y):
 return x*y+2

Обычно декоратор выполняет какую-то работу дополнительно к тому, что делает сама функция. Например, в веб-фреймворке Django есть декоратор login_required - он проверяет, что пользователь уже авторизовался, и только в этом случае вызывает исходную функцию.

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

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

Собственно функция-декоратор должна принимать только один аргумент - исходную функцию. Но можно писать функции, которые возвращают декораторы:

def print_on_call(text):
def decorator(func):
 def wrapper(*args,**kwargs):
   print ">> "+text
   return func(*args,**kwargs)
 return wrapper
return decorator

@print_on_call("F called!")
def f(x):
...

Другой пример использования декораторов - реализация делегатов (методов объекта, которые вызывают метод другого класса с тем же именем):

def delegate(cls):
def decorator(meth):
 name = meth.func_name
 def wrapper(*args,**kwargs):
   m = object.__getattribute__(cls,name)
   result = m(*args,**kwargs)
   return result
 return wrapper
return decorator

class A(object):
x = 0
def two(self,z):
 r = self.x*z
 self.x = z
 return r

class B(object):
x = 3

@delegate(A)
def two(self,z):
 pass

b = B()
print b.two(5)                # Выводит 15

11. Дескрипторы

Дескриптор — это класс с определенными методами __get__() и __set__(). Предполагается, что __get__() возвращает значение экземпляра, а __set__() — соответственно, устанавлнивает.

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

В Питоне есть стандартный класс-дескриптор property, конструирующий свойство объекта из getter-а и setter-а. Типичный пример использования property:

class A(object):
def getx(self):
 print "Getter called."
 return self._x

def setx(self,value):
 print "Setting .x to %s" % value
 self._x = value

x = property(getx,setx)

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

Таким образом, дескрипторы - это значительное обобщение свойств (properties), имеющихся в C#.

12. Метаклассы

В Питоне всё есть объект. В том числе, классы - это тоже объекты.
Самые часто используемые объекты — это экземпляры классов. А классы, в свою очередь, являются экземплярами метаклассов.

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

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

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

>>> class Meta(type):
... def whoami(cls):
... print "I'm a", cls.__name__
...
>>> class A(object):
... __metaclass__ = Meta # Указываем используемый метакласс
... def do_something(self):
... print "Doing something."
...
>>> a = A()
>>> A.whoami()
I'm a A
>>> a.do_something()
Doing something.

Также можно переопределять процесс создания классов:

>>> class Meta2(type):
...   def __new__(cls,name,bases,dct):  #Конструктор
...     print "Creating class",name
...     return type.__new__(cls,name,bases,dct)
...   def __init__(cls,name,bases,dct):  #Инициализатор
...     print "Init'ing class", name
...     super(Meta2,cls).__init__(name,bases,dct)
...     cls.x = 25      # Добавляем атрибуты к классу
...     cls.y = 30
...
>>> class B(object):
...   __metaclass__ = Meta2
...   def f(self):
...     print "Calling F."
...
Creating class B
Init'ing class B
>>> b = B()
>>> b.x
25
>>> b.f()
Calling F.

Таким образом, метаклассы позволяют часть логики каждого класса вынести за пределы самого класса. Это еще одна возможность для аспектно-ориентированного подхода.

Доклад по Python: часть II

3. Объекты.

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

>>> a = 1
>>> a.__str__() # этот метод дает строковое представление объекта
'1'

Функции принимают в качестве аргументов объекты и возвращают объекты. Например, функция может принимать функцию в качестве аргумента и возвращать класс, или принимать строку и возвращать функцию.

Рассмотрим помаленьку все традиционные принципы ООП.


4. Инкапсуляция.

Инкапсуляция подразумевает: алгоритмы работы с данными хранятся вместе с данными. Для атомарных значений мы это уже видели в предыдущем разделе (a.__str__()). Для экземпляров пользовательских классов это реализуется образом, очень похожим на C++ или Java:

class A(object): # object - класс, стоящий в вершине иерархии наследования
x = 0
y = 0

def move(self,x,y):
  self.x = x
  self.y = y

a = A()
a.move(2,3)

Здесь можно увидеть, что в Питоне указатель на экземпляр класса передается в методы явным образом, как первый аргумент (из стандарта С++ известно, что там это реализовано так же, только этот первый аргумент явно не выписывается). Здесь видно следование первому принципу философии Питона: явное лучше неявного.

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


5. Наследование.

Наследование подразумевает возможность создания классов объектов, ведущих себя почти также, как "родительский" класс, но "немного по-другому". В простейшем случае реализация наследования в Питоне похожа на C++:

class A(object):
x = 0

class B(A):
y = 1

Возможно и множественное наследование: class A(B,C,D):...

Типичная проблема, возникающая при проектировании в стиле ООП, состоит в следующем. Объект некоторого типа (например, Сотрудник) требуется передавать в качестве аргумента в различные функции. Разным функциям нужны разные свойства и методы этого объекта, причем набор свойств и методов объекта, которые нужны каждой функции, фиксирован. При этом хотелось бы сделать все эти функции полиморфными, то есть способными принимать объекты разных типов.

Эта проблема решается различными способами. В С++ для этого используется множественное наследование. В Java - интерфейсы. В Ruby - mix-ins (примеси).

В Питоне используется концепция, называемая Duck Typing: «Если ЭТО ходит, как утка, и крякает, как утка - значит, это утка». То есть, если у объекта есть все нужные функции свойства и методы, то он подходит в качестве аргумента. Например, в функцию

def f(x):
return x.get_value()

можно передавать объект любого типа, лишь бы у него был метод get_value().

Еще одна типичная проблема, возникающая в связи с множественным наследованием - не всегда очевидно, в каком порядке будут просматриваться родительские классы в поисках нужного свойства или метода. В Питоне для упрощения этой проблемы у каждого класса есть свойство __mro__ (method resolution order):

>>> class A(object): pass
...
>>> class B(object):
... x = 0
...
>>> class C(A,B):
... z = 3
...
>>> C.__mro__
(<class 'C'>, <class 'A'>, <class 'B'>, <type 'object'>)


6. Полиморфизм.

Полиморфизм - это способность функции работать с аргументами разных типов.
В C++ и Java полиморфизм тесно связан с наследованием. Например, в C++, если объявлено, что функция f принимает экземпляр класса A, то она может принимать экземпляр любого класса, унаследованного от A. В Java это поведение расширено: за счет интерфейсов (interfaces) есть возможность передавать в функцию экземпляры классов, не связанных "генетически" (но реализующих один интерфейс).

В Питоне полиморфизм реализован за счет Duck Typing: любая функция может принимать объекты любого типа, но если она попытается использовать свойства, которых у данного объекта нет, возникнет исключение (exception) (функция может перехватить его в конструкции try...except и сделать в этом случае что-то другое). За счет этого, например, функция, работающая с файлами, может принимать в качестве аргумента имя файла или дескриптор открытого файла - и действовать по обстоятельствам.

Таким образом, в Питоне (как и было задумано создателями парадигмы ООП) полиморфизм и наследование - совершенно ортогональные принципы.


7. Интроспекция.

Про этот принцип регулярно забывают, когда рассказывают об ООП на примере С++, а между тем это один из основополагающих принципов.

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

У каждого объекта есть некоторое количество атрибутов. Атрибуты, имена которых, начинаются с подчеркивания, считаются приватными (private), хотя это и не влияет на область видимости - это только соглашение. "Более приватными" являются атрибуты, имена которых начинаются с двух подчеркиваний - снаружи они винды только как __имя-объекта__имя-атрибута__. Атрибуты, начинающиеся с двух подчеркиваний и заканчивающиеся двумя подчеркиваниями, имеют специальный смысл.

Список всех атрибутов любого объекта можно получить с помощью встроенной функции dir:

>>> a = 1
>>> dir(a)
['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__str__', '__sub__', '__truediv__', '__xor__']

Объект, имеющий атрибут __call__, можно вызывать как функцию (собственно, функции в Питоне отличаются от остальных объектов только наличием этого атрибута). Для проверки, можно ли использовать объект как функцию, используется стандартная функция callable(f). Таким образом, методы объекта - это атрибуты, которые можно вызывать.

У функций и классов есть атрибут __doc__, содержащий так называемый docstring - строку документации. При описании функции она пишется на отдельной строке после def, при описании класса - после class. Стандартная функция help() выдает информацию о любом объекте.

Атрибут __name__ любого объекта содержит его имя. У экземпляров классов атрибут __class__ содержит ссылку на класс этого объекта.

Стандартная функция type() возвращает тип объекта (тип - это тоже объект).

С помощью функции isinstance(obj,cls) можно выяснить, является ли объект экземпляром данного класса (или одного из дочерних классов). А функция issubclass(cls1,cls2) выясняет, является ли cls1 потомком cls2.

Модуль inspect, входящий в стандартную поставку Питона, содержит некоторые дополнительные возможности интроспекции. В частности, функция inspect.getargspec(func) сообщает, сколько и каких аргументов ожидает получить функция.


8. Динамизм.

Этот принцип не был сформулирован как один из основных для ООП, однако референсная реализация ООП - Smalltalk - этим свойством обладает.

Речь идет о том, что свойства объекта (включая даже его тип) могут изменяться во время исполнения. Пример:

>>> class A(object):
... pass

>>> a = A()
>>> a.x = 25 # создаем новый атрибут объекта
>>> b = A() # другой экземпляр того же класса
>>> print b.x # вызовет исключение: у объекта b нет атрибута x
>>> b.y = 30 # создаем другой атрибут
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', 'x']
>>> dir(b)
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', 'y']

Можно создавать "на ходу" даже методы класса:

>>> A.method = lambda self,s: "<%s %s>" % (s,self.x)
>>> c = A()
>>> c.x = 25
>>> c.method("Text")
'<Text 25>'

Доклад по Python: часть I

1. Что такое?..

Python - это интерпретируемый алгоритмический объектно-ориентированный язык со строгой динамической типизацией, полиморфизм в нем реализован в виде Duck Typing.

Трансляция питона организована очень схожим с Java образом. Именно, исходник компилируется в байт-код, а затем этот байт-код исполняется. Это сходство настолько велико, что существует реализация Питона (Jython), генерирующая Java байт-код для исполнения виртуальной машиной Java. Различие состоит в политике, когда записывать байт-код на диск. Напомню, для Java традиционный способ запустить только что написанную программу такой: запускаем компилятор, подсовывая ему исходник - он генерирует байт-код и записывает его в файл. Затем запускаем виртуальную машину, подсовывая ей байт-код - и она его исполняет.
Питон же обычно не записывает байт-код на диск. В простейшем случае запуск программы происходит так: мы "скармливаем" исходник интерпретатору; он генерирует байт-код, но оставляет его в памяти, а затем передает виртуальной машине (являющейся частью интерпретатора). Это ускоряет запуск программы за счет отсутствия необходимости записывать байт-код на диск.
Однако, при загрузке (импорте) модулей Питон пытается сохранить байт-код, чтобы в следующий раз загрузка модуля происходила быстрее. Есть возможность и саму программу записать в виде байт-кода. Интерпретатору Питона можно подсовывать не только исходники, но и байт-код - он загрузится быстрее.
За счет такого сходства в устройстве с Java имеем и большое сходство в производительности (она примерно одинаковая, только Питон чуть быстрее загружает программы за счет того, что не пишет байт-код на диск).
И именно из-за этого сходства Питон обычно сравнивают именно с Явой.

Еще одно сходство с Явой (и многими другими интерпретируемыми и даже некоторыми компилируемыми языками) - это автоматическое управление памятью. В Питоне нет new[] и delete[], память отводится и освобождается автоматически. Алгоритм сборки мусора как бы "двухслойный": во-первых, сам интерпретатор реализует reference counting (удаляя объекты, на которые никто не ссылается), и во-вторых, есть время от времени запускаемый garbage collector, работающий по более замысловатым, но более быстрым и надежным алгоритмам (например, reference counting не удалит два объекта, ссылающихся друг на друга, даже если на них больше никто не ссылается).

Удобным свойством интерпретатора Питона является наличие REPL (read-eval-print loop), то есть возможности вводить языковые конструкции с консоли и тут же получать результат. Это часто используется для проверки каких-нибудь идей или для отладки.

1.1. Синтаксис.

В самых общих чертах синтаксис Питона напоминает С или Паскаль. Операторы записываются обычно по одному на строку. Присваивание записывается как в С, знаком =. Но при этом присваивание не возвращает значения, поэтому его нельзя использовать в условии. Для сравнений используются обычные для С знаки ==, !=, >,<.>=,<=. Небольшое отличие состоит в том, что Питон понимает "двойные" сравнения в "математическом" смысле, т.е. 0 < x < 10 понимается как 0 < x and x < 10. Основные конструкции проще показать на примерах:

if x < 0:
 print "Yes"
elif x==0:
 print "X is 0"
else:
 print "No"

for i in [1,2,3]:
 print i
else:
 print "Loop was not break'ed"

while x>0:
 print x
 x -= 1

try:
 z = x/y
except ZeroDivisionError,e:
 print e
else:
 print "Divided sucsessfully."
finally:
 print "Some cleanup."

def fun(x,y):
 return x+y

class Child(Parent):
x = 0
def method(self,x,y):
 return self.x - x + y

f = open("abc.txt")
for line in f:
 print "<%s>" % line
f.close()

В последнем примере показана замена функции sprintf: "строка" % (данные). В проектируемой сейчас версии Python3000 этот способ исчезнет, а вместо него появится другой: "Value {0}, Value {1}".format("one", 2).


1.2. Типы данных.

В Питоне выделяют атомарные и структурные (или ссылочные) типы данных. К атомарным типам относятся числа и строки. Структурные типы - это списки, кортежи (tuples), словари, функции, классы и экземпляры классов.

Данные некоторых типов (а именно - кортежи и строки) являются неизменяемыми.

Списки записываются так: [1, "one", 25]. Список может содержать любое количество объектов любого типа. Обращение к элементу списка - по индексу: a[2] (элементы нумеруются с нуля). Добавление элементов в список можно делать так:

a = a + [25]

или так (предпочтительней, т.к. быстрее):

a.append(25).

Кортежи записываются как значения через запятую: a,b,c. Часто для ясности кортежи приходится записывать в скобках: (a,b,c). Кортежи, как и списки, могут содержать значения любых типов, но, в отличие от списков, являются неизменяемыми.

Для строк, списков и кортежей есть специальный синтаксис для обращения к части данных, называемый срезами (впервые такой синтаксис появился еще в Фортране):

>>> a = "abcde"
>>> a[3:5]
'de'
>>> a[:2]
'ab'
>>> a[4:]
'e'
>>> a[:-2]
'abc'
>>> a[::-1]
'edcba'
>>> a[5:2:-1]
'ed'
>>> a[:]
'abcde'
>>> a[::2]
'ace'

Словари в Питоне - это структура, соответствующая хэшам в Перле, массивам в PHP и std::map в C++. Записываются так:

{'a': 1, 'b': 2, 'c': 3}

или так:

dict(a=1,b=2,c=3).

В качестве индексов в словарях могут быть использованы числа, строки, и вообще, любые объекты, имеющие метод __hash__() (например, кортежи). Обращение к элементам словаря выглядит так:

print d['key']

Метод keys() возвращает список из ключей словаря, а values() - список из значений. Порядок следования ключей не определен:

>>> d = dict(a=1,b=2,c=3)
>>> d.keys()
['a', 'c', 'b']
>>> d.values()
[1, 3, 2]

Функции создаются так:

def f(x):
"Documentation string (docstring)"
return x*x

или так:

f = lambda x: x*x

О классах и их экземплярах будем подробно говорить дальше.

2. Типизация.

Главное отличие Питона от Явы (если брать только чисто "лингвистические" свойства) - это типизация. Напомню, в Яве используется строгая статическая типизация с явным объявлением типов переменных. Это означает, что типы всех переменных известны в момент компиляции, и тогда же происходит проверка типов. Это дает преимущество в том плане, что значительная часть ошибок отлавливается в момент компиляции. Зато это замедляет компиляцию. В Питоне используется строгая динамическая типизация. "Динамическая" означает, что типы переменных становятся известными только во время выполнения, и тогда же выполняются проверки типов. Это дает больше возможностей написать неработающий код, но ускоряет компиляцию и дает значительную гибкость. Пример:

>> a = 20 # теперь a - это число, тип int
>> a = "a string" # а теперь - строка, тип str.

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

>>> x = [1,2,3] # x - это список
>>> y = x # y указывает туда же, куда x (копируется указатель).
>>> y[1] = 5 # изменяем элемент из y
>>> x # он изменился и в x.
[1, 5, 3]

Таким образом, в терминах C++, имя переменной - это ссылка (указатель), (void*). Исключением являются атомарные типы данных - числа и строки. Пример:

>>> a = 1
>>> b = a # здесь копируется уже не ссылка, а собственно значение
>>> b = 3 # присваиваем другое значение...
>>> a # на переменную a это не повлияло.
1

По той же схеме передаются аргументы в функцию.

За счет того, что информация о типе хранится вместе со значением, она доступна во время исполнения. Пример:

>>> a = 1
>>> type(a)
<type 'int'>
>>> a = "a string"
>>> type(a)
<type 'str'>

Таким образом, имеет смысл запись вроде if type(a) == str:...

Доклад по Python: About

Сегодня прочитал для группы желающих обзорный доклад по Python. Выложу его здесь, в следующих трех постах.

Объем - около 3-х часов.
Что это такое. Особенности, отличия от других языков.
Плюсы и минусы. ООП в питоне. Сравнение реализации ООП в питоне и Ц++/Жаба.
Характерные приемы программирования и дизайна.

Главная задача - даже не "агитировать за питон", а просто расшевелить мозги.


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

FAQ: что такое Linux?

Сподобился-таки на еще один FAQ. Это "для самых маленьких", так что за отсутствие строгости просьба не пинать.

Q. Что такое эта Linux?

A. Linux - это свободная операционная система.

Q. Так. А что такое операционная система?

A. Это комплекс программ, запускающий все остальные программы, и необходимый им (программам) для 1) работы с оборудованием компьютера, 2) для взаимодействия с пользователем. Кроме того, операционная система (как правило) позволяет запускать несколько программ одновременно и обеспечивает их взаимодействие между собой. Коротко говоря, операционная система (ОС) - это главная программа на компьютере. Примерами операционных систем являются: UNIX, Linux, Solaris, Windows, DOS.

Q. Так. А что означает "свободная"?

A. Термин "свободная" применительно к программе означает, что лицензия на эту программу гарантирует вам как минимум четыре основных свободы: 0) Свобода запускать программу в любых целях; 1) Свобода изучения работы программы и адаптация ее к вашим нуждам; 2) Свобода распространять копии, так что вы можете помочь вашему товарищу; 3) Свобода улучшать программу и публиковать ваши улучшения, так что все общество выиграет от этого.

Q. Кто создает Linux и другие свободные программы?

A. Огромное количество разработчиков по всему миру.

Q. Ну как эта компания называется?

A. Это не компания. Это то, что люди называют _сообществом_. Просто большое количество людей, которых объединяют только общие взгляды на IT-индустрию и общее дело.

Q. А какая им от этого выгода?

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

Q. А какая выгода компаниям, раз эти программы бесплатные?

A. Во-первых, программы эти не бесплатные, а свободные. Разница примерно как между "халявным пивом" и "свободным словом". В частности, это означает, что эти программы можно продавать и покупать, но при этом любой желающий может получить их свободно. Но все равно не бесплатно - придется платить за носитель (диск) или за интернет-трафик. Так что многие компании зарабатывают, распространяя свободные программы - например, рассылая диски по почте. В России самая известная из таких компаний - это LinuxCenter. Во-вторых, многие компании зарабатывают в основном не на продаже программ, а на их поддержке. Ведь скачать программу - это только начало, дальше нужно научиться ее использовать. Для организаций это выливается в издержки по обучению персонала, издержки по внедрению, и издержки на поддержку пользователей. Неудивительно, что существуют компании, специализирующиеся на решении таких проблем. Это составляет основной доход таких гигантов, как RedHat и Novell. В Магнитогорске этим занимается компания RTFM.

Q. И много их, этих энтузиастов?

A. Точной статистики нет ни у кого. Однако есть оценки, согласно которым над одной свободной программой _в среднем_ работают 3 человека. А общее количество свободных программ оценивается в 378000. Простым перемножением получаем свыше миллиона разработчиков.

Q. А много ли людей пользуются Linux?

A. Опять же, точной статистики нет. Но, как минимум, известно, что Linux используется во всех государственных учереждениях в Бельгии, Франции, Норвегии, Китае. Это уже многие миллионы человек. У нас в стране многие ВУЗы используют Linux - в частности, Московский государственный технический университет им.Н.Э.Баумана. Кроме того, очень многие используют Linux, не зная об этом. Linux стоит на миллионах серверов в Интернете. Linux используется в автоматизации производства. Linux установлен на множестве небольших устройств - это ADSL-модемы и другое сетевое оборудование, смартфоны и КПК, DVD-плейеры и многое другое. Многие миллионы человек, использующие эти устройства, тем самым используют Linux.

Q. Как давно существует Linux?

A. Собственно Linux появилась в 1991 году. Однако часто, говоря "Linux", подразумевают операционную систему, от которой Linux берет все основные идеи - UNIX. UNIX появилась в 1969 году.

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

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

Q. Что за слова такие - "исходный код", "скомпилировать" ?

A. Программисты пишут программы на специальных языках, называемых языками программирования. Эти языки более-менее близки к обычным, естественным языкам, на них вполне может читать и писать человек (при соответствующей подготовке, разумеется). Вот эти тексты, которые пишут программисты, и называются "исходными кодами". Однако компьютер сам по себе "не понимает" этих языков программирования, он понимает только так называемый "машинный код", образно говоря - единицы и нули. Для перевода с языков программирования на машинный язык созданы программы - трансляторы, или, иначе, компиляторы. Так что чтобы получить из исходных кодов нечто, что можно запустить, нужно эти исходные коды _скомпилировать_.

Q. И чем же так замечательно распространение программ в исходных кодах?

A. Коммерческие программы (обычно) распространяются без исходных кодов, в виде уже скомпилированного машинного кода. Весь фокус в том, что обратное преобразование - из машинного кода в исходный - технически очень сложно, а юридически - запрещено лицензией. А машинный код человеку все равно не понять. Таким образом, производитель может встраивать в свои (коммерческие, закрытые) программы все что ему вздумается - вредоносный или шпионский код, например - пользователь об этом даже не узнает. А при наличии исходных кодов их может прочитать и понять любой программист, и он быстро выявит любые несуразности. Если вы не программист, вы можете просто позвать знакомого программиста…

Q. Но это все не означает, что я должен… как его… компилировать все программы?

A. Конечно, не означает. Свободные программы распространяются не только в исходных кодах, но и в скомпилированном виде. Огромное количество свободных программ поставляется на дисках с дистрибутивом операционной системы Linux.

Тоже присоединяюсь

... к http://ivlad.livejournal.com/184754.html. Цитата:

В связи с т.н. "делом Поносова" (http://ru.wikipedia.org/wiki/Дело_Поносова ) хочу сказать, что если вы - учитель информатики (или любой другой учитель, или представитель администрации школы), который хочет (или, скажем мягче, готов попробовать) использовать Linux в учебном процессе, но не знает, с чего начать, я готов встретиться, рассказать и показать. Более-менее в любые выходные. Безвозмездно, то есть даром. =)

Правда, в совсем любые выходные я не могу (в частности, пол-февраля меня не будет в городе - буду в Перми на студенческой научной школе по программированию с 5-го по 11-е), но уж через e-mail (см. в профиле) меня найти можно. Ну и напомню - живу я в Магнитогорске Челябинской области, выезжаю редко. Если надо - могу до Белорецка съездить.

Также запостил предложение присоединяться на наш LUG (http://lug.mgn.ru), авось, еще кто-нибудь откликнется.

From Windows to Linux

Эти записки предназначаются для людей, которые привыкли пользоваться Windows, но хотят перейти на Linux. Это не учебник по Linux, но я постараюсь дать краткое описание основных отличий, без понимания которых практически невозможно работать в Linux.

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

Главный источник документации - команда man. Если вы работаете в консоли, достаточно набрать

man имя-топика,

чтобы получить справку по нужной теме. В случае, если вы работаете в графическом окружении, нужно из меню вызвать эмулятор терминала (например, xterm), и в нем набрать указанную выше команду. Прежде всего предлагаю изучить руководство по самой команде man, набрав "man man".

Кроме того, по Linux и связанным вопросам существует много бумажных и электронных книг. Например, после прочтения этой заметки я посоветовал бы начинающему пользователю начать читать книгу Алексея Федорчука, доступную на http://linuxcenter.ru под названием "Введение в POSIX ивизм", или ее бумажную версию, вышедшую недавно под названием "Доступный UNIX: Linux, FreeBSD, DragonFlyBSD, NetBSD, OpenBSD".

Далее я постоянно буду ссылаться в скобках на страницы man, например: (man hier).

Следующее отличие - устройство файловой системы. В Windows у вас есть несколько носителей информации, перечисленных в окне "Мой компьютер", и на каждом из них есть своя файловая система - система вложенных папок (директорий) и файлов в них. В Linux существует единая файловая система, здесь нет такого понятия как "Диск C:". Графически файловую систему удобно представлять как дерево. Корень этого дерева - это корневая директория файловой системы, она содержит в себе директории bin, usr, etc и прочие, те, в свою очередь - еще директории и файлы…

Разделителем директорий в пути в Linux служит слэш (/), а не бэкслэш (\), как в Windows. Корень файловой системы сам по себе обозначается как "/". Такким образом, если в Windows типичный путь выглядит как "C:\Windows\System", то в Linux - "/usr/local/bin". Нужно заметить, что файловая система Linux чуствительна к регистру символов, так что "file" и "FiLE" - это имена разных файлов.

Еще одна особенность файловой системы Linux - то, что устройства, подключаемые к компьютеру, предстают файлами, расположенными в директории /dev.

Каждый носитель информации (жесткий диск или usb-флэш) содержит собственную файловую систему (ФС) со своей структурой директорий. Чтобы к этой ФС можно было получить доступ, она должна быть подключена к единой файловой системе Linux, при этом нужно указать, к какой из ветвей дерева нужно осуществлять подсоединение. Например, если на флэшке есть файлы "file1.doc", "file2.doc" и директория "dir" с файлом "indir" внутри, то после подсоединения ФС флэшки к директории /mnt/flash мы будем иметь файлы /mnt/flash/file1.doc, /mnt/flash/file2.doc, /mnt/flash/dir/indir. Операция подсоединения называется монтированием, и выполняется с помощью команды mount (man mount). Перед тем, как физически отсоединить носитель (выдернуть флэшку, например), необходимо произвести действие, обратное монтированию - размонтирование, иначе можно потерять данные на нем. Размонтирование производится с помощью команды umount.

Если у вас есть несколько разделов диска, или несколько дисков, с которыми вам нужно работать постоянно, то, чтобы эти диски монтировались при старте системы автоматически, нужно прописать их в файле /etc/fstab (man fstab).

Следующее отличие касается установки программ. В Windows программа, как правило, при установке кладет все свои файлы в c:\program files\имя-программы, и, возможно, еще в c:\windows или куда-нибудь еще. В Linux файлы программ раскладываются по директориям не по принадлежности программам, а по их предназначению. Так, все исполнимые файлы самых необходимых программ лежат в /bin, все конфигурационные файлы - в /etc, библиотеки - в /lib и т.д. При этом программы, входящие в состав дистрибутива Linux, но не являющиеся необходимыми для запуска системы, кладут свои файлы в иерархию /usr (/usr/bin - исполнимые файлы, /usr/lib - библиотеки, и т.д). Программы, не входящие в состав дистрибутива и установленные пользователем, располагаются в /usr/local (/usr/local/bin и т.д). На расположение и назначение всех этих директорий существует стандарт - Filesystem Hierarchy Standart (FHS). Он описан в man hier.

Четвертое различие относится к системе безопасности. В Windows имеются лишь минимальные средства разграничения прав доступа, и по ряду причин чаще всего они не используются вовсе. В Linux это весьма мощные средства, и используются они постоянно. В системе есть некоторое количество пользователей, различающихся по имени (login) и паролю (password). Каждый пользователь может входить в одну или несколько групп. Обычный пользователь может изменять файлы только в своей домашней директории (home), в частности, он не может устанавливать и удалять программы. Благодаря этому обычный пользователь ни случайно, ни специально не может повредить всю систему в целом или данные других пользователей. Но один из пользователей отличается от остальных. Это root - системный администратор. Ему по определению разрешено все. Именно поэтому категорически не рекомендуется работать в системе под именем root. Представляться системе root-ом нужно только для проведения административных мероприятий: установки и удаления программ, форматирования дисков и тому подобных задач.

Далее, в Linux графический интерфейс не является неотъемлемой частью операционной системы, как в Windows. Графический интерфейс - все эти окна, иконки и курсоры - обеспечивается отдельным приложением, работающим наравне с остальными. Поэтому сбой в работе графической системы не влечет за собой сбой в работе ОС в целом. (за подробностями о работе графики в Linux см. man X, man Xserver).

Исторически в Linux основным режимом работы был режим работы с командной строкой. При этом у вас нету никаких окошек и иконок, а есть приглашение командной оболочки и мигающий курсор. Вы набираете на клавиатуре команды, подтверждая их нажатием Enter, а компьютер выполняет их и вновь выдает приглашение набрать команду. При этом доступны автодоплнение команд и их аргументов, а также полная справка о том, как работает каждая команда - по команде "man <имя-команды>". Программа, которая с вами непосредственно общается, называется командной оболочкой (shell). Командной оболочкой по умолчанию является bash, поэтому за подробностями о работе с командной строкой обращайтесь к man bash.

Каждая команда имеет вид:

$ <имя-команды> <опции> <параметры>.

Здесь "$" - это приглашение командной строки, его печатает оболочка. Имя команды - это одно слово, то есть последовательность английских букв и цифр. Оно указывает, что нужно сделать, то есть это глагол в языке общения с командной оболочкой. Имена команд обычно являются сокращениями от соответствующих английских глаголов, например "cp" - от "copy", копировать.

Опции бывают "короткие" и "длинные". Короткие опции выглядят как одна английская буква (или цифра) с дефисом впереди, например, "-f". Длинные опции выглядят как английское слово, предваренное двумя дефисами, например, "—force". Обычно каждая короткая опция имеет длинный аналог (то есть существует "длинная" опция, делающая то же самое), но не наоборот. Длинные опции проще запоминать, зато короткие опции быстрее набирать. Опции задают режимы работы команды - например, опция "-f" (или "—force", что то же самое) команды cp указывает команде переписывать файлы при совпадении имен. Нектоторые опции имеют аргументы - те пишутся через пробел или через знак равенства от опции, например "—backup=numbered". Таким образом, опции - это дополнения в языке командной строки. Короткие опции можно комбинировать, например, "cp -b -d" можно сократить до "cp -bd".

Параметры задают объекты, с которыми должна работать команда - например, файлы, которые нужно копировать. Таким образом, параметры - это существительные.

Опции и параметры у каждой команды свои, среди них могут быть как обязательные, так и необязательные. Все они описаны в man <имя-команды>.

Если вы работаете в режиме командной строки, то графическую оболочку обычно можно запустить командой startx. Существуют программы графического режима, позволяющие работать с командной строкой в отдельном окне. Такие программы называются эмуляторами терминала. Самой популярной из них является xterm.

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

DOS	Linux	Примечание
ATTRIB (+-)attr file	chmod file	полностью отличаются
BACKUP	tar -Mcvf device dir/	то же самое
CD dirname\\	cd dirname/	почти тот же самый синтаксис
COPY file1 file2	cp file1 file2	то же самое
DEL file	rm file	будьте осторожны, нет восстановления файлов
DELTREE dirname	rm -R dirname/	то же самое
DIR	ls	не полностью похожий синтаксис
DIR file /S	find . -name file	полностью отличаются
EDIT file	vi file	я думаю, вы не полюбите его (а зря!)
	jstar file	выглядит как редактор в dos
EDLIN file	ed file	забудьте его
FORMAT	fdformat,
	mount, umount	достаточно отличный синтаксис
HELP command	man command,	та же философия
	info command
MD dirname	mkdir dirname/	почти тот же самый синтаксис
MORE file	less file	намного лучше
MOVE file1 file2	mv file1 file2	то же самое
NUL	/dev/null	то же самое
PRINT file	lpr file	то же самое
PRN	/dev/lp0,
	/dev/lp1	то же самое
RD dirname	rmdir dirname/	почти тот же самый синтаксис
REN file1 file2	mv file1 file2	не для множества файлов
RESTORE	tar -Mxpvf device	другой синтаксис
TYPE file	less file	намного лучше
WIN	startx	на разных полюсах!

---

Last updated 19-May-2006 00:56:04 YEKST