Brittbot

Author: Brittany Gates

  • Reading “Grokking Algorithms”

    Reading “Grokking Algorithms”

    I started Phase 1 of the Software Engineer roadmap Gemini created for me by reading “Grokking Algorithms” by Aditya Bhargava. I bought the book from Amazon a few weeks ago, and after reading the first four chapters and completing the exercises I want to give a partial review.

    So Far Reading “Grokking Algorithms” Is Easy

    I’ve read several different programming books this year and reading “Grokking Algorithms” has been one of the easiest. The writing style is concise, but packed with great information. With the combination of the drawings for the various topics I’m able to learn about Binary Search and Quick Sort faster. That’s the main reason why Bhargava wrote the book. He said learning about algorithms is tough enough, and many of the books about the topic don’t make learning it easier. I’m fine with learning from text-only books because I have a great imagination and can picture the words and topics in my mind. Yet, with the easy reading style I don’t have to “think” as hard.

    So Far Reading “Grokking Algorithms” Is Fun

    It’s fun reading this book! Not only do I like the writing style, but the drawings are fun and fit well with the different topics. The drawings aren’t distracting, but they aren’t low-quality either. Finally, I like the exercises throughout each chapter. Those aren’t incredibly easy so I feel I’m not learning anything. Nor are they so difficult that I give up and feel dumb. As each chapter progresses the difficulty ramps up gradually. Those reasons are why I think the book is fun.

    The Book Finally Helped Me Understand Recursion

    Like many students I find recursion difficult. I tried different learning methods and media to understand it, but I couldn’t. I knew why programmers used it, but since I couldn’t get it to work in my code properly I decided against using it. So when the chapter about recursion came I was a little nervous, as I remembered my past failures. Yet, this book helped me understand why recursion is important in certain applications, and how to use it properly in code. Grokking Algorithms taught me how recursion uses the Call Stack to operate, and using the debugger in PyCharm I got to see that in action. Now I don’t feel any nervousness about recursion.

  • Google Fullstack Software Engineer Roadmap Created By Gemini

    Google Fullstack Software Engineer Roadmap Created By Gemini

    I am in the part of my journey to upgrade from a Data Center Technician at Google to a Software Engineer in the company where I need a detailed roadmap. I used the website Developer Roadmaps and found it lacking. However, that’s a free source so I won’t complain too much. Since I use Gemini for many other tasks, I decided to ask for it to give me a Google Fullstack Software Engineer Roadmap. And it did! In today’s post I’ll review what the LLM created and my study plan.

    Gemini’s Google Fullstack Software Engineer Roadmap

    First, I like Gemini’s introduction to its roadmap for me:

    Here is a comprehensive roadmap designed to help you transition from your current tech stack and personal project experience to an L3 Fullstack Software Engineer role at Google, with a strong focus on areas critical for success in their interview process.

This plan emphasizes not just learning new technologies, but also solidifying core computer science principles and adopting best practices in software development.

    I need to explain what the “L3” means. It’s the entry-level role for a Software Engineer (SWE) at Google. This role requires usually 0 to 1 years of professional experience.

    Gemini’s approach to creating a roadmap for me is in three phases spanning a matter of months:

    • Phase 1: Foundational Strengthening (Estimated: 2-4 Months)
    • Phase 2: Fullstack & System Design Enhancement (Estimated: 3-5 Months)
    • Phase 3: Software Engineering Best Practices & Interview Prep (Estimated: 2-3 Months, Ongoing)

    Let’s review each phase in more detail.

    Phase 1: Foundational Strengthening (Estimated: 2-4 Months)

    The first phase in the Google Fullstack Software Engineer Roadmap is “about building a rock-solid foundation, especially in areas Google heavily emphasizes” according to Gemini.

    In this phase are three topics I’ll cover:

    1. Algorithms & Data Structures (The Most Critical Area)
    2. Unit Testing & Test-Driven Development (TDD)
    3. Deep Dive into Python

    I’m glad learning about algorithms and data structures is the first topic because I feel it’s the right time in my studies to do so. Although Gemini suggested I use some Coursera courses to learn this (such as “Algorithms, Part I & II” by Princeton University) I’m going to use the second edition of “Grokking Algorithms” by Aditya Bhargava. I learn better through reading (which I wrote about previously on my blog). However, I will follow the LLM’s plan to practice on LeetCode and HackerRank.

    As for Unit Testing I’ll spend time reading the official documentation that Gemini told me to read. I’m not sure if I want to buy a book about that. I may watch a few videos and see how I get along. Basically I need to learn the following:

    • Testing Frameworks: unittest and pytest for Python.
    • Assertions: Understanding common assertion methods.
    • Test Fixtures: Setting up and tearing down test environments.
    • Mocks & Stubs: Isolating components for testing.
    • Code Coverage: Tools and importance.
    • TDD Principles: Write tests before code.

    Finally, to get better at Python I will purchase the “Fluent Python” book by Luciano Ramalho. Gemini suggests I dive deeper into the language by learning all of this:

    • Advanced Data Structures: collections module (e.g., deque, Counter, defaultdict), heapq.
    • Generators & Iterators: Understanding lazy evaluation.
    • Decorators & Context Managers: How to create and use them.
    • Metaclasses (Basic Understanding): How they work at a high level.
    • Concurrency & Parallelism: threading, multiprocessing, asyncio.
    • Object-Oriented Programming (OOP): Deeper understanding of classes, inheritance, polymorphism, design patterns.
    • Performance Optimization: Profiling code, using cProfile, understanding GIL.

    Is the estimated duration of two to four months doable for me? Yes, if I dedicate myself everyday with at least two hours a study time.

    Phase 2: Fullstack & System Design Enhancement (Estimated: 3-5 Months)

    The second phase in the Google Fullstack Software Engineer Roadmap “focuses on broadening your fullstack capabilities and introducing system design concepts” according to Gemini.

    In this phase are two topics I’ll cover:

    1. Modern Frontend Development
    2. Advanced Backend Concepts & System Design

    Frankly, this going to be a new change for me because I’m so used to using Bootstrap. I told Gemini of my current tech stack, and it told me it’s time for an upgrade:

    • JavaScript (ES6+): async/await, Promises, Modules, Destructuring, Spread/Rest operators, this keyword, closures.
    • Framework: React.js (Highly Recommended for Google), Angular, or Vue.js. Focus on one and master it.
    • Component lifecycle, Hooks (for React), State Management (Context API, Redux/Zustand for React).
    • Routing (React Router).
    • Component libraries (e.g., Material-UI, Ant Design, or Shadcn UI if using React with Next.js concepts).
    • Build Tools: Webpack/Vite (basic understanding).
    • CSS-in-JS/Tailwind CSS: Modern styling approaches.
    • Responsive Design: Beyond Bootstrap, understanding Flexbox and Grid.
    • Accessibility (A11y) & Performance: Best practices.

    Instead of learning React.js, I’m going to learn Angular since Google created that framework and uses it on internal (and some external) applications. Everything else I’m fine with learning.

    As for the backend Gemini gave me this:

    • Flask Mastery: Dive deeper into Flask extensions, blueprints, context, custom decorators, error handling.
    • Relational Databases (PostgreSQL):
    • Advanced SQL: Joins, subqueries, window functions, indexing, optimization.
    • Database Design: Normalization, denormalization, schema evolution.
    • ORM: Deeper dive into SQLAlchemy.
    • NoSQL Databases (Basic Understanding): When to use them (e.g., Redis for caching, MongoDB for flexible schemas).
    • RESTful API Design: Best practices, idempotency, versioning, authentication/authorization (OAuth2, JWT).
    • Microservices vs. Monoliths: Understanding trade-offs.
    • Caching: Strategies (client-side, server-side, CDN).
    • Message Queues: Basic understanding (e.g., Celery with RabbitMQ/Redis for background tasks).
    • Load Balancing & Horizontal Scaling: Basic concepts.
    • Monitoring & Logging: Tools and principles.

    Again, this is so much to learn. Which is why I think it’ll probably take me closer to five months to learn instead of three months.

    Phase 3: Software Engineering Best Practices & Interview Prep (Estimated: 2-3 Months, Ongoing)

    The third phase in the Google Fullstack Software Engineer Roadmap “focuses on polishing your engineering skills and specifically preparing for Google’s interview loop” according to Gemini.

    In this phase are two topics I’ll cover:

    • Software Engineering Best Practices
    • Google-Specific Interview Preparation

    This phase is heavy on developing the normal workflows for SWEs (such as using Git and going through Code Reviews), along with interview preparation. This phase is last, and I think it should be in my study plan because this is good to learn a month or two before starting interviewing. Thus, I’m not going to start on Phase 3 until probably Q2 of 2026.

    My Final Verdict On Gemini’s Google Fullstack Software Engineer Roadmap

    Overall, I’m happy with the road the LLM provided. I exported the plan into a Google Doc which resides in my Google Drive. Thus, I have access to it where I go. I also had the LLM add check-boxes to each action item in each topic so I can mark them off as I learn them.

    My start date will be the middle of this month (July). I’ll post updates on my blog.

  • Returning From Break

    Returning From Break

    I’m returning from break to writing blog posts again! While I missed providing new content for my readers, the nearly four months away did help with my hectic schedule. I’ll explain what I accomplished during my break, along with my new posting schedule.

    What I Accomplished While On Break

    • Stopped reading Algorithms Illuminated Part 1: The Basics by Tim Roughgarden because it was too advanced for me. Instead, I need to start with a book about the basics of algorithms. (However, I was able to create my own version of the Karatsuba Multiplication Algorithm which is available to download from my GitHub repo.)
    • Did a deep-dive about Bootstrap’s Utilities, and implemented those changes on all three of my Web Apps.
    • Refreshed my JavaScript skills using MDN Web Docs to fix some of the Front-End issues with my Web Apps. You know, addEventListener is a pretty nifty tool. So is document.querySelector.
    • Revisited Nodejs and Express because I wanted to recreate my Web Apps in JavaScript. Only completed one conversion before I got fed up with server-side JavaScript and went back to Python.
    • Improved my knowledge of Flask by learning about Blueprints and implementing those in my Web Apps.
    • Started building a blogging website, but realized I needed to refresh my database skills.
    • Learned PostgreSQL by reading Practical SQL by Anthony DeBarros. (I highly recommend this book!)
    • Got the idea to create a CLI To-Do list using PostgreSQL as the database.
    • Read the documentation about argparse and Psycopg for a long time (probably hours).
    • Created TaskDB using my new argparse, Psycopg, and PostgreSQL skill-sets.
    • Used Gemini a bunch to refine my code, ask questions, and learn new programming techniques.

    As you can see and read as I’m returning from break I was quite busy in my self-study endeavors. I thought about writing all the stuff I learned and did at work, but some of it I can’t talk about so I decided against it. Just know that I was quite busy there too as I had various projects regarding network equipment and/or fiber to deploy and/or audit. Google needs more Trillium Tensor Processing Units (TPUs) since users love Veo 3 and Flow.

    My New Posting Schedule

    Although I’m returning from break, I’m still busy at work. In addition, I haven’t let up from my self-study since I still want to get a Software Engineering job. Yet, I won’t let that stop me from posting new content on this website. I’ll just post a new post (or two) every Monday at 6 AM EST.

  • Taking A Break

    Taking A Break

    I’m taking a break from new posts on my blog for an uncertain time period. That’s the reason why I haven’t posted anything new since March 6th.

    Reasons Why I’m Taking A Break

    The main reason I’m taking a break from posting new content on my website is due to an increased workload at my job. I knew this was coming since late last year. January was the start date for the additional workload, but various delays pushed the date back. February passed with more delays. Then in March we had a new start date, but more problems arose. Thus, the new projects my team and I have to work on started this week. I already worked overtime the past two weekends trying to get one particular high-priority project completed. Thankfully we’re almost done.

    The other reason I’m taking a break from posting new content is that I’m deep into learning right now. I finished reading Think Python by Allen B Downey and completed some of the exercises in the book. It’s a great book and I highly recommend it to anyone seeking to improve their Python programming skills beyond the beginner level. I thought about writing a review, but I decided against it due to time constraints.

    After that I completed the tutorial on the Flask website to creating a blog website. I’ve wanted to create my own blog website, which is why I completed the tutorial. I started on it, but it’s no where near completion.

    That’s because I got an idea to practice web scraping with Python using the Requests and BeautifulSoup modules. After multiple hours of reading those modules’ documentation, and practicing in PyCharm, I created the design to scrape the latest winning lottery numbers for my web app Click-Go-Lotto. I deployed the new feature this past weekend. Go check it out!

    Finally, I started learning about algorithms. I’m reading Algorithms Illuminated Part 1: The Basics by Tim Roughgarden. This is going to be a slow-read for me since I haven’t dealt with knowing or using algorithms before. Thus, I’m taking notes in my notebook. This helps me to retain and understand the information better.

  • Becoming A Junior Developer Who Can Code

    Becoming A Junior Developer Who Can Code

    I finally read the viral blog post that came out almost a month ago about how the newest junior developer can’t code. The author, using his own experience at his current place of employment, wrote about his displeasure seeing how these developers rely too much on coding tools like Cursor and/or Copilot. Others use ChatGPT or Claude to get their code snippets and perform their job. As a budding developer myself I rather not develop a crutch on AI tools. Thus, I avoid using those tools as much as possible. Here’s how I’m becoming a junior developer who can code.

    Briefly Explaining The Author’s Position

    The way I understood the author’s position in his post is like this:

    1. He doesn’t like how the junior developers he works with rather type in a prompt to ask for the code fitting certain requirements instead of trying to code it themselves.
    2. When these developers run into an issue with the AI-generated code, the author doesn’t like how they used the AI tools to seek a solution instead of trying to solve the problem themselves.
    3. Thus, these developers avoid the struggle of writing and/or debugging code so they don’t learn. Hence, they don’t know how to code.

    How I’m Becoming A Junior Developer Who Can Code

    First, when it comes to my Integrated Developer Environment (IDE) I don’t use any AI assistants like Cursor or Copilot. Of course I get notifications from my IDE trying to persuade me to use them (PyCharm and VSCode), but I ignore them. What I do instead is design my application using pen and paper. I write out the logic flow and a little pseudocode. Designing this way really helps me understand my objective, find any potential problems, and create solutions.

    Second, I write the code, test it out, and debug it if it fails. If I mess up my logic, then writing it out again as laid out in the IDE to compare it to my initial design really helps me find the logic flaw. Sometimes I’ll talk out loud as that helps me too.

    Third, if I get stuck during the debugging process I use Google Search for a hint. Usually that helps me get going as I can figure out the rest of the solution to my problem. Then it’s back to writing code, testing it out, and debugging if needed.

    Finally, if the hint doesn’t help me I’ll use Gemini and ask it to explain to me why my code doesn’t work. When it provides a working solution I read through the explanation to learn where I went wrong. If the explanation confuses me I ask Gemini to explain it a different (or simpler) fashion. It usually does.

    Conclusion

    Becoming a junior developer who can code is fun, but also frustrating. The struggle to write functioning code, or debug non-working code, is tough. Sometimes it just suck. However, the feeling of finally fixing it makes the struggle worth it. And in the future I’ll know how to resolve that issue faster because I already dealt with it. By allowing an AI assistant or tool to do my work for me only cheats myself of becoming a competent code.