Как написать программу для проекта

Первый опыт написания полноценной программы

Время на прочтение
17 мин

Количество просмотров 13K

Каждый начинающий программист мечтает реализовать свой собственный проект. Не написать простенький код, по заданию преподавателя, а воплотить в жизнь свои идеи. Так и я, изучая C++ 3-4 месяца, решился попробовать разработать макет электронного журнала для преподавателей.

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

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

  1. Регистрацию (Reg),

  2. Авторизацию (Authon),

  3. Выбор группы (GroupSelection),

  4. Возможность выставлять оценки (Grades),

  5. Возможность выставлять посещаемость (Attendance),

  6. Возможность писать комментарии к датам (Comment),

  7. Возможность устанавливать dedlin’ы (Deadline).

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

блок-схема программы

блок-схема программы

Аналогично, были созданы блок схемы для каждой функции.

авторизация

авторизация
регистрация
регистрация
выбор группы
выбор группы
выставление оценок
выставление оценок
простановка посещаемости
простановка посещаемости
написание комментариев к датам
написание комментариев к датам
установка dedlin’ов
установка dedlin’ов

Написание кода программы

Первым шагом написания программы является добавления необходимых заголовочных файлов, а именно:

  1. iostream — заголовочный файл с классами, функциями и переменными для организации ввода-вывода.

  2. string —  это заголовочный файл для взаимодействия с
    классами string (строками).

  3. fstream — заголовочный файл, включающий набор классов, методов и функций, которые предоставляют интерфейс для чтения/записи данных из/в файл.

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

std::string nameofgroup;

Чтобы удобно группировать данных в одной переменной для каждого объекта, который оперирует этими данными, мною было объявлено несколько классов, а именно:

Класс данных о преподавателе – DataofTeature.

class DataofTeature
{
public:
	std::string name; //имя преподавателя
	std::string surname; //фамилия преподавателя
	std::string patronymic; //отчество преподавателя
	std::string login; //логин преподавателя
	std::string password; //пароль преподавателя
};

Класс данных о студенте – DataofStudent.

class DataofStudent
{
public:
	std::string group; //название группы студента
	std::string name; //имя студента
	std::string surname; //фамилия студента
};

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

Reg

Функция Reg реализует полноценную регистрацию, с записью данных о пользователе в текстовый файл.

В ходе выполнения функции, пользователю предлагается ввести ФИО, логин и пароль. После получения программой логина, проверяется его наличие в системе, если логин совпадает с ранее записанным в базу логинов, то пользователя предлагается ввести логин повторно. Как только программа получает ФИО, пароль и уникальный логин, происходит запись логина в базу для логинов (при открытие базы данных используется режим открытия ios_base::app, позволяющий открыть файл для записи в конец файла, при этом, сохраняя ранее записанные данные), создание специализированного файла для регистрационных данных пользователя, и запись в него ФИО, аналогично создается специальный файл для хранения логина и пароля конкретного пользователя. Формирования уникальных файлов происходит по принципу сложения строк. Например, path=path+teature1.login+txt, где path-путь к директории, в которой хранятся файлы программы, teature1.login – уникальный логин пользователя, txt- строка, хранящая в себе “.txt”.

void Reg()
{
	std::string path = "C:\journal\regdata", datalog = "C:\journal\logdata.txt", txt = ".txt", user = "C:\journal\", delfile = "C:\journal\delfile.txt"; //объявление переменных типа string
	bool flag = 1; //объявление переменной типа bool
	DataofTeature teature1; //объявление переменной класса DataofTeature
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "tttРегистрация:n"; //ввод даных, необходимых для регистрации
	std::cout << "Введите фамилию: ";
	std::cin >> teature1.surname;
	std::cout << "Введите имя: ";
	std::cin >> teature1.name;
	std::cout << "Введите отчество: ";
	std::cin >> teature1.patronymic;
	std::cout << "Введите логин: ";
	std::cin >> teature1.login;
	while (flag)
	{
		bool flag2 = 0;
		fin.open(datalog);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (teature1.login == data)		//проверка на существование данного логина в файле
				{
					flag2 = 1;
					flag = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Данный логин уже существует, придумайте другой логин: "; //прозьба ввести логин повторно, если введенный до этого уже существует
			std::cin >> teature1.login;
			flag = 1;
		}
		else
		{
			flag = 0; //изменение булевой переменной для выхода из цыкла
		}
		fin.close();
	}
	path = path + teature1.login + txt; //формирование пути, для создания файла с ФИО аккаунта
	fout.open(path);
	if (fout.is_open())
	{
		fout << teature1.surname << "n";
		fout << teature1.name << "n";			//запись данных в файл
		fout << teature1.patronymic << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
	std::cout << "Введите пароль: ";
	std::cin >> teature1.password;		//ввод пароля
	fout.open(datalog, std::ios_base::app); //открыть файл для записи в конец файла
	if (fout.is_open())
	{
		fout << teature1.login << "n"; //запись данных в файл
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
	user = user + teature1.login + txt; //формирование пути хранения логина и пароля
	fout.open(user); //открытия файла
	if (fout.is_open())
	{
		fout << teature1.login << "n";
		fout << teature1.password << "n";		//запись данных в файл
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
}

Authon

Функция Authon реализует авторизацию пользователя в программу.

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

void Authon()
{
	std::string path = "C:\journal\regdata", datalog = "C:\journal\logdata.txt", txt = ".txt", user = "C:\journal\", delfile = "C:\journal\delfile.txt", login, password, filelog = ""; //объявление переменных типа string
	DataofTeature teature1; //объявление переменной класса DataofTeature
	std::ifstream fin; //объявление переменной класса ifstream
	bool flag = 1; //объявление переменной типа bool
	std::cout << "tttАвторизация:n";
	std::cout << "Введите логин: ";
	std::cin >> login;			//ввод логина
	while (flag)
	{
		bool flag2 = 0;
		fin.open(datalog);		//проверка наличия логина в базе логинов
		if (fin.is_open())
		{
			while (!fin.eof())
			{
				std::getline(fin, filelog);
				if (login == filelog)
				{
					flag = 0;
					flag2 = 0;
					break;
				}
				else
				{
					flag2 = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Такого логина не существует, введите логин повторно: n";			//просьба ввести логин повторно
			std::cin >> login;
		}
		fin.close();
	}
	user = user + login + txt; //формирования пути нахождения файла с логинами и паролями
	flag = 1;
	std::cout << "Введите пароль: ";		//ввод пароля
	std::cin >> password;
	while (flag)
	{
		bool flag2 = 0;
		fin.open(user);
		if (fin.is_open())
		{
			while (!fin.eof())
			{
				std::getline(fin, filelog);
				if (password == filelog)
				{								//проверка верности пароля
					flag = 0;
					flag2 = 0;
					break;
				}
				else
				{
					flag2 = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть//
		}
		if (flag2)
		{
			std::cout << "Пароль введен не верно, попробуйте еще раз: n";		//просьба ввести пароль повторно
			std::cin >> password;
		}
		fin.close();
	}
	std::cout << "Добро пожаловать ";
	path = path + login + txt;
	fin.open(path);
	if (fin.is_open())
	{
		std::string data = "";					//вывод приветствия на экран
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << data << " ";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	std::cout << "n";
}

GroupSelection

Функция реализует полноценный выбор группы в программе.

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

void GroupSelection()
{
	DataofStudent stud1; //объявление переменных класса DataofStudent
	std::string allgroup = "", path = "C:\journal\allgroup\allgroup.txt", delfile = "C:\journal\allgroup\delfile.txt", path2 = "C:\journal\allgroup\", txt = ".txt", choice = ""; //объявление переменных типа string
	bool flag = 1; //объявление переменных типа bool
	std::ifstream fin; //объявление переменной класса ifstream
	std::ofstream fout; //объявление переменной класса ofstream
	std::cout << "Полный список групп: n";
	fin.open(path);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);		//вывод а экран полного списка групп
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть//
	}
	fin.close();
	std::cout << "Введите название группы, которую хотите открыть: ";
	std::cin >> stud1.group;	//ввод название необходимой группы
	while (flag)
	{
		bool flag2 = 1;
		fin.open(path);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (stud1.group == data)	//проверка на наличие введенной группы в списке групп
				{
					flag2 = 0;
					flag = 0;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Данной группы не существует, введите другую группу: ";
			std::cin >> stud1.group;	//просьба ввести название группы повторно
			flag = 1;
		}
		else
		{
			flag = 0;	//изменение буливой переменной для выхода из цыкла
		}
		fin.close();
	}
	nameofgroup = stud1.group; //присваивание названия группы в глобальную переменную
}

Grades

Функция Grades реализует, простановку оценок студентам.

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

void Grades()
{
	DataofStudent student1; //объявление переменных класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\grade", choice = ""; //объявление переменных типа string
	bool flag = 0, flag2 = 1; //объявление переменных типа bool
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату за которую вы хотите проставить оценки: ";
	std::cin >> choice;	//ввод даты 
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		flag = 1;		//проверка наличия файла с оценками на данную дату
	}
	fin.close();
	if (flag)
	{
		fin.open(way + nameofgroup + attendance + choice + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())		//запись данных существующего файла в специализированный файл
			{
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		fin.close();
		fout.close();
	}
	else
	{
		fin.open(way + nameofgroup + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{									//запись  в специализированный файл списка группы 
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		fin.close();
		fout.close();
	}
	fin.open(way + delfile);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())	//вывод списка группы на экран
		{
			std::getline(fin, data);
			std::cout << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	std::cout << "Введите фамилию и имя студента. которому вы хотите выставить оценку: " << std::endl;
	std::cin >> student1.name;	//ввод фамили и имени студента
	while (flag2)
	{
		fin.open(way + delfile);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (data == student1.name)
				{
					flag2 = 0;	//проверка наличия данно ФИ в списке группы
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Такого студента не существует, повторите ввод фамилии и имени: "; //повторный ввод ФИ студента
			std::cin >> student1.name;
		}
		fin.close();
	}
	fin.open(way + delfile);
	fout.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open() and fout.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			if (data == student1.name)
			{
				bool flag3 = 1;
				for (int i = 0; i < data.length(); i++)
				{											//процесс нахождения ФИ студента в файле
					if (flag3 and data[i] != 't')
					{
						fout << data[i];	//запись данных в файл с оценками
					}
					else
					{
						flag3 = 0;
					}

				}
				std::string choice2;
				std::cout << "Введите оценку: ";	//ввод оценки
				std::cin >> choice2;
				fout << "t" << choice2 << "n";	//запись данных в файл с оценками
			}
			else
			{
				fout << data << "n";	//запись данных в файл с оценками
			}
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	fout.close();
	std::cout << "n";
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << "ttt" << data << "n";	//вывод измененных данных на экран
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Attendance

Функция Attendance реализует простановку посещаемости студентов с последующей записью в файл.

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

void Attendance()
{
	DataofStudent student1; //объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\attendance", choice = "";//объявление переменных типа string
	bool flag = 0, flag2 = 1; //объявление переменной типа bool
	std::ofstream fout; //объявление пременной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату за которую вы хотите проставить посещаемость: ";
	std::cin >> choice; //ввод даты
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		flag = 1;	//проверка на наличие файла
	}
	fin.close();
	if (flag)
	{
		fin.open(way + nameofgroup + attendance + choice + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())	//запись данных файла в промежуточный файл
			{
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "EROR";
		}
		fin.close();
		fout.close();
	}
	else
	{
		fin.open(way + nameofgroup + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{						//запись списка группы в промежуточный файл
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "EROR";
		}
		fin.close();
		fout.close();
	}
	fin.open(way + delfile);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << data << "n";	//ввывод списка группы на экран
		}
	}
	else
	{
		std::cout << "EROR";
	}
	fin.close();
	std::cout << "Введите фамилию и имя студента. которому вы хотите выставить посещаемость: " << std::endl;
	std::cin >> student1.name;	//ввод фамили и имени студента
	while (flag2)
	{
		fin.open(way + delfile);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (data == student1.name)	//проверка на наличие данного студента в группе
				{
					flag2 = 0;
				}
			}
		}
		else
		{
			std::cout << "EROR";
		}
		if (flag2)
		{
			std::cout << "Такого студента не существует, повторите ввод фамилии и имени: ";	//повторный ввод ФИ студента
			std::cin >> student1.name;
		}
		fin.close();
	}
	fin.open(way + delfile);
	fout.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open() and fout.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			if (data == student1.name)
			{
				bool flag3 = 1;
				for (int i = 0; i < data.length(); i++)
				{
					if (flag3 and data[i] != 't')
					{
						fout << data[i];	//процесс нахождения студента в файле
					}
					else
					{
						flag3 = 0;
					}

				}
				std::string choice2;
				std::cout << "Введите посещаемость: ";
				std::cin >> choice2; //ввод посещаемости
				fout << "t" << choice2 << "n";
			}
			else
			{
				fout << data << "n";
			}
		}
	}
	else
	{
		std::cout << "EROR";
	}
	fin.close();
	fout.close();
	std::cout << "n";
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data); //вывод измененных данных на экран
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Comment

Функция Comment реализует в программе написание комментария к дате.

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

void Comment()
{
	DataofStudent student1;//объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\comment", choice = ""; //объявление переменнх типа string
	std::ofstream fout;//объявление переменной класса ofstream
	std::ifstream fin;//объявление переменной класса ifstream
	std::cout << "Введите дату для которой вы хотите оставить коментарий: ";
	std::cin >> choice; //ввод даты
	fout.open(way + nameofgroup + attendance + choice + txt, std::ios_base::app);
	if (fout.is_open())
	{
		std::string choice2;
		std::cout << "Введите коментарий: "; //ввод коментария
		std::cin >> choice2;
		fout << choice2 << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	std::cout << "n";
	fout.close();
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);	//вывод изменненных данных на экран
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();

}

Deadline

Функция Deadline реализует в программе создание dedlin’а и комментария к нему, с записью этих данных в файл.

В ходе выполнения функции, пользователю предлагается ввести дату, на которую он хочет установить deadline. При получении программой даты, происходит открытие файла с режимом открытия ios_base::app (открыть файл для записи в конец файла). Наименование файла и путь его нахождения формируется, путем сложения строк. Пользователю предлагается ввести комментарий. Происходит запись данных в файл. После на экран выводятся изменённые данные файла.

void Deadline()
{
	DataofStudent student1; //объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\deadline", choice = ""; //объявление переменной типа string
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату на которую вы хотите установить deadline: ";
	std::cin >> choice; //ввод даты
	fout.open(way + nameofgroup + attendance + choice + txt, std::ios_base::app);
	if (fout.is_open())
	{
		std::string choice2;
		std::cout << "Введите коментарий к deadlin'у: "; //ввод коментария 
		std::cin >> choice2;
		fout << choice2 << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	std::cout << "n";
	fout.close();
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << "ttt" << data << "n"; //вывод измененных данных на экран
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Main

Аналогично, основываясь на блок схеме, был написан код основной части программы.

В ходе выполнения программы, на экран выводится меню. Пользователю предлагается выбрать один из пунктов. При выборе пункта 1, вызывается функция Reg, а затем функция Authon; При выборе пункта 2, вызывается функция Authon; При выборе пункта 3 происходит выход из программы. После успешной авторизации вызывается функция GroupSelection. После выбора группы на экран выводится меню дальнейших действий. Пользователю предлагается выбрать один из пунктов. При выборе пункта 1 вызывается функция Grades; При выборе пункта 2 вызывается функция Attendance; При выборе пункта 3 вызывается функция Deadline; При выборе пункта 4 вызывается функция Comment; При выборе пункта 5 происходит выход из программы.

void main()
{
	std::string choice = ""; //объявление переменной типа string
	bool flag = 1; //объявление переменной типа bool
	setlocale(0, ""); //установка языкового стандарта для яязыка
	std::cout << "tttДобро пожаловать в электронный журналn"; //вывод меню на экран
	std::cout << "tttЕсли вы ходите зарегистрироваться введите 1ntttЕсли выхотите авторизоваться введите 2ntttЕсли вы хотите закрыть программу введите 3n";
	std::cin >> choice;//ввод символа, отвечающего за выбор пункта меню
	if (choice == "3")
	{
		return; //выход из программы
	}
	while (flag)
	{
		if (choice == "1")
		{
			flag = 0;
			Reg(); //регистрация
			Authon();//авторизация
		}
		else
		{
			if (choice == "2" and flag)
			{
				Authon(); //авторизация
				flag = 0;
			}
			else
			{
				std::cout << "Сделайте выбор повторно: ";
				std::cin >> choice; //повторное осуществленеи выбора пункта меню
			}
		}
	}
	GroupSelection(); //выбор группы
	std::cout << "ntttВыберете дальнейшее действие:n"; //вывод меню выбора дальнейших действий
	std::cout << "tttЕсли вы хотите поставить оценку студенту, введите 1ntttЕсли проставить посещаемость, введите 2ntttЕсли вы хотите установить дату конца дедлайна, введите 3ntttЕсли вы хотите написать коментарий, введите 4ntttЕсли вы хотите закрыть программу введите 5n";
	std::cin >> choice; // ввод символа, отвечающего за выбор пункта меню
	flag = 1;
	while (flag)
	{
		if (choice == "1")
		{
			flag = 0;
			Grades(); //простанока оценки
		}
		if (choice == "2")
		{
			flag = 0;
			Attendance(); //простановка посещаемости
		}
		if (choice == "3")
		{
			flag = 0;
			Deadline(); //установка deadlin'a
		}
		if (choice == "4")
		{
			flag = 0;
			Comment(); //написание комментария
		}
		if (choice == "5")
		{
			return; //выход из программы
		}
		if (choice != "1" and choice != "2" and choice != "3" and choice != "4" and choice != "5")
		{
			flag = 1;
			std::cout << "Повторите ввод: ";
			std::cin >> choice; //повторное осуществление выбора пункта меню
		}
	}
}

Для реализации полноценной работоспособности моей программы необходимо создать несколько текстовых файлов и директорий согласно диаграмме.

диаграмма

диаграмма

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

Тестирование и отладка программы

Для проведения корректного и полного тестирования следует поставить несколько тест кейсов, а именно.

Тестирование работы регистрации

Тестирование работы регистрации
Тестирование авторизации
Тестирование авторизации
Тестирование выбора группы
Тестирование выбора группы
Тестирование постановки оценки
Тестирование постановки оценки
Тестирование постановки посещаемости
Тестирование постановки посещаемости
Тестирование установки даты конца дедлайна
Тестирование установки даты конца дедлайна
Тестирование написания комментария к дате
Тестирование написания комментария к дате

В ходе тестирования программы критических ошибок выявлено не было.

Заключение

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

  • Класс DataofTeature, хранящий в себе информацию о преподавателе.

  • Класс DataofStudent, хранящий в себе информацию о студенте.

  • Функция Reg, реализующая регистраци.

  • Функцию Authon, реализующая авторизацию в программу.

  • Функция GroupSelection, реализующая выбор группы.

  • Функция Grades, реализующая простановку оценок.

  • Функция Attendance, реализующая простановку посещаемости.

  • Функция Comment, отвечающая за возможность написания комментария к дате.

  • Функция Deadline, дающая возможность установить дэдлайн и написать к нему комментарий.

  • Функция main, в которой реализовано основное взаимодействие пользователя с программой (меню и т.д.).

Весь код программы был написан в среде разработки Visual Studio 2022. Суммарный объем строк в тексте программы составляет 724.

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

Нужно ли это писать?

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

В этом вопросе сразу два компонента: 

  1. Люди уже делают то, что будет улучшать ваша программа. То есть существует некоторый спрос на эту работу. 
  2. Люди делают это руками, а значит, они хотели бы это автоматизировать.

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

🤔 Например, вы придумали программу для ведения бюджета: туда нужно вводить данные о ваших покупках по категориям, а она бы складывала траты за месяц. Делают ли это люди? Вроде делают, но до поры. Обычно человек начинает вести бюджет, два месяца что-то пишет, а потом забрасывает, потому что денег от этого больше не становится. А еще есть приложения банков, которые сами считают статистику трат. Маловероятно, что очередной менеджер личного бюджета как-то изменит ситуацию. 

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

Полезное ядро

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

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

✅ Например, в приложении для напоминаний полезное ядро — само напоминание, которое вываливается в нужный момент. Потом, может быть, нужно дать напоминанию статус «Я это уже сделал в этом месяце» или «Напомни мне через…» и опцию повторного срабатывания через какое-то время. 

🤔 А вот интерфейс установки напоминания и инфраструктура для хранения напоминаний не так важны на первом этапе. 

💡 Часто такое же полезное ядро уже реализовал кто-то другой в виде бесплатной библиотеки. Это большая удача: взяли, изучили, допилили — быстро выпустили свой продукт. 

На каком языке?

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

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

Не подменяйте программирование поиском идеальной технологии. 

Составьте схему или план

Когда у вас появится функциональное ядро, прикиньте на листочке, как будет устроен проект целиком:

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

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

Как начать писать программу и не пожалеть

Схема работы внутреннего чат-бота редакции на Python. На неё ушло 15 минут, и стало понятно, как именно нужно обрабатывать запросы от пользователей и что делать, если потребуется восстановить данные после сбоя

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

✅ Вместо этого можно использовать метод быстрых версий:

  1. Выбрать самое простое действие, которое можно сделать прямо сейчас. Например, вывести стартовую картинку или отправить на сервер строчку «Привет, это тестовый запрос!». Убедиться, что всё работает.
  2. Выбрать следующее действие, которое добавляем в проект, например отрисовку главной страницы или сохранение JSON-запроса в файл. Написать код и проверить, как всё работает.
  3. Если работает — перейти к следующему действию, если нет — исправить и потом всё равно перейти.

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

Всё, за дело

  1. Убедитесь, что это кому-то нужно (даже если это только вы).
  2. Возьмите тот язык, которым владеете (а не идеальный).
  3. Реализуйте центральный модуль (хотя бы базово).
  4. Нарисуйте схему работы всего остального (не держите в голове).
  5. Прописывайте мелкие действия и тут же тестируйте (а не пишите сразу всю кодовую базу за один раз).

Этого хватит, чтобы собрать личный проект. А там и до совместного недалеко, но совместный — это немного более сложная история. 

Корректор:

Екатерина Череповицына

Вёрстка:

Кирилл Климентьев

Муниципальное бюджетное
общеобразовательное учреждение средняя общеобразовательная школа №46 с
углубленным изучением отдельных предметов

Электронные весы

Проект
подготовил

Ученик
 8А класса школы

 МБОУ
СОШ №46 Котляр Егор.

Руководитель
Таборских Н.А

Сургут
2016

Оглавление.

Введение………………………………………………………………………3

Актуальность…………………………………………………………….3
Цели…………………………………………………………………………..3
Задачи……………………………………………………………………….3
Как можно использовать продукт……………………………..3

Основная
часть проекта…………………………………………….4

Теоретическая
часть…………………………………………………4

Ход
работы ………………………………………………………………5-6

Результаты
проекта…………………………………………………6

Описание
возникших проблем……………………………………..6

Заключение…………………………………………………………………..6

Список
источников информации…………………………………6

Введение.

Актуальность.

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

Цель проекта.

Целью данного проекта является создание
полезной вычислительной программы для взвешивания продуктов на языке
программирования С++.

Задачи проекта.

·       
Составить описание программы;

·       
Составить краткое описание
языка программирования С++;

·       
Разработать программу;

·       
Написать инструкцию для
программы;

·       
Составить руководство
пользователя
;

Как
можно использовать продукт?

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

Основная
часть проекта

Теоретическая
часть

Краткое
описание языка программирования С++

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

Краткое
описание кода в языке С++, использующиеся в моей программе

(a,
ab,cd
– примеры переменных)

#include
<Название библиотеки> — позволяет ввести в программу библиотеку, которая
позволяет использовать другие команды, в зависимости.

main(void)
– основа программы.

int a,ab,cd…;
– позволяет перечисленным переменным являться целочисленными переменными.

float a,ab,cd…;
– позволяет перечисленным переменным являться переменными с плавающей запятой.

printf(«Сообщение»)
– выводит какое-либо сообщение в рабочую область программы.

n
– переход на следующую строку.

scanf(«%f
«,&
a); — позволяет переменной
присвоить введённое пользователем значение с плавающей запятой.

scanf(«%d«,&a);
— позволяет переменной присвоить введённое пользователем целочисленное значение

system(«cls»);
— полностью очищает рабочую область программы.

while(Условие)
{Тело цикла} – задает цикл, который выполняется, пока условие будет верно.

if(Условие)
{Тело} – выполняет указанное тело логической операции, если условие верно.

break; — позволяет
выйти из цикла вне зависимости от выполнения условия.

kbitt()
– позволяет определить, нажата ли какая-то клавиша или нет.

Описание
программы

Программа написана на языке С++, она
представляет собой симулятор современных электронных весов. В них
поддерживается расчет стоимости 10 разных продуктов. В нее включены мои
наработки, такие как: пролистываемый список продуктов и «защита от дураков».
Пролистываемый список позволяет, используя всего лишь две кнопки, просмотреть
название продукта, его код, а также цену за килограмм. «Защита от дураков»
позволяет весам находить часть очевидно неверных вводимых человеком значений
(например, отрицательная масса или не указанный в списке код продукта). В
программе около 500 строчек кода и использовано более 20 разных команд.

Ход
работы

Разработка
программы

Для
начала я составил блок-схему, которая поможет мне в определение плана работы
над программой:

 

Для начала я создал приветствие продавца, там
же написана версия программы и её автор (я) на английском, так как язык
программирования плохо поддерживает русский язык. Продолжение выполнения
программы я решил сделать при нажатии клавиши
Enter.
После чего я разработал ввод цен на товары продавцом. В нем я фиксировано
создал наименования продуктов, а также решил, что всего их будет 10,
потому
что я не могу сделать так, чтобы можно было изменять список продуктов при
выполнении программы, из-за неполного знания о программном языке С++. Здесь я
использовал «защиту от дураков». Цена за килограмм не может быть отрицательной
или равна нулю, так как отрицательной цены за килограмм не существует, а если
она будут равна нулю, то прибыли товар не принесет, а продавцу это не нужно.
Если же продавец по случайности введет отрицательное значение или ноль, то защита
сработает и попросит еще раз ввести цену продукта за килограмм. Далее я работал
над списком товаров, который пролистываться вверх и вниз покупателем для
ознакомления со списком товаров путем нажатия стрелочки вверх и вниз соответственно,
а при нажатии
Enter этот список закрывается.
Далее программа запрашивает код продукта из просмотренного покупателем списка,
а также массу где. Если же введенное число оказывается нулем или отрицательным,
то срабатывает «защита от дураков» и покупатель повторно вводит это число. После
чего происходим расчет, и выдается чек покупателю. После этого нажимается
Enter
и снова показывается список продуктов, т.е. программа зациклена. Чтобы
остановить программу нужно закрыть её.

Результаты
проекта

Я добился цели проекта путем тщательной
работы над ним.

Проблемы.

В
моей программе не смотря на некоторые плюсы, есть проблемы. Ими являются:

·         
Не полностью усовершенствованная защита
«защита от дураков».

·         
Нет возможности изменять список продуктов
при выполнении программы.

·         
Нет возможности использовать русский язык
в программе.

·         
Программу можно использовать только на
компьютере.

Заключение

·       
Удалось ли достичь поставленных целей?

Да. Мне удалось достичь поставленной цели путем изучения
и использования возможностей С++.

·       
Чему я научилась работая над проектом?

Работая
над проектом, я улучшил свои навыки программирования в С++.

·       
Как я собираюсь развивать свое
исследование?

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

Список источников информации.

Википедиа — https://ru.wikipedia.org


Загрузить PDF


Загрузить PDF

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

  1. 1

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

    • Изучите свои ежедневные задачи на компьютере. Есть ли какой-нибудь способ, с помощью которого вы могли бы автоматизировать часть этих задач, используя программу?
    • Запишите все идеи. Даже если это кажется глупым или диковинным в этот момент, все может измениться в нечто полезное или даже блестящее.
  2. 2

    Проверьте другие программы. Что они делают? Как они могли бы сделать это лучше? Чего им не хватает? Ответы на эти вопросы могут помочь вам самим придумать идеи для написания программы.

  3. 3

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

  4. 4

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

    Реклама

  1. 1

    Загрузите хороший текстовый редактор. Почти все программы написаны в текстовых редакторах, а затем скомпилированы для работы на компьютерах. В то время как вы можете использовать такие программы, как Блокнот или TextEdit , настоятельно рекомендуем вам скачать редактор с подсветкой синтаксиса (например, Notepad + + , JEdit или Sublime Text). Это позволит вам намного легче визуально разбирать код.

    • Некоторые языки, такие как Visual Basic, включают редактор и компилятор в одном пакете.
  2. 2

    Учите язык программирования. Все программы создаются с помощью кодирования. Если хотите создавать собственные программы, то должны быть знакомы хотя бы с одним языком программирования. Языки, которые должны будете выучить, будут варьироваться в зависимости от типа программы, которую вы хотите создать. К наиболее полезным и важным из них относятся:

    • C — С является языком низкого уровня, который тесно взаимодействует с аппаратной частью компьютера. Это один из старых языков программирования, который по-прежнему имеет широкое применение.
    • C++ — самым большим недостатком C является то, что он не объектно-ориентированный. Здесь станет полезным C++ . C++ в настоящее время является самым популярным языком программирования в мире. Такие программы, как Chrome, Firefox, Photoshop и многие другие созданы с помощью C++ . Он также является очень популярным языком для создания видеоигр.
    • Java — Java является развитием языка С++ , он чрезвычайно портативный. Большинство компьютеров, независимо от операционной системы, может запустить виртуальную машину Java, позволяя программе быть использованной почти повсеместно. Он широко используется в видеоиграх и программном обеспечении для бизнеса и часто рекомендуется в качестве основного языка.
    • C# — C# является языком на основе Windows, это одним из основных языков, используемых при создании программ Windows. Он тесно связан с Java и C + +, его легко выучить, если вы уже знакомы с Java. Если вы хотите создать программу для Windows или Windows Phone, вам следует присмотреться к этому языку.
    • Objective-C — это еще один «кузен» языка C, который специально предназначен для систем Apple. Если вы хотите создать iPhone или IPad приложения, этот язык для вас.
  3. 3

    Загрузите компилятор или интерпретатор. Для любого языка высокого уровня, такого как C++ , Java и многих других, вам понадобится компилятор для преобразования кода в формат, который может использовать компьютер. Есть множество компиляторов на выбор в зависимости от языка, который вы используете.[1]

    • Некоторые языки являются интерпретируемыми языками, а это значит, что им не нужен компилятор. Вместо этого им нужен только интерпретатор языка, установленный на компьютере, и программы смогут запускаться мгновенно. Некоторые примеры интерпретируемых языков включают Perl и Python.
  4. 4

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

    • Объявление переменных — переменные являются способом временного хранения ваших данных в вашей программе. Эти данные могут быть сохранены, изменены, на них можно влиять и обращаться позже в программе.
    • Использование условных операторов (if, else, when, и др.) — это одна из основных функций программы, она описывает, как работает логика. Условные операторы связаны с «true» (истинными) и «false» (ложными) утверждениями.
    • Использование циклов (for, goto, do, etc.) — циклы позволяют повторять процессы снова и снова, пока не будет дана команда остановиться.
    • Использование управляющих последовательностей — эти команды выполняют такие функции, как создание новых линий, отступов, цитат и многое другое.
    • Комментирование кода — комментарии необходимы для запоминания того, что делает ваш код, помогая другим программистам понять код, а также для временного отключения части кода.
    • Разберитесь с обычными выражениями.
  5. 5

    Найдите несколько книг по выбранному вами языку. Есть книги для каждого языка и для каждого уровня знаний. Вы можете найти книги по программированию в вашем местном книжном магазине или любом интернет-магазине. Книга может стать бесценным инструментом, когда вы можете держать ее под рукой во время работы.

    • Помимо книг, Интернет является бесконечной сокровищницей руководств и учебников. Поищите учебные пособия по выбранному вами языку на таких сайтах, как CodeAcademy, Code.org, Bento, Udacity, Udemy, Khan Academy, W3Schools и многих других.
  6. 6

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

    • Занятия стоят денег, поэтому убедитесь, что вы подписываетесь на курсы, которые помогут вам выучить то, что вы хотите знать.
  7. 7

    Задавайте вопросы. Интернет — фантастический способ связываться с другими разработчиками. Если вы обнаружили, что зашли в тупик в одном из ваших проектов, обратитесь за помощью на такие сайты, как StackOverflow. Убедитесь, что вы спрашиваете в интеллигентной манере и можете доказать, что вы уже пробовали несколько возможных решений.

    Реклама

  1. 1

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

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

    Соберите команду. Если вы разрабатываете программу по своему усмотрению, вы можете использовать прототип, чтобы помочь построить команду. Команда поможет вам быстрее отследить ошибки, итерационные особенности, а также разработать визуальные аспекты программы.[2]

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

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

  4. 4

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

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

    Реклама

  1. 1

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

    • Если вы разрабатываете коммерческий продукт, вы хотите убедиться, что все ваши тестеровщики подписали соглашение о неразглашении информации (NDA). Это убережет их от рассказывая другим о вашей программе и предотвращения утечек в прессе и другим пользователям.
    • Найдите время, чтобы придумать основательный план тестирования. Убедитесь, что ваши тестировщики имеют способ легкого сообщения об ошибках в программе, а также легкого доступа к новым версиям альфа-тестирования. GitHub и другие хранилища кодов являются отличным способом, чтобы легко управлять этим аспектом.
  2. 2

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

    • Попробуйте вводить лишние даты, если ваша программа имеет дело с датами. Действительно старые даты или даты из далекого будущего могут вызывать странные реакции в программе.
    • Вводите неправильный вид переменных. Например, если у вас есть форма, которая запрашивает возраст пользователя, введите слово и посмотрите, что происходит с программой.
    • Если ваша программа имеет графический интерфейс, нажимайте по всему. Что происходит, когда вы возвращаетесь к предыдущему экрану или нажимаете кнопки в неправильном порядке?
  3. 3

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

    • Severity — степень строгости ошибки является мерой того, какой ущерб вызывает ошибка. Ошибки, которые разрушают программу, повреждают данные, воздерживая программу от запуска, называются «Blocker». Функции, которые не работают или возвращают неверные результаты, помечены как «Critical», тогда как трудно использовать или плохо выглядящие особенности помечены Major. Есть также Normal, Minor и Trivial ошибки, которые оказывают влияние на небольшие разделы или менее важные функции.
    • Priority — приоритет ошибки определяет, в каком порядке вы их решаете при попытке исправить ошибки. Исправление ошибок в программном обеспечении является трудоемким процессом и отнимает время вместе того, чтобы добавлять новые функции и шлифовать. Таким образом, вы должны принять приоритет ошибки во внимание, чтобы убедиться, что уложитесь в сроки. Все ошибки Blocker и Critical имеют наивысший приоритет, который иногда называют P1. P2 ошибки, как правило, Major ошибки, которые планируется исправлять, но не будут воздерживать продукт от отправки. Р3 и Р4 ошибки, как правило, не планируют исправлений и попадают в категорию » хорошо иметь».
  4. 4

    Добавьте больше возможностей. Во время альфа-тестирования вы будете добавлять новые функции в вашу программу, чтобы приблизить ее к программе, изложенной в документе вашего проекта. Альфа-тестирование – это этап, когда прототип превращается в основу для полной программы. К концу этапа альфа-тестирования ваша программа должна иметь все его реализованные возможности.

  5. 5

    Не отклоняйтесь слишком далеко от вашей первоначальной проектно-технической документации. Общей проблемой в разработке программного обеспечения является «разрастание возможностей в программах», где новые идеи добавляются, вызывая потерю основного акцента, и расширение времени разработки между слишком большим количеством различных функций. Вам нужно, чтобы ваша программа была лучшей в том, что она делает, а не «мастером на все руки».[3]

  6. 6

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

  7. 7

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

    Реклама

  1. 1

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

    • В зависимости от потребностей вашего продукта вы можете или нет проводить открытое бета-тестирование.
  2. 2

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

  3. 3

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

    • Дизайн и функциональность UI (пользовательского интерфейса) может быть очень трудным и сложным. Люди делают целую карьеру на проектировании пользовательских интерфейсов. Просто убедитесь, что ваш личный проект является простым в использовании и простым для восприятия на глаз. Профессиональный интерфейс может оказаться невозможным без наличия бюджета и команды.
    • Если у вас есть бюджет, есть много внештатных графических дизайнеров, которые потенциально могли бы спроектировать пользовательский интерфейс по контракту для вас. Если у вас есть солидный проект, который, как вы надеетесь, станет следующим большим делом, найдите хорошего дизайнера пользовательского интерфейса и сделайте его частью вашей команды.
  4. 4

    Продолжайте «охоту» на ошибки. На протяжении всей бета-фазы вы все равно должны быть внесены в каталог и обозначена приоритетность отчетов об ошибках из базы пользователей. Поскольку все больше тестеров будет иметь доступ к продукту, скорее всего, новые ошибки будут найдены. Ликвидируйте ошибки на основе их приоритета, придерживаясь окончательных сроков.[4]

    Реклама

  1. 1

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

    • Размещайте информацию о вашей программе на смежных досках объявлений. Убедитесь, что вы следуете правилам размещения в зависимости от того форума, который выбираете, чтобы ваши сообщения не были помечены как спам.
    • Отправьте пресс-релизы на технические сайты. Найдите некоторые технические блоги и сайты, которые соответствуют жанру вашей программы. Отправьте редакторам пресс-релиз с подробным описанием вашей программы и что она делает. Включите несколько скриншотов.
    • Сделайте несколько видео YouTube. Если ваша программа предназначена для решения определенной задачи, создайте видео на YouTube, показывая свою программу в действии. Структурируйте их как «How-To» видео.
    • Создайте страницы в социальных сетях. Вы можете создать бесплатно Facebook и Google + страницы для вашей программы, можете использовать Twitter как для компании, так и новостей о конкретной программе.
  2. 2

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

  3. 3

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

  4. 4

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

    Реклама

Источники

Об этой статье

Эту страницу просматривали 14 354 раза.

Была ли эта статья полезной?

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

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

Их очень много: бэкенд, фронтенд, создание мобильных приложений, программирование «железа» и т. д.

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

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

Корпорация Google, ныне входящая в состав холдинга Alphabet, заранее подумала о том, чтобы предоставить разработчикам все условия для удобного создания приложений на свою платформу Android. Для этого еще в 2013 году была представлена среда разработки Android Studio.

Это мощный инструмент разработки (IDE), в котором собраны все необходимые возможности для быстрого создания приложений на смартфоны с операционной системой «Андроид». Если вы хотите заниматься программированием для смартфона, установка и использование данной среды будет необходимостью.

Как установить Android Studio? Все очень просто – данное средство разработки распространяется бесплатно самой компанией Google, и скачать его можно со страницы https://developer.android.com/studio.

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

Рабочая среда в Android Studio

Компания постаралась сделать так, чтобы ее инструмент разработки просто не имел достойных конкурентов. В Android Studio все организовано максимально удобно, аккуратно, любой проект виден во всех своих мельчайших деталях. Здесь собраны все необходимые возможности для разработки:

  • гибкая настройка системы дает возможность подстроить работу под себя;
  • встроенный эмулятор приложений позволяет запускать создаваемые программы и тестировать прямо на ПК;
  • унифицированное рабочее пространство дает возможность легко подгонять проект под любые смартфоны и задавать перечень версий Android, которые должны поддерживаться
    приложением;
  • можно вносить изменения в проект уже с запущенным эмулятором, не перезапуская его заново, что очень удобно и облегчает работу;
  • в программу встроена масса полезных функций, таких как поддержка Google Cloud Platform, интеграция с GitHub и другое.

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

Создаем первые проекты

После того, как вы скачали установочный файл Android Studio, который занимает около 1 Гб, установили его стандартным путем, остается только начать работать. Для новичка все кажется сложным, но первые простые проекты для старта можно смело делать. Рассмотрим наиболее типичный пример – создадим приложение Hello World!

Чтобы начать, запустите программу и создайте свой первый проект, нажав в появившемся окне на строчку «New Project». Далее необходимо задать такие параметры проекта, как название, имя компании-разработчика (пишем что угодно), локализация проекта – путь размещения рабочих файлов.

В следующем окне разработчику предлагается выбрать, для каких версий Android создается его программа, на какие устройства: смартфоны и планшеты, смарт-часы, ТВ и прочее. В следующем окне выбирается шаблон пользовательского интерфейса, который максимально подходит для будущей программы. Для «HelloWorld!» подойдет базовый вариант Empty Activity. Далее после ввода основной информации о проекте касательно его имени и тайтла остается лишь нажать на кнопку «Finish» и начать работать.

Чтобы создать надпись «HelloWorld!» на экране приложения, используем инструмент TextView. Также давайте добавим Button с надписью «Click Me». Если открыть текстовый редактор кода, то приложение должно выглядеть так:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">
    <TextView
        android:id="@+id/textView"
        android:text="HelloWorld!"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="24dp"
        android:gravity="center"
        android:textSize="25sp"/>
    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="24dp"
        android:text="Click Me"/>
</LinearLayout>

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

Далее откроем класс MainActivity и добавим для обработки нажатие и после-нажатие изменяем текст. Пример кода:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val textView = findViewById<TextView>(R.id.textView)
    val button = findViewById<Button>(R.id.button)
    button.setOnClickListener {
        textView.text = "You clicked button"
    }
}

Приложение готово! Надо его лишь запустить и протестировать. Для этого необходимо предварительно настроить работу эмулятора Android Studio и нажать на кнопку Run в главном окне интерфейса. В зависимости от мощности компьютера разработчика, с определенной скоростью запустится эмулятор, и в нем отобразится ваше творение – приложение, в котором по центру экрана красуется надпись «HelloWorld» и кнопка. После нажатия кнопки надпись меняется на «You clicked button»

На чем сфокусироваться новичку

Начиная программировать в Android Studio, не стоит сразу браться за сложные проекты.

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

Все моменты программы осваиваются быстро и относительно просто, но не стоит забывать, что Android Studio – это все же создание приложения, и оно требует от человека знания языка программирования, и лучше всего, чтобы это был Kotlin или Java.

В качестве заключения отметим, что Android Studio – мощная среда разработки, которую стоит использовать каждому человеку, желающему начать писать программы под Android.

#Руководства

  • 18 июл 2018

  • 1

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

 vlada_maestro / shutterstock

Анатолий Ализар

Пишет про разработку в Skillbox Media. Работал главным редактором сайта «Хабрахабр», ведёт корпоративные блоги.

Язык программирования для мобильной разработки на Android очень простой — это Java. Сейчас Google активно продвигает Kotlin как язык, который сможет заменить Java. Приложения пишут и на C++.

Создание простейшего приложения состоит из нескольких этапов:

  • проект в Android Studio;
  • создание пользовательского интерфейса;
  • добавление активностей, навигации и действий;
  • тест-драйв приложения в эмуляторе.

Первым делом установите программу Android Studio. Это официальная среда разработки (IDE) для Android, она работает на Windows, macOS и Linux. Хотя при разработке программ для Android можно использовать и другие среды, кроме Android Studio.

Если на компьютере не установлены Android SDK и другие компоненты, то Android Studio автоматически скачает их. Android SDK — это среда программирования, в которую входят библиотеки, исполняемые файлы, скрипты, документация и т.д.

Android SDK компилирует код вместе с любыми данными и ресурсами в файл с расширением .apk. Он содержит всё необходимое для установки приложения на Android-устройство.

Полезно установить и эмулятор Android, чтобы запускать и тестировать приложения. Эмулятор поставляется в комплекте с Android Studio.

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

Android-приложение состоит из четырёх компонентов. Каждый компонент — это точка входа, через которую система или пользователь может получить доступ.

  • Активность (activity) — элементы интерактивного пользовательского интерфейса.
    Одна активность задействует другую и передаёт информацию о том, что намерен делать пользователь, через класс Intent (намерения). Активности подобны веб-страницам, а намерения — ссылкам между ними. Запуск приложения — это активность Main.
  • Сервис (service) — универсальная точка входа для поддержания работы приложения в фоновом режиме.
    Этот компонент выполняет длительные операции или работу для удалённых процессов без визуального интерфейса.
  • Широковещательный приемник (broadcast receiver) транслирует нескольким участникам намерения из приложения.
  • Поставщик содержимого (content provider) управляет общим набором данных приложения из файловой системы, базы данных SQLite, интернета или другого хранилища.

Теперь попробуем сделать своё приложение для Android.

Выбираем название приложения, домен компании, путь к проекту и название пакета. Указываем, включить ли поддержку опциональных языков программирования C++ и Kotlin.

Задаём одну или несколько целевых платформ для сборки. Для этого используется SDK и AVD, менеджер виртуальных устройств Android. Инструмент позволяет устанавливать в SDK пакеты, которые поддерживают несколько версий ОС Android и несколько уровней API (интерфейсов программирования приложений).


Справка

Чем ниже версия Android, тем больше устройств, на которых приложение запустится. Чем выше версия, тем богаче функциональность API.


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

После нескольких минут сборки Android Studio открывает интерфейс IDE. Здесь три основных момента.

Если выбрать в выпадающем меню вид Android, то вы увидите файлы проекта. Например, наша основная активность называется app > java > ru.skillbox.skillboxapp > FullscreenActivity. При создании проекта мы указали вместо активности Main полноэкранную активность.

Далее можно посмотреть файл app > res > layout > activity_fullscreen.xml. Это XML-файл с макетом для UI нашей основной активности.

Наконец, третий важный файл app > manifests > AndroidManifest.xml описывает фундаментальные характеристики приложения и определяет все его компоненты.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="ru.skillbox.skillboxapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".FullscreenActivity"
            android:configChanges="orientation|keyboardHidden|screenSize"
            android:label="@string/app_name"
            android:theme="@style/FullscreenTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

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

Запускаем на Android-устройстве или в эмуляторе.

Смартфон или планшет для этого подключаем в режиме USB-отладки, которая активируется в Настройках разработчика в меню Настройки.

Для запуска в эмуляторе нажимаем в Android Studio кнопку Run в меню Run (Shift+F10). Выбираем подходящее устройство и версию ОС, портретную или ландшафтную (альбомную) ориентацию.

Android Studio установит эмулятор и запустит его.

Пользовательский интерфейс Android-приложения создаётся через иерархию макетов (layouts, объекты ViewGroup) и виджетов (объекты View). Макеты управляют расположением дочерних виджетов на экране. Сами виджеты — это непосредственно компоненты UI: кнопки, текстовые поля на экране и т.п.

Интерфейс активностей создаётся в Android Studio в редакторе макетов (Layout Editor) и хранится по большей части в XML-файлах.

  • Открываем файл app > res > layout > activity_fullscreen.xml.
  • Добавляем на экран из палитры (Palette) виджеты перетаскиванием мышью.
  • Например, берём текстовое поле (PlainText). Это виджет EditText, куда пользователь может вводить текст.
  • Добавляем кнопки и другие нужные элементы.

Также на экран можно перетащить кнопки и другие элементы.

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

  • Заходим в код app > java > FullscreenActivity.
  • Добавляем метод SendMessage() в класс FullscreenActivity, чтобы при нажатии на кнопку вызывался этот метод.
  • Создаём намерения (класс Intent) для перехода от одной активности к другой, новые активности, навигацию и всё остальное, что необходимо для приложения.

И, конечно, начинаем мечтать, как монетизировать приложение.

Учись бесплатно:
вебинары по программированию, маркетингу и дизайну.

Участвовать

Научитесь: Профессия Мобильный разработчик
Узнать больше

#Введение

Программирование — не только написание кода, но и ещё планирование кода; определение того какие фичи нужны, а какие нет. У меня есть своя система, определяющая: как заниматься планированием программ, фич; как организовывать себя; как не забывать идеи. И я хочу в этой статье рассказать об этом. Что-то в этой системе придумал сам, что-то украл у других людей.

Эта статья может быть полезна начинающим программистам.

#На примере программы для изучения английских слов

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

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

#2Создание продукта

#3Сбор идей

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

#4Беспорядочный сбор идей

Я беру файлик и называю его ideas.md. Теперь в нём будут лежать все идеи по данному проекту.

Сначала надо просто накидать всё что лежит в голове без всякого порядка. Я набросал, затем перечитывал это по многу раз и вносил те элементы что ещё не записал. Причём я записывал все идеи, даже самые безумные, мало ли что потом может пригодиться или случиться.

На беспорядочный сбор идей ушло 20 минут, и в результате получился такой файл:

(желательно его не читать, а просто увидеть масштаб)

@341bd26/ideas.md diff

  • Хотелось бы загружать из текста и из субтитров, чтобы была кнопка, которая читает буфер обмена
    • Чтобы при добавлении субтитров или текста, смотрелись все слова, и те что уже известны или выучены, не добавлялись, а новые слова показывались для дальнейшего добавления
  • Интерфейс добавления слова
    • Известные или выученные слова фильтруются
    • Показывается английское слово
    • Предлагается добавить его русский перевод вручную
    • Либо есть кнопка «я уже знаю это слово»
  • Чтобы для данного слова можно было видеть его контекст использования
  • Чтобы в специальном файле можно было настравить раскладку клавиатуры, чтобы автоматически раскладка подстраивалась без переключения раскладки.
  • Можно менять местами язык вопросов и ответов
  • Как вводятся слова:
    • Слово, которое не набиралось ни разу, надо сначала ввести n раз
    • Слова, которые 5 раз отвечались правильно, считаются на сегодня законченными
    • Слова, которые отвечаются неправильно, получают рейтинг -2
    • Так же контроллируется дата, когда человек отвечал и как. Если некоторое слово долго не набиралось, то необходимо его повторить, причем если до этого повторение работало хорошо, то приоритет меньший.
    • Только когда слово зарабатывает рейтинг кратный 5, то в записях фиксируется дата, когда это было сделано
  • Приоритет слов для набора: Каждая категория сортируется в случайном порядке
    • Слова, которые не набирались 5 раз
    • Слова, которые имеют отрицательный рейтинг
    • Слова, которые имеют рейтинг меньше 5
    • Слова, которые имеют рейтинг выше 5, но весь этот рейтинг был заработан свыше 5 дней назад
    • Слова, которые имеют рейтинг выше 10, но весь этот рейтинг был заработан свыше 5 дней назад
    • Слова, которые имеют рейтинг выше 15, но весь этот рейтинг был заработан свыше 20 дней назад (слова, которые давно не повторялись)
    • Слова, которые имеют рейтинг выше 20, но весь этот рейтинг был заработан свыше 20 дней назад
    • Всё, больше точно не надо
  • В центре экрана написано слово, которое надо перевести, ниже его написаны варианты ответа в виде «____ __», причем необходимо, чтобы _ были раздельны
    • Не соотносится с многозначностью слов, пусть будет просто N полей с не важно какой длиной
  • Как справляться с многозначностью слов
    • Для данного английского слова хранится множество пар русских слов, аналогично наоборот
    • Если сейчас показывается многозначное английское слово, то внизу нужно ввести все добавленные его русские смыслы
    • В статистике оценивается пара (русское слово, английское слово)
    • Если какое-то значение многозначного слова уже выучено или не требует повторения, то оно не показывается для ввода, оно просто показывается текстом, чтобы можно было понять какие смыслы введены, а какие нет
  • Статистика
    • Для каждого слова запоминается сколько раз его печатали, сколько правильно, сколько неправильно.
    • Для каждого дня запоминается сколько слов за сегодня отработано по полной, сколько слов отработано вообще итд.
    • Попробовать рисовать статистику через графики egui.
    • Ведётся количество новых добавленных слов в день
    • Где-то должно быть окошко чтобы посмотреть просто количество всех слов в системе, количество выученных слов и количество изучаемых слов
  • При добавлении новых слов есть возможность говорить: я это слово знаю; это не знаю. Чтобы не учить лишний раз известные слова, и чтобы в других текстах они не добавлялись как неизвестные.

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

#4Систематизация идей

У меня есть принцип, что что-то надо систематизировать и разбирать на категории только в двух случаях:

  • Когда ты точно знаешь что эта категория использовалась ранее и она работает.
  • У тебя есть критическая масса элементов этой категории.

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

На это тоже ушло 20 минут.

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

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

В итоге файл с идеями теперь выглядит так:

@5387e15/ideas.md diff

систематизированные идеи

Реализовать в первую очередь

  • Общий интерфейс
    • Добавление слов
      • Через субтитры .src
      • Через текст
    • Окошко для выучивания слов показывается всегда и его нельзя закрыть, либо оно вообще привязано к фону
  • Интерфейс получения слов из текста или субтитров
    • Есть две кнопки: «добавить как текст», «добавить как субтитры»
  • Интерфейс добавления слова
    • Известные или выученные слова фильтруются
    • Показывается английское слово
    • Предлагается добавить его русский перевод вручную (новая строка означает новый смысл)
    • Есть кнопка «добавить переводы слова»
    • Либо есть кнопка «я уже знаю это слово»
  • Интерфейс ввода слова
    • Вверху написано английское (или русское) слово
    • Внизу N полей для ввода всех многозначностей этого слова
    • Некоторые поля могут быть серыми с уже написанными словами, так как эти слова выучены или не требуют сейчас повторения
    • Для перехода вниз или проверки текущего слова можно нажать Enter
    • Показывается правильно или неправильно введено слово только после введения всех слов
    • Для кажого слова показывается точками сколько раз ещё предстоит его вводить на сегодня
  • Порядок ввода слова
    • Первые 2 раза слово вводится с подсказкой программы
    • Затем 3 раза нужно ввести слово по памяти на сегодня
    • Следующий раз ввести слово 5 раз нужно через день и более
    • На этом этапе слово считается наполовину выученным
    • Потом 5 раз через неделю и более
    • Потом 5 раз через месяц и более
    • После этого слово считается абсолютно выученным
    • Каждая ошибка добавляет необходимость вводить ещё один лишний раз это слово
  • Слова в очереди
    • Русские и английские слова даются вперемешку
    • Всё вперемешку
    • Перебирается каждое слово и смотрится, нужно ли его набирать сегодня и сколько раз
  • Как справляться с многозначностью слов
    • Для данного английского слова хранится множество пар русских слов, аналогично наоборот
    • В статистике оценивается пара (русское слово, английское слово)
  • Статистика
    • Для каждого слова запоминается:
      • Сколько раз его печатали, сколько правильно, сколько неправильно
      • Все даты майлстоунов, когда его печатали в первый день, во второй день, черз неделю, через месяц

сложные идеи

Реализовать потом

  • Интерфейс получения слов из текста или субтитров
    • Программа всегда видит буфер обмена, если открыто это окно
    • Внизу серым написан текст, который сейчас находится в буфере обмена
    • Показывается только 200 первых символов этого текста, далее ставится троеточие и подписано количество байт занимаемых всем текстом
  • Интерфейс добавления слова
    • Чтобы для данного слова можно было видеть его контекст использования
  • Интерфейс статистики слова
    • Когда добавлено (дата, количество дней назад)
    • Сколько раз вводилось
    • Сколько правильно, сколько неправильно
    • Все майлстоуны (дней после добавления)
  • Интерфейс ввода слова
    • Есть кнопочка (i) напротив каждого слова, на которую можно нажать и посмотреть статистику этого слова
  • Интерфейс окна «раскладка клавиатуры»
    • Тебя просят включить русский язык и ввести все английские буквы, как если бы они находились при включённом английском языке
    • Аналогично при включённом английском языке просят ввести все русские буквы
    • Таким образом программа запоминает раскладку клавиатуры и сохраняет её в настройки, чтобы потом использовать чтобы не переключать раскладку клавиатуры
  • Статистика
    • Попробовать рисовать статистику через графики egui.
    • Где-то должно быть окошко чтобы посмотреть просто количество всех слов в системе, количество выученных слов и количество изучаемых слов
    • Для каждого дня запоминается:
      • Сколько слов сегодня отработано по полной
      • Сколько попыток совершено вообще, сколько правильных, сколько неправильных
      • Сколько задолженность на сегодня
      • Сколько слов сегодня добавили
      • Как долго была включена программа (простои больше 15 секунд не учитываются)
    • Можно получить статистику за всё время, суммировав статистику за каждый день

отсортировать

#3Планирование структур данных и функций

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

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

Найти нужную структуру данных — это уже значит решить половину задачи.

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

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

Хорошая цитата из доклада

Мой ответ на вопрос о том зачем нужны типы, отлично иллюстрируется цитатой Коннора МакБрайда, тоже очень известного теоретика в области ЯП. Он в трэде жалуется на то что последние 20-30 лет писали ЯП таким образом чтобы типы сами выводились из программы, тогда как можно было делать всё наоборот: можно было писать типы, из которых потом выводятся программы. Мне кажется что это очень глубокая мысль. И, честно говоря, когда я это осознал, то очень сильно поменял своё отношение к тому как пишу код. Потому что ведь на самом деле типы — это идеальная проекция вашей доменной модели приложения на код, которая всегда будет актуальней кода, потому что если она внезапно перестаётся быть актуальной, то код не тайп-чекается. И это с моей точки зрения самое главное — написать крутой, корректный, правильный тип, насколько хорошо позволяет ваш ЯП. Даже если у вас не очень мощные типы, всегда есть возможности спроектировать вашу систему так, чтобы типы там отражали вашу доменную область наилучшим образом. Тогда процесс имплементации становится делом техники. В Idris’е даже есть момент: если вы правильно написали тип, то код может вывестись сам. Но в реальной жизни, когда мы не используем такие ЯП, как правило, когда есть хороший тип, то вы просто пишите банальный код и всё очень просто и понятно. И это мой ответ на то зачем же нужны типы.

41:18

Таймкод 39:19

Ещё есть идея, что чтобы удобнее было писать код, надо подумать о том как представить данные в том виде, чтобы задача в них решалась максимально естественно, и перевести их в этот формат:

×1.5
png

Ссылка на твит

Далее я буду кидаться коммитами, начинающимися с @. Мне кажется что оптимальным способом смотрения их будет: открыть в новой вкладке и пролистать diff, увидеть примерно что произошло. Либо можно просто их игнорировать, особо ничего не потеряете. Смотреть что происходило в коммитах может быть полезно если вам нужны прям детали как происходила моя разработка.

Спустя два коммита (@a8549a3, @b79f219) и 1ч 20м, у меня получились следующие типы, которые далее будут являться основой всего:

/// Итерация изучения слова, сколько ждать с последнего изучения, сколько раз повторить, показывать ли слово во время набора
struct LearnType {
    /// Сколько дней ждать с последнего изучения
    wait_days: i8,
    count: i8,
    show_word: bool,
}

/// Статистика написаний для слова, дня или вообще
struct TypingStats {
    typed: i32,
    right: i32,
    wrong: i32,
}

/// Обозначает одну пару слов рус-англ или англ-рус в статистике
enum WordStatus {
    /// Мы знали это слово раньше, его изучать не надо
    KnowPreviously, 

    /// Мусорное слово, артефакт от приблизительного парсинга текстового файла или субтитров
    TrashWord,

    /// Мы изучаем это слово
    ToLearn { 
        translation: String,

        /// Когда это слово в последний раз изучали
        last_learn: Day, 

        /// Количество изучений слова, при поиске того что надо печатать, проходим по всему массиву
        learns: Vec<LearnType>, 

        /// Статистика
        stats: TypingStats, 
    },

    /// Мы знаем это слово
    Learned { 
        translation: String,

        /// Статистика
        stats: TypingStats, 
    },
}

struct WordsSaved(BTreeMap<String, Vec<WordStatus>>);

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

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

Интерфейс распланировал за 32м: @0cab890, и после этого планирования даже чуть-чуть улучшились и основные структуры данных.

#3Написание кода

Далее за 1ч написал код логики: @96eb608.

Затем за 2ч 45м написал код интерфейса до минимально рабочего состояния: @7b8de3d.

Кстати, писать работающий код поверх распланированных функций и типов крайне приятно, код так легко и быстро идёт.

Итак, на отметке чистого времени у нас 6ч 16м, и программа выглядит следующим образом:

×1
png

Здесь работает всего три окошка и основной функционал.

#3Todo-листы

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

Нам больше не настолько нужен файлик с идеями, удаляем оттуда всё реализованное: (он стал совсем маленьким)

@47b0669/ideas.md diff

идеи неизвестной полезности

  • Чтобы при добавлении слов замерялась их частотность, даже частотность известных, и она просто суммировалась к тому что уже хранится, чтобы можно было видеть частотность выученных слов. Хотя и для этого придётся какой-то сложный интерфейс пилить.
  • Интерфейс добавления слова
    • Чтобы для данного слова можно было видеть его контекст использования
  • Интерфейс ввода слова
    • Есть кнопочка (i) напротив каждого слова, на которую можно нажать и посмотреть статистику этого слова
  • Интерфейс статистики слова
    • Когда добавлено (дата, количество дней назад)
    • Сколько раз вводилось
    • Сколько правильно, сколько неправильно
    • Все майлстоуны (дней после добавления)

И заводим файлик todo, в котором разместим конкретные todo-пункты для выполнения:

@47b0669/learn_words.todo diff

общее:
  ✔ сделать чтобы по интерфейсу написания слова можно было легко перемещаться @done (21-07-29 23:34)
  ✔ чтобы субтитры могли возвращать ошибку и она показывалась в окне @done (21-07-29 23:41)
  ☐ сделать чтобы перемещение по интерфейсу ввода слова делалось через enter
  ☐ добавить чтобы каждое слово знало свой текущий уровень
  ☐ чтобы из файла считывалась комбинация (Words, Settings), и чтобы она же сохранялась
  ☐ замер времени в программе
    + когда простой мышки или клавиатуры больше 15 секунд, программа переходит в режим паузы, и прекращает замер времени, и это показывается на весь экран
    + время в программе за сегодня показывается снизу
    + каждый день запоминается количество времени в програме

раскладка:
  ☐ сделать окно для раскладки клавиатуры
    + галочка "использовать автопереключение раскладки", и если галочка отмечена, то далее показывается всё что есть
    + введите все свои английские символы
    + введите все свои русские символы
    + если ввести символ не можешь, значит ставить пробел
    + чтобы чекалось если вдруг из двух разных языков находятся одинаковые символы, тогда отвергать такую раскладку
    + можно ставить enter для удобства
    + сравнивалось количество символов без enter, и говорилось когда они совпадают а когда нет
    + кнопка "использовать эту раскладку"
  ☐ сделать виджеты поля ввода, которое умеет определять текущую раскладку и язык ответа и автоматически подменять буквы
  ☐ раскладка должна храниться в settings

статистика:
  ☐ статистика количества слов в программе:
    + известные
    + мусорные
    + изучаемые на каждый уровень
    + изученные полностью
  ☐ основа для замера каждый день
    + замерять количество попыток
    + новых неизвестных слов
    + обновляется либо вручную, либо при закрытии программы, либо при открытии окна статистики
    + заодно замерять количество попыток вообще
  ☐ показывать статистику за сегодня внизу
  ☐ запоминание количества слов каждого уровня каждый день
  ☐ плитка как на гитхабе
    + можно выбирать какой параметр показывать, учитывая всё что известно для текущего дня
  ☐ график количества запомненных слов за все дни, условно какую площадь он занимает, со stems

васм:
  ☐ хранение в куках
  ☐ заюзать quad_rand
  ☐ при закрытии вкладки чтобы автоматически сохранялся прогресс
  ☐ кнопки для считывания и загрузки своих данных в программу в меню в пункте Data -> {Import, Export}

Тут стоит отвлечься насчёт того как я веду todo-списки. Одни люди это делают через GitHub, другие через приложение на телефон, а я через расширение для текстового редактора. Я пишу в Sublime + PlainTasks, так же есть похожее расширение для VSCode: Todo+.

Учтите, что этот файл выглядит очень хорошо только в Sublime + PlainTasks, от markdown здесь никакого форматирования к сожалению не делается.

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

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

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

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

#3Обычный цикл разработки

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

На таймере чистого времени 21ч 21м и следующий результат:

×1.2
png

Тут уже намного больше фич, и я сам полноценно начал пользоваться программой. Но во время пользования очень много начало болеть и я записал ещё больше туду-пунктов.

На таймере 33ч 23м чистого времени и я публикую статью про эту програму.

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

Программу можно считать завершённой.

#3Куда девать выполненные туду-пункты

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

@42b5e72/learn_words.todo link

общее:
  ☐ для stackplot сделать чтобы самые маленькие по площади были в самом низу, а самые большие в самом вверху

статьи:
  ✔ рассказать о quad-storage @done (21-08-10 21:52)
  ☐ написать статью о том как сделал эту прогу
  ☐ 1 сентября опубликовать статью по результатам месячного использования этой проги

далёкая перспектива:
  ☐ https://github.com/emilk/egui/issues/595
  ☐ в зависимости от того что выключается в stackplot в легенде, убирать это из вычислений, для этого надо внедрить фичу в egui

рефакторинг:
  ✔ причесать функцию ui, вынести поля ввода со всеми их фичами в отдельную функцию, чтобы не было этого копипаста, а данные в отдельную структуру @done (21-08-10 19:27)
  ☐ для того чтобы тратилось меньше памяти, и прога работала быстрее за счёт уменьшения числа аллокаций, использовать айдишники строк, а все строки хранить в одной структуре
  ☐ переделать так, чтобы в words хранился не массив, где слово может быть выученным и подлежащем изучению, а чтобы сверху там было (trash, known, (learn, и вот уже внутри learn массив (либо выученное, либо изучаемое))) (сомнительное удобство)
  ☐ попытаться заюзать gat

-------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------
АРХИВ:
-------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------

общее:
  ✔ сделать чтобы по интерфейсу написания слова можно было легко перемещаться @done (21-07-29 23:34)
  ✔ чтобы субтитры могли возвращать ошибку и она показывалась в окне @done (21-07-29 23:41)
  ✔ добавить чтобы каждое слово знало свой текущий уровень @done (21-07-30 14:18)
  ✔ чтобы из файла считывалась комбинация (Words, Settings), и чтобы она же сохранялась @done (21-07-30 14:23)
  ✔ замер времени в программе @done (21-07-30 15:01)
    + когда простой мышки или клавиатуры больше 15 секунд, программа переходит в режим паузы, и прекращает замер времени, и это показывается на весь экран
    + время в программе за сегодня показывается снизу
    + каждый день запоминается количество времени в програме
  ✔ сделать чтобы перемещение по интерфейсу ввода слова делалось через enter @done (21-07-31 23:24)
  ✔ сделать базовое окно about @done (21-07-31 23:35)
  ✔ кажется на васме протекает буфер обмена при использовании русских символов. видимо путаются количество чаров и длина в байтах, надо пофиксить @done (21-08-01 00:10)


раскладка:
  ✔ сделать окно для раскладки клавиатуры @done (21-07-30 19:30)
    + галочка "использовать автопереключение раскладки", и если галочка отмечена, то далее показывается всё что есть
    + введите все свои английские символы
    + введите все свои русские символы
    + если ввести символ не можешь, значит ставить пробел
    + чтобы чекалось если вдруг из двух разных языков находятся одинаковые символы, тогда отвергать такую раскладку
    + можно ставить enter для удобства
    + сравнивалось количество символов без enter, и говорилось когда они совпадают а когда нет
    + кнопка "использовать эту раскладку"
  ✔ сделать виджеты поля ввода, которое умеет определять текущую раскладку и язык ответа и автоматически подменять буквы @done (21-07-30 19:30)
  ✔ раскладка должна храниться в settings @done (21-07-30 19:30)

статистика:
  ✔ основа для замера каждый день @done (21-07-30 15:34)
    + замерять количество попыток, правильных и неправильных
    + новых неизвестных слов
    + обновляется либо вручную, либо при закрытии программы, либо при открытии окна статистики
    + заодно замерять количество попыток вообще
  ✔ показывать статистику за сегодня внизу @done (21-07-30 15:34)
  ✔ запоминание количества слов каждого уровня каждый день @done (21-07-30 15:34)
  ✔ статистика количества слов в программе: @done (21-07-30 16:23)
    + известные
    + мусорные
    + изучаемые на каждый уровень
    + изученные полностью
    + вычисляется при вызове программы из words
  ✔ график количества запомненных слов за все дни, условно какую площадь он занимает, со stems, по уровням @done (21-07-30 17:40)
  ✔ аналогично верхнему график количества правильных и неправильных попыток @done (21-07-30 17:40)
  ✔ плитка как на гитхабе @done (21-07-30 23:36)
    + можно выбирать какой параметр показывать, учитывая всё что известно для текущего дня

васм:
  ✔ кнопки для считывания и загрузки своих данных в программу в меню в пункте Data -> {Import, Export} @done (21-07-30 18:03)
  ✔ заюзать quad_rand @done (21-07-31 14:51)
  ✔ хранение в куках @done (21-07-31 22:20)
    + https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Client-side_storage
  ✔ попробовать скомпилить под васм @done (21-07-31 23:12)
  ✔ при закрытии вкладки чтобы автоматически сохранялся прогресс @done (21-07-31 23:12)

рефакторинг:
  ✔ сделать trait ClosableWindow, и функцию process_window, которая обрабатывает окно, которое может закрыться, чтобы не копипастить это постоянно. или лучше структуру, которая оборачивается вокруг структуры окна, умеет закрываться, сама конструирует окно, и сама в функции ui отслеживает когда окно хотят закрыть @done (21-07-30 16:06)

критичное:
  ✔ если просто нажимать кнопку мыши без движения, то выскакивает пауза @done (21-08-02 21:20)
  ✔ для того чтобы читать буфер обмена, пользователь должен сам нажать ctrl+v, тогда мб убрать автоматическое считывание буфера обмена, аналогично для ctrl+c @done (21-08-02 21:54)
  ✔ подсказки должны даваться с пробелом, а то из-за курсора их не видно @done (21-08-02 21:55)
  ✔ чтобы автосохранение было после каждого слова @done (21-08-02 21:56)
  ✔ если нажать use this text с пустым текстом, то происходит паника, file: "src/main.rs", line: 1185, col: 38 @done (21-08-02 22:01)
  ✔ кажется в копипасте нельзя вставить текст длиньше 32768 символов @done (21-08-02 22:37)
  ✔ переделать настройки количества изучения, чтобы они не копипастились в каждое слово, а были глобальны @done (21-08-02 23:12)
    + тогда надо чтобы это можно было задавать в окне settings

сделать следующим:
  ✔ при вводе слова с подсказкой необходимо вводить не только перевод слова, но и его самого. это нужно, потому что я пытаюсь ускориться, и не читаю что за слово с подсказкой я пишу @done (21-08-03 17:22)
  ✔ наверное за сессию надо изучать меньше слов, а не все добавленные. сделать настройку, которая позволяет взять N (пусть для начала будет 20) слов в пул, и изучать их, и только когда они кончатся, изучать дальше. @done (21-08-03 17:48)
  ✔ окно-редактор-просмотрщик слов, где можно искать слова fuzzy поиском, где сразу отображается внутренность @done (21-08-03 20:20)
  ✔ автоматическое открытие окна просмотрщика слов, где фильтрование происходит по текущему добавленному слову @done (21-08-03 20:20)
  ✔ окно для редактирования одного слова @done (21-08-03 22:16)
  ✔ сделать карандашик напротив слова, которое открывает окно для этого слова и позволяет его редактировать @done (21-08-03 22:16)
  ✔ всё-таки добавить фичу, показывающую контекст конкретного слова, заодно показывать частоту его встречи в данном тексте @done (21-08-03 23:02)
  ✔ должна быть возможность выбирать количество новых слов, и количество слов для повторения @done (21-08-04 14:57)
  ✔ после добавления текста или субтитров должно показываться окно с инфой: @done (21-08-04 17:20)
    + всего слов
    + уникальных слов
    + отфильтровано
      + известные (known, trash, learned)
      + изучаемые (tolearn)
    + неизвестных
  ✔ синхронные субтитры, когда одновременно показывается и русский и английский вариант @done (21-08-04 23:51)
    ✔ разобраться с выделением текста при поиске @done (21-08-04 23:55)
    ✔ чтобы когда в вводе ничего нет, или нашлись новые результаты, скролл улетал на начало @done (21-08-04 23:57)
    ✔ 0 всегда обозначает отсутствие скролла @done (21-08-04 23:57)
    ✔ сделать чтобы скролл целился на лейбл только после нажатия кнопки @done (21-08-04 23:57)
    ✔ убрать массив в поиске слова @done (21-08-05 00:03)
  ✘ вынести общую часть в коде find_whole_word @cancelled (21-08-05 00:14)
  ✔ сделать чтобы нулевой элемент не показывался в кнопочках, и чтобы не выделялся, и чтобы на него нельзя было попасть @done (21-08-05 00:14)
  ✔ в окне добавления слова может унести контекст вправо @done (21-08-05 13:52)
  ✔ возможность менять масштаб в настройках @done (21-08-05 14:02)
  ✔ должна быть галочка, позволяющая двигать график @done (21-08-05 14:19)
  ✔ нужна белая тема, ибо на тёмной глазам неприятно @done (21-08-05 14:35)
    + запоминать тему в настройки
    + рисовать всё окно белым или чёрным в зависимости от темы
    + запомнить цвета для всяких штук типо activity в зависимости от темы
  ✔ заюзать нормальный рандом, который инициализируется текущим временем @done (21-08-05 19:22)
  ✔ после ввода какого-то слова неправильно, надо его снова ввести с подсказкой, и переходить дальше не разрешит, пока правильно не напишешь @done (21-08-10 16:34)
    + после неправильного ввода слова его надо снова написать даже несколько раз
  ✔ пропускать окно проверки для ввода с подсказкой @done (21-08-10 16:34)
  ✔ после ввода слова должна быть возможность инвертировать правильный и неправильный результаты @done (21-08-10 16:34)
    + чтобы там использовалось right_to_left
    + для этого надо регистрировать попытки не после их ввода, а после нажатия кнопки "next"
  ✔ чтобы если нажимается backspace на пустом поле или кнопке, фокус запрашивался назад @done (21-08-10 17:54)
  ✘ перевести Words на хранение двух разных языков, и при выборе слов для набора считать только английские слова @cancelled (21-08-10 18:21)
  ✘ сортировать слова для добавления не по их алфавитному написанию, а по порядку как они встречаются в тексте, чтобы лишний раз не читать одни и те же предложения @cancelled (21-08-10 21:51)
  ---
  ✔ в окне add words должно быть поле где можно добавлять известные переводы этого слова @done (21-08-10 18:12)
  ✔ сделать кнопку для скипа добавляемых слов @done (21-08-10 18:12)
  ✔ нужна возможность отменить предыдущее нажатие при добавлении слова, а то так можешь быстро нажимать что знаешь слово и раз, пропустил одно @done (21-08-10 18:12)
    + запоминать одно слово, и удалять его из words методом для удаления, если нажалась кнопка back
  ---
  ✔ сделать чтобы при выборе слов добавлялись сразу переводы, и выбор останавливался когда набиралось больше чем нужное количество, или все слова кончались @done (21-08-10 19:02)
  ✔ в первую очередь должны выбираться наиболее старые слова в окне выбора слов @done (21-08-10 19:02)
  ✔ писать сколько осталось набрать это слово сегодня @done (21-08-10 19:12)
  ✔ чтобы на кнопке при нажатии backspace отправляло назад @done (21-08-10 19:16)
  ✔ должна быть кнопка отмены текущего набора и выбора количества слов для изучения @done (21-08-10 19:26)
  ✔ наверное лучше сначала набрать все слова, которые ты не знаешь с подсказкой, в рандомном порядке, а уже затем набирать все слова которые надо без подсказки набирать причём надо сделать не просто выбор рандома, а чтобы нормально shuffle'ился весь массив, аналогично всё остальное, чтобы подряд не шло два раза одно и то же слово никогда @done (21-08-10 19:46)
  ---
  ✔ чтобы при переименовании перевода, перевод тоже переименовывался нормально @done (21-08-11 18:15)
  ✔ сохранять всё после изменения слова @done (21-08-11 18:15)
  ✔ в окне edit word должна быть возможность удалять конкретный перевод слова, и добавлять новые, в окне выставления дня должно автоматически ставиться сегодняшний день @done (21-08-11 18:25)
  ---
  ✔ чтобы через настройки можно было задавать уровни и количество повторений. @done (21-08-11 18:39)
  ---
  ✔ сделать чтобы текущий день считался локальным, а то у меня в 0:00 день был не сегодняшний @done (21-08-11 19:04)
  ✘ законтрибьютить user_dpi в egui-miniquad @cancelled (21-08-11 19:27)
  ✘ мб попробовать отображать панику на экране @cancelled (21-08-11 19:27)
  ✔ баг: не все слова выбираются когда выбираешь для повторения то, что не имеет перевода для повторения @done (21-08-11 23:02)
  ---
  ✔ перейти на egui-web, egui-glium @done (21-08-11 22:25)
  ✔ добавить возможность скачивать экспорт как файл @done (21-08-12 14:58)
  ✘ добавить кнопку, которая выделяет всё @cancelled (21-08-12 14:58)
  ---
  ✔ оптимизировать цвета в белой теме, мб через отдельное окно @done (21-08-13 19:18)
  ✘ заставить в вебе работать изменение масштаба @cancelled (21-08-13 20:24)

не криитчное:
  ✔ кажется нативное приложение не хочет сохранять статистику в файл @done (21-08-01 23:06)
  ✔ кажется окно добавления слов не фильтрует известные слова @done (21-08-01 23:12)
  ✔ невозможно нажать пробел из-за замены символов @done (21-08-02 21:06)
  ✔ слова должны быть огромными, а не простой label @done (21-08-02 21:06)
  ✔ чтобы слова можно было удалять @done (21-08-03 23:15)
  ✘ при вводе слова должна быть возможность посмотреть его статистику @cancelled (21-08-03 23:15)
  ✘ при вводе в попытках слова должна быть возможность отредактировать это слово (типо иногда оставил лишнее окончание или что-то такое) @cancelled (21-08-03 23:15)
  ✔ в окне добавления слов по тексту показывать сколько было уникальных, а сколько отфильтровалось @done (21-08-05 14:35)
  ✔ добавить learned translations в окно добавления слов @done (21-08-05 14:36)
  ✘ в github стате затемнять на dim 0 те элементы где 0 @cancelled (21-08-05 14:39)
  ✘ должна быть возможность добавлять алиасы для какого-то слова, типо если ты его ввёл не так, чтобы оно считалось тоже правильным. @cancelled (21-08-11 19:04)
    + тогда должна быть кнопка после ввода слова, которая не только отменяет неверность текущего ответа, но и одновременно добавляет его в алисы
    + это не нужно, так как есть кнопка invert

#2Время работы над этой программой

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

@aba59d5/video.md link

информация

  • (во времени не учитывается время на написание статей)
  • время написания первых идей: 20 минут
  • время их ситематизации: 20 минут
  • планирование структур данных, связанных с основной логикой, без учёта интерфейса: 1 час 20 минут
  • планирование структур и методов интерфейса: 32м (2:32)
  • написание кода основной логики: 1 час (3:32)
  • написание кода интерфейса до минимально рабочего состояния: 2ч 45м (6:16)
  • 6ч 16м ————————————————— Минимально рабочее состояние
  • сделал два пункта и распланировал дальнейшие идеи в todo: 45м (7:02)
  • слетел таймер
  • три общих пункта: 47м (0:47)
  • основа статистики: 34м (1:21)
  • рефакторинг окон: 30м (1:51)
  • реализация статистики и других мелких улучшений: 1ч 53м (3:44)
  • раскладка клавиатуры: 1ч 4м (4:48)
  • github-like плитка: 3ч (7:44)
  • написал quad-storage: 1ч 49м (9:33)
  • заставил запускаться в васме, пофиксил баги и небольшие дополнения: 1ч 50м (11:23)
  • скинул таймер
  • написание статьи про программу: 2ч 56м
  • 21ч 21м ————————————————— Средне рабочее состояние
  • закончил править все критичные пункты: 1ч 30м
  • начал таймер
  • сделал чтобы можно было выбирать количество слов: 44 минуты (0:44)
  • сделал чтобы можно было искать по всем словам с fuzzy поиском и это работало при добавлении слова: 1ч 2м (1:46)
  • сделал окно для редактирования одного слова: 53м (2:39)
  • добавил показ контекста данного слова из текста: 46м (3:15)
  • для работы можно выбирать количество новых слов и количество слов для повторения: 21м (3:36)
  • добавил вывод информации о количестве слов в тексте после добавления: 20м (3:56)
  • фича синхронных субтитров: 3ч 26м (7:22)
  • мелкие фичи: 57м (8:19)
  • переход на другой генератор рандома: 10м (8:29)
  • сбросил таймер
  • дописал статью про программу с учётом новых фич и пользования: 2ч 3м
  • 33ч 23м ————————————————— Первый релиз
  • повторение слов после неправильного ввода и инвертирование результатов: 1ч 48м
  • улучшения окна add words: 20м
  • выбор переводов при выборе слов и выбор наиболее задолженных слов: 43м
  • улучшения набора слова: 45м
  • улучшения окна edit word: 30м
  • задание количества повторений в настройках: 11м
  • чтобы текущий день считался правильно с учётом тайм-зоны: 37м
  • переехал на egui_template: 2ч 13м
  • написал про второй релиз: 30м
  • 41ч ————————————————— Второй релиз
  • добавил скачивание статистики в виде файла: 1ч 15м
  • оптимизировал цвета в белой теме: 1ч 2м
  • не смог заставить в вебе работать изменение масштаба: 1ч
  • написание статьи про imgui: 2ч 44м
  • написание статьи про то как пишу программы: 1ч

#2Пример сложной фичи

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

Когда дело доходит до такой сложной фичи, её надо хорошо продумать.

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

Вот результат продумывания в файлике ideas.md:

@80a5703/ideas.md diff

синхронные субтитры

  • это будет отдельное окно, которому можно указывать конкретное слово, а оно будет их искать все его встречи в первом предоставленном тексте
  • окно для добавления имеет два поля для ввода текста: Lang 1 (to search words), Lang 2 (translation of Lang 1).
  • у окна для показывания есть метод, который позволяет ввести в поиск нужное слово, если окно открыто. в отличие от окна поиска, это окно не открывается автоматически
  • использует column для окна вставки субтитров
  • использует grid для показывания параллельно. так как там могут быть пустые места с обоих сторон.
  • использует код аналогичным scrolling для выбора элемента скролла
  • перебирает одновременно оба субтитра и смещает указатель текущего времени, если у текущего времени есть пересечение с тем что на другом языке, связывает их в один
  • ещё в окне показывается номер элемента слева, то есть grid состоит из 3 элементов
  • если одна фраза на одном языке пересекается с несколькими на другом языке, то она показывается только для первой
  • есть галочка искать по словам или по вхождениям

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

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

×1
jpg

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

×1
jpg

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

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

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

Так что крайне советую вам прокачаться в олимпиадном программировании на codeforces. LeetCode фигня, ибо он плохо замеряет время работы программы, и вообще задачки там слабые.

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

#2Про чистое время

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

Моё чистое время замерялось только во время работы, перерывы я не засчитывал. Ещё я работал не по 8 часов в день, а меньше: иногда 2, иногда 4. И самое главное — между этими подходами у меня были большие перерывы в виде отдыха и сна. Так что это может быть причиной почему я так эффективно работал.

На работе мы работаем с перерывами, итого за 8 часов рабочего дня, из них по-настоящему рабочими получается всегда меньше. Говорят, 4-6.

Да и даже если захотеть, и каждый день работать по 8 часов идеально, чтобы все эти 8 часов были чистым временем, то так долго не протянешь. Устанешь уже на следующий день. А если не устанешь, то в долговременной перспективе тебя ждёт выгорание и проблемы с психическим здоровьем.

Так что все эти инициативы по переходу на 4-часовой или 6-часовой рабочий день имеют смысл.

#На примере фичи для Portal Explorer

Это пример про то как я внёс непростую фичу в другую програму.

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

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

Поэтому сначала я взял и начал расписывать вопросы и ответы на них. Здесь самое главное — продумать как фича встанет в имеющуюся структуру программы. Я рассуждал в форме текста. Когда появилось первое понимание — накидал struct’урки и enum’ы. Наблюдать результат рассуждений и типы можно на скриншоте ниже:

×1
png

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

×1.1
png

Теперь, после того как у меня всё чётко и понятно в голове, я мог начать очень эффективно фигачить код,.

И затем код был благополучно реализован. Конечно, пару штук на планировании я забыл, но без этого никуда.

#Про пет-проекты

Немного мыслей про то как делать пет-проекты, кажется что они подходят духу статьи.

#2Поиск аналогов

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

Тщательней ищите аналоги, изучайте их досконально, читайте статьи и пользуйтесь. Ведь, как известно, самый лучший проект — это тот, который не пришлось сделать.

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

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

#2Важнее что-то не делать

Просто процитирую tonsky:

Давайте расскажу вам про главное правило пет-проектов. Главное правило пет-проектов: придумать, как ничего не делать.

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

«Скрипты. Планировщик в CI запускает тесты, оформленные в pytest/junit/whatever, рисует красивые картинки, срёт уведомлениями, если что-то пошло не так. Надо только определиться, кто отвечает за реакцию на уведомления.»

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

Но в пет-проектах, к сожалению, зарплату не платят, поэтому приходится адаптироваться. Что не так с этим предложением?

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

Трюк с пет-проектами в том, чтобы обмануть себя и успеть сделать что-то, что можно показать людям до того, как ты устанешь и тебе надоест. А тебе устанет и надоест, trust me. Поэтому количество нерелевантной работы надо резать жестко и беспощадно. И поэтому я так доволен решением с авторизацией: работы нет, а тестирование выполняется.

Классическая иллюстрация этого принципа это «не пишите движок блога». Потому что устанете быстрее, чем напишете первый пост. Люди, которые хостятся на Github Pages с готовым шаблоном или на WordPress — те, которым интересно решить проблему; люди, которые пишут движок — те, которым интересно попрокрастинировать. Поэтому вы читаете этот текст в Телеграмме, а не на каком-то самописном сайте с собственным компилятором — я бы этот компилятор до сих пор писал.

Другой пример из недавнего — Roam Research. Чуваки лет то ли пять, то ли семь сидят без сервера вообще, тупо складывают все в Firebase и ничего, работают, денег подняли. Во всей инфраструктуре нет ни одного сервера. Потом пришел создатель Athens Research, решил склонировать Roam, но еще больше не заморачиваться, и не стал делать даже Firebase. Просто сделал локального клиента, так еще и без авторизации обошелся. И все равно 2 ляма поднял. Легенда.

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

#2Прототипирование

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

Ещё крайне важно делать результат быстро и сразу им пользоваться, ибо потребность в некоторых фичах невозможно понять пока не попользуешься.

Поэтому ImGui здесь отлично заходит для прототипов или пет-проектов. Он ускоряет разработку.

#2Сразу отбрасывать сложные фичи

Как мне удалось так быстро сделать программу для изучения английских слов?

Потому что на самом начальном этапе я откинул самые сложные фичи:

  • Иметь встроенный словарь
  • Нормализация слов (убрать -s, -ing, -ed итд.)
  • Retained mode интерфейс

Благодаря этому я тратил время только на войну с собой. Не воюя с другими библиотеками.

Такие вещи надо заранее откидывать, иначе ты никогда не закончишь свой проект. Вначале всё должно быть тупо и вручную.

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

#Автоматизация

Щас хайпятся всякие GitHub Copilot, которые типо пишут код за программистов, и типо бу-бу-бу программистов заменят машины.

Посмотрите на эту статью ещё раз. Разве такое можно автоматизировать? Это настоящее мышление, которое требуется для программирования даже джуном. Это нельзя автоматизировать до тех пор, пока не будет создан сильный ИИ. А до тех пор Copilot будет только инструментом, который немного упрощает разработку в руках программиста.

А когда создадут сильный ИИ, то отпадёт смысл в любом человеческом труде на планете Земля, так что нет смысла волноваться конкретно за программистов. Все станем бесполезными вместе.

#Заключение

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

Если вам нравится что я делаю, то подписывайтесь на меня в Telegram и YouTube.

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