DEV Community: Masafumi Saito

Python Testing and Debugging for beginners

Masafumi Saito — Sat, 12 Jul 2025 06:56:08 +0000

Python Testing and Debugging

Today, I want to share some thoughts on errors and debugging that we encounter all the time when writing programs, plus some strategies to prevent them.

Specifications, Testing, and Debugging

First, let's clarify some terms.

Specification

A specification is what you want to achieve by writing your program.

Testing

Testing means actually running your program to see if it meets the specification. The input and expected output pairs you use for testing are called test cases.

Debugging

Sometimes when you test your program, it doesn't work as specified. We call these issues bugs, and the process of fixing them is called debugging.

Development Flow

Analyze the specification
Write the program
Test it
Debug it
Test again...

You keep repeating steps 1-4 in a loop.

Useful Statements for Debugging

`assert` Statement

The assert statement is super useful for testing and debugging.

It declares that the condition following assert should be True. If it's false, you get an AssertionError.

Here's what happened when I triggered an AssertionError in my terminal:

The assert statement stays quiet when conditions are met, but throws an error when they're not. This makes it perfect for checking preconditions in your program.

`print` Statement

The print statement is your next best friend.

It's super handy for checking what's happening inside functions during execution. Local variables (variables defined inside functions) can't be accessed from outside the function, so print statements help you peek inside.

Let's look at an example with a function that takes x, y, z arguments and swaps x and y:

The AssertionError tells us something's wrong, but it's hard to figure out exactly what. That's where print statements come to the rescue.

Using print statements, we can see that after the first if statement, the local variable values got messed up.

By adding a local variable, we can get the intended behavior and make the AssertionError disappear.

Types of Errors

There are basically three types of errors.

Syntax Errors

Syntax errors happen when your code doesn't follow Python's rules.

Common examples:

Forgetting to close quotes or brackets

Forgetting colons

Messed up indentation

Syntax errors don't happen during program execution - they prevent the program from running at all.

Runtime Errors

Runtime errors occur when you're actually running the program.

Examples include:

Using undefined variables or functions → NameError
Trying to reference a local variable as if it were global → UnboundLocalError
Dividing by zero → ZeroDivisionError

Runtime errors have specific, descriptive names. Reading the error messages carefully often helps you fix them.

Logic Errors

Logic errors happen when your program runs fine but doesn't do what you intended. This isn't really an error with the program itself - it's a mistake made by the programmer.

Most bugs are actually logic errors.

This is where assert statements shine again. By adding assertions to check preconditions, you can convert logic errors into AssertionErrors, making them easier to spot.

Combining assert and print statements gives you the basics of debugging.

Keep struggling (and enjoying) your Python learning journey!

See you later! 👋

Python Beginner's Take on Software 3.0

Masafumi Saito — Fri, 11 Jul 2025 15:01:23 +0000

A Python Beginner's Take on Software 3.0

Today I tried to think through Andrej Karpathy: Software Is Changing (Again)https://youtu.be/LCEmiRjPEtQ?si=cc4WYlH3Jj3U3RnD and figure out my learning path going forward.

The Evolution of Software

Software 1.0

Humans write code and give instructions to computers. Like writing if statements and for loops.

Software 2.0

Instead of humans writing code, we train neural networks through datasets and optimization using neural network weights.

Software 3.0

Programming LLMs using natural language (English). This will gradually replace code written in Software 1.0 and 2.0.

Coding Beginner's Honest Opinion

I'm just a coding beginner - didn't study computer science or anything. I do vibe coding sometimes, using natural language to code. But here's the thing - I can't properly evaluate what gets generated. There might be security issues, tests might pass but maybe they're not designed well... I'm always worried about stuff like that. That's why I started learning from scratch.

I think the future work for people in software boils down to three things:

Building stuff using AI
Setting up environments so AI can work smoothly
Giving proper feedback to AI systems

That's exactly why I think mastering Software 1.0 and 2.0 is crucial in the Software 3.0 era.

When you think of AI as a team member, everyone needs to play a manager-like role - removing blockers so AI can do its thing effectively.

Being able to code × Management skills × Some other strength

It's all about this multiplication. That's what I want to figure out.

What do you think about that? What should we focus on in this new era?

Python Learning Progress for a Japanese Beginner

Masafumi Saito — Thu, 10 Jul 2025 13:18:48 +0000

Python Learning Progress for a Japanese Beginner

I decided to use the University of Tokyo's Python lecture materials (https://utokyo-ipp.github.io/IPP_textbook.pdf) to build my Python fundamentals before diving into the Pymodbus library.

Why Did I Pick the University of Tokyo Materials?

At first, I was thinking about using Automate the Boring Stuff with Python (https://automatetheboringstuff.com/), which is recommended on Python's official beginner guide (https://wiki.python.org/moin/BeginnersGuide/NonProgrammers).

Automate the Boring Stuff with Python

English
Free web version

University of Tokyo Python Lecture Materials

Japanese
Covers the absolute basics
Available in HTML, Google Colab, and printable PDF versions - all completely free

Why I Went with the Japanese Materials

I wanted to learn in Japanese (my native language) so I could really understand everything properly

- From experience, I learn way better when I can read from paper

Today's Progress

Today I studied basic arithmetic operations and fundamental variable declaration and assignment.

Two things really stuck with me:

Division operators: The clear difference between regular division / and integer division // was a nice refresher
Assignment statements: When you define variables using =, it's called an "assignment statement," and executing it is called "assignment." The assignment statement takes the result from the right side and assigns it to the left side. But this is totally different from the mathematical =, which represents substitution.

I'm planning to take it slow and make sure I really get it.

Catch you later! 👋

Modbus Protocol - A Python Beginner's Summary

Masafumi Saito — Wed, 09 Jul 2025 13:26:52 +0000

Modbus Protocol - A Python Beginner's Summary

I work in Tokyo as a B2B sales rep for wastewater treatment equipment. Recently, there's been growing demand not just for automated equipment itself, but also for remote monitoring and IoT integration of facilities.

How can I respond to these needs? This question is what motivated me to start learning Python, AWS, AI, and ML.

Today, I want to leave some notes about the Modbus Protocol, which is the foundation of Python's Pymodbus library, from a beginner's perspective.

What is the Modbus Protocol?

The Modbus Protocol is a set of communication rules for industrial machines to talk to each other. Originally developed by Modicon (a PLC manufacturer) in 1979.

The protocol specifications are publicly available and anyone can use it commercially for free.

Due to its simplicity, many industrial devices support the Modbus Protocol.

How Modbus Protocol Communication Works

Modbus Protocol uses a master/slave communication method.

Master (Client): PC, monitoring systems

Slave (Server): Sensors, actuators, PLCs

The actual process works like this:

Master sends a command (request)
Only the specified slave executes that command
Slave sends back the result (response)
Master receives the result

Internal Structure of Modbus-Compatible Devices

1. Memory Space (Data Areas)

Modbus Protocol-compatible devices have 4 types of memory spaces for storing information, just like PC memory. These are called data areas.

Coil: Stores digital values (ON/OFF or True/False), read/write access
Discrete Input: Stores digital values (ON/OFF or True/False), read-only access
Input Register: Stores analog values (numerical data), read-only access
Holding Register: Stores analog values (numerical data), read/write access

Item	Digital Values	Analog Values
Data Nature	Discrete (ON/OFF)	Continuous (numerical)
Representation	True/False, 1/0	0~65535 numbers
Data Size	1 bit	16 bits
Use Cases	Switches, relays, LEDs	Temperature, pressure, flow, voltage
Modbus Data Areas	• Coil • Discrete Input	• Input Register • Holding Register

Key Point

Each manufacturer and model stores different things in different areas, so you must always check the manual.

Example: Temperature Controller

Data Area	Data Type	Access	Stored Information
Coil	Digital	Read/Write	Heater control, alarm reset
Discrete Input	Digital	Read-only	Alarm status, operation status
Input Register	Analog	Read-only	Current temperature, sensor values
Holding Register	Analog	Read/Write	Set temperature, control parameters

2. Types of Modbus Communication

Type	Communication Method	Data Format	Connection	Features
Modbus RTU	Serial communication	Binary	RS-485 cable	• Most common • Fast & efficient • Compact data
Modbus ASCII	Serial communication	ASCII characters	RS-485 cable	• Human-readable format • Easy to debug • Double data volume
Modbus TCP/IP	Ethernet	Binary	LAN cable	• LAN cable connection • Internet capable • High-speed, long-distance

Modern PLCs (Mitsubishi Electric, Omron, Keyence, etc.) have standard support for Modbus TCP/IP communication, making it mainstream for new systems.

Summary

I didn't get to write much code today, but I gained some fundamental knowledge about the technology that supports IoT.

Next time, I want to try writing actual Modbus communication code using the Pymodbus library.

See you tomorrow! 👋

AWS CLI and CDK Setup Journey - Part 2

Masafumi Saito — Tue, 08 Jul 2025 16:24:15 +0000

AWS CLI and CDK Setup Journey - Part 2

Continuing from yesterday, I'm diving deeper into AWS CLI and CDK setup today!
Yesterday's post 👇
https://dev.to/tofu1216/setting-up-aws-cli-and-cdk-2onp

Still following this awesome AWS official documentation:
https://docs.aws.amazon.com/cdk/v2/guide/hello-world.html

Here's my real experience going through Steps 5-12, including the bumps I hit along the way.

Step 5: Check Your CDK Stack List

Yesterday I got AWS CDK and local bootstrap all set up, so we're ready to deploy!
Let's check what Stacks we have (Stacks are basically how CDK groups and manages AWS resources together).

Run this command:

cdk list

You should see just one Stack:

HelloCdkStack

Step 6: Define Your Lambda Function

Time to update lib/hello-cdk-stack.ts with this code:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });
  }
}

As Claude explained to me:

Constructs are basically AWS resources (like Lambda or S3) represented as TypeScript classes.
Think of them as blueprints that include settings and dependencies.

This Function construct needs three key arguments:

scope: Where to place this function in the parent hierarchy (I'm still wrapping my head around this one - someone please help! 🤲)
id: Unique identifier for this function
props: The actual function settings
- runtime: The language and version Lambda runs on
- handler: Which function to execute
- code: The actual function code

Step 7: Define the Lambda Function URL

We'll use the Function construct's addFunctionUrl helper method to create a Lambda function URL. To output this URL value when we deploy, we'll create an AWS CloudFormation output using the CfnOutput construct. (Still figuring this part out too, but apparently Lambda needs a URL to run!)

Add this code to lib/hello-cdk-stack.ts:

export class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Define the Lambda function resource
    // ...

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new cdk.CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

Step 8: Synthesize the CloudFormation Template

Now let's run this command to convert our TypeScript code into a CloudFormation template:

cdk synth

If successful, you'll see the CloudFormation template output like this:

Resources:
  HelloWorldFunctionServiceRole<unique-identifier>:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: sts:AssumeRole
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: "2012-10-17"
      ManagedPolicyArns:
        - Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunction<unique-identifier>:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ZipFile: "

          \        exports.handler = async function(event) {

          \          return {

          \            statusCode: 200,

          \            body: JSON.stringify('Hello World!'),

          \          };

          \        };

          \      "
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRole<unique-identifier>
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRole<unique-identifier>
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrl<unique-identifier>:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunction<unique-identifier>
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurl<unique-identifier>:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunction<unique-identifier>
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:<unique-identifier>
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrl<unique-identifier>
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/<unique-identifier>/version
    Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
  CheckBootstrapVersion:
    Assertions:
      - Assert:
          Fn::Not:
            - Fn::Contains:
                - - "1"
                  - "2"
                  - "3"
                  - "4"
                  - "5"
                - Ref: BootstrapVersion
        AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.

Now we're ready to deploy!

Step 9: Deploy the CDK Stack

Let's deploy our CDK stack! This takes the CloudFormation template we just generated and deploys it through AWS CloudFormation.

cdk deploy --profile your-profile-name

⚠️ Don't forget to specify your --profile!

Once it's done, head over to the AWS Console and check out your resources in both Lambda and CloudFormation.

Lambda

CloudFormation

How CloudFormation Templates and CDK Work Together 🔍

Let me break down what's happening behind the scenes:

What is a CloudFormation Template?

A file written in JSON/YAML format that describes AWS resource configurations
Think of it as a blueprint that tells AWS "how to build what"
AWS CloudFormation service reads this and creates the actual resources

What is CloudFormation?

A service that reads JSON/YAML files and provisions actual AWS resources
It's like a "converter/execution engine"

How CDK Works:

CDK is a tool that includes CloudFormation service
Write code in TypeScript
cdk synth converts your program code into CloudFormation template (JSON/YAML format)
cdk deploy uses CloudFormation to deploy

Your CDK Code (TypeScript)
        ↓ cdk synth
CloudFormation Template (JSON)
        ↓ cdk deploy
CloudFormation Service (AWS)
        ↓ executes
Actual AWS Resources (Lambda, etc.)

Step 10: Test Your Application

Use the URL that was displayed when you ran the cdk deploy command to test your function:

curl https://<api-id>.lambda-url.<Region>.on.aws/

Here's my actual execution - it worked perfectly! 👌

Step 11: Make Changes to Your Application

Let's modify our Lambda code a bit. I changed myFunction like this:

// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
  runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js
  handler: "index.handler",
  code: lambda.Code.fromInline(`
    exports.handler = async function(event) {
      return {
        statusCode: 200,
        body: JSON.stringify('Hello CDK I'm AWS Lambda!!'),
      };
    };
  `),
});

To preview your changes, run:

cdk diff --profile your-profile-name

Then deploy again:

cdk deploy --profile your-profile-name

And test the URL again:

curl https://<api-id>.lambda-url.<Region>.on.aws/

But here's where I hit a snag:

Internal Server Error%

I checked the Lambda function logs in CloudWatch and found a syntax error!

Turns out the culprit was the apostrophe in I'm! Since I was using single quotes to wrap the string, the ' in I'm was being interpreted as the end of the string, causing a syntax error. Changed it to I am and everything worked perfectly! ⭕️

Step 12: Clean Up Your Application

Finally, let's clean up. This command will delete all the resources we created:

cdk destroy --profile your-profile-name

Run the command and check the AWS Console. The Lambda function should be gone.

In CloudFormation, you'll notice the stack is still there. Apparently this is normal behavior. If you're not using CDK anymore, you might want to delete it manually.

If you do delete it, you can always bring it back with:

cdk bootstrap --profile your-profile-name

Wrap Up

That's it! AWS CDK setup is complete. Now if I set up CDK in other environments within IAM Identity Center, I can easily switch between environments using command line profiles.

This is incredibly convenient!!

See you tomorrow! 👋

Setting up AWS CLI and CDK

Masafumi Saito — Mon, 07 Jul 2025 15:54:33 +0000

Setting up AWS CLI and CDK

Yesterday, I set up AWS IAM Identity Center. You can check out my previous post here:
https://dev.to/tofu1216/why-use-aws-iam-identity-center-2jko

Today, I want to connect my local VS Code environment with AWS CLI and CDK.

What Makes AWS CLI and CDK So Convenient?

Let me recap what AWS CLI and CDK bring to the table:

AWS CLI lets you operate from the terminal, so you don't have to manually click through AWS console settings anymore.
AWS CDK allows you to write infrastructure using programming languages instead of hand-writing YAML files.
This theoretically enables someone like me (an individual) to build enterprise-level infrastructure. (Though I still have a lot to learn! 🔥)

Setting up AWS CLI

I followed this official AWS documentation for the CLI setup: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html

Sign in to AWS access portal using your IAM Identity Center username and password.
Click on Access keys for your account and copy the SSO start URL and SSO region information.
Run the following command in your local VS Code terminal:

aws configure sso

You'll be prompted to enter information as follows:

Item	Input
SSO session name (Recommended)	Set freely
SSO start URL	URL copied from previous step
SSO region	Region copied from previous step
SSO registration scopes	Enter `sso:account:access`

A browser will launch for authentication. After completing authentication, enter the remaining items in the terminal:

Item	Input
There are n AWS accounts available to you.	Select the account you want to use
There are n roles available to you.	Select the role you want to use
CLI default client Region	For example, Tokyo is `ap-northeast-1`
CLI default output format	Press Enter (json will be set as default)
CLI profile name	Enter any name for your configuration

What is a profile name?

A profile name is what you use to save and identify your CLI session settings (from login to logout). You can create multiple profiles, which is convenient because it allows you to work in parallel with different permissions.

Setting up AWS CDK

I followed this official AWS documentation for CDK setup: https://docs.aws.amazon.com/cdk/v2/guide/hello-world.html

Here are the key points I encountered while doing steps 1-3:

Step 1: Create a CDK project

Create a new CDK project by running this command in your terminal:

mkdir hello-cdk && cd hello-cdk

Initialize the project (prepare it for execution) with this command. I followed the tutorial default and used TypeScript:

cdk init app --language typescript

Step 2: Configure AWS environment

To get your AWS account ID, run this command in the terminal. Make sure to use the --profile option to specify your profile name:

aws sts get-caller-identity --profile your-profile-name --query "Account" --output text

⚠️ I got multiple errors when I ran this command without specifying --profile, so be careful!

To get your AWS region name, run this command in the terminal. Make sure to use the --profile option to specify your profile name:

aws configure get region --profile your-profile-name

⚠️ I got multiple errors when I ran this command without specifying --profile, so be careful😅

Open your project files and edit bin/hello-cdk.ts. Replace the env information with your own account ID and region:

import 'source-map-support/register'; 
import * as cdk from 'aws-cdk-lib'; 
import { HelloCdkStack } from '../lib/hello-cdk-stack'; 
const app = new cdk.App(); 
new HelloCdkStack(app, 'HelloCdkStack', {
    env: { account: '123456789012', region: 'us-east-1' },
});

⚠️ The env is initially commented out, so you need to remove the // from //env.
⚠️ Don't forget to save with Shift + S after making changes!

Step 3: Bootstrap your AWS environment

What is bootstrapping?

Bootstrapping is preparing the foundational resources that AWS CDK needs to perform deployment operations.

The following are automatically created in your AWS environment:
├ S3 bucket (for storing CDK assets)
├ IAM roles (permissions used by CDK)
├ ECR repository (for Docker images)
└ SSM parameters (configuration information)

Bootstrapping before/after

Before:

AWS environment: Empty state
└ CDK deploy → Error (no workspace available)

After:

AWS environment:
├ CDKToolkit-S3Bucket (asset storage)
├ CDKToolkit-IAMRole (deployment permissions)
└ CDK ready
    └ CDK deploy → Success

Why is this necessary?

When CDK converts code to AWS resources, it follows this process (my buddy Claude taught me this! 🎓):

Compile TypeScript and other code
Store generated files in S3
Create resources with CloudFormation

=> This workflow requires dedicated S3 buckets and IAM roles.

How to bootstrap

Run this command in your terminal:

cdk bootstrap --profile your-profile-name

⚠️ I got multiple errors when I ran this command without specifying --profile, so be careful😭

Tomorrow I'll actually follow the tutorial and create Lambda resources!

Why Use AWS IAM Identity Center?

Masafumi Saito — Sun, 06 Jul 2025 12:14:35 +0000

Why Use AWS IAM Identity Center?

While researching how to integrate AWS with VS Code, I discovered that AWS IAM Identity Center was the recommended service. This got me thinking about why this service is so valuable.

I had already set up environment separation using AWS Organizations:

Root 
├── Infrastructure
│   ├── Development(dev@)
│   └── Demo(demo@)
├── Production
│   └── Production(prod@)
└── Security
    └── Admin (admin@)

However, I was manually creating IAM users in each environment, making password management increasingly difficult. (I should have researched this sooner!)

While AWS Organizations allows you to group AWS accounts under the same organization, IAM users and roles created in each account aren't connected across the organization. This means AWS Organizations alone cannot provide centralized access management. To switch environments, I had to sign out and log back into different accounts.

This is where AWS IAM Identity Center becomes incredibly useful.

It allows you to create IAM Identity Center users that can access IAM roles across all environments. From a single user account, you can create, assign, and switch between IAM roles in different environments.

This enables centralized access management at the organizational level. You only need to manage one password for the IAM Identity Center user.

(Seriously, I wish I had discovered this earlier!)

Setup Summary

IAM Users vs IAM Identity Center Users

Feature	IAM Users	IAM Identity Center Users
Management	Individual per AWS account	Centralized in management account
Authentication	Separate login per account	Single Sign-On (SSO)
Password Management	Multiple passwords	Single password for all accounts
Access Method	Direct login to each account	Role switching via AWS Access Portal
Permission Management	Individual setup per account	Centralized via permission sets

Before / After Comparison

Before (Manual Setup)

Independent Account Structure with IAM Users:
├ aws-admin@ (Management): admin-saito
├ aws-dev@ (Development): dev-admin
├ aws-demo@ (Demo): demo-admin
└ aws-prod@ (Production): prod-admin

Challenges:
- Managing 4 different passwords
- Re-authentication for each environment switch
- Individual permission changes in each account

After (IAM Identity Center)

Centralized Management:
Management Account (aws-admin@)
├ IAM Identity Center User: admin
├ Group: MyGroup-Administrators
├ Permission Set: AdministratorAccess
└ Access Settings:
    ├ aws-dev@ / AdministratorAccess
    ├ aws-demo@ / AdministratorAccess
    ├ aws-prod@ / AdministratorAccess
    └ aws-admin@ / AdministratorAccess

Improvements:
- Single password for all environments
- Seamless environment switching via AWS Access Portal
- Centralized permission management

The difference is remarkable – from managing multiple passwords and constant re-authentication to a single, streamlined access experience across all AWS environments.

Tomorrow, I'll try AWS CDK.

Git & GitHub Basics: A Beginner's Guide

Masafumi Saito — Sat, 05 Jul 2025 12:17:27 +0000

Git & GitHub Basics: A Beginner's Guide

I keep forgetting these steps every time I ask AI, so I'm documenting them for future reference. Here's how to connect your local development environment with GitHub repositories using Git and GitHub - the essential basics of these convenient code version management tools.

Note:

Git is version control software that runs on your local computer
GitHub is a web service that manages Git repositories in the cloud

1. Creating an Account

GitHub URL: https://github.com/

Detailed getting started documentation: https://docs.github.com/en/get-started/onboarding/getting-started-with-your-github-account

2A. Creating a Repository on GitHub First

# Use terminal commands on your local computer
# 1. Clone the GitHub repository to your local PC (first time only)
git clone https://github.com/username/repository-name.git

# 2. Navigate to the cloned folder
cd repository-name

# 3. Create and edit files
# (Create index.html or other files here)

# 4. Add changed files to "staging"
# (Staging = commit preparation area)
git add .
# ↑ "." means "all files in the current folder"

# 5. "Commit" the files in staging
# (Commit = save changes as a record)
git commit -m "Initial commit"
# ↑ Text after -m is the commit message (description of changes)

# 6. Upload local changes to GitHub (remote)
git push origin main
# ↑ origin = GitHub repository, main = main branch

2B. Creating Local Files First

# 1. Initialize current folder as a Git repository
git init
# ↑ Make an empty folder "manageable by Git"

# 2. Link GitHub repository with local folder
git remote add origin https://github.com/username/repository-name.git
# ↑ origin = alias for GitHub repository
# ↑ remote add = set "this local folder connects to this GitHub"

# 3. Create and edit files
# (Create index.html or other files here)

# 4. Add changed files to "staging"
git add .
# ↑ Specify created files to "include in next commit"

# 5. "Commit" the files in staging
git commit -m "Initial commit"
# ↑ Save changes as a record (still local only)

# 6. Upload local changes to GitHub (remote)
git push origin main
# ↑ main = branch name (default main branch)

3. Summary of Creation Methods

Methods A and B achieve the same result but in different order:

Method A: Create GitHub repository → Clone to local
Method B: Create local files → Link to GitHub repository

For beginners, Method A (git clone) is recommended.

4. Creating Branches

When making major feature changes or UI design modifications during development, I recommend using the branch feature.

GitHub allows you to create parallel working environments. These working environments are called branches.

Branch concept:

- main branch (default)
- feature-login branch (code implementing login functionality)

Good practice: Use main for production environment (shouldn't break) and feature for experimental code (okay to break).

How to create branches:

# 1. Check current branch
git branch
# ↑ Current branch is marked with "*" (usually main)

# 2. Create and switch to new branch
git checkout -b feature/login-form
# ↑ feature/login-form = branch name (commonly includes feature name)
# ↑ -b = create new + switch simultaneously

# 3. Work on the new branch
# (Create and edit login form here)

# 4. Commit changes
git add .
git commit -m "Add login form feature"

# 5. Push new branch to GitHub
git push origin feature/login-form
# ↑ First push of new branch

# 6. Return to main branch
git checkout main
# ↑ or git switch main

# 7. Update main branch to latest
git pull origin main
# ↑ Prepare for potential changes by others

# 8. Merge new branch into main
git merge feature/login-form
# ↑ Integrate feature/login-form changes into main

# 9. Delete merged branch (optional)
git branch -d feature/login-form
# ↑ Remove unnecessary branch

Give it a try, everyone!

DEV Community: Masafumi Saito

Python Testing and Debugging for beginners

Python Testing and Debugging

Specifications, Testing, and Debugging

Specification

Testing

Debugging

Development Flow

Useful Statements for Debugging

assert Statement

print Statement

Types of Errors

Syntax Errors

Runtime Errors

Logic Errors

Python Beginner's Take on Software 3.0

A Python Beginner's Take on Software 3.0

The Evolution of Software

Software 1.0

Software 2.0

Software 3.0

Coding Beginner's Honest Opinion

Python Learning Progress for a Japanese Beginner

Python Learning Progress for a Japanese Beginner

Why Did I Pick the University of Tokyo Materials?

Automate the Boring Stuff with Python

University of Tokyo Python Lecture Materials

Why I Went with the Japanese Materials

- From experience, I learn way better when I can read from paper

Today's Progress

Modbus Protocol - A Python Beginner's Summary

Modbus Protocol - A Python Beginner's Summary

What is the Modbus Protocol?

How Modbus Protocol Communication Works

Internal Structure of Modbus-Compatible Devices

1. Memory Space (Data Areas)

Key Point

2. Types of Modbus Communication

Summary

AWS CLI and CDK Setup Journey - Part 2

AWS CLI and CDK Setup Journey - Part 2

Step 5: Check Your CDK Stack List

Step 6: Define Your Lambda Function

Step 7: Define the Lambda Function URL

Step 8: Synthesize the CloudFormation Template

Step 9: Deploy the CDK Stack

How CloudFormation Templates and CDK Work Together 🔍

Step 10: Test Your Application

Step 11: Make Changes to Your Application

Step 12: Clean Up Your Application

Wrap Up

Setting up AWS CLI and CDK

Setting up AWS CLI and CDK

What Makes AWS CLI and CDK So Convenient?

Setting up AWS CLI

What is a profile name?

Setting up AWS CDK

Step 1: Create a CDK project

Step 2: Configure AWS environment

Step 3: Bootstrap your AWS environment

What is bootstrapping?

Bootstrapping before/after

Why is this necessary?

How to bootstrap

Why Use AWS IAM Identity Center?

Why Use AWS IAM Identity Center?

Setup Summary

IAM Users vs IAM Identity Center Users

Before / After Comparison

Before (Manual Setup)

After (IAM Identity Center)

Git & GitHub Basics: A Beginner's Guide

Git & GitHub Basics: A Beginner's Guide

1. Creating an Account

2A. Creating a Repository on GitHub First

2B. Creating Local Files First

3. Summary of Creation Methods

4. Creating Branches

`assert` Statement

`print` Statement