The Linux kernel is one of the largest and most active open-source projects, but its massive codebase and unique development culture create a high barrier to entry for newcomers. While many guides focus on the technical methodology of sending the first patch (like using git send-email), beginners often feel lost about how to build expertise and contribute sustainably afterward.

I propose to present a beginner's contribution guide focused on the Linux kernel security domain within the Operating Systems and Distributions track. This talk will be based on existing materials (e.g., LKCamp tutorials and DebConf etherpad notes) but will be enhanced with practical tips from my own experience in kernel security activities, reframing the discussion using the security subsystem as a case study for analysis and participation. The format will be a Lightning Talk covering how to overcome beginner hurdles, analysis methods, and engagement strategies, emphasizing the use of the staging tree and security-related TODO lists.

This presentation targets beginners who want to contribute to the Linux kernel but don't know where to start, or those who are wondering about their next steps after their first contribution.

This session guides those new to Linux kernel development through the introductory process. It provides step-by-step explanations, from building foundational knowledge (C language, OS concepts, Git) and setting up the environment (email client, using the checkpatch.pl script), to analyzing unfamiliar subsystems (researching security papers/conference materials, tracking Git history), and making initial contributions (bug reports, code reviews, patch submissions). Drawing from my own experience starting with curiosity in the security domain, I will share tips on building expertise and emphasize practical strategies like monitoring mailing lists and leveraging conference materials (e.g., Linux Plumbers Conference). The content is designed to minimize the confusion beginners face and encourage an enjoyable journey.

Part 1: The Hurdles Beginners Face (What Stops Us?)
* High Barrier to Entry: The need for extensive background knowledge (OS, computer architecture) and the importance of patience.
* Getting Used to the Kernel Environment: Understanding fundamental kernel behaviors like execution context and synchronization mechanisms.
* The First "Real" Contribution:
* Quick review of the development process documentation (Documentation/process).
* Summary of technical procedures: using checkpatch.pl, get_maintainer.pl, and setting up git send-email.
* The meaning and limitations of contributions like coding style fixes or working in drivers/staging.
* "Now What?": The inevitable wandering after the first contribution. Shifting the perspective from "What should I do?" to "What do I want to do?"

Part 2: How to Analyze an Unfamiliar Subsystem (Without Starting from Scratch)
* Design Before Code: Understanding the subsystem's purpose and the big picture first.
* Efficient Research: How to use kernel documentation, related academic papers, conference presentations (LPC, LSFMM), and technical blogs.
* The Latest Code is Too Complex: Strategies for reducing complexity during analysis.
* The Power of History Tracking: Starting with the simpler, initial versions of the code and following the git history and mailing list archives (lore.kernel.org) to understand the context of changes.

Part 3: Contributing to Kernel Development is Not Just About Coding
* Diverse Roles in the Community: Understanding different contribution methods (maintainer, reviewer, developer, bug reporter) and strategic positioning.
* Benefits of Starting as a Reviewer:
* Learning the latest technical trends by reading others' code.
* Code reviewers are always in short supply: A way to gain expertise while naturally contributing to the community.
* Tracking Trends: The importance of monitoring mailing lists, tips for using email clients efficiently (e.g., mutt), and leveraging news sites like LWN.net.

Conclusion:
* Enjoy the journey of kernel contribution.