Aaaand, I’m back!

Time's certainly flown in the past few months. Now that things have calmed down a bit, I'm thrilled to reconnect and share more about my ongoing coding journey. I last left you on May 15th, so let's get you caught up. Here's a quick rundown/TL;DR:

1. I graduated from Rithm School

2. Took a trip to Spain

3. Began part-time work as an engineer at Smol AI

4. Currently scouting for full-time engineering opportunities

5. Now, free to catch up over coffee! Let's chat.

Subscribe now

Rithm Recap

Mid-June marked the end of my time at Rithm School. And while I still keep in touch with many of my classmates, and it's been a unique shift transitioning from student life to a more independent routine. 

Graduating from Rithm wasn't just a milestone, it was a massive leap in my coding journey. The extensive learning packed into those 16 weeks was intense, and I'm proud of the progress I made.

In a recent LinkedIn post after graduation, I shared my Rithm by-the-numbers:

• → 251,495 lines of JS and Python code in class-related work

• → 696,925 lines of JS and Python code in personal projects

• → 1,806 commits in 83 repositories

• → 231h 48m in my programming notes app

• → 173h 31m in VS Code

• → 56h 42m in ChatGPT

• → 29h 38m in the terminal

• → 3 frontend + backend web apps built and deployed

• → 14 15 email newsletters sent (and counting!)

Starting Small at Smol AI

As you may know, I've started working with Swyx at Smol AI as a part-time contractor. The hands-on experience with production code and a fantastic team of engineers has been phenomenal. 

Smol AI is part of Vercel’s first AI Accelerator cohort, which connects us with an exceptional community of AI Engineers shaping the future with cutting-edge models and tools.

Keep tabs on my LinkedIn or Twitter for updates on the Smol Menubar, an LLM aggregator project I've been refining:

I'm planning a detailed post about refactoring Menubar. It's been a real-life lesson on how coding principles like encapsulation and polymorphism improve scalability, extensibility, and maintenance.

Job Hunt

Outside my work at Smol AI, I'm also actively seeking full-time software engineering roles. The job market in the Bay Area is showing promising signs after a challenging start to the year. 

I'm taking my time, ensuring I bring my A-game to each application, while also building a portfolio showcasing my work across a diverse set of technologies.

If you come across any roles in the Bay Area that might align with my skills and aspirations, please feel free to share. I'm always eager for opportunities to grow within a team.

Well, that's all for now! You can expect more frequent updates, and please don't be a stranger if you fancy a tech chat.

Subscribe now

One that’s getting a particularly high degree of attention is LangChain, a library that makes it easy to connect with other LLM providers’ (e.g. Anthropic, Cohere, GPT4All, etc.) APIs and even chain them together in a standardized way with integrations into vector-based DBs like Pinecone.

For this first test, I built a simple Tic-Tac-Toe game to see if the LLM would be smart enough to beat me in this strategically very simple game.

Sadly after a few dozen tests with both Open AI’s GPT 3.5-Turbo and Anthropic’s chat completions API, both models were failing miserably:

I did a bit of sleuthing and found a number of online discussions about ChatGPT’s deficiency when it comes to playing this simple game. Without going too deep, the reason why appears to have a lot to do with the activity LLMs are specifically trained to do: predict the next most logical word to follow a given set of words. Playing a game, even one as simple as Tic-Tac-Toe, is a fundamentally different activity.

While it was disappointing GPT wasn’t going to be suited to solve this particular problem, I was pretty excited to find that tic-tac-toe is a simple enough game that every possible move can actually fit nicely into a tree data structure.

Working with a tree like this is something that comes up often in technical interviews for engineering roles, but comparatively comes up far less often in the role itself (depending on your focus). As such, I like many aspiring professional engineers, have spent many evenings studying these data structures and strategies for traversing them efficiently. But I’ve always struggled with figuring out what a realistic, real-world application of this knowledge would look like.

It turned out that my struggle ended in one of the least likely places: a game of tic-tac-toe.

In the tree above, you have 9 possible board positions for the first move, eight for the second move, seven, and so on. So the overall number of combinations could be represented as 9! or 362,880 total possible nodes in a fully expanded tree. But this ignores the fact that the game is often over before all 9 squares are filled. So if you end each branch at the “terminal” move, you’re left with 26,830 total nodes, a completely manageable number for a computer to process.

So, what’s the best way to navigate this tree of possible Tic-Tac-Toe game states? Enter: the Minimax algorithm.

The Minimax algorithm is a recursive method used for decision making in game theory and artificial intelligence. The principle is simple: it's all about minimizing the worst-case scenario. In the context of Tic-Tac-Toe, this means that we assume that the opponent will always make their best possible move.

For every possible move, we play it out to the end (the "terminal" move), scoring the outcome. We give a high score if our AI wins, a low score if it loses, and a middling score if it's a draw. We then work our way back up the tree, choosing the highest (max) score if it's the AI's turn, and the lowest (min) if it's the opponent's. This is the "minimax" part of the algorithm.

Let's illustrate this with some Python code:

Note: The evaluate(board) function in this snippet a separate part of the implementation that evaluates the current state of the board and returns a score.

Here, we're using a 3x3 matrix (list of lists in Python) to represent our Tic-Tac-Toe board. We assign a score of 10 to a winning move for the AI, -10 for a winning move for the opponent, and 0 for a draw or non-terminal move.

The isMaximizingPlayer parameter is a boolean that we flip at each depth level to represent whose turn it is. When it's the AI's turn, we want to maximize the score, and when it's the opponent's turn, we want to minimize the score.

The depth parameter is initially the number of empty cells and decreases as we make more moves. It's used as a simple way to stop the recursion when all cells are filled. 

This function recursively calls itself, playing out every possible game until it hits a terminal state or reaches maximum depth. It then evaluates the board, choosing the path that maximizes the AI's minimum gain.

To decide the AI's move, we'd simply call the minimax function for each possible move and choose the one that returns the highest score.

Originally, I was aiming to create an AI-enabled Tic-Tac-Toe champion. But as it turns out, programming and problem solving often leads you down paths you didn’t expect.

Instead of using AI, I found myself applying the Minimax algorithm, a concept I'd studied but hadn't yet gotten the chance to use in a real-world situation. Suddenly, those evenings spent studying trees and decision-making algorithms were paying off, and I actually started seeing “trees” of decisions and data in lots of places in my life (org charts, file systems, DOM trees, decision trees, etc. etc.).

So, even though I didn't end up where I initially thought I would, this one actually turned out to be a pretty great learning experience.

In conclusion, my friends, remember: Coding isn't always a straightforward path, but sometimes, those unexpected turns lead you to some pretty "tree-mendous" places. And even if you can't "branch" out with AI, don't worry, you can always "leaf" it to good old algorithms to save the day. After all, they're pretty unbe-leaf-able!

Until next time, keep exploring, keep learning, and remember to take the "root" less traveled - it might just lead you to a game of unbeatable Tic-Tac-Toe! Happy coding and keep "tree-ting" yourself to new coding adventures!

PS: Try your hand at the algo-enabled game here, and let me know if you win!

Hey everyone,

Welcome to the latest edition of the Sean is Coding newsletter! At my coding bootcamp, Rithm School, this week marked the end of the formal instruction portion, and we're all collectively moving forward into the "professional projects" phase of the program.

Numbers API

During "project season," as they call it, the goal is to provide us with experience working in a larger, production-level codebase that contains a substantial amount of pre-existing code. My team has been tasked with picking up the Numbers API project, modernizing it, and extending the codebase.

Numbers API is an open-source project that Rithm School acquired a few years ago and now maintains. Our mission is to bring this app up to speed with modern web technologies and practice working comfortably in a large, pre-existing codebase.

Recruiting

In addition to projects, we're also starting to think about recruiting for software engineering jobs as the program draws to a close. I'm excited to get a bit of a break from all-day instruction and, quite frankly, to start talking to people again. I haven't had a chance to put much thought into my resume and portfolio yet, so I'm really looking forward to having a bit more time to dedicate to that effort.

Next.JS + LangChain

Since we didn't have an assessment this past weekend, I seized the opportunity to get acquainted with Next.JS and LangChain, two technologies I've been eager to gain more experience with. So far, I've deployed a basic Tic Tac Toe app using Vercel that mostly works, but it needs a lot more refinement before it's ready for prime time.

Next.JS is an amazing framework overall. Its approach to handling routing is incredibly straightforward and clever. I'm also loving the idea of using serverless functions for handling tasks like backend API calls without the need to build and deploy an entire server instance.

LangChain has streamlined the process of working with the OpenAI LLM, making it much easier to incorporate into projects. Over the coming weeks, I plan to flesh out my portfolio by expanding on some of the more backend-intensive projects we started in Rithm, and by extending some of the side project ideas I began experimenting with during my downtime in the program.

It's hard to believe that the program will be wrapping up in just six short weeks. The time seems to have flown by, but I'm genuinely excited to use this period to focus on applying what I've learned to build out my portfolio and establish a solid foundation for entering the job market.

As always, thanks for following along!

Sean

Welcome back to another issue of Sean is Coding! I've got a shorter update for you this week, but still packed with exciting news. Let's dive in!

Subscribe now

🎯 Jobly Front-End: A Busy Sprint

This week we had a multi-day sprint implementing the front-end for Jobly, an Indeed.com-like job search tool. You might remember that we built the backend in Express two weeks ago. We created the frontend as a mostly single-page app using React, and I've got to say, I absolutely despise unit testing the frontend. However, I do enjoy working with React despite its faults—it feels more like backend engineering but on the frontend, thanks to modular components and hierarchy.

💡 Full-Stack Exposure & Learning

Working end-to-end has been super fun, and I'm loving the exposure to both sides of development. The variety of programming challenges is helping me approach engineering problems more logically and stay organized.

🤖 AI Corner: Geek Out Time!

I've been geeking out over some of the latest AI innovations this week. It's incredible how fast things are happening:

• I got access to Pinecone's free plan for vector DB storage (congrats on the huge funding round, Pinecone!). I'm excited to play around with AutoGPT and Langchain—stay tuned for more on that.

• Tana, one of my favorite note-taking apps, launched a game-changing AI feature that lets you build custom prompts and auto-populate fields. I've started using it for a JavaScript reference data type methods table, but that's just the beginning!

• OpenAI extended my access to ChatGPT plugins, including GPT-4 with browsing. It's still a bit finicky, but having an AI agent research on your behalf is mind-blowing. I've been asking it to research and write interesting prompts for Midjourney.

• Speaking of, here are some different “unexpected double exposures” I’ve been playing around with. I’m finding that MJ v5 can really generate some stunning shots if you give it just a few powerful descriptors:

  

  

  

🔜 Next Week: More Progress

Can't wait to share more about my progress next week! Until then, onward and upward!

Sean

Welcome to the 11th edition of Sean is Coding!

This week, I want to share a bit about how I've been using ChatGPT to level up my learning process and share some of the prompts that have helped me the most.

Since ChatGPT's launch last November, there has been a lot of doom and gloom around how it will put programmers—and knowledge workers in general—permanently out of jobs. The truth is we'll be lucky if it lets us live at all, let alone have jobs.

But there's no putting this cat back in the bag. LLMs are here to stay and those who don't embrace them are going to be the first to be left behind.

Not only that, ChatGPT really is a tremendously valuable tool for learning and knowledge-related tasks. I've fully embraced it at this point. I pay for the pro plan. I have it pinned to my iPhone home screen. I have plugins to access it with a keyboard shortcut. It reads and summarizes my notes for me. I'm all-in.

ChatGPT as a Learning Buddy

But the area where ChatGPT has made the most difference has been in my journey to change careers and become a software engineer. It's like having a chat thread open with an infinitely patient and always available private tutor who knows everything.

ChatGPT helps me in a bunch of ways:

1. It personalizes and contextualizes concepts by answering my questions and having a conversation until I get it.

2. It finds answers quickly by pulling together info from different sources into a clear, tailored response.

3. It expands my thinking by being a creative study partner, helping me create study tools and building on them with new info.

Contextual Prompting

To get the most out of ChatGPT as a learning tool, I try to be very clear with it about my goals, use progressive prompting, and ask it direct follow-up questions to address my own knowledge gaps.

I'll usually start by telling ChatGPT what I already know about a topic. That way, it can fill in the gaps in my knowledge and present the info in a way that makes sense to me.

Here are some examples of starter prompts that I've recently used and which have yielded awesome learning chats with ChatGPT. Feel free to use these as a starting point for your own programming adventure:

1. What are the key principles of clean code and why are they important?

2. How do design patterns help in building scalable and maintainable software? Can you provide some examples of commonly used design patterns?

3. What is the difference between imperative and declarative programming? Can you provide examples of languages that primarily use each approach?

4. How do I choose the right data structure for a specific problem? Can you provide examples of different data structures and their use cases?

5. What are the main differences between object-oriented, functional, and procedural programming paradigms? Can you give examples of languages that represent each paradigm?

6. How can I write efficient algorithms? Can you explain the concept of time complexity and Big O notation?

7. What are some best practices for managing dependencies and version control in a software project?

8. What is the purpose of unit testing, integration testing, and end-to-end testing? How can I implement these in my projects?

9. How can I identify and avoid common programming mistakes, such as memory leaks, race conditions, and deadlocks?

10. What is refactoring, and how can it improve the quality of my code? Can you provide examples of common refactoring techniques?

11. How do I improve the readability and maintainability of my code? What are some best practices for documentation and commenting?

12. What are some key principles and techniques for writing secure code? Can you explain concepts like input validation and output encoding?

13. Can you explain the concept of Continuous Integration and Continuous Deployment (CI/CD)? How does it help in improving software development processes?

14. What are some strategies for effectively debugging and troubleshooting code issues?

15. How can I optimize the performance of my code? What tools and techniques are available for profiling and analyzing performance bottlenecks?

In sum, ChatGPT has been a game-changer in my programming learning process. It gives me instant access to personalized and contextual information that's helped me learn faster and tackle more complex programming ideas, than I'd otherwise have been able to at this point in my journey.

Even if you're not learning to code specifically, I'd encourage you if you're not already to take a hard look at LLMs like ChatGPT and see if there's something that it can help you learn or do more efficiently or creatively.

Hey everyone!

Welcome to the 10th edition of Sean is Coding. Time flies when you're having fun — I seriously can't believe we're already at double digits in this newsletter. With that said, let's dive right into what's been going on this week.

This week was primarily spent tackling a large backend project: developing the API for a fake job board service called "Jobly." We spent three of our five days with our pair programming partners and dove deep on the area with a heavy emphasis on test-driven development, security, authentication, and authorization, and simply keeping code clean and well organized.

With a codebase as sizable as this one, keeping everything straight quickly became a challenge and really highlighted for me why it’s so important to maintain good naming conventions and predictable file structure.

Jobly was also our first chance to work with the concept of maintaining “test coverage,” in an app. We were given an existing but incomplete codebase that already had close to 100% testing coverage, and our challenge was not to let that percentage drop. So we were encouraged to lean on test-driven development (TDD). TDD is a process where you write tests for the code before writing the code itself. It helps you ensure that your code is meeting the requirements and is less likely to have bugs. It's been a bit of a mental shift, but it did not take long to see the immense benefits of leading with testing. Obviously, TDD isn’t always possible, but when you have the time to work this way, it is surely the best process for writing near bulletproof code.

We also flexed a lot in the way of security this week, building out authentication and authorization routes and their corresponding middleware. And we employed some different techniques to protect our service and its users from attacks.

Separately, I'm excited to announce that TheraGPT has finally grown up and graduated to living at its very own URL: theragpt.ai! I've given the site a fresh coat of paint to provide a little more personality, and we now have uptime monitoring to eliminate cold start latency and keep each request fast. So go ahead and check it out! I’ve already heard some really inspiring stories from people who it’s helped out!

As always, thank you for joining me on this adventure, and I hope you find these insights as interesting / exciting as I do. Stay tuned for more coding stories and updates on my journey to software engineering!

Until next time,

Sean

Happy Easter to those of you who celebrate! I hope you're enjoying the holiday with family, friends, or just a relaxing day to yourself. We just got back from a fun Easter Egg hunt with the kids. It was a blast watching them excitedly gather up eggs, and it was super fun getting to know some of the other parents in our daughter’s kindergarten class a little better.

Now, let's dive into the latest updates from my software engineering bootcamp at Rithm School.

🔄 Switching Gears: JavaScript, Node.js, and Express.js

This week, we returned to JavaScript after three weeks of immersing ourselves in Python. It felt like a small whiplash getting reacquainted with semicolons, curly braces, and let/const, but our instructors assured us that switching back and forth will become easier over time.

The transition was made smoother thanks to our foundation in Python and Flask, as we began exploring Node.js and Express.js for running JavaScript on the backend. Node.js comes with most of the modules, like file system access, to make JavaScript work more like a proper server-side programming language. Express.js is a lightweight web app framework, much like Flask but for JavaScript.

To build web apps entirely in JavaScript, we had to get really tight with Promises and async/await. Async and await take care of most of the awkwardness that comes with JavaScript being single-threaded, but because of the promise object, it’s still noticeably more mental work to write asynchronous code in JS than in Python. I find this kind of ironic since JS was built to be a web language, but it is what it is, and honestly, it’s kind of fun to untangle.

🤖 Introducing TheraGPT: Your AI Therapist

Last week, I mentioned I’m working on a side-project called TheraGPT. With the AI craze sweeping the tech world, I've been eager to align my programming efforts more with AI/ML.

TheraGPT is built on the Open AI’s chat completions API, and the idea is simple: you provide a negative thought that's been troubling you, and TheraGPT identifies the cognitive distortions, suggests strategies for overcoming them, and offers a reframed thought to help you think more productively and objectively about the situation.

I'm thrilled to announce that an early (very early) MVP of TheraGPT is now live at https://theragpt.onrender.com/! Please give it a try and let me know what you think. The initial page load might take a minute or two since I'm using a free server.

It's a super-simple 2-route Flask app (a single GET and POST route) that uses JavaScript to handle the POST request asynchronously. It uses a single-field WTForm to accept and authenticate the request, and there's no database, so if you like the output you see, I recommend taking a screenshot or copying and pasting.

Source code is available here, along with a list of some of my planned new features: https://github.com/seanoliver/thera-gpt

This was a ton of fun to build, and even though it's very rudimentary, I'm kind of proud of it because it's the first time since starting this journey I've been able to go from "Oh, that's a cool idea" to "This idea is now a thing I made!"

That's all for this week! I appreciate you following along on this journey. Your support means the world to me. Until next time, keep exploring and learning!

Sean

Hey everyone,

Welcome to the eighth edition of "Sean is Coding" - the Spring Break edition. This week was a nice breather from the day-to-day intensity of Rithm, and I got to catch up on some life stuff while also diving deeper into the world of AI and programming. So, let's get right into it!

Spring Break Shenanigans

First off, I have to say that it was fantastic to have a week off from the bootcamp. It gave me the opportunity to focus on important things like cleaning the house, conquering the laundry mountain, and spending quality time with friends and family. I even managed to squeeze in a quick trip back home to Pennsylvania to visit my mom. It was great to recharge and reconnect!

Exploratory Learning

With a bit more time on my hands, I had the chance to dive into some interesting coding projects and brush up on my skills. I paired up with a few of my favorite bootcamp buddies to work on some independent study projects that we had been itching to tackle. I also took the opportunity to work through the "Advent of Code" 2022 challenge set and revisited some data structures and algorithms courses on Udemy that I'd been meaning to get back to.

Pre-Introducing TheraGPT

Most excitingly, this week allowed me to embark on a new side project that I'm calling TheraGPT. As many of you know, I've been swept up in the AI wave that's been taking over San Francisco and the tech world. With TheraGPT, I'm aiming to combine some of what I’ve been learning on the programming side with my fascination for AI/ML.

TheraGPT is an app I'm building using Open AI’s chat completions API. It was inspired by the realization that ChatGPT actually performs pretty well as a thoughtful and empathic CBT (Cognitive Behavioral Therapy) psychologist. The idea is simple: you input a negative thought that's been troubling you, and TheraGPT will

• identify the cognitive distortions present,

• provide strategies for overcoming those distortions, and

• offer a reframed thought as an example to help you think more productively and objectively about the situation.

I tested TheraGPT with my mom, who struggles with anxiety and negative thought spirals, and she absolutely loved it. It was a proud moment for me, and I can't wait for more of you to check it out once it's ready.

In the meantime, here’s a clip of what it looks like to give you a sense (and the full source code is on Github). It's close to launch, but I still need to add some finishing touches and deploy it to a server.

That's it for this week's Spring Break edition of "Sean is Coding." As always, thank you for joining me on this journey, and I look forward to sharing more updates and exciting developments in the coming weeks!

Until next time,

Sean

This week, I had the chance to revisit a web-based version of Mad Libs we’d made in my bootcamp using Flask a few weeks ago.

The original version came with just two static, pre-written story templates. Users could select a template, fill in the required words, and read the completed story.

I revisited the project with the intent of making this experience a little more dynamic using Open AI’s ChatGPT API to replace the pre-existing stories with an AI-generated story that would be different every time. The process of doing so was extremely exciting and really demonstrates the seismic changes AI is bringing to software development right now.

Here’s the main function that retrieves a new Mad Lib story template from ChatGPT:

def fetch_gpt_story():
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system",
             "content": os.getenv('MADLIBS_SYSTEM_INSTRUCTIONS')},
            {"role": "user",
             "content": os.getenv('MADLIBS_USER_INSTRUCTIONS')}
        ]
    )
    return response['choices'][0]['message']['content']

Most of this function is boilerplate, the real magic of "programming" this came from writing the system and user-level prompts. For instance, here is the system prompt:

You are a helpful assistant that generates funny stories with blanked-out words indicated by curly braces. The blanked words should be mad-libs style descriptors of the type of word, such as noun, adjective, adverb, person name, place, country, action verb, etc.

This prompt contains essential instructions for users to follow when filling in the blanks. For example, descriptors inside the curly braces must be entirely lowercase, and every term in curly braces must end with two underscores and a number. The descriptor should also include a numerical indicator to designate words that are intended to be re-used as part of the story.

The descriptor must be descriptive enough to signal the user to provide an input word that will make sense when placed in the sentence. For example, if the sentence is "She {verb__1} to see him but she was too late," consider saying {past_tense_verb__1} instead of {verb__1} because a past-tense verb would sound more natural in that sentence. Additionally, users must respond with the Mad Libs story only, without any chat-style conversation before or after the story content.

The exciting thing about this method of programming is that, instead of importing a dataset and processing it using an algorithm, we can simply ask the API to provide the data in a format that is immediately usable. 

This approach is going to have a enormous impact on application development, making developers more productive while reducing the cost of building custom software. It’s such an exciting time to be entering this field.

I’m working on getting a deployable version of this ready to share in the next couple of days.

Deploying a Twitter Clone

Most of the class time this week was spent building and deploying an end-to-end Twitter clone called Warbler. Unlike Mad Libs, Warbler is actually live for you to check out right now.

One of the most surprisingly fascinating aspects of building Warbler was implementing user authentication, data protection, and privacy. We explored how to use cryptography and hashing to store user passwords securely, making it almost impossible for any malicious users to access user data.

Hashing, in particular, is a really fascinating area of mathematics computer science. A hashing algorithm takes an input (e.g. a user’s password) and maps it to a fixed-size output (a hashed string) that represents the original data. Importantly, a good hashing algorithm is both stable and one-way:

1. Stable, meaning it always provides the same hashed output string for a given input (this is ignoring any salting certain algorithms might do to vary the hashed strings superficially — the underlying hash value remains the same).

2. One-way, meaning that even though this input always produces the same output, there is no mathematical way to reverse the hash and turn it back into the input. 🤯

Authentication happens when a new user input (i.e. a password, correctly typed by the user) is hashed and compared to the stored hashed value in the database. The actual password itself is never stored anywhere.

Overall, I’ve gotta say, it’s been another thrilling (and admittedly exhausting) week. And I can’t get over how exciting it is to be entering software engineering at this moment with the ground beneath us shifting toward an AI-powered future.

Contents:

1. Progress Report

2. Bug Report

3. Surf Report

4. Tweet Report

Progress Report

And just like that, week 4 at Rithm is in the can—it's been another great week of learning. We continued to focus on the backend, but this week, our primary focus was on databases and how to interact with them using SQLAlchemy in our Flask applications.

Databases and SQL

We started the week by learning the basics of SQL (Structured Query Language) and how to interact with relational databases using SQL queries. We practiced creating tables, inserting data, updating records, and querying the data using various conditions.

SQLAlchemy

Once we had a firm grasp of SQL, we moved on to learn SQLAlchemy, a powerful Python ORM (Object Relational Mapper) that makes it easier to interact with databases in a more Pythonic way. We learned how to create models, define relationships between tables, and perform CRUD operations without having to write raw SQL queries.

Using SQLAlchemy in our Flask applications made it much easier to manage the data and keep our code clean and organized. It also helped us maintain a consistent structure across our projects.

Next week is our final week in Python, and we’re diving into security, authorization, and cryptography! Onward!

Bug Report

This week's bug was related to the relationships between tables in our database. We were working on a blog application where users can create posts and leave comments on them.

We defined two models, User and Post, and created a one-to-many relationship between them, where a user can have many posts but each post belongs to one user.

We also defined another model, Comment, and created a one-to-many relationship between Post and Comment.

The bug occurred when we tried to retrieve all the comments associated with a specific post. We were expecting the comments to be sorted by their creation time, but they were returned in a seemingly random order.

After a bit of debugging, we realized that we forgot to define an order_by attribute for the relationship between Post and Comment. By default, SQLAlchemy doesn't order the related records unless explicitly specified.

To fix the issue, we modified the relationship definition in the Post model as follows:

class Post(db.Model):
    # ...
    comments = db.relationship('Comment', backref='post', order_by='Comment.created_at')
    # ...

With this change, SQLAlchemy now orders the related comments by their creation time, as we originally intended.

Surf Report

1. Seeking Cerebral Valley: A Photographic Tour of San Francisco’s AI Underground (The Information)

2. SF’s Central Subway saw declines in ridership during its first two months of service, data show (SF Chronicle)

3. GPT-4 was released (Open AI)

4. Midjourney v5 was released (Midjourney via Twitter)

Tweet Report

Dan Shipper highlights four ways to leverage GPT-4 to be an excellent writing partner.

Nick St. Pierre knocks it out of the park with another stunning piece of AI-generated content. This time, a fully blown 30-second video written, directed, and shot (almost) entirely using various AI tools. The future is now!

Contents:

1. Progress Report

2. Bug Report

3. Surf Report

4. Tweet Report

Progress Report

And just like that, our third week of bootcamp at Rithm School has come and gone and this was a big one.

• We switched from JS to Python and from frontend to backend

• We started building servers and APIs using Flask, a backend web framework for Python

• We spent a lot of time thinking about type safety and ways to be really diligent about ensuring we’re passing and working with the right kinds of data before we get to deep in implementation.

Python

We waded into the wild world of backend this week, exchanging JavaScript for Python and the browser console for the Terminal.

One major takeaway I have from this week is that it is a lot easier to learn a programming language when you’re not also learning programming at the same time.

Python is similar enough to JavaScript that it didn’t really feel like we needed to slow down in terms of learning new concepts just because we were looking at it through the lens of a different language.

So far, coding in Python is a bunch of fun. That it was designed from the ground up to be a fully-fledged programming language really makes it feel a lot richer out of the box. I’m particularly liking:

• Doctests — The idea that you can just build self-documenting unit tests directly into your functions is insanely satisfying.

• Errors — There is no undefined in Python! When you request something that isn’t there, or is an incorrect type, you just get an error. I feel like I can get things done so much more quickly now.

• Methods — There are so many more methods available in the standard Python API that you need to build from scratch or by importing other libraries in JavaScript. Some of my faves are zip(), title(), and sorted().

Flask

We also dove into the Flask framework and started building server-side APIs for the first time. This is one area where I’m relieved to be coming in with some background from Ruby on Rails. The concept of constructing endpoints as routes was thankfully already familiar to me, so I could focus my attention on teasing out the details of how Flask works.

Bug Report

It’s hard to put my finger on one bug in particular since this week was also the week we started to dive more deeply into testing frameworks and test-driven development.

With all the API work we’re doing, I’ve been doing most of my debugging work by dropping breakpoints into my app and exploring the variable environment at different places in the thread of execution.

Just yesterday, my partner and I were building an online Boggle game, and we wrote a view function that would generate a UUID for a new Boggle game and assign it to a new game instance with a freshly shuffled board.

@app.post("/api/new-game")
def new_game():
    """Start a new game and return JSON: {game_id, board}."""

    game_id = str(uuid4())
    game = BoggleGame()
    games[game_id] = game

    return jsonify({"game_id": game_id, "board": game.board})

What looks like 4 lines of code was actually about 50 lines of debugging requests via iPython and pdb to play around with the data available at the time of request. I’m finding that I actually really love the exploratory / investigative nature of this aspect of the work! Maybe I’ve got a future in backend yet!

Surf Report

Some of my favorite links from this week.

1. Why was there a run on Silicon Valley Bank. A solid explainer for the uninitiated like me on how something so big could go so bad so quickly.

2. Cascadia Code Font. I discovered this font for my VS Code editor earlier in the week and it’s quickly taking over as the default font on most of my notes / writing apps. I never thought I’d turn my back on iA Writer, but this font really slaps! Check out the cursive stylistic set for italics, too. Chef’s kiss.

3. LLMs are not going to destroy the human race. I’m about 90% through Nick Bostrom’s Superintelligence, a book that is not making me feel good about our ability to handle an AI future. This article makes me feel a bit better about the near term.

4. Build Your Own AI Chatbot with ChatGPT API. Guide for building a chatbot with the ChatGPT API in Python. The transition to AI will be on par with the transition to mobile: It’s going to swallow everything, and I honestly think it’s never been a better time to learn to code. 

Tweet Report

Some of my favorite tweets from this week. My timeline filters out any tweets that mention Elon Musk.

Speaking of AI, here’s a great chart showing the landscape of VC investment in AI at the moment.

Best take I’ve heard yet on Peter Thiel’s role in the run on SVB:

I really hate it when I agree with David Sacks, but he’s right. There were many ways SVB could have avoided this outcome, but one lesson we should all take away is that we need guardrails for banks to ensure banks are managing our liquid assets responsibly.

1. Progress Report

2. Bug Report

3. Surf Report

4. BONUS: Midjourney Report (with Prompts!)

Progress Report

• Wrapped up week 2 of Rithm, where we spent time getting familiar with HTTP requests passing data back and forth between the front-end and the backend.

• The week concluded with a fun two-day sprint where we paired off and built the front-end for a Hacker News clone called “Hack or Snooze.”

• I think the most valuable part of it all for me was learning how to work with someone else on such a relatively large codebase, where it matters where functions are implemented and how they’re scoped.

• In the evening hours, I also started working through Colt Steele’s excellent Algorithms and Data Structures Masterclass I’d purchased back in December. I feel like Rithm is doing a great job getting me used to how programming works in the real world. This course is more of a deep dive into designing and working with some of the more complex data structures you tend to encounter in interview questions.

• This weekend: Our weekend assessment this week is building a Jeopardy clone that gets questions from a generic trivia API and organizes them into categories.

• Next week: Starting Monday we switch to Python and start building servers in Flask. Super excited as I’ve got a lot to learn in this area.

Bug Report

If debugging is the process of removing bugs, then programming must be the process of putting them in.

— Edsger W. Dijkstra

... and this week, we put in (and subsequently took out!) a lot of bugs.

The Hack or Snooze project followed an object-oriented pattern, where data and functionality were managed together in classes that represented different entities relevant to the app (e.g. users, stories, etc.). We had a lot of functions that passed the data in these objects back and forth between the server resulting in a variety of tricky TypeErrors that ultimately had to do with the format of data as it passes between servers and clients.

One tricky fact of working with server requests is properly manipulating and acting on the data that they send back. Servers can only send strings back to the client. It’s usually JSON-formatted and it’s often nested in a larger data structure containing response headers and other information about the server response.

Here’s what one of our server responses might look like:

If you look inside that data field, you see the data we’re looking for, but it’s still not an instance  so we can’t run any of our instance methods on it:

So we ultimately needed to instantiate instances of each story object as they were recalled from the server. We used a JS library called Axios for the request, but the same can be done using the fetch() API:

Surf Report

1. Honestly, it’s probably the phones.

2. Social media becoming pay-to-play.

3. Marc Andreessen stopped drinking.

4. Jailbreak ChatGPT Prompts.

BONUS: Midjourney Report

I’ve been playing around with Midjourney in my spare time and have started experimenting with some of the “pro-level” prompts you might be seeing more and more of from prompt engineering influencers. Here’s a hilarious meme from one of those influencers that I think effectively captures the sea change we’re seeing in AI-generated art:

Here are some of my favorite creations from this week:

Cyborg Baby

cyborg baby| with a visible detailed brain| muscles cable wires| detailed cyberpunk background with neon lights| biopunk| cybernetic| unreal engine| CGI | ultra detailed| 4k

Meditations

anime style wizard floating over pond in Meditation peaceful silence --niji --q 2

Wormhole

wormhole into a parallel universe ultra detailed celestial high resolution 16:9 cinematic photorealistic --chaos 100 --q 2

Post-Apocalyptic SF Future

san francisco skyline in the high tech future::3 photorealistic::5 realistic::3 sunlight::3 DSLR::2 panorama::2.5 wide angle lens::2 satellite imagery::1.5 --ar 2:1 --v 4 --quality 2 --stylize 1000 --chaos 100

Asian Battle Queen

ancient chinese queen::2 ultra modern::1 natural lighting::2 glowing::3 fluorescent::2 DSLR::1 wide angle lens::1 defocus::-0.5 --ar 2:1 --v 4 --quality 2

1. Progress Report (Part 1): Week 1

2. Progress Report (Part 2): Connect Four

3. Bug Report: The Trouble with this

4. Surf Report: Tech Layoffs Feeding Startup Surge?

Progress Report (Part 1): Week 1

We are off to the races! Today marks the end of my first week at Rithm School. The schedule is necessarily intense, but sustainable. Our days start at 9:30 am and end at around 6 pm. Days are split between a mix of lectures and hands-on labs where we work in pairs building apps and solving algorithmic challenges.

I am really enjoying the teaching staff and my classmates. It's a serious program and it feels serious, but we’re also having fun with it. It very much feels like we're all in this together, supporting each other as we learn and grow as developers.

One thing I'm still trying to figure out is how to make progress on "life stuff" outside class. With such limited “free” daytime hours, I'm still figuring out the best way to stay on top of laundry, exercise, and food consumption.

Overall, though, I’m grateful to have the opportunity to immerse myself in programming to this extent with a cohort of other like-minded people.

Progress Report (Part 2): Connect Four

One of the apps we built in lab this week was a browser-based version of Connect Four in JavaScript. The next day, we refactored our code to fit within the Object-Oriented Programming paradigm centered around a unified Game object that manages the data and functionality for a given game, along with "Player" objects to manage individual player preferences.

Having to do this refactoring was was a great exercise. It really helped to highlight the importance of context in function calls and also highlighted in practical terms some of the real benefits of OOP. Once we refactored the functionality into Game objects, things that would have been extremely complicated to do became trivial. For example, spinning up multiple simultaneous instances of a game, extending the game class to allow for subclasses with special rules like more players, bigger boards, and so on.

I’ve started a running list on GitHub of new features I plan to roll out, but in the meantime you can start playing with the simple version here: https://seanoliver.dev/connect-four-oo/

Bug Report: The Trouble with this

If debugging is the process of removing bugs, then programming must be the process of putting them in.

— Edsger W. Dijkstra

Each week, I’ll share a particularly nasty bug I encountered along with how I resolved it.

This week's bug involves the infamous this keyword in JavaScript. In my game object, I have a method called makeHtmlBoard, which creates the game board and adds a click event listener to the top of each column, allowing the user to drop a piece in their turn. There's also an endGame method that congratulates the winner and should stop the user from being able to continue to add pieces to the board.

Here are the relevant sections of code:

class Game {
  makeHtmlBoard() {
	// ...
  	top.addEventListener('click', this.handleClick.bind(this));
	// ...
  }

  endGame(msg) {
   // ...
    top.removeEventListener('click', this.handleClick.bind(this));
	// ...
  }
}

Unfortunately, we quickly realized that endGame was not actually removing the event listener, so a user could keep dropping pieces onto the game board even after the game had ended.

We added some console.log()s in various places to confirm that:

1. Every line of code was, in fact, running when it was supposed to

2. this correctly referenced the current instance of Game each time it was used

After exhausting other possibilities, we realized we weren’t fully familiar with all the magic the bind() function was doing under the hood. We’d only been introduced to it in a lecture earlier that day.

We took a trip to the MDN docs and our mistake dawned upon us:

The bind() method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.

The bind() method creates a new function! D’oh! 🤦‍♂️

While they might look the same, the removeEventListener was referencing a different function in memory than addEventListener, so it couldn’t find the correct listener to remove!

The solution was to store a single version of the bound function reference in a variable in the Game constructor and use it for both adding and removing the event listener:

class Game {
  constructor(height = 6, width = 7) {
    // ...
    this.boundHandleClick = this.handleClick.bind(this);
    // ...
  }

  makeHtmlBoard() {
    // ...
    top.addEventListener('click', this.boundHandleClick);
    // ...
  }

  endGame(msg) {
    // ...
    const top = document.getElementById('column-top');
    top.removeEventListener('click', this.boundHandleClick);
    // ...
  }
}

Surf Report: Tech Layoffs Feeding Startup Surge?

1. Tech layoffs are feeding a new startup surge

2. Tim Urban’s new book is finally here!

3. Aliens mostly hang out in America

4. Emoji proposals rejected by the Unicode Consortium

Memory Game. I wrapped up the final pre-work project before bootcamp begins next week. It’s a traditional memory game where you have to flip over two cards at a time trying to find two that match.

Building it was a fun, iterative process that had me going back over the code I'd already written for the base-level functionality and enriching it with new features and capabilities. I started with the ability to flip over a single card and then added layers of feature logic one at a time: allowing two cards at a time to be flipped, randomly generating the colors on the back, letting the user set the number of cards, letting the user restart the game, keeping track of the score, and using GIFs instead of colors as the card backs.

It was cool to see that even as I added most of this functionality, the length of the underlying JS file didn't change much from when I'd finished it with just the basic card flip capability. You can see in the commit history that most of my updates had me adding as many lines of code as I was deleting.

I also had a very “proud dad” moment with Mika as she excitedly dove right into beta testing my 1-player game, finding a way to turn it into a 2-player game, and beating me at it. We are now playing it every night at dinner time and she's making feature requests. 🤦‍♂️

Deep Work. I started and finished reading Deep Work by Cal Newport this week. I’ve long been a fan of Cal’s writing so I was excited to dig right into this one. I feel like now was the perfect time for me to come across it, too, as the satisfaction that comes with doing deep work is one of the things that has drawn me to programming in the first place. Cal defines “deep work” as follows:

Deep Work: Professional activities performed in a state of distraction-free concentration that push your cognitive capabilities to their limit. These efforts create new value, improve your skill, and are hard to replicate.

This is opposed to “shallow work:”

Shallow Work: Noncognitively demanding, logistical-style tasks, often performed while distracted. These efforts tend to not create much new value in the world and are easy to replicate.

There’s no way to escape shallow work—in fact some jobs, including most executive-level jobs, are made up almost entirely of shallow work. But the goal should be to minimize the deep as much as one can and/or is appropriate. Because of “The Deep Work Hypothesis:”

The Deep Work Hypothesis: The ability to perform deep work is becoming increasingly rare at exactly the same time it is becoming increasingly valuable in our economy. As a consequence, the few who cultivate this skill, and then make it the core of their working life, will thrive. 

This focus on delivering truly differentiated value to the world is something that’s becoming more important as things like AI start gobbling up knowledge work—and marriages!—and the idea of learning a skill once and doing it for the rest of your life goes away. My favorite futurist who is actually a historian, YNH, first introduced me to the concept in Homo Deus and it feels really relevant here, especially when you consider that learning something new is in itself deep work:

Traditionally, life has been divided into two main parts: a period of learning followed by a period of working. Very soon this traditional model will become utterly obsolete, and the only way for humans to stay in the game will be to keep learning throughout their lives, and to reinvent themselves repeatedly. Many if not most humans may be unable to do so.

— Yuval Noah Harari, Homo Deus

But what’s more personally important to me is the sense of satisfaction that comes from entering the flow state (h/t to Csikszentmihalyi). He writes that, “human beings, it seems, are at their best when immersed deeply in something challenging.”

Ironically, jobs are actually easier to enjoy than free time, because like flow activities they have built-in goals, feedback rules, and challenges, all of which encourage one to become involved in one’s work, to concentrate and lose oneself in it. Free time, on the other hand, is unstructured, and requires much greater effort to be shaped into something that can be enjoyed.

The me from 10 years ago would have scoffed at this idea, but as I’ve gotten older I’ve come to appreciate the process of working toward accomplishing things because it’s in that process that I demonstrate the values to which I hold myself.

Problems

Stolen wallet. My cross-body bag, containing my wallet and keys, was stolen from me yesterday en route to Pennsylvania to pay my mom a long overdue visit. As a result, I had to cancel the trip at the very last minute and fly back to California just eight hours after having landed in Newark.

Needless to say, it was an extremely stressful and depressing 36 hours, and the hassle of having to re-secure my accounts and replace the things that were lost is one that I’ll be dealing with for the foreseeable future.

When I’m feeling down, I turn to a note that I keep on my phone where I collect quotes that inspire me and remind me to take a broader perspective. This one stood out to me yesterday:

Everything can be taken from a man but one thing: the last of the human freedoms—to choose one’s attitude in any given s4et of circumstances, to choose one’s own way.

— Viktor Frankl, Man’s Search for Meaning

It’s very hard to read this sentiment from a guy who survived Auschwitz and keep feeling bad about myself. So here are some silver linings:

• I am learning a ton about the EDC movement (not the music festival, but just as cool IMO), and I’m currently geeking out over a set of minimalist supplies for keeping my important items with me securely at all times moving forward.

• This interruption gave me a lot of downtime which I was able to put to some good use. I read the entirety of Deep Work and I made a lot of progress on an open source Logseq theme I hope to launch in the coming days as part of my developer portfolio.

• I was inspired by the—surprisingly—authentically good people that work for United’s ground and baggage services team. They really exhausted every option they could to help me out, including stopping a fully boarded plane from taking off so the flight crew could search my seat area.

NodeLists and HTMLCollections. While working through the Memory Game project I encountered the first of what I expect will be many quirky behaviors of some of JavaScript’s built-in functions.

In the function that checks the two flipped cards to see if they match, I had planned to flip cards that do not match back over by iterating over them and adjusting their class name accordingly:

const flippedCards = document.getElementsByClassName('flipped');

function checkMatches() {
  if (flippedCards[0].className === flippedCards[1].className) {
    for (const card of flippedCards) {
      card.classList.toggle('matched');
      card.classList.toggle('flipped');
    }
  }
}

Unfortunately getElementsByClassName returns an HTMLCollection which is a live list of elements that updates in real time to reflect the conditions specified at declaration time.

So in this case, each time I toggled off the flipped class from a given card, the card dropped out of the list and everything behind it moved up by one index value. In other words if I had two cards in flippedCards, my function would flip the card at index 0, drop it from the list, and move the second card to index 0 which, from JavaScript’s point of view, had already been handled. The second card wasn’t getting flipped!

The function querySelectorAll, on the other hand, returns a NodeList which is “static.” Each element is essentially a reference to the live element but the references are static from the time they were declared.

I had a helpful chat about this with my cohort-mates in our Slack channel and landed on a couple solutions:

1. Iterate backwards through the HTMLCollection, so the next index value always will exist, or

2. Use querySelectorAll

I actually like the “live” aspect of the HTMLCollection because it means that I can declare flippedCards once and then know that it’s reflecting whatever is live in the DOM whenever it’s called, as opposed to having to keep track of when it was most recently declared. So I ended up going with option 1.

Plans

Rithm School. Classes begin Monday morning! I have to say, it’s been a long time getting to this moment, and I’m now at the point where I’m itching to get started. The time is upon us!

Surf Report

Here are some interesting tidbits I’ve found on the internet this week. Thanks to ChatGPT for the clever name for this section.

Here's a sampling of some of the interesting stuff I've found from around the internet.

Chart: Apple vs. China. I’m not sure there’s a lot to take away from this other than the fact that, wow, Apple is really, really big. (Source: Compounding Quality)

PianoGPT. An amazing demo applying predictive piano playing to a low-fidelity 8-button controller. This was actually made in 2018, long before ChatGPT. There’s even a live web demo you can play with here.

Wirecutter’s Identity Theft Article. Say what you will about the NYTimes, I’ve always found Wirecutter’s product reviews to be particularly practical and unbiased. Their article on identity theft solutions is also really useful because it shares a comprehensive list of actions you can take to be proactive about securing your identity. This is an area to which I really haven’t paid enough attention. 

This bag theft issue (knock on wood) could have been a lot worse, and it really can happen to anyone. If you haven’t already, I encourage you to take a look at your information security measures and make sure you’re doing what you can to protect yourself.

The Latest

I’m wrapping up a rewarding first week of funemployment before my bootcamp cohort begins classes. For those of you I haven’t told already, I’m joining Rithm School, an SF-based (but now fully remote) software engineering bootcamp that teaches JavaScript and Python.

I’m using the time this week and next to work through the packet of pre-work that covers foundational topics like web technologies, algorithms, and basic data structures in JavaScript. It also includes some fun assignments like this kooky Meme Generator, a battery of 60+ algorithm problems we had to solve, and some other basic web projects to get our feet wet.

I also had some great conversations, dinners, and pair programming sessions with an array of colleagues and friends, some of which I hadn’t caught up with since the pandemic lockdowns began.

Look What I Learned

Here’s a new programming concept/technique I learned this week.

DOM Manipulation in JS

Until now, most of my exposure to JS has been about learning the basics of programming—manipulating data types and structures, techniques like closure and recursion, functional vs. object-oriented paradigms, etc.

But the main benefit of a language like JavaScript is in all the ways it interacts with the browser right out of the box. I’d known about this, of course, but didn’t really get a chance to sink my teeth in until this Meme Generator project this week.

You can play with the tool live here.

Shiny Object

I love trying out new apps, gadgets, and other useful products before they break into the mainstream zeitgeist. Here’s a peek into what’s been piquing my interest recently:

Readwise Reader

Readwise recently launched their read-it-later app called Reader, and it’s completely blowing my mind. I’ve tried similar apps like Pocket, Instapaper, Raindrop, and others, but they never stuck. Usually they ended up becoming cluttered and overwhelming with links whose context I’d forgotten.

For the first time, I find myself actually making time to go through it and actually process the stuff I marked to read later.

Why I like it

• They’ve really figured out how to parse all kinds of pages and present the content well. I rarely get any weirdly truncated text or missing images.

• Highlighting works flawlessly and syncs not only across the desktop and mobile apps, but even to the original website where the content was posted.

• All of the highlights go into my Readwise SRS queue and into my second brain in Logseq.

• Text-to-speech read aloud on the mobile app for when I’m out and want to catch up on some reading.

• AI generated article summaries

• Auto expands Twitter threads and treats them like normal articles

• It also has a “feed” area that takes in emails, email newsletters, and RSS feeds from which you can pick and choose what you want without having everything clutter your inbox queue.

I’ve always had a deep passion for new technology, problem-solving, and building useful things. Now after a decade building a career in product marketing, I’m finally taking the leap to build one around my love of programming and software engineering.

Since starting this journey in earnest, I’ve found such immense fulfillment in learning new skills, discovering creative solutions, and being a part of a community of driven developers (and fellow devs-in-training). For me, this is a move that feels long overdue, so I’m excited to learn in public and share what I’m learning, building, and struggling with. Hit subscribe to follow along!