DEV Community: Sammy Tran

🔗 Why You Should Bookmark Links

Sammy Tran — Wed, 13 Nov 2024 16:00:00 +0000

Welcome to the eighth issue of the Software Mastery newsletter.

In this issue, I want to talk about bookmarking links.

Over the past year, I’ve become informally known as the person to go to when you need a link to something because I almost always have it.

The thing about having links is it’s not really about memory. Links are long and ugly, so the only practical way to retrieve them is to bookmark them.

When Should I Bookmark Something?

Usually, as I’m working on certain tasks, I come across resources that could be useful in the future.

For example, I might find an internal wiki page that contains a solution to a problem I have or explains a concept more intuitively than the official documentation does.

To determine whether I should bookmark something, I base my decision on two factors:

How long did it take me to find this resource? Some resources are the top search result of a common query, so they’re easy to find in the future; other resources are like buried treasure, found after a long journey.
How likely will I, or someone else, need this resource in the future? If you’re certain you’ll only need something once, it might not be worth bookmarking. For resources that you keep coming back to, retrieval should be fast.

How Do I Keep Things Organized?

Making a conscious effort to bookmark useful links is half the battle. The other half is figuring out a way to organize them so you can retrieve them later.

For links I intend to bookmark, I organize them in folders based on a team/service.

At Amazon, teams are encouraged to follow a service-based model; to get non-trivial things done, you often need to integrate with multiple services across the company.

For every team/service that my team needs to interact with, I maintain the following bookmarks, at a minimum:

A link to the team/service’s wiki.
A link to the service’s operational dashboard, if available.
A link to my team’s onboarding request for this particular service.

Besides those three, I create additional bookmarks for links I struggle to retrieve over time.

Nowadays, in a world where you can search across all your bookmarks in most browsers, I wouldn’t recommend spending much time thinking about bookmark organization.

You can even maintain a flat hierarchy of bookmarks if you describe them well enough to retrieve them later through search.

Your Turn!

I hope this issue inspired you to start bookmarking useful links you come across in your work or studies.

Ideally, these bookmarks should be published and maintained in a team wiki to maximize knowledge sharing.

Did you find this newsletter useful? Reply to this email or comment on this post to let me know!

Thanks for reading!

Sammy

📚 2 Books Junior Engineers Should Read

Sammy Tran — Wed, 06 Nov 2024 16:00:00 +0000

Welcome to the seventh issue of the Software Mastery newsletter.

In this issue, I want to share two software engineering books every junior engineer should read in their first year or two to maximize their performance.

For junior engineers, I would recommend the following books:

A good book on your main programming language.
A Philosophy of Software Design by John Ousterhout.

A Good Book On Your Main Programming Language

My first book recommendation is not a specific book because it depends on what programming language you spend the most time working with.

Whatever that language is, there’s a lot of value in learning about all it has to offer regarding features, APIs, and tools.

When you understand a programming language and its ecosystem deeply, you can better read code from others and write idiomatic code yourself.

As a software engineering intern at university, I saw noticeable growth in the quality of my Java after reading the well-known Effective Java by Joshua Bloch.

I didn’t understand everything in that book the first time, but as I read more Java written by senior engineers, I saw real-life examples of the patterns described in that book.

For other programming languages, here are some suggestions:

C# — C# in Depth by Jon Skeet
Go — The Go Programming Language by Donovan and Kernighan
JavaScript — JavaScript: The Good Parts by Douglas Crockford
Rust — Programming Rust: Fast, Safe Systems Development by Blandy et al.
Python — Fluent Python: Clear, Concise, and Effective Programming by Luciano Ramalho

A Philosophy of Software Design by John Ousterhout

My second book recommendation is a software design book not specific to any one programming language.

I’m a fan of A Philosophy of Software Design because, unlike other books in space, like the divisive Clean Code by Robert C. Martin, this book teaches some underlying principles of software design, rather than a list of rules to follow.

Here are some of my favorite takeaways from this book:

We’re all fighting against complexity. As software systems evolve, they become increasingly complex, making them harder to understand and modify. Incrementally investing in software design is one mechanism for keeping complexity under control.
Modules have an interface and an implementation. Modules, as described in the book, can have many forms (e.g., a service, a class, a function, etc.). When we use a module, we have to learn its interface (cost) to benefit from the functionality in its implementation (benefit).
Modules should be deep. A module is deep if it provides rich functionality behind simple interfaces, thus minimizing its cost while maximizing its benefits.

Your Turn!

I hope this issue inspired you to pick up some software engineering books.

Nowadays, people don’t read books cover-to-cover as often as they used to. I guarantee you’ll stand out if you commit to finishing one this year.

Are you currently reading any software engineering books? Reply to this email or comment below to let me know!

Best,

Sammy

🧠 How to Learn Unfamiliar Codebases

Sammy Tran — Wed, 30 Oct 2024 15:00:00 +0000

Welcome to the sixth issue of the Software Mastery newsletter.

In this issue, I want to share how I approach learning a new codebase.

Learning a new codebase can be daunting for anyone, especially when the codebase is large and has been around for years. This is true, whether you’re a university student starting your first internship, or a seasoned industry veteran.

Whenever I have to work in an unfamiliar codebase, I do the following:

Learn about the codebase at a high level.
Identify relevant entry points.
Trace through the code using an IDE.
Make changes.

Learn About The Codebase At A High Level

When learning a new codebase, it’s a good idea to ask a colleague for a quick whiteboarding session and read any existing documentation.

The objective here is to develop an understanding of the big picture. Usually, this means understanding the codebase in terms of boxes and arrows.

Diagrams enable you to start building a mental model of how a system works at a high level.

This understanding helps you identify which parts of a system are relevant to your task and which ones you can learn later.

Identify Relevant Entry Points

To deepen your understanding of a codebase, you have to read code. It isn’t always obvious where to start, however, especially when the codebase is massive.

The key here is to identify entry points relevant to what you’re trying to do. An entry point is the beginning of a code path. For simple programs written in languages like Java, the main method is an example of an entry point.

For backend services, the easiest way to identify entry points is to figure out what framework is being used. Frameworks enforce a structure on a codebase, which can give you some clues on where to start your exploration.

Here are a few example frameworks and what they can tell you about entry points:

Spring Boot — For RESTful services, all classes annotated with @RestController are HTTP request handlers.
Django — The urlpatterns variable defined in the root URL configuration contains the mapping between URL patterns and views.
gRPC — For gRPC frameworks, there should be a .proto file somewhere with a named service containing RPC methods clients can invoke.

Trace Through The Code Using An IDE

At this step, the objective is to gain a deeper understanding of what happens in a particular scenario.

One efficient way to navigate through a code path is to use an IDE. Common IDE shortcuts like “jump to definition“ allow you to follow a code path until its conclusion by drilling down the call stack.

To organize your thoughts, consider taking notes. For example, for a full-stack e-commerce platform, your notes might look like this:

A user clicks on the “Purchase” button.
A POST request is sent to the purchase service’s /v1/purchases endpoint.
Since the purchase service is a Spring Boot application, the entry point is the PurchaseController.
The purchase controller validates the request body, submits the order to the Orders database table, and returns a 200 OK HTTP response.

Make Changes

Now that you’ve figured out the relevant entry points and traced through the code, you should have a rough idea of what’s going on in the code paths you need to modify.

At this point, you need to start getting your hands dirty. As you start implementing, you’ll begin to unearth the things you don’t know, which will help guide your learning.

Codebase knowledge comes from the hard-earned experience of making changes, not just reading. The more changes you make, the more you’ll understand.

Your Turn!

I hope this issue gave you some ideas on navigating unfamiliar codebases.

Remember that getting up to speed with large codebases is a skill that takes a lifetime to master. Don’t get discouraged if you’re having a hard time!

Do you have any tips on getting familiar with codebases? Reply to this email or comment below to let me know!

Wishing you the best,

Sammy

✅ How To Get Faster Code Reviews

Sammy Tran — Wed, 23 Oct 2024 15:00:00 +0000

Welcome to the fifth issue of the Software Mastery newsletter.

In this issue, I want to share a few tips on getting faster code reviews.

When I started working in the tech industry as an intern, I was shocked at how long it took to get a code review.

Sometimes, a published code review would take up to a week before someone looked at it and left feedback. This delay is particularly frustrating when working on features that require multiple sequential code changes.

Over time, I’ve learned that there are some things you can do to improve the time it takes to get an approval:

Make your change easy to review.
Assign the change to specific people.
Use your manager as a forcing function.

Make Your Change Easy To Review

Code reviewers are human. Sometimes, your code isn’t getting reviewed because the reviewer opened the pull request, thought it would take a lot of time/effort, and decided to procrastinate.

If this is the problem, here are a few suggestions on how to create beautiful pull requests:

Self-review the code before publishing the pull request. The longer you stay on a team, the better you should understand your code reviewers. After putting up a draft pull request, take the time to review the change yourself and anticipate concerns your reviewers might have.
Test your changes enough to convince your reviewer that it is correct. This tip is important when your reviewer doesn’t have a lot of context. If you can show through thorough automated and manual testing that the change works, they will be more inclined to sign off on it.
Try to keep the pull requests short and focused. To make pull requests easy to review, keep the changes focused on one thing. Try not to mix refactoring with behavior changes, for example, as that bloats the size of the pull request, making it harder to review.

Assign The Change To Specific People

At companies, pull requests typically notify an entire team. If you don’t request a review from specific people, it is common for the bystander effect to occur, where everyone thinks someone else will review the pull request, so nobody reviews it!

To combat this, I recommend two solutions:

Request a review from specific people. To find out who to request a review from, look at who has previously pushed changes to this software package or area of the codebase. These engineers are likely the most capable of reviewing your change.
Message them and follow up. After publishing the review, consider sending a direct message to the reviewer to let them know you are waiting for their review. If they haven’t reviewed after two days, follow up with them. After four days, follow up with them again. This might seem aggressive, but sometimes engineers forget because they’re busy.

Use Your Manager As A Forcing Function

If you’ve done everything in the previous sections and you’re still not getting your code reviewed, it’s time to escalate to your manager.

Make it clear to your manager that you have been waiting on a code review, and that the long wait times are impacting your productivity.

Assuming you have a reasonable manager, they will likely reach out to your reviewer, which should help move things along.

If you find yourself having to do this too often, however, there may be systemic issues at play (e.g., the engineers are so overworked that they don’t have time to review code).

Your Turn!

I hope this issue gave you some ideas on how to get faster code reviews.

I’ve personally used all three of these suggestions throughout the past year and have seen some success.

Do you have any suggestions on getting faster code reviews? Reply to this email or comment below to let me know!

As always, thanks for reading!

Sammy

🤖 Supercharge Productivity With AI

Sammy Tran — Wed, 16 Oct 2024 15:00:00 +0000

Welcome to the fourth issue of the Software Mastery newsletter.

In this issue, I want to share two AI tools I use to boost my productivity as a software engineer.

When I began experimenting with AI chatbots and coding assistants after ChatGPT went viral, I wasn’t sold on using them for work.

In the early days, ChatGPT struggled to produce code snippets that ran correctly, and AI chatbot suggestions were not good.

A lot has changed in 2024, however, and I am thoroughly impressed with the improvements made in the past year.

I currently spend the bulk of my time using two AI tools:

Claude 3.5 Sonnet via Amazon Bedrock for generating code from natural language.
Amazon Q Developer for generating code in IntelliJ.

Claude 3.5 Sonnet

Claude 3.5 Sonnet is an LLM you can chat with.

Released in June 2024, Claude 3.5 Sonnet excels at complex tasks such as coding and visual understanding.

Claude 3.5 Sonnet’s Artifacts feature displays certain types of output side-by-side!

I recently used Claude 3.5 Sonnet to create matplotlib graphs for some data I wanted to visualize for a demo at work.

Despite not remembering how to use this graphing library, I produced a correct and working graph in under 30 minutes by iterating on the code with the LLM.

Claude 3.5 Sonnet is free, so consider trying it, even if you typically use ChatGPT!

Amazon Q Developer

Amazon Q Developer is an IDE plugin for Visual Studio, Visual Studio Code, and IntelliJ.

With this plugin, you can chat with Amazon Q and get inline code suggestions without leaving your IDE.

The inline code suggestions are the best part!

The inline suggestions are particularly good at writing repetitive sections of code (e.g., creating POJOs, writing unit tests, wiring things up with dependency injection, etc.).

Usually, I either go with Amazon Q’s first suggestion or continue writing code myself until it figures out what I’m trying to do.

If you’re looking for a non-Amazon alternative, I’ve heard good things about GitHub Copilot.

Your Turn!

I hope this issue inspired you to experiment with AI tools to become a better software engineer.

With the recent rise of AI software engineers like Devin, I’ve seen aspiring and current software engineers getting nervous about losing their jobs.

I don’t believe these tools will make our jobs obsolete, but I do expect software engineers will need to learn to use AI to augment their abilities.

Do you have a favorite AI tool? Reply to this email or comment below to let me know!

Thanks for reading!

Sammy

🍌 How to Learn AWS Services Fast

Sammy Tran — Wed, 09 Oct 2024 15:00:00 +0000

Welcome to the third issue of the Software Mastery newsletter.

In this issue, I want to share how I approach learning new AWS services. Since I work at Amazon, it’s no surprise that I spend many hours building on AWS.

AWS has over 200+ services, so it is impossible for anyone, even Amazon employees, to be familiar with every service.

It’s common to be asked to build something with an AWS service you’ve never used before. We live in a fast-paced world, so there probably isn’t enough time to pick up a book or course.

Whenever I have to learn a new AWS service quickly, this is what I do:

Learn what the AWS service is used for.
Understand the AWS service’s key concepts.
Learn how to create the necessary infrastructure.
Dive straight into building.

Let’s look at each step in detail, using AWS Batch as an example (I had to do this for work a few months ago!).

Learn What the AWS Service Is Used For

When learning a new AWS service, the first step is understanding the service at a high level.

I often do some combination of:

Reading the official AWS user guides.
Watching a quick YouTube video.
Using Wikipedia.

For example, according to the AWS Batch user guide:

Depending on your familiarity with batch processing, the description above may or may not make sense.

If you aren’t familiar with batch processing, reading the Wikipedia page or watching a YouTube video should help fill in the gaps.

Understand the AWS Service’s Key Concepts

All AWS services have a few fundamental terms or concepts that are essential to learn. To guide my learning, I typically refer to one or both of the resources below:

Key concepts pages from official AWS documentation.
AWS re:Invent presentations/workshops.

For AWS Batch, I would start by reading the Components of AWS Batch section of the official documentation to learn some basic terms. Next, I would watch this introductory re:Invent session from 2016.

Even though this session is eight years old, the fundamental concepts described in the video are still relevant today.

Learn How to Create the Necessary Infrastructure

At this point, you should have a rough idea of what an AWS service does, and some of the key concepts for that service.

If you’re learning an AWS service for work, the next thing you’ll likely want to learn is how to provision the necessary AWS infrastructure using your infrastructure as code (IaC) framework of choice.

Common IaC frameworks include:

For our AWS Batch example, I would Google something like “AWS Batch CDK docs” and look through the examples in the official documentation.

If you need something more structured, you could consider finding a tutorial for the framework you’re using.

Dive Straight Into Building

With all the information gathered from the previous sections, you should know enough to get started on a project or work assignment.

As you start building, you’ll inevitably have questions or need to look things up; this is normal at this stage. It is important to start building, as it will help guide and motivate your learning.

Your Turn!

I hope this issue gave you some insight into how you can pick up new AWS services using free resources available on the Internet.

Are you learning any AWS services at the moment? Reply to this email or comment on this post to let me know!

As always, thanks for reading!

Sammy

⌨ 3 IDE Shortcuts I Use Daily

Sammy Tran — Wed, 18 Sep 2024 15:00:00 +0000

Welcome to the second issue of the Software Mastery newsletter.

In this issue, I want to share three shortcuts you should be aware of when navigating large codebases as a software engineer:

Search for a file by name.
Search for a string in your codebase.
Jump to declaration (and back).

Whether you're new to a codebase or an expert, these shortcuts will make you more productive at finding what you’re looking for.

Since I primarily use IntelliJ, my examples will be for this IDE. However, all the mentioned shortcuts should also be available in other IDEs.

Search for a File by Name

Sometimes, we know the name of the file we want to find, but we either don’t remember which folder it is in or don’t want to expand a bunch of folders in an IDE’s file explorer to get to it.

In these cases, it’s useful to know how to search for a file by name. In IntelliJ, one way to do this is Ctrl + Shift + N, which opens the search everywhere window on the "Files" tab.

In this window, you can type the name of the file you want to open. For Java and other object-oriented programming languages, you’ll want to type the name of a class here (e.g., MyAwesomeClass).

Search for a String in Your Codebase

Searching for a string in a codebase is useful for various reasons:

You can search for examples of how to use some class or method.
You can find comments or documentation you vaguely remember reading before.
You can search for a piece of code you want to navigate to, even if you don’t remember the file it’s in.

In IntelliJ, you can search for a string with Ctrl + Shift + F, which opens the find in files window.

Jump to Declaration (and Back)

Finally, the last shortcut I want to share is actually a pair.

When working in an unfamiliar codebase, you often need to read code written by other people, which invokes more code written by other people, and so on.

For your sanity, you’ll want to know how to jump to the declaration of a class, method, or field and how to go back to where you were before.

In IntelliJ, you can jump to declaration with Ctrl + B. To go back, one option is Ctrl + Alt + Left Arrow.

Your Turn!

I hope this week’s issue convinced you to use these three IDE shortcuts in your day-to-day work.

Are there any other shortcuts you can’t live without? Reply to this email or comment below to let me know!

Thanks for reading!

Sammy

🔍 2 Tips on Googling Effectively

Sammy Tran — Wed, 11 Sep 2024 15:00:00 +0000

Welcome to the first issue of the Software Mastery newsletter.

In this issue, I want to share two tips about how to search effectively on Google.

Googling is a fundamental skill for software engineers, so much so that it’s a meme:

Engineers use Google for various reasons:

They forgot how to do something in a particular programming language.
They want to understand an error they’re seeing.
They need to learn about some engineering concepts.

Googling is a way to find resources, but ultimately, whether we’re able to find what we’re looking for depends on our search query.

Sometimes, the resource we’re looking for is out there, but Google isn’t ranking it highly enough in the search results for us to see it.

To refine a search query, here are two tips to get started:

Use the site: operator to restrict results to a particular site.

Use the after: operator to filter outdated results.

The `site:` Operator

For certain search queries, we’re only interested in results from specific websites. To force Google to only show us results from a particular website, we can add site: to a search query, followed by the website.

If you, for example, are particularly interested in what the people of Hacker News have to say about working at Google, you could write a search query like:

working at Google site:news.ycombinator.com

Here’s a more practical example. Suppose you’re developing on an EC2 instance and just ran docker build -t my-project . to create a Docker image for your application. After a few minutes, the command fails with the following error message:

> docker build -t my-project .
Unable to find image 'python:latest' locally
latest: Pulling from library/python
5040bd298390: Pull complete
fce5728aad85: Pull complete
76610ec20bf5: Pull complete
52f3db4b5710: Extracting [==================================================>] 129.8 MB/129.8 MB
45b2a7e03e44: Download complete
75ef15b2048b: Download complete
e41da2f0bac3: Download complete
C:\Program Files\Docker\Docker\Resources\bin\docker.exe: failed to register layer: Error processing tar file(exit status
 1): write /usr/share/doc/libfreetype6/reference/ft2-type1_tables.html: no space left on device.

To filter Google’s search results for Stack Overflow posts, you could write the following search query:

docker no space left on device site:stackoverflow.com

This type of query can be useful sometimes if websites other than Stack Overflow are ranking highly for this particular search query but do not contain what you’re looking for.

The `after:` Operator

Software engineering moves fast. As new versions of programming languages, frameworks, and libraries get released, tutorials and other resources get outdated quickly.

To retain search results after a certain year, we can add the after: operator to a search query, followed by a year, year-month, or year-month-day.

For example, if you’d only like to see Spring Boot tutorials written in 2024, you can write a search query like:

spring boot tutorial after:2023

Here’s another example that combines the after: operator with the site: operator.

Suppose I’m interested in what OpenAI has been up to in the past month, and I’m particularly interested in discussions about OpenAI on Reddit. I can find recent OpenAI-related Reddit posts with:

openai after:2024-07 site:reddit.com

Your Turn!

I hope this week’s issue gave you some ideas on how you can use Google’s search operators to find what you need on the Internet.

Do you have any tricks for refining your search queries? Reply to this email or comment below!

Thanks for reading! Until next time,

Sammy

DEV Community: Sammy Tran

🔗 Why You Should Bookmark Links

When Should I Bookmark Something?

How Do I Keep Things Organized?

Your Turn!

📚 2 Books Junior Engineers Should Read

A Good Book On Your Main Programming Language

A Philosophy of Software Design by John Ousterhout

Your Turn!

🧠 How to Learn Unfamiliar Codebases

Learn About The Codebase At A High Level

Identify Relevant Entry Points

Trace Through The Code Using An IDE

Make Changes

Your Turn!

✅ How To Get Faster Code Reviews

Make Your Change Easy To Review

Assign The Change To Specific People

Use Your Manager As A Forcing Function

Your Turn!

🤖 Supercharge Productivity With AI

Claude 3.5 Sonnet

Amazon Q Developer

Your Turn!

🍌 How to Learn AWS Services Fast

Learn What the AWS Service Is Used For

Understand the AWS Service’s Key Concepts

Learn How to Create the Necessary Infrastructure

Dive Straight Into Building

Your Turn!

⌨ 3 IDE Shortcuts I Use Daily

Search for a File by Name

Search for a String in Your Codebase

Jump to Declaration (and Back)

Your Turn!

🔍 2 Tips on Googling Effectively

The site: Operator

The after: Operator

Your Turn!

The `site:` Operator

The `after:` Operator