Week Zero: Getting Prepared for Turbin3 Builder's Intensive Journey

Shortly after submitting our final project for the Ackee School of Solana, discord user, Apollo Surfer created a group chat to prepare us for the Turbin3 Builder’s Program; It is worth noting that our results for Ackee were yet to come out then — that shows the confidence and grit found in this community — truly inspiring!

Thankfully, we all came out strong; & those who had problems resolved them quickly;

It's been three long weeks since then. Christmas holidays came and are now long forgotten. Heck, we are in a new year. So happy New Year to everyone reading this. Today, the much-awaited Turbin3 Builder’s Program commences. It’s a stark reminder that time keeps marching on, and so we must too;

Building the Future of Solana, Together

After hearing so much about the program and its reputation for excellence, I knew this was a crucial step in my Web3 journey. So I started searching for help;

Shortly before 2024 ended, I had a brief chat with Jeff, Turbine’s CEO - basically the organizer…here’s what he said: 'Turbin3 isn't just another course - it's an intensive builder's journey that will transform how you think about blockchain development.'

When I asked for pointers, he emphasized the importance of understanding the fundamentals deeply and being ready to dive into real-world applications. “The program isn't about theoretical knowledge - it's about building, breaking things, and learning from the process”, he says.

Lastly, his hint on what could be a helper:

My findings from sieving through past discord conversations

A few days ago, instead of mindless scrolling on Twitter, I decided to spend my time on their discord server, so I went to the oldest message and kind of read through, what became clear patterns of success and growth.

The following is what I discovered:

1. They were asked to read PaulX Escrow Tutorial Program. It serves as an introduction to Solana program development using pure Rust without any frameworks. While intimidating at first, the goal isn't to master every concept—it's more like a rite of passage to familiarize yourself with the fundamentals. The main objective is getting the code to compile, even if you don't fully grasp every detail yet.

2. A Capstone Project that focuses on core concepts: PDAs, Ownership and Authority - these fundamentals will be our building blocks for creating robust Solana programs. From my understanding, the overall goal here is to build a useful product that will bring Solana and web3 to the masses;

Resource Spotlight

Top 3-5 resources that helped me this week:

1. Introduction to Blockchain and Web3 by EDX→ This course was first recommended to me by a friend, and since taking it I’ve recommended it to anyone who cares to ask me about Blockchain

2. PaulX Escrow Program → A foundational example demonstrating core Solana concepts in action. The program showcases proper account management, security considerations, and state handling - essential patterns for any Solana developer.

3. Solana Developer Bootcamp Videos → I saw this course on YouTube shortly after I got into Ackee, but I couldn’t go through it, I had a skim through it; It’s very condensed and intensive. No surprise that Jeff also recommends it: You can follow them here, and here;

4. Rust + Solana for Beginners → This one was also recommended by a friend, Apollo Surfer this time. He recommended it over the weekend after I shared a draft of this post with him, the first few chapters I took look rock solid compared to other courses I’ve taken on similar subjects. Besides, if Apollo recommends it, no more additional thoughts; Just do it!

5. Rust Handbook → When we did Turbine, one of the Instructors who was a Turbin3 Alumni hinted at reading the first 12 chapters of this guide. While I’ve only read the first 9 chapters, I will be hoping for the next 3 chapters. H/T to Chiamaka for reminding me.

My Plans for Turbin3 Tuesday Times

It should roughly be around a thousand words; so at most 4-6 minutes of reading through to quickly catch up and it will contain 5 sections, namely:

1. Technical Deep Dive:

   Each week, I'll break down one core concept we've covered, making it digestible for fellow builders. Expect clear, practical insights, whether it's understanding PDAs or mastering program architecture. We will also touch on Key implementation Insights and highlight common pitfalls and solutions.

2. Code Snippet of the Week

   I’ll include a relevant code snippet that illustrates an important concept or solution in this section. Let’s take PaulX tutorial for example, here’s my dissecting his Escrow definition in state.rs.

    pub struct Escrow {
        /// Tracks if this escrow account has been initialized
        pub is_initialized: bool,
   
        /// The public key of the account that started this escrow (Alice)
        pub initializer_pubkey: Pubkey,
   
        /// The public key of the temporary token account holding Alice's tokens
        pub temp_token_account_pubkey: Pubkey,
   
        /// The account that will receive Bob's tokens
        pub initializer_token_to_receive_account_pubkey: Pubkey,
   
        /// The amount of tokens Alice expects from Bob
        pub expected_amount: u64,
    }
   
    impl Pack for Escrow {
        // Size in bytes: 1 (bool) + 3 * 32 (Pubkey) + 8 (u64) = 105 bytes
        const LEN: usize = 105;
   
        /// Unpacks a byte buffer into an Escrow instance
        fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
            // Take a reference to the first 105 bytes of the source data
            let src = array_ref![src, 0, Escrow::LEN];
   
            // Split the 105 bytes into separate sections using array_refs:
            // - 1 byte for is_initialized
            // - 32 bytes each for the three pubkeys
            // - 8 bytes for the expected_amount
            let (
                is_initialized,
                initializer_pubkey,
                temp_token_account_pubkey,
                initializer_token_to_receive_account_pubkey,
                expected_amount,
            ) = array_refs![src, 1, 32, 32, 32, 8];
   
            // Convert the is_initialized byte into a boolean
            let is_initialized = match is_initialized {
                [0] => false,
                [1] => true,
                _ => return Err(ProgramError::InvalidAccountData),
            };
   
            // Construct and return the Escrow struct
            Ok(Escrow {
                is_initialized,
                initializer_pubkey: Pubkey::new_from_array(*initializer_pubkey),
                temp_token_account_pubkey: Pubkey::new_from_array(*temp_token_account_pubkey),
                initializer_token_to_receive_account_pubkey: Pubkey::new_from_array(*initializer_token_to_receive_account_pubkey),
                expected_amount: u64::from_le_bytes(*expected_amount),
            })
        }
    }
   

3. Resource Spotlight

   Top 3-5 resources that helped me during the week. It will follow the structure [Resource Name] - Brief description of why it's valuable just as we saw earlier. Submissions are always welcome for this section; plus adequate credit will be given. We are all here to learn and grow;

4. Community Corner [Fellow Builder Highlights]

   Fellow Builder Highlights Each week, I'll spotlight innovative approaches and clever solutions from our cohort, fostering a collaborative learning environment.

5. Community Corner [Notable Discussions]

   The most impactful conversations from our Discord and Twitter communities are distilled into actionable insights for those who don’t like the Discord scrolling through and whatnot. Working groups have been created for more synchronization – the only unfortunate part is there are Alpha, Beta, Charlie, and Delta groups but there’s no Easy Company (if you know what I mean).

   

How You Can Contribute

1. Share Your Learning Journey: Document your experiences, challenges, and solutions. Your insights could be invaluable to fellow builders facing similar obstacles.

2. Mentor New Builders: If you're experienced in certain areas, consider mentoring newcomers. Even sharing small tips can make a significant difference.

Looking Ahead

As we progress through Q1 2025, our focus remains on building robust, secure, and innovative solutions on Solana. I hope that the Demo Day won’t just be a presentation but instead a celebration of our collective achievement and growth as builders.

Get Involved

Join our community on Discord;

Remember, every great project starts with a single line of code. Let's build something amazing together.

Happy Building!

Daniel Asaboro;

---

This newsletter is part of our commitment to fostering a strong, supportive community of Solana builders. Together, we're not just building programs - we're building the future of decentralized applications.