My Journey in Open-Source Library DevelopmentМой путь в разработке open source библиотекиMein Weg in der Entwicklung einer Open-Source-LibraryMon parcours dans le développement d'une librairie open source我做 open source 库的经历
Open source isn’t just about publishing code, it’s about creating impact, learning in public, and connecting with a community. In this post, I’ll walk you through my process of developing an open-source library and show you why it’s one of the most rewarding things you can do as a developer.
Prehistory
In the spring, while watching one of Yegor Bugaenko’s streams — I was inspired by the idea of open-source development. Yegor asserted that if you want to go beyond being an ordinary developer and become a more sought-after and unique specialist, you need to create something of your own. Whether it’s a book, a blog, a library, or even a framework, such projects allow you to stand out among many other developers, especially in today’s IT market. This not only demonstrates your professionalism but also shows genuine engagement in the development of the field.
All of this made me think: how do I really stand out among other developers? Despite years of working in IT and participating in various projects, I still didn’t have anything of my own — something that could showcase my uniqueness and professionalism.
Searching for Ideas
I revisited my old pet projects on GitHub, but quickly realized that none of them were truly significant. So, I decided to start from scratch and create something new. Full of motivation and enthusiasm, I began to think about what I could write that would be in demand, at least among a small audience, and that would match my skills.
For two or three days, I analyzed ideas for my open-source project. The more I pondered, the more it seemed that everything had already been written, and that what had yet to be realized would be impossible to achieve alone. Let me say right away: this is a misleading perspective. Don’t let it destroy your potential. Yes, much has already been created, but that’s no reason to give up and abandon the idea of creating something of your own.
Now, I’ll explain why:
There’s always a chance to catch a trend and create a tool or service that quickly becomes popular. For example, during the COVID-19 pandemic, websites were developed that provided real-time statistics on infections and the latest news. Currently, we are witnessing a trend toward AI services, which continues to gain momentum. All it takes is to seize the moment and offer a solution that is in demand during that period.
It’s not necessary to be the first in a niche to conquer it. Let’s take Discord as an example: it appeared in 2015 when there were already established players like TeamSpeak, Ventrilo, Skype, and RaidCall. Yet, within just a few years, Discord became the leader in its segment. The key is not the novelty of the idea, but how effectively you address an existing problem.
The most important aspect of creating something new is to identify a real problem and offer a solution. This can be a global challenge or a small but significant issue that needs improvement. It’s crucial to understand what difficulties other developers or regular users face and how you can help them overcome these challenges.
After further reflection, I felt a desire to create something useful for the .NET community — a small library that could facilitate project development. Since my primary focus is .NET, I decided to concentrate on what I already know and do well. One idea that came to mind was to create a library for tracking input events from the keyboard and mouse.
A month before that, while working on a desktop application for Windows, I faced the task of tracking key presses on the keyboard to perform certain actions. The main nuance was that it needed to work regardless of whether our application was active. Since there were no ready-made solutions at that time, I utilized native P/Invoke calls and successfully achieved the desired result. At that moment, I didn’t consider that other developers might also face this issue and that a small library addressing this problem could be quite useful.
Yes, it’s not a library that will change anyone’s life, but it’s the first step toward creating something of my own. It’s an opportunity to gain valuable experience and spend time engaging in something I am truly passionate about, which is why I decided to take action.
Development
The first step was brainstorming ideas for the functionality my library would have. I wanted its capabilities to be as broad as possible while remaining accessible and user-friendly. My goal was for the user not to have to write more than 3-5 lines of code in most scenarios.
During the brainstorming process, I came up with the idea that it would be possible not only to track input but also to control it. For example, with code, one could simulate button presses or key combinations, move the mouse cursor, disable certain keys so that the system wouldn’t respond to their presses, or even change key bindings. All these features were implemented gradually through updates.
As soon as I finalized the set of features, I enthusiastically began development. Writing the code was not particularly challenging, but I focused on its structure and cleanliness so that other developers could easily understand what was done and why. During the development process, I conducted global refactoring several times, changing the organization and names, as well as extracting parts of the code into separate classes. I paid special attention to separating platform-dependent code (as I planned to create a cross-platform solution in the future) from the library code itself. This would prevent the need to rewrite the entire codebase when moving away from P/Invoke. I also took the time to add XML comments so that users of the library could understand what each method or class does.
After completing the first version of the library, I uploaded it to NuGet (the package management system for the .NET platform, similar to npm or pip). I wanted to receive some feedback to understand whether anyone was interested in this project and which direction I should take next. Before promoting my library, I decided to create a README file in the GitHub repository, including information about the library’s goals and a brief guide on how to use it.
The First Users
I decided to search for my first users on Reddit. After finding several suitable communities, I wrote a brief post titled “Open Source C# Library for Handling Keyboard/Mouse Events in Windows UI Apps”. It was a bit stressful, and honestly, I didn’t expect any significant results. However, surprisingly, it paid off. One of the posts received about 14,000 views and approximately 30 comments with positive feedback. It was an incredible feeling that I wish everyone could experience: the realization that the time spent on the project was not in vain. Although I didn’t create something groundbreaking, I understood that there are people who find it genuinely useful and who are willing to support my efforts.
After gathering all the feedback, I decided to continue the development and stay in touch with the most interested users who left comments. I actively communicated with them and listened to their requests for functionality they would like to see. Over the next month, I released several small updates and then refocused on attracting users.
On GitHub, there is a special type of repository called “awesome” — these are collections of links and resources compiled on specific topics, for example, awesome-dotnet. My goal was to promote my library in each of these repositories. Although this was not an easy task — a library with 10-15 stars on GitHub does not attract much interest — I still managed to get into several of them. This significantly increased user traffic and drew attention to my project.
Community Contribution to the Development
During the further development, I encountered many small tasks for which I sometimes lacked the desire and energy to complete. So, I decided to take advantage of one of the benefits of open-source development — attracting enthusiasts who were willing to help with these tasks. To do this, I turned to the Up-for-Grabs service, which provides a list of open-source repositories with active issues for those who want to contribute. After adding my repository and creating several issues, I immediately received requests for assistance.
After my library was downloaded more than a thousand times, I decided to actively work on the documentation. Since the first update, the functionality of the library had significantly increased, and the examples in the README file were no longer sufficient. Of all the possible options, I chose the simplest and most accessible: I created a separate Markdown file and detailed all the classes offered by the library. I also decided to write a small guide for advanced users who want to make full use of the library’s capabilities. To my surprise, a guy who specializes in writing technical documentation reached out to me and offered his help. He assisted me in properly structuring the material and accurately describing all the details. With his help, we quickly completed this task.
Open-source development is a great opportunity to meet and expand your network with other programmers. So far, nine people from different countries have contributed to the library, including the United States, Australia, Argentina, Canada, Germany, Poland, and others. They have assisted in writing functionality, unit tests, and documentation. Moreover, it has been a wonderful exchange of experience and enjoyable communication. Perhaps with some of the contributors, we can start a new project together.
Despite having a job and other commitments, I want to continue development and release a full version with the features that I believe should be included in the library. My future plans include making it cross-platform and decoupling it from specific UI frameworks.
Conclusion
In conclusion, I would like to summarize everything I’ve said. Never be afraid to try something new and don’t stand still. If you truly love programming and want to grow as a developer, strive to create something of your own — whether it’s a small library or a service. You never know where it might lead. Throughout the development of this library, I found joy not only in programming but also in meeting people and making new connections. I plan to continue engaging in open-source development, not only by advancing my own projects but also by contributing to community libraries — this is also a great experience.
If you enjoyed the story, I would be grateful if you could support the library with a star on GitHub!
Open source это не просто публикация кода, это создание влияния, обучение публично и связь с сообществом. В этой статье я расскажу, как разрабатывал свою open source библиотеку, и покажу, почему это одна из самых ценных вещей, которые можно сделать как разработчик.
Предыстория
Весной, на одном из стримов Егора Бугаенко, меня зацепила идея open source разработки. Егор утверждал, что если вы хотите выйти за рамки обычного разработчика и стать более востребованным и уникальным специалистом, нужно создать что-то своё. Будь то книга, блог, библиотека или даже фреймворк, такие проекты позволяют выделиться среди множества других разработчиков, особенно на сегодняшнем IT-рынке. Это не только демонстрирует профессионализм, но и показывает реальную вовлечённость в развитие отрасли.
Всё это заставило меня задуматься: как мне действительно выделиться среди других разработчиков? Несмотря на годы в IT и участие в разных проектах, у меня всё ещё не было ничего своего, чего-то, что показывало бы мою уникальность и профессионализм.
Поиск идеи
Я заглянул в свои старые pet-проекты на GitHub, но быстро понял, что среди них нет ничего по-настоящему значимого. Поэтому я решил начать с нуля и создать что-то новое. Полный мотивации и энтузиазма, я начал думать, что можно написать такого, что будет востребовано хотя бы у небольшой аудитории и при этом подойдёт под мои навыки.
Два-три дня я анализировал идеи для open source проекта. Чем больше я думал, тем сильнее казалось, что всё уже написано, а то, что ещё не реализовано, в одиночку не сделать. Сразу скажу: это обманчивая позиция. Не дайте ей задушить ваш потенциал. Да, многое уже создано, но это не повод сдаваться и отказываться от идеи сделать что-то своё.
Сейчас объясню почему:
Всегда есть шанс поймать тренд и сделать инструмент или сервис, который быстро станет популярным. Например, во время пандемии COVID-19 появлялись сайты со статистикой по заражениям в реальном времени и последними новостями. Сейчас мы наблюдаем тренд на AI-сервисы, и он продолжает набирать обороты. Главное, поймать момент и предложить решение, востребованное в этот период.
Не обязательно быть первым в нише, чтобы её занять. Возьмём Discord: он появился в 2015-м, когда уже были TeamSpeak, Ventrilo, Skype и RaidCall. И всё же всего за несколько лет Discord стал лидером в своём сегменте. Дело не в новизне идеи, а в том, насколько эффективно вы решаете существующую проблему.
Самое важное в создании чего-то нового, найти реальную проблему и предложить решение. Это может быть глобальная задача или небольшое, но значимое улучшение. Важно понимать, с какими сложностями сталкиваются другие разработчики или обычные пользователи и как именно вы можете им помочь.
После дальнейших размышлений мне захотелось сделать что-то полезное для .NET-сообщества, небольшую библиотеку, которая упрощает разработку проектов. Поскольку я в основном работаю с .NET, я решил сконцентрироваться на том, что уже хорошо знаю и умею. Одна из идей, что пришла в голову, библиотека для отслеживания input-событий с клавиатуры и мыши.
За месяц до этого, работая над desktop-приложением для Windows, я столкнулся с задачей отслеживать нажатия клавиш для определённых действий. Главный нюанс: это должно работать независимо от того, активно наше приложение или нет. Готовых решений тогда не было, поэтому я использовал нативные вызовы P/Invoke и успешно добился нужного результата. В тот момент я не подумал, что другие разработчики тоже могут столкнуться с этой проблемой и что небольшая библиотека для её решения может оказаться весьма полезной.
Да, это не библиотека, которая изменит чью-то жизнь, но это первый шаг к созданию чего-то своего. Возможность получить ценный опыт и потратить время на то, что мне по-настоящему интересно. Поэтому я решил действовать.
Разработка
Первым шагом был брейншторм по функциональности будущей библиотеки. Я хотел, чтобы её возможности были как можно шире, оставаясь при этом удобными и понятными. Цель была такой: чтобы в большинстве сценариев пользователю не нужно было писать больше 3-5 строк кода.
В процессе брейншторма родилась идея: можно не только отслеживать input, но и управлять им. Например, кодом симулировать нажатия клавиш или их комбинаций, двигать курсор мыши, отключать отдельные клавиши, чтобы система не реагировала на их нажатие, или даже переназначать клавиши. Все эти возможности были реализованы постепенно через обновления.
Как только я зафиксировал набор фич, я с энтузиазмом приступил к разработке. Писать код было не особо сложно, но я уделял внимание структуре и чистоте, чтобы другие разработчики легко понимали, что и зачем сделано. По ходу разработки я несколько раз делал глобальный рефакторинг: менял организацию и названия, выносил части кода в отдельные классы. Особое внимание уделял отделению платформо-зависимого кода (в планах было сделать решение кросс-платформенным) от самой библиотеки. Это позволило бы избежать переписывания всей кодовой базы при отходе от P/Invoke. Также я потратил время, чтобы добавить XML-комментарии, чтобы пользователи библиотеки понимали, что делает каждый метод или класс.
Закончив первую версию, я выложил её на NuGet (это система управления пакетами для .NET, аналог npm или pip). Мне хотелось получить какой-то фидбек, чтобы понять, есть ли интерес к проекту и куда двигаться дальше. Перед продвижением я решил создать README в GitHub-репозитории, с информацией о целях библиотеки и краткой инструкцией по использованию.
Первые пользователи
Первых пользователей я решил искать на Reddit. Найдя несколько подходящих комьюнити, я написал краткий пост под названием «Open Source C# Library for Handling Keyboard/Mouse Events in Windows UI Apps». Это было слегка стрессово, и, честно говоря, я не ждал значимых результатов. Но, к удивлению, оно сработало. Один из постов получил около 14 000 просмотров и примерно 30 комментариев с положительным фидбеком. Это было невероятное чувство, которое я бы пожелал испытать каждому: понимание, что время, потраченное на проект, было не зря. Я не создал что-то прорывное, но осознал, что есть люди, которым это действительно полезно и которые готовы поддержать мои усилия.
Собрав весь фидбек, я решил продолжить разработку и поддерживать связь с самыми заинтересованными пользователями, которые оставили комментарии. Я активно с ними общался и слушал их пожелания по функциональности. За следующий месяц я выпустил несколько небольших обновлений, а затем снова сместил фокус на привлечение пользователей.
На GitHub есть особый тип репозиториев под названием «awesome», это коллекции ссылок и ресурсов на определённые темы, например, awesome-dotnet. Моя цель была попасть в каждый из таких репозиториев. Это было непросто: библиотека с 10-15 звёздами на GitHub не вызывает большого интереса, но мне всё же удалось попасть в несколько из них. Это заметно увеличило трафик и привлекло внимание к проекту.
Вклад сообщества
В процессе дальнейшей разработки я сталкивался со множеством мелких задач, на которые у меня иногда не хватало желания и энергии. Поэтому я решил воспользоваться одним из плюсов open source разработки: привлечь энтузиастов, готовых помочь. Для этого я обратился к сервису Up-for-Grabs, он предоставляет список open source репозиториев с активными issues для тех, кто хочет внести вклад. После добавления моего репозитория и создания нескольких issues я сразу получил предложения о помощи.
Когда библиотека была скачана больше тысячи раз, я решил активно заняться документацией. С первого обновления функциональность сильно выросла, и примеров в README уже не хватало. Из всех вариантов я выбрал самый простой и доступный: создал отдельный Markdown-файл и подробно описал все классы, которые предоставляет библиотека. Я также решил написать небольшой гайд для продвинутых пользователей, желающих использовать возможности библиотеки по максимуму. К моему удивлению, ко мне обратился парень, специализирующийся на технической документации, и предложил помощь. Он помог правильно структурировать материал и точно описать все детали. Вместе мы быстро закрыли эту задачу.
Open source разработка, отличная возможность знакомиться и расширять свой network среди других программистов. На текущий момент в библиотеку внесли вклад девять человек из разных стран, включая США, Австралию, Аргентину, Канаду, Германию, Польшу и другие. Они помогали с функциональностью, юнит-тестами и документацией. Кроме того, это был замечательный обмен опытом и приятное общение. Возможно, с кем-то из контрибьюторов мы запустим новый проект вместе.
Несмотря на работу и другие обязательства, я хочу продолжать развивать библиотеку и выпустить полноценную версию с фичами, которые, по моему мнению, в ней должны быть. В планах сделать её кросс-платформенной и отвязать от конкретных UI-фреймворков.
Заключение
В завершение хочу подытожить всё сказанное. Никогда не бойтесь пробовать новое и не стойте на месте. Если вы по-настоящему любите программирование и хотите расти как разработчик, стремитесь создавать что-то своё, будь то небольшая библиотека или сервис. Вы никогда не знаете, куда это вас приведёт. За время работы над библиотекой я нашёл радость не только в программировании, но и в знакомствах с новыми людьми. Я планирую и дальше заниматься open source: не только развивать свои проекты, но и контрибьютить в библиотеки сообщества, это тоже отличный опыт.
Если вам понравилась эта история, я буду благодарен, если вы поддержите библиотеку звездой на GitHub!
Open Source bedeutet nicht nur, Code zu veröffentlichen, sondern Wirkung zu schaffen, öffentlich zu lernen und sich mit einer Community zu vernetzen. In diesem Beitrag erzähle ich, wie ich meine Open-Source-Library entwickelt habe, und zeige, warum das eines der wertvollsten Dinge ist, die man als Entwickler tun kann.
Vorgeschichte
Im Frühling, während einer der Streams von Yegor Bugaenko, hat mich die Idee von Open-Source-Entwicklung gepackt. Yegor behauptete, wenn man über den gewöhnlichen Entwickler hinauswachsen und zu einem gefragteren, einzigartigeren Spezialisten werden möchte, muss man etwas Eigenes erschaffen. Sei es ein Buch, ein Blog, eine Library oder sogar ein Framework, solche Projekte erlauben es einem, sich von vielen anderen Entwicklern abzuheben, gerade auf dem heutigen IT-Markt. Das zeigt nicht nur Professionalität, sondern auch echtes Engagement für die Entwicklung der Branche.
All das brachte mich zum Nachdenken: Wie hebe ich mich wirklich von anderen Entwicklern ab? Trotz Jahren in der IT und der Teilnahme an verschiedenen Projekten hatte ich noch immer nichts Eigenes, etwas, das meine Einzigartigkeit und Professionalität zeigen könnte.
Auf der Suche nach Ideen
Ich schaute mir meine alten Pet-Projekte auf GitHub an, merkte aber schnell, dass keines davon wirklich bedeutend war. Also entschied ich, von Null anzufangen und etwas Neues zu bauen. Voller Motivation und Enthusiasmus überlegte ich, was ich schreiben könnte, das gefragt wäre, zumindest bei einer kleinen Zielgruppe, und das zu meinen Skills passt.
Zwei oder drei Tage lang analysierte ich Ideen für mein Open-Source-Projekt. Je mehr ich nachdachte, desto mehr schien es, als sei alles schon geschrieben und das, was noch nicht umgesetzt sei, allein gar nicht zu schaffen. Ich sage es direkt: das ist eine trügerische Sichtweise. Lass sie dein Potenzial nicht zerstören. Ja, vieles wurde schon erschaffen, aber das ist kein Grund, aufzugeben und die Idee, etwas Eigenes zu bauen, fallen zu lassen.
Hier ist, warum:
Es gibt immer eine Chance, einen Trend zu erwischen und ein Tool oder einen Service zu bauen, der schnell populär wird. Etwa während der COVID-19-Pandemie wurden Websites entwickelt, die Echtzeit-Statistiken zu Infektionen und die neuesten News lieferten. Aktuell sehen wir einen Trend zu AI-Services, der weiter an Fahrt aufnimmt. Es kommt nur darauf an, den Moment zu nutzen und eine Lösung anzubieten, die in dieser Zeit gefragt ist.
Man muss nicht der Erste in einer Nische sein, um sie zu erobern. Nehmen wir Discord als Beispiel: Es kam 2015 auf den Markt, als es bereits etablierte Player wie TeamSpeak, Ventrilo, Skype und RaidCall gab. Trotzdem wurde Discord innerhalb weniger Jahre zum Marktführer in seinem Segment. Der Schlüssel ist nicht die Neuheit der Idee, sondern wie effektiv du ein bestehendes Problem löst.
Das Wichtigste, wenn man etwas Neues erschaffen will, ist ein echtes Problem zu finden und eine Lösung anzubieten. Das kann eine globale Herausforderung sein oder ein kleines, aber bedeutendes Anliegen, das verbessert werden muss. Es ist entscheidend zu verstehen, mit welchen Schwierigkeiten andere Entwickler oder gewöhnliche Nutzer kämpfen und wie du ihnen helfen kannst, diese zu überwinden.
Nach weiterem Nachdenken kam der Wunsch auf, etwas Nützliches für die .NET-Community zu bauen, eine kleine Library, die die Projektentwicklung erleichtert. Da mein Hauptfokus auf .NET liegt, entschied ich mich, mich auf das zu konzentrieren, was ich bereits gut kenne und kann. Eine Idee, die mir kam: eine Library zum Tracking von Input-Events von Tastatur und Maus.
Einen Monat zuvor, während ich an einer Desktop-Anwendung für Windows arbeitete, stand ich vor der Aufgabe, Tastendrücke zu tracken, um bestimmte Aktionen auszuführen. Der entscheidende Punkt war, dass es funktionieren musste, unabhängig davon, ob unsere Anwendung aktiv war oder nicht. Da es zu der Zeit keine fertigen Lösungen gab, nutzte ich native P/Invoke-Aufrufe und erreichte erfolgreich das gewünschte Ergebnis. In dem Moment habe ich nicht daran gedacht, dass andere Entwickler vor demselben Problem stehen könnten und eine kleine Library, die das löst, ziemlich nützlich sein könnte.
Ja, es ist keine Library, die jemandes Leben verändern wird, aber es ist der erste Schritt, etwas Eigenes zu erschaffen. Eine Gelegenheit, wertvolle Erfahrung zu sammeln und Zeit in etwas zu investieren, für das ich wirklich brenne. Deshalb beschloss ich, zur Tat zu schreiten.
Entwicklung
Der erste Schritt war ein Brainstorming zu den Features meiner Library. Ich wollte, dass ihre Möglichkeiten so breit wie möglich sind, dabei aber zugänglich und nutzerfreundlich bleiben. Mein Ziel war, dass der Nutzer in den meisten Szenarien nicht mehr als 3-5 Zeilen Code schreiben muss.
Während des Brainstormings kam mir die Idee, dass man Input nicht nur tracken, sondern auch steuern könnte. Etwa per Code Tastendrücke oder Tastenkombinationen simulieren, den Mauszeiger bewegen, bestimmte Tasten deaktivieren, sodass das System nicht auf ihre Drücke reagiert, oder sogar Tastenbelegungen ändern. All diese Features wurden schrittweise über Updates umgesetzt.
Sobald die Feature-Liste stand, ging ich mit Begeisterung an die Entwicklung. Den Code zu schreiben war nicht besonders schwierig, aber ich achtete auf Struktur und Sauberkeit, damit andere Entwickler leicht verstehen, was und warum gemacht wurde. Während der Entwicklung machte ich mehrere Male globales Refactoring, änderte Organisation und Benennung und extrahierte Teile des Codes in eigene Klassen. Besondere Aufmerksamkeit legte ich auf die Trennung von plattformabhängigem Code (ich plante, das Ganze später cross-platform zu machen) vom eigentlichen Library-Code. Das würde verhindern, dass die gesamte Codebase neu geschrieben werden muss, wenn man sich von P/Invoke löst. Ich nahm mir auch die Zeit, XML-Kommentare hinzuzufügen, damit Nutzer der Library verstehen, was jede Methode oder Klasse tut.
Nach Fertigstellung der ersten Version lud ich sie auf NuGet hoch (das Paketmanagement-System für .NET, ähnlich npm oder pip). Ich wollte Feedback bekommen, um zu verstehen, ob jemand am Projekt interessiert war und in welche Richtung es weitergehen sollte. Vor der Vermarktung erstellte ich eine README-Datei im GitHub-Repository, mit Informationen zu den Zielen der Library und einer kurzen Anleitung zur Nutzung.
Die ersten Nutzer
Meine ersten Nutzer suchte ich auf Reddit. Nachdem ich mehrere passende Communities gefunden hatte, schrieb ich einen kurzen Post mit dem Titel „Open Source C# Library for Handling Keyboard/Mouse Events in Windows UI Apps”. Es war ein bisschen stressig, und ehrlich gesagt erwartete ich keine bedeutenden Ergebnisse. Überraschenderweise zahlte es sich aus. Einer der Posts erhielt etwa 14.000 Views und ungefähr 30 Kommentare mit positivem Feedback. Es war ein unglaubliches Gefühl, das ich jedem wünsche zu erleben: das Bewusstsein, dass die in das Projekt investierte Zeit nicht umsonst war. Auch wenn ich nichts Bahnbrechendes geschaffen hatte, verstand ich, dass es Leute gibt, die es wirklich nützlich finden und bereit sind, meine Bemühungen zu unterstützen.
Nachdem ich alles Feedback gesammelt hatte, entschied ich mich, die Entwicklung fortzusetzen und mit den interessiertesten Nutzern, die Kommentare hinterließen, in Kontakt zu bleiben. Ich kommunizierte aktiv mit ihnen und hörte ihre Wünsche zu Features, die sie sehen wollten. Im darauffolgenden Monat veröffentlichte ich mehrere kleine Updates und konzentrierte mich danach wieder auf das Anwerben von Nutzern.
Auf GitHub gibt es einen speziellen Typ von Repository namens „awesome”, das sind Sammlungen von Links und Ressourcen zu bestimmten Themen, etwa awesome-dotnet. Mein Ziel war, meine Library in jedes dieser Repositorys zu bringen. Obwohl das keine leichte Aufgabe war, eine Library mit 10-15 Stars auf GitHub erregt nicht viel Interesse, schaffte ich es trotzdem in einige davon. Das erhöhte den Traffic deutlich und lenkte Aufmerksamkeit auf mein Projekt.
Beitrag der Community zur Entwicklung
Während der weiteren Entwicklung stieß ich auf viele kleine Aufgaben, für die mir manchmal Lust und Energie fehlten. Also entschied ich, einen der Vorteile von Open-Source-Entwicklung zu nutzen, Enthusiasten anzuziehen, die bei diesen Aufgaben helfen wollten. Dafür wandte ich mich an den Service Up-for-Grabs, der eine Liste von Open-Source-Repositorys mit aktiven Issues für Menschen bereitstellt, die beitragen möchten. Nachdem ich mein Repository hinzugefügt und mehrere Issues erstellt hatte, erhielt ich sofort Hilfsangebote.
Nachdem meine Library mehr als tausend Mal heruntergeladen wurde, beschloss ich, mich aktiv um die Dokumentation zu kümmern. Seit dem ersten Update hatte sich die Funktionalität der Library deutlich erweitert, und die Beispiele in der README reichten nicht mehr aus. Von allen möglichen Optionen wählte ich die einfachste und zugänglichste: ich erstellte eine separate Markdown-Datei und beschrieb alle Klassen, die die Library bietet, detailliert. Ich entschied auch, eine kleine Anleitung für fortgeschrittene Nutzer zu schreiben, die die Möglichkeiten der Library voll ausschöpfen wollen. Zu meiner Überraschung meldete sich ein Typ, der auf technische Dokumentation spezialisiert ist, und bot seine Hilfe an. Er half mir, das Material richtig zu strukturieren und alle Details präzise zu beschreiben. Mit seiner Hilfe erledigten wir diese Aufgabe schnell.
Open-Source-Entwicklung ist eine großartige Gelegenheit, andere Programmierer kennenzulernen und das eigene Netzwerk zu erweitern. Bisher haben neun Menschen aus verschiedenen Ländern zur Library beigetragen, darunter aus den USA, Australien, Argentinien, Kanada, Deutschland, Polen und anderen. Sie halfen beim Schreiben von Funktionalität, Unit-Tests und Dokumentation. Außerdem war es ein wunderbarer Austausch an Erfahrungen und angenehme Kommunikation. Vielleicht starten wir mit einigen der Contributor zusammen ein neues Projekt.
Trotz Job und anderer Verpflichtungen möchte ich die Entwicklung fortsetzen und eine vollständige Version mit den Features veröffentlichen, die meiner Meinung nach in der Library enthalten sein sollten. Meine zukünftigen Pläne umfassen, sie cross-platform zu machen und von spezifischen UI-Frameworks zu entkoppeln.
Fazit
Zum Abschluss möchte ich alles Gesagte zusammenfassen. Hab nie Angst, etwas Neues auszuprobieren, und bleib nicht stehen. Wenn du das Programmieren wirklich liebst und als Entwickler wachsen willst, versuche, etwas Eigenes zu schaffen, sei es eine kleine Library oder ein Service. Du weißt nie, wohin es führen kann. Während der Entwicklung dieser Library fand ich Freude nicht nur am Programmieren, sondern auch daran, Menschen kennenzulernen und neue Verbindungen zu knüpfen. Ich plane, mich weiter in Open Source zu engagieren, nicht nur durch das Vorantreiben meiner eigenen Projekte, sondern auch durch Beiträge zu Community-Libraries, das ist ebenfalls eine großartige Erfahrung.
Wenn dir die Geschichte gefallen hat, wäre ich dankbar, wenn du die Library mit einem Star auf GitHub unterstützen würdest.
L’open source ce n’est pas seulement publier du code, c’est créer un impact, apprendre en public et se connecter à une communauté. Dans cet article, je te raconte mon processus de développement d’une librairie open source et te montre pourquoi c’est l’une des choses les plus gratifiantes qu’on puisse faire en tant que développeur.
Préhistoire
Au printemps, en regardant un des streams de Yegor Bugaenko, j’ai été inspiré par l’idée du développement open source. Yegor affirmait que si tu veux dépasser le statut de développeur ordinaire et devenir un spécialiste plus recherché et unique, tu dois créer quelque chose à toi. Que ce soit un livre, un blog, une librairie ou même un framework, ce genre de projets te permet de te démarquer parmi beaucoup d’autres développeurs, surtout sur le marché IT d’aujourd’hui. Cela ne montre pas seulement ton professionnalisme mais aussi un engagement réel dans le développement du domaine.
Tout ça m’a fait réfléchir : comment me démarquer vraiment des autres développeurs ? Malgré des années en IT et la participation à divers projets, je n’avais toujours rien à moi, quelque chose qui pouvait montrer mon caractère unique et mon professionnalisme.
À la recherche d’idées
Je suis revenu sur mes vieux pet projects sur GitHub, mais j’ai vite réalisé qu’aucun d’eux n’était vraiment significatif. Du coup, j’ai décidé de repartir de zéro et de créer quelque chose de nouveau. Plein de motivation et d’enthousiasme, j’ai commencé à réfléchir à ce que je pouvais écrire qui serait demandé, au moins par une petite audience, et qui correspondrait à mes compétences.
Pendant deux ou trois jours, j’ai analysé des idées pour mon projet open source. Plus je réfléchissais, plus il me semblait que tout avait déjà été écrit, et que ce qui restait à réaliser serait impossible à faire seul. Je vais le dire tout de suite : c’est une perspective trompeuse. Ne la laisse pas détruire ton potentiel. Oui, beaucoup a déjà été créé, mais ce n’est pas une raison d’abandonner et de renoncer à l’idée de créer quelque chose à soi.
Voilà pourquoi :
Il y a toujours une chance d’attraper une tendance et de créer un outil ou un service qui devient rapidement populaire. Par exemple, pendant la pandémie de COVID-19, on a vu apparaître des sites donnant des statistiques en temps réel sur les infections et les dernières nouvelles. Actuellement, on assiste à une tendance autour des services AI qui continue à prendre de l’ampleur. Il suffit de saisir le moment et de proposer une solution demandée à ce moment-là.
Pas besoin d’être le premier dans une niche pour la conquérir. Prends Discord : il est apparu en 2015 alors qu’il y avait déjà des acteurs établis comme TeamSpeak, Ventrilo, Skype et RaidCall. Pourtant, en quelques années seulement, Discord est devenu leader sur son segment. La clé n’est pas la nouveauté de l’idée, mais l’efficacité avec laquelle tu réponds à un problème existant.
Le plus important quand on crée quelque chose de nouveau, c’est d’identifier un vrai problème et d’offrir une solution. Cela peut être un défi global ou un problème petit mais significatif qui a besoin d’être amélioré. Il est crucial de comprendre quelles difficultés rencontrent d’autres développeurs ou des utilisateurs ordinaires, et comment tu peux les aider à les surmonter.
Après plus de réflexion, j’ai eu envie de créer quelque chose d’utile pour la communauté .NET, une petite librairie qui pourrait faciliter le développement de projets. Comme mon focus principal est .NET, j’ai décidé de me concentrer sur ce que je connaissais déjà bien. Une idée qui m’est venue : créer une librairie pour tracker les input events du clavier et de la souris.
Un mois avant, en travaillant sur une application desktop pour Windows, j’avais eu à tracker les appuis de touches du clavier pour exécuter certaines actions. La principale subtilité, c’était que ça devait fonctionner que notre application soit active ou non. Comme il n’y avait pas de solution toute faite à l’époque, j’ai utilisé des appels natifs P/Invoke et j’ai réussi à obtenir le résultat voulu. À ce moment-là, je n’ai pas pensé que d’autres développeurs pouvaient aussi avoir ce problème et qu’une petite librairie pour le résoudre pouvait s’avérer très utile.
Oui, ce n’est pas une librairie qui changera la vie de qui que ce soit, mais c’est un premier pas pour créer quelque chose à moi. Une opportunité d’acquérir une expérience précieuse et de passer du temps sur quelque chose qui me passionne vraiment. C’est pour ça que j’ai décidé de me lancer.
Développement
La première étape a été un brainstorming sur les fonctionnalités que ma librairie aurait. Je voulais que ses capacités soient aussi larges que possible tout en restant accessibles et faciles à utiliser. Mon objectif : que l’utilisateur n’ait pas à écrire plus de 3-5 lignes de code dans la plupart des scénarios.
Pendant le brainstorming, l’idée m’est venue qu’il serait possible non seulement de tracker les inputs, mais aussi de les contrôler. Par exemple, par code, simuler des appuis de touches ou des combinaisons, déplacer le curseur de la souris, désactiver certaines touches pour que le système ne réponde pas à leur appui, ou même changer les bindings. Toutes ces features ont été implémentées progressivement à travers les updates.
Une fois la liste de features finalisée, je me suis lancé dans le développement avec enthousiasme. Écrire le code n’était pas particulièrement difficile, mais je me suis concentré sur sa structure et sa propreté pour que d’autres développeurs puissent facilement comprendre ce qui a été fait et pourquoi. Pendant le développement, j’ai fait plusieurs refactorings globaux, en changeant l’organisation et les noms, en extrayant des parties du code dans des classes séparées. J’ai porté une attention particulière à séparer le code dépendant de la plateforme (je prévoyais à terme une solution cross-platform) du code propre à la librairie. Cela permettrait d’éviter de réécrire toute la codebase quand on s’éloignerait de P/Invoke. J’ai aussi pris le temps d’ajouter des commentaires XML pour que les utilisateurs de la librairie comprennent ce que chaque méthode ou classe fait.
Après avoir terminé la première version, je l’ai uploadée sur NuGet (le système de gestion de paquets pour .NET, similaire à npm ou pip). Je voulais obtenir du feedback pour comprendre si quelqu’un s’intéressait au projet et dans quelle direction aller ensuite. Avant de promouvoir ma librairie, j’ai créé un README dans le repository GitHub, avec des informations sur les objectifs de la librairie et un petit guide d’utilisation.
Les premiers utilisateurs
J’ai décidé de chercher mes premiers utilisateurs sur Reddit. Après avoir trouvé plusieurs communautés adaptées, j’ai écrit un bref post intitulé « Open Source C# Library for Handling Keyboard/Mouse Events in Windows UI Apps ». C’était un peu stressant, et honnêtement, je ne m’attendais à aucun résultat significatif. Mais étonnamment, ça a payé. L’un des posts a fait environ 14 000 vues et environ 30 commentaires positifs. C’était un sentiment incroyable que je souhaite à tout le monde de vivre : la réalisation que le temps passé sur le projet n’a pas été en vain. Je n’avais pas créé quelque chose de révolutionnaire, mais j’ai compris qu’il y a des gens qui trouvent ça vraiment utile et qui sont prêts à soutenir mes efforts.
Après avoir rassemblé tout le feedback, j’ai décidé de continuer le développement et de garder le contact avec les utilisateurs les plus intéressés qui avaient commenté. Je communiquais activement avec eux et écoutais leurs demandes de fonctionnalités. Le mois suivant, j’ai sorti plusieurs petites updates puis je me suis recentré sur l’attraction d’utilisateurs.
Sur GitHub, il existe un type spécial de repository appelé « awesome », ce sont des collections de liens et de ressources rassemblées par sujet, par exemple awesome-dotnet. Mon objectif était de promouvoir ma librairie dans chacun de ces repositories. Même si ce n’était pas facile, une librairie avec 10-15 étoiles sur GitHub n’attire pas beaucoup d’intérêt, j’ai quand même réussi à entrer dans plusieurs d’entre eux. Cela a significativement augmenté le trafic et attiré l’attention sur mon projet.
La contribution de la communauté au développement
Au fur et à mesure du développement, j’ai rencontré beaucoup de petites tâches que je n’avais parfois ni l’envie ni l’énergie de terminer. Du coup, j’ai décidé de profiter d’un des avantages du développement open source : attirer des passionnés prêts à aider sur ces tâches. Pour ça, je me suis tourné vers le service Up-for-Grabs, qui fournit une liste de repositories open source avec des issues actives pour ceux qui veulent contribuer. Après avoir ajouté mon repository et créé plusieurs issues, j’ai immédiatement reçu des propositions d’aide.
Quand ma librairie a été téléchargée plus de mille fois, j’ai décidé de travailler activement sur la documentation. Depuis la première update, la fonctionnalité de la librairie avait significativement augmenté, et les exemples dans le README ne suffisaient plus. Parmi toutes les options possibles, j’ai choisi la plus simple et la plus accessible : j’ai créé un fichier Markdown séparé et détaillé toutes les classes proposées par la librairie. J’ai aussi décidé d’écrire un petit guide pour les utilisateurs avancés qui veulent profiter pleinement des capacités de la librairie. À ma surprise, un mec spécialisé dans la rédaction de documentation technique m’a contacté pour proposer son aide. Il m’a aidé à structurer correctement le matériel et à décrire avec précision tous les détails. Avec son aide, on a rapidement bouclé cette tâche.
Le développement open source est une excellente opportunité de rencontrer d’autres programmeurs et d’élargir son network. À ce jour, neuf personnes de différents pays ont contribué à la librairie, dont les États-Unis, l’Australie, l’Argentine, le Canada, l’Allemagne, la Pologne et d’autres. Ils ont aidé à écrire de la fonctionnalité, des unit tests et de la documentation. En plus, ça a été un superbe échange d’expérience et une communication agréable. Peut-être qu’avec certains des contributeurs on pourra démarrer un nouveau projet ensemble.
Malgré un travail et d’autres engagements, je veux continuer le développement et sortir une version complète avec les fonctionnalités qui, à mon avis, devraient être incluses dans la librairie. Dans mes plans futurs : la rendre cross-platform et la découpler de frameworks UI spécifiques.
Conclusion
Pour conclure, je voudrais résumer tout ce que j’ai dit. N’aie jamais peur d’essayer quelque chose de nouveau et ne reste pas immobile. Si tu aimes vraiment la programmation et que tu veux grandir en tant que développeur, efforce-toi de créer quelque chose à toi, que ce soit une petite librairie ou un service. Tu ne sais jamais où ça peut te mener. Tout au long du développement de cette librairie, j’ai trouvé de la joie non seulement à programmer, mais aussi à rencontrer des gens et à créer de nouvelles connexions. Je prévois de continuer à m’impliquer dans l’open source, pas seulement en faisant avancer mes propres projets mais aussi en contribuant aux librairies de la communauté, c’est aussi une super expérience.
Si l’histoire t’a plu, je te serais reconnaissant de soutenir la librairie avec une étoile sur GitHub !
Open source 不仅仅是发布代码，它关乎产生影响、在公开场合学习、与社区建立联系。在这篇文章里，我会讲讲自己做一个 open source 库的过程，并告诉你为什么这是作为开发者最值得做的事情之一。
缘起
春天的时候，我看 Yegor Bugaenko 的一个直播，被 open source 这个想法点燃了。Yegor 说，如果你想超越普通开发者，成为更有市场、更独特的专业人士，就需要做点属于自己的东西。无论是一本书、一个博客、一个库，甚至是一个框架，这种项目可以让你在众多开发者中脱颖而出，尤其在当下的 IT 市场。这不仅展示你的专业性，也展示你对这个领域真正的投入。
这些都让我开始反思：怎样才能在其他开发者中真正凸显出来？尽管我在 IT 行业工作多年、参与过各种项目，我依然没有什么属于自己的东西，那种能展示我的独特和专业的东西。
寻找点子
我翻了翻自己 GitHub 上的旧 pet 项目，很快意识到没有一个是真正有分量的。所以我决定从零开始，做点新的东西。带着满满的动力和热情，我开始想能写点什么东西，让它至少在小范围内有需求，同时又匹配我的技能。
我花了两三天分析自己这个 open source 项目的点子。想得越多，越觉得好像所有东西都已经被写出来了，而那些还没实现的东西，一个人也搞不定。先说一句：这是一种很有迷惑性的视角，别让它毁了你的潜力。是的，已经有很多东西被创造出来了，但这不是你放弃做自己东西的理由。
我来解释一下为什么：
你总有机会抓住一个趋势，做出一个工具或服务，让它快速变得流行。比如 COVID-19 大流行期间，出现了一批提供实时感染统计和最新新闻的网站。现在我们看到的是 AI 服务的趋势，它还在持续增长。要做的，就是抓住时机，提出在那个时期被需要的解决方案。
在那之前一个月，我在做一个 Windows 桌面应用时，遇到一个需求，要监听键盘按键去触发某些操作。关键的一点是，不管我们的应用是否处于活动状态，它都要能工作。当时没有现成的解决方案，所以我用了原生的 P/Invoke 调用，顺利达到了目标。当时我没想到其他开发者可能也会遇到这个问题，而一个解决这个问题的小库可能会相当有用。
一旦功能集敲定，我就充满热情地开始写代码。代码本身写起来不算特别难，但我注重它的结构和清晰度，让其他开发者能轻松看懂为什么这么写。开发过程中我做了几次全局重构，调整组织结构、改名、把代码抽到独立的类里。我特别注意把平台相关的代码（因为未来计划做成跨平台）和库本身的代码分开，这样以后脱离 P/Invoke 时就不用整体改写代码。我也花时间加了 XML 注释，方便库的使用者理解每个方法或类的作用。
Open source 开发是一个认识其他程序员、扩展 network 的绝佳机会。目前为止有九个人为这个库贡献过代码，来自不同国家，包括美国、澳大利亚、阿根廷、加拿大、德国、波兰等。他们帮忙写功能、单元测试和文档。除此之外，这也是一次非常棒的经验交流和愉快的沟通。说不定我能和某些贡献者一起开始一个新项目。
最后我想总结一下前面说的内容。永远不要害怕尝试新东西，不要原地踏步。如果你真的热爱编程，并想作为开发者继续成长，就努力做点属于自己的东西，无论是一个小库还是一个服务。你永远不知道它会把你带到哪里。在做这个库的过程中，我不仅在编程里找到了乐趣，也在认识新朋友、建立新联系中获得了快乐。我打算继续参与 open source，不仅推进自己的项目，也给社区的库做贡献，这同样是非常棒的经历。
Discussion