Su Ho | Engineering Lead

How I stay up to date as a software engineer

Mon, 10 Feb 2025 13:12:12 GMT

“Am I falling behind the team?”

Many developers quietly ask themselves this question. It can feel worse when teammates seem to know every new tool and practice.

One of my direct reports once asked, “How often do you check technology news, such as library updates?”

That question stayed with me because I had faced the same problem. Staying current can compete with the time we need to build deeper expertise.

Over time, I built a small system that helped me grow from a junior developer into an engineering leader. It turns a noisy stream of updates into a manageable learning routine.

Start with a few reliable sources#

Start with sources that match your primary technology stack. Your stack might include iOS, Android, Ruby on Rails, or another web framework.

Follow developers, technical blogs, and maintainers whose work you trust. Medium, DEV, X, Substack, GitHub, and LinkedIn can help you find them.

You can also follow engineering blogs from Netflix, Cloudflare, Meta, and Google. Communities such as Hacker News and Lobsters are also useful.

For code changes, watch the repositories and release notes for your main frameworks. Keep the official documentation nearby when you need to verify a claim.

Books and courses can help when you want a more structured path. YouTube and Udemy are two places to look.

Learn with other people#

Reading is only part of the system. Online and local communities give you a place to ask questions and compare experiences.

Discord and Slack communities can make those conversations easier. Local meetups and conferences can help you build relationships outside your company.

When you feel ready, try speaking or mentoring. Explaining an idea to someone else often shows you which parts you still need to learn.

Connect online discussion with local relationships

Online spaces keep questions moving. Local events turn useful exchanges into stronger professional relationships.

Ask and share

Bring insights back

Online communities

Discussion forums Stack Overflow, Reddit Chat platforms Discord, Slack

Local events

Language meetups Practice with nearby peers Conferences Compare broader experience

Discussion forums

Forums preserve searchable questions and detailed answers. They work well when you need context that others can reuse.

Try: Write one precise question and include what you already tried.

The goal is not to join every community. Choose one or two places where the discussions help you learn.

Build a routine you can keep#

A small routine is easier to keep than an ambitious study plan. Consistency matters more than intensity.

Try spending 20 to 30 minutes each day on one activity. You can read an article, review an open-source repository, or watch a technical talk.

Add one weekly goal when that routine feels comfortable. Study a concept, test a tool, or write about what you learned.

Turn daily inputs into weekly practice

Small daily inputs create exposure. One focused weekly session converts a useful signal into understanding or practice.

Steady exposure
builds depth

Daily

20-30 min

Read an article Review open source Watch a talk

Weekly

One focused session

Deep-dive a concept Experiment with a tool Write what you learned

Read an article

A short article keeps you exposed to new practices without taking over the day.

Try: Save one useful point for your weekly session.

Start small, even if you only have 15 minutes. Keep a learning journal and review it each month. Adjust the routine when it stops working for you.

Improve the routine with evidence

Start with a small commitment, record what happens, then use the evidence to shape the next version of your routine.

A simple loop
creates steady improvement

1 Start small 15 minutes 2 Track progress Learning journal 3 Adjust and iterate Review monthly

Start small

A small starting point lowers the cost of beginning and makes consistency more realistic.

Try: Set a timer and begin one focused activity.

What my system looks like#

I started my career as a software developer who worked mainly on mobile applications. I later became a Senior Software Developer and then an Engineering Lead.

As my role changed, my reading changed with it. I now follow iOS, mobile development, web development, leadership, and artificial intelligence (AI).

These are some of the resources in my current system:

I also participate in these communities:

Start with a small system#

You do not need to copy my entire setup. Start with four small steps:

Choose three resources that you want to follow.
Join one online community.
Set aside 20 minutes daily for learning.
Create a simple learning journal.

Staying current does not mean knowing everything. A useful system helps you notice what matters, learn at a steady pace, and protect time for deeper work.

If you build your own version, I would enjoy hearing what works for you. Share it with me on X or LinkedIn.

What is your leadership style?

Tue, 07 Jan 2025 09:28:45 GMT

Leading can be hard. Sometimes, it just sucks.

I learned that quickly when someone asked me to become an Engineering Lead. I had little experience in people management, and I did not know how to describe my leadership style.

Looking back, I had already used different approaches to handle team challenges. I just did not have clear names for them.

This post introduces six leadership styles through software engineering examples. The reflection questions can help you recognize the styles that you already use.

What is a leadership style?#

A leadership style is the approach that you use to guide, influence, and support a team. It appears in how you make decisions, communicate, and manage the work.

See your style in three daily behaviors

Leadership becomes easier to recognize when you inspect how you communicate, make decisions, and support the team.

Leadership styleYour repeated choices

1 Communication Share context and feedback 2 Decision-making Involve, decide, and delegate 3 Team support Build autonomy and growth

Communication

Communication shows how you explain the why, align on information, invite feedback, and handle conflict.

Try: Ask whether the team has enough context to act without guessing.

Reflect on how you lead#

You do not need a formal test to begin. Start with a few honest questions about how you work with your team.

Decision-making#

How do you make choices?
Who do you involve in a decision?
Which decisions do you delegate?
How much autonomy do team members have?

Communication#

Which communication channels do you use, and how often?
How do you give and receive feedback?
How do you share information with the team?
How do you handle conflict?

Team support#

How do you motivate direct reports and team members?
How do you approach performance reviews?
How do you support each person’s development?
How do you set goals with the team?

Your answers will probably change with the situation. That does not make them inconsistent. Many leaders combine several styles and adjust them over time.

Leadership styles#

Each style below has useful qualities and real limitations. As you read, think about the situations where you recognize your own behavior.

Transactional leadership#

Transactional leadership focuses on clear exchanges between leaders and team members. Leaders define structured tasks, expected results, rewards, and consequences.

These leaders set clear expectations and goals for their team. They monitor performance and provide feedback based on outcomes.

This clarity can help with routine tasks, compliance work, and measurable goals. A rigid version of the style can limit creativity. Morale can also fall when output becomes the only measure of success.

Create a clear performance loop

Transactional leadership defines the exchange, supports execution, reviews the result, and returns to a clearer expectation.

Transactional leadershipExplicit exchange

1 Set expectations Task, target, owner 2 Connect outcomes Rewards and consequences 3 Focus execution Deliver known work 4 Review performance Monitor and give feedback

Set expectations

Clear expectations define what success looks like, which standards apply, and who is accountable.

Try: Confirm the expected result before discussing the method.

Transformational leadership#

Transformational leadership uses a shared vision to inspire change. These leaders connect daily work with a larger purpose and encourage people to grow.

The four I’s of Transformational Leadership
1. Idealized Influence: Leaders act as role models for their team, inspiring trust and respect.
2. Inspirational Motivation: Leaders communicate a vision for the future, motivating team members to achieve their best.
3. Intellectual Stimulation: Leaders encourage creativity and innovation. They provide learning opportunities and welcome different perspectives and ideas.
4. Individualized Consideration: Leaders focus on the unique potential of each team member, providing personalized support and development opportunities.

This style can support engagement, creativity, and meaningful change. It can be less effective during a crisis that requires a quick decision. An ambitious vision can also cause burnout when resources do not match it.

Laissez-faire leadership#

Laissez-faire leadership gives team members significant autonomy and little direct supervision. Leaders provide resources, then let the team manage its work and decisions.

Laissez-faire (/ˌlesāˈfer/) is French for “let them do what they want.”

This style empowers experienced team members and encourages innovation. It can also increase job satisfaction for self-motivated employees. However, less experienced team members might lack direction. Teams can also become misaligned with organizational goals without effective monitoring.

Servant leadership#

Servant leadership puts the team’s needs before the leader’s authority or personal interests. These leaders focus on support, trust, well-being, and development.

Traditional Leader	Servant Leader
Views leadership as a position of power and authority.	Views leadership as a chance to serve others.
Uses power and control to direct and manage team members.	Shares power and control to drive engagement.
Measures success through outcomes and results.	Measures success through growth and development.
Speaks	Listens

This style builds relationships and trust within the team. It can improve collaboration, cohesion, and performance. However, leaders might struggle to make decisions in high-pressure situations. Without clear direction, others might think that these leaders lack authority.

Autocratic leadership#

Autocratic leadership gives one leader most of the decision-making authority. The leader assigns tasks and processes with little input from the team.

This style supports quick decisions during crises or situations that require clarity. It also creates consistent task execution. However, it can cause low morale and high turnover when team members feel undervalued. It also limits creativity by excluding the team’s insights and expertise.

Democratic leadership#

Democratic leadership invites team members to participate in decisions. The leader gathers different views, helps the group build consensus, and guides the overall direction.

This style increases team member support and commitment to decisions. Diverse input can create a culture of collaboration and innovation. However, consensus can make decisions slow. Conflicting opinions can also cause indecision without a clear resolution process.

So, what is your leadership style?#

After exploring these styles, return to the reflection questions. Your answers can show which approaches you use most often.

You do not need one permanent leadership style. A thoughtful leader adapts while staying clear and consistent with the team.

I am still learning which approach fits each situation. If you want to compare notes, mention me on X or LinkedIn. I would enjoy hearing what leadership looks like for you.

iOS security best practices for storing sensitive data

Sun, 10 Nov 2024 00:00:00 GMT

Sensitive data can leak from places that seem harmless during development. Local storage, debug logs, and third-party software development kits (SDKs) all deserve a careful review.

This post covers the checks that I use as a practical starting point.

Local data storage#

iOS applications often handle passwords, secret keys, and personally identifiable information (PII). Match the storage method to the sensitivity of each value.

Do not save authentication tokens or credentials in UserDefaults without encryption.
Do not store application programming interface (API) keys or encryption keys in .plist files or hard-coded strings.

Store sensitive values in Keychain. When cryptographic keys need hardware protection, consider the Secure Enclave.

For more advanced cases, consider envelope encryption and store the root key in Keychain.

Use kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly with SecAccessControlCreateWithFlags to restrict Keychain access to an unlocked, passcode-protected device.

Logging#

Logs are useful during development, but they can expose sensitive data. Review calls to NSLog, assert, print, and any custom logging tools.

Remove log statements that include credentials, tokens, personal data, or request contents that can contain those values.

If logs are required, enable them only in DEBUG or development builds.

AppDelegate.swift

#if DEBUG
    NSLog(...)
#endif

Third-party SDKs#

I have integrated Firebase, Braze, and AppsFlyer into mobile applications. These services can process user behavior and advertising data.

Before you add a third-party SDK, check which data your app sends to it. I use these review steps:

Review their code, requested permissions, and known vulnerabilities.
Anonymize data before sending it to third-party services to prevent PII exposure.
Encrypt data, such as email addresses, before sending it when required.
Inspect all API requests for sensitive information. Use Proxyman to intercept and inspect traffic between the client and service.

These checks will not replace a full security review. They will help you catch common data exposure problems before a release.

How I troubleshoot iOS Universal Links

Wed, 23 Oct 2024 00:00:00 GMT

Universal Links can be frustrating when a working integration suddenly stops opening the app. My team ran into that exact problem.

The project configuration had worked before, but the links started opening in Safari. We needed a way to narrow down the cause.

This guide focuses on an existing integration. If you are setting up the feature, start with Apple’s Universal Links documentation.

Confirm the basic association#

Before troubleshooting, confirm that your project has a two-way association between the app and website. This association specifies the URLs that your app handles.

Host the apple-app-site-association file at /.well-known/apple-app-site-association on your website. Add the Associated Domains capability with an applinks configuration to your Xcode project.

Check where the link opens#

If the link opens your app’s home screen, the basic association is working. The remaining problem is probably in the app’s URL routing.

Handle the URL in the app, then route it to the correct screen or flow for that endpoint.

If the link opens Safari, inspect the Apple App Site Association (AASA) file. This check is useful when the same configuration worked before.

Test the link from Notes#

I use the Notes app for a quick check. Add each URL that you want to test. Then touch and hold a link to view its options.

If Universal Links are configured correctly, you should see two options:

Open in {Your App Name}
Open in Safari

Your choice sets the default behavior for future Universal Links from that domain. Repeat the test to select the other option.

If you do not see Open in {Your App Name}, check whether the AASA file is publicly accessible.

Inspect the public AASA file#

Run this command in Terminal:

Terminal window

curl -v https://{your-domain}/.well-known/apple-app-site-association

A 301 or 302 HTTP status code indicates a redirect. The hosted AASA file must be directly accessible.

A redirect is allowed when another app triggers the Universal Link. Safari opens first, then your app opens.
A 403 or 404 HTTP status code indicates an access problem. The file might not be public, or another rule might block it.

I encountered this issue when Cloudflare blocked all bot traffic to the website. Cloudflare classified AASA requests as bot traffic. Ensure that your configuration permits direct AASA access from all geographic locations and Internet Protocol (IP) addresses.

Check Apple’s cached AASA file#

Finally, verify which AASA file Apple’s content delivery network (CDN) has cached for your domain.

Open this URL in your browser: https://app-site-association.cdn-apple.com/a/v1/{your-domain}.

Alternatively, run this command in Terminal:

Terminal window

curl -v https://app-site-association.cdn-apple.com/a/v1/{your-domain}

Compare this response with the file on your website. The Apple CDN response is the version available to your app.

When you install the app, the device immediately downloads the AASA file from the CDN. The device checks for updates approximately once a week. Reinstall the app to download a newer file because the CDN has no direct invalidation option.

These checks helped my team separate an app routing problem from a website or CDN problem. I hope they make your next investigation a little easier.

If problems remain, see Apple’s TN3155: Debugging universal links.

How the two-pointer technique works

Tue, 10 Sep 2024 00:00:00 GMT

The two-pointer technique tracks two positions in the same collection. Each pointer moves according to the result of the current comparison.

This technique often replaces a nested search with one pass. It works well with sorted arrays, linked lists, pairs, triplets, and subarrays.

When to consider two pointers#

Look for two pointers when the input is already sorted. You can also use them when sorting does not remove information that you need.

For example, suppose you need to find two values in a sorted array whose sum matches a target. Start one pointer at each end:

hasPairWithSum.ts

function hasPairWithSum(values: readonly number[], target: number): boolean {
  let left = 0;
  let right = values.length - 1;

  while (left < right) {
    const sum = values[left] + values[right];

    if (sum === target) {
      return true;
    }

    if (sum < target) {
      left += 1;
    } else {
      right -= 1;
    }
  }

  return false;
}

Move the left pointer when the sum is too small. Move the right pointer when the sum is too large.

Each pointer visits the array at most once. The algorithm uses O(n) time and O(1) extra space.

If you must return original indexes, keep them before sorting. Sorting an unsorted array changes those indexes.

Problems to practice#

These problems use different forms of the same technique:

You can find more examples in the two-pointer problem list on LeetCode.

Libraries I consider for a new iOS project

Tue, 23 Apr 2024 00:00:00 GMT

I do not add the same dependencies to every iOS project. Each dependency adds maintenance work, so it should solve a clear problem.

Still, a short list helps when I start a project. These are the libraries and tools that I consider first.

User interface#

I prefer SwiftUI for new interfaces, so this section does not include UIKit-specific libraries.

`Kingfisher`#

Kingfisher handles common image downloading, caching, and display tasks:

Load images asynchronously.
Cache images.
Display placeholders, loading indicators, and fade-in effects for downloaded images.
Load animated images, such as Graphics Interchange Format (GIF) files.

I consider Kingfisher when an app loads many remote images or needs more control than a small custom loader provides.

Networking#

`Alamofire`#

Alamofire is a Swift Hypertext Transfer Protocol (HTTP) networking library. Its interface builds on Apple’s Foundation networking stack.

Alamofire can:

Make network requests.
Handle, validate, and cache responses.
Handle authentication.
Download and upload data.
Adapt and retry requests.
Apply security controls, such as Secure Sockets Layer (SSL) pinning.

Foundation can handle many networking needs without another dependency. I consider Alamofire when its request adapters, retries, or response handling remove meaningful project code.

Security#

`KeychainAccess`#

iOS apps must protect passwords, authentication tokens, and other credentials. KeychainAccess wraps Keychain with a smaller Swift interface.

KeychainAccess provides these features:

Store and retrieve sensitive data in the keychain.
Synchronize Keychain items with iCloud.
Integrate with Touch ID and Face ID.
Use Shared Web Credentials.

Tools#

`Firebase/Crashlytics`#

Firebase Crashlytics is a crash-reporting tool from Google’s Firebase platform. It helps teams investigate crashes that affect users.

Firebase Crashlytics provides these capabilities:

Curated crash reports with detailed stack traces.
Real-time alerts for new issues, regressed issues, and growing issues.

`SwiftLint`#

SwiftLint enforces Swift style and conventions in your codebase. Its configurable rules can match your team’s coding standards and preferences.

SwiftLint provides:

Code style enforcement.
Customizable rules and configurations.
Integration with Xcode and continuous integration and continuous delivery (CI/CD) pipelines.

Integrate the dependencies with CocoaPods#

This example uses CocoaPods as the dependency manager. Add the dependencies that your project needs to its Podfile:

Podfile

# User Interface
pod 'Kingfisher'

# Networking
pod 'Alamofire'

# Security
pod 'KeychainAccess'

# Tools
pod 'Firebase/Crashlytics'
pod 'SwiftLint'

Treat this list as a starting point, not a project template. Before you add a dependency, check its maintenance status and confirm that the project needs it.

Why my iOS team switched to Clean Architecture

Wed, 27 Mar 2024 00:00:00 GMT

Switching to Clean Architecture helped our mobile teams collaborate. It also added boilerplate and complexity, so the decision was not free.

This post explains why we changed our iOS architecture and what happened afterward. If the approach is new to you, read The Clean Architecture first.

The problem we needed to solve#

Before switching to Clean Architecture, we used the View, Interactor, Presenter, Entity, and Router (VIPER) architecture. VIPER is well known in the iOS community, and many companies have adopted it.

Our iOS developers understood VIPER, but developers outside the team did not always know its terms. That difference mattered when we started rotating people across iOS, Android, and Flutter projects.

Without a shared architecture, developers needed more time to understand code from another platform. Even familiar ideas had different names.

The architecture we chose#

After research and discussion, we chose Clean Architecture with model-view-viewmodel (MVVM). Google’s Guide to App Architecture inspired our implementation.

The guide targets Android projects, but its boundaries and terms also made sense for our other mobile platforms.

Why Clean Architecture fit our team#

After comparing Clean Architecture with VIPER, we found these differences:

VIPER and Clean Architecture use different terms. For example, an iOS developer might say Interactor while an Android developer says UseCase.
Clean Architecture and MVVM gave our mobile developers shared terms. Those terms made cross-platform discussions and code reviews easier.
VIPER was unfamiliar to some iOS developers. New team members had to learn its components, abstractions, and vocabulary before they could contribute comfortably.

What changed for us#

We switched to Clean Architecture with MVVM and now use it for new projects. Collaboration across iOS, Android, and Flutter has improved.

Mobile developers can discuss a UseCase, Repository, Domain Layer, or Data Layer with the same meaning. They can also review code from other platforms with less context.

We created a document that explains how to implement Clean Architecture with MVVM on iOS. Its sections cover the Presentation, Domain, and Data layers with code examples.

We also applied Clean Architecture and MVVM to our iOS templates. The templates give new projects the same starting structure.

Clean Architecture is not a default answer for every project. Discuss the extra boundaries and boilerplate before your team adopts it. For us, the shared cross-platform language made that cost worthwhile.

This change worked because it addressed a collaboration problem that our team could already see. If your team has a similar problem, the same architecture might be worth exploring.

If you have questions, mention me on X or LinkedIn with this post.

My #GitHubUnwrapped

Mon, 01 Jan 2024 00:00:00 GMT

This video shows my GitHub activity in 2023.

Why a Next.js lint check can miss TypeScript errors

Tue, 26 Dec 2023 00:00:00 GMT

Linting and type checking can look like the same safety net, but they catch different problems. I learned that when a passing workflow still produced a failed build.

Why linting was not enough#

I had a continuous integration (CI) workflow for a Next.js and TypeScript project. The workflow only ran the linter:

linting.yml

- name: Install dependencies
  run: npm ci

- name: Lint code
  run: npm run lint

The lint check passed, but the production build failed during type checking. The linter and TypeScript compiler were checking different problems.

Add an explicit type check#

I fixed the gap by running the TypeScript compiler before the linter.

First, add a typecheck script to package.json:

package.json

{
  "scripts": {
    "typecheck": "tsc --noEmit"
  }
}

Then add the new step to the CI workflow:

linting.yml

- name: Install dependencies
  run: npm ci

# Add a type-checking step.
- name: Typecheck
  run: npm run typecheck

- name: Lint code
  run: npm run lint

The workflow now stops on type errors before it starts the production build. For more context, see the related Next.js discussion.

How I check Cloudflare image caching with Dr.FLARE

Fri, 15 Dec 2023 00:00:00 GMT

Cloudflare image caching can be hard to inspect from response headers alone. I use Dr.FLARE, a Chrome extension, to make that process easier.

The extension presents cache information in a visual format. It can help you understand how Cloudflare handles each image request.

For setup details, see the Cloudflare Community post about the Dr.FLARE debugging extension.

How to sign Git commits with GPG on macOS

Wed, 29 Nov 2023 00:00:00 GMT

GNU Privacy Guard (GPG) lets you sign Git commits with a cryptographic key. Git hosting services can then mark the commit as verified.

The setup has a few moving parts on macOS. Here is the sequence that works for my configuration.

Install and configure GPG#

Install GPG and pinentry-mac with Homebrew:

Terminal window

brew install gnupg pinentry-mac

pinentry-mac lets you enter the key passphrase in a macOS window instead of Terminal.

Create the GPG configuration directory with private permissions:

Terminal window

mkdir -p ~/.gnupg
chmod 700 ~/.gnupg

Add pinentry-mac to the GPG agent configuration:

Terminal window

echo "pinentry-program $(which pinentry-mac)" >> ~/.gnupg/gpg-agent.conf

Add this line to the startup file for your shell:

Terminal window

export GPG_TTY=$(tty)

For Zsh, use ~/.zshrc. For Bash, use ~/.bash_profile or ~/.bashrc, depending on how you start the shell.

Reload the startup file. This example reloads ~/.zshrc:

Terminal window

source ~/.zshrc

Stop the current GPG agent. GPG will start it again when needed:

Terminal window

gpgconf --kill gpg-agent

Create a signing key#

Start the interactive key generator:

Terminal window

gpg --full-generate-key

Choose a supported key type and size. Set an expiration period that fits how you plan to manage the key.

Use an email address that you have verified on GitHub. GitHub uses this address when it verifies a commit signature.

List your secret keys with their long IDs:

Terminal window

gpg --list-secret-keys --keyid-format=long

The output includes a line similar to this one:

Terminal window

sec   rsa4096/YOUR_LONG_KEY_ID 2026-08-21 [SC]

Copy the value after the slash. The remaining examples use YOUR_LONG_KEY_ID as a placeholder.

Export the public key:

Terminal window

gpg --armor --export YOUR_LONG_KEY_ID

Configure Git to use the key and sign commits by default:

Terminal window

git config --global user.signingkey YOUR_LONG_KEY_ID
git config --global commit.gpgsign true

Create a signed test commit:

Terminal window

git commit -S -m "Test signed commit" --allow-empty

The pinentry-mac window asks for your passphrase. Enter it and select OK.

Add the public key to GitHub#

Copy the public key:

Terminal window

gpg --armor --export YOUR_LONG_KEY_ID | pbcopy

Then sign in to GitHub. Open Settings > SSH and GPG keys and add the copied public key.

GitHub can now verify commits that use this key and a verified email address from your account.

For more detail, see the official guides for creating a GPG key, configuring Git with that key, and configuring GPG Agent.

How I rebase linked or chained pull requests

Tue, 28 Nov 2023 00:00:00 GMT

Linked pull requests let me split a large change into smaller reviews. The tradeoff appears when an earlier branch changes or merges.

Git provides two options that make this cleanup easier. I use --onto for one branch and --update-refs for a branch chain.

Move one branch with `--onto`#

Consider the following Git history:

gitGraph
    commit id: "0-19as8su"
    commit id: "1-0a9s8ds"
    branch feature-1
    checkout feature-1
    commit id: "2-a0s9asd"
    commit id: "3-ss91820" type: HIGHLIGHT
    branch feature-2
    checkout feature-2
    commit id: "4-as98dam"
    commit id: "5-as0d9km"
    checkout feature-1
    commit id: "6-0as9d8s"
    commit id: "7-as90dia"
    checkout main
    merge feature-1 id: "8-0as9d8s"

We create feature-1 from main. We then create feature-2 from feature-1 and continue working on it.

Later, we add two commits to feature-1 and merge that branch into main.

At this point, feature-2 still starts from the earlier feature-1 commit. Check out feature-2, then move its commits onto main:

Terminal window

git checkout feature-2
git rebase --onto main 3-ss91820

Here, 3-ss91820 is the commit where feature-2 branched from feature-1. Git takes the later commits and reapplies them onto main.

The new history looks like this:

gitGraph
    commit id: "0-19as8su"
    commit id: "1-0a9s8ds"
    branch feature-1
    checkout feature-1
    commit id: "2-a0s9asd"
    commit id: "3-ss91820" type: HIGHLIGHT
    checkout feature-1
    commit id: "6-0as9d8s"
    commit id: "7-as90dia"
    checkout main
    merge feature-1
    branch feature-2
    checkout feature-2
    commit
    commit

Update a branch chain with `--update-refs`#

The --update-refs option can update the branches in a chain during one rebase. Consider this history:

%%{init: { 'gitGraph': {'showCommitLabel': false}} }%%
gitGraph
    commit
    commit
    branch feature-1
    checkout feature-1
    commit
    commit
    branch feature-2
    checkout feature-2
    commit
    commit
    checkout feature-2
    branch feature-3
    checkout feature-3
    commit
    commit
    commit
    checkout feature-1
    commit
    commit
    checkout main
    merge feature-1

After we merge feature-1 into main, the remaining work has two parts:

Rebase feature-2 onto main.
Rebase feature-3 onto feature-2.

Check out the last branch in the chain. Then use --update-refs to complete both steps:

Terminal window

# Check out the top branch in the chain.
git checkout feature-3

# Rebase the branch onto main and update every branch in the chain.
git rebase main --update-refs

The new history looks like this:

%%{init: { 'gitGraph': {'showCommitLabel': false}} }%%
gitGraph
    commit
    commit
    branch feature-1
    checkout feature-1
    commit
    commit
    checkout feature-1
    commit
    commit
    checkout main
    merge feature-1
    branch feature-2
    checkout feature-2
    commit
    commit
    checkout feature-2
    branch feature-3
    checkout feature-3
    commit
    commit
    commit

This approach keeps the branch relationships intact without a separate rebase for every branch. I still review the new history before I force-push anything.

A better architecture for implementing forms in iOS applications

Tue, 04 May 2021 00:00:00 GMT

How to implement a clean, maintainable form architecture with UITableView.

Creating a local authentication SDK on CocoaPods

Wed, 24 Mar 2021 00:00:00 GMT

A step-by-step guide to creating and publishing a biometric authentication SDK on CocoaPods.

Su Ho | Engineering Lead

How I stay up to date as a software engineer

Start with a few reliable sources#

Learn with other people#

Online communities

Local events

Build a routine you can keep#

What my system looks like#

Start with a small system#

What is your leadership style?

What is a leadership style?#

Reflect on how you lead#

Decision-making#

Communication#

Team support#

Leadership styles#

Transactional leadership#

Transformational leadership#

Laissez-faire leadership#

Servant leadership#

Autocratic leadership#

Democratic leadership#

So, what is your leadership style?#

iOS security best practices for storing sensitive data

Local data storage#

Logging#

Third-party SDKs#

How I troubleshoot iOS Universal Links

Confirm the basic association#

Check where the link opens#

Test the link from Notes#

Inspect the public AASA file#

Check Apple’s cached AASA file#

How the two-pointer technique works

When to consider two pointers#

Problems to practice#

Libraries I consider for a new iOS project

User interface#

Kingfisher#

Networking#

Alamofire#

Security#

KeychainAccess#

Tools#

Firebase/Crashlytics#

SwiftLint#

Integrate the dependencies with CocoaPods#

Why my iOS team switched to Clean Architecture

The problem we needed to solve#

The architecture we chose#

Why Clean Architecture fit our team#

What changed for us#

My #GitHubUnwrapped

Why a Next.js lint check can miss TypeScript errors

Why linting was not enough#

Add an explicit type check#

How I check Cloudflare image caching with Dr.FLARE

How to sign Git commits with GPG on macOS

Install and configure GPG#

Create a signing key#

Add the public key to GitHub#

How I rebase linked or chained pull requests

Move one branch with --onto#

Update a branch chain with --update-refs#

A better architecture for implementing forms in iOS applications

Creating a local authentication SDK on CocoaPods

`Kingfisher`#

`Alamofire`#

`KeychainAccess`#

`Firebase/Crashlytics`#

`SwiftLint`#

Move one branch with `--onto`#

Update a branch chain with `--update-refs`#