I was only one call away from selling all my Sony gear and moving to Lumix.

On paper, it made sense. Open gate recording, aggressive pricing, and in 2025 everyone seems to be saying the same thing: Lumix lenses are better now. The idea that you don’t really need native Lumix glass anymore gets repeated so often that it starts to feel like fact.

But here’s the problem. I’m already heavily invested in Sony lenses. And I travel a lot. When you live out of a backpack, every gram matters more than spec sheets and YouTube thumbnails.

Instead of trusting reviews or jumping because the internet is excited, I decided to slow down and do something boring. I compared lens weights. Side by side. Category by category. Zooms, primes, travel lenses, the stuff I actually carry.

Not to prove one system is “better”, but to answer a very selfish question: what would this switch really cost me in weight?

Below is that comparison.

Full-Frame Lens Weight Comparison

This comparison focuses purely on weight.
All lenses listed are full-frame, and when multiple versions exist, the latest model is used.

Ultra-Wide Zoom Lenses

Wide-Angle Zoom Lenses

Standard Zoom Lenses

Telephoto Zoom Lenses

All-in-One Travel Zooms

Ultra-Telephoto Zoom Lenses

Ultra-Wide Prime Lenses

Wide-Angle Prime Lenses

Standard Prime Lenses

Telephoto Prime Lenses

Macro Lenses

Super-Telephoto Prime Lenses

Travel Kit Weight Examples

“Holy Trinity” Zoom Setup

• Sony
  16–35mm f/2.8 GM II + 24–70mm f/2.8 GM II + 70–200mm f/2.8 GM II
  Total: 2287g
• Lumix
  16–35mm f/4 + 24–70mm f/2.8 + 70–200mm f/2.8
  Total: 3005g

Sony is 718g lighter (24%) and has faster lens on wide end.

After doing this research, I decided to stay with Sony.

Not because Lumix is bad. It’s not. In fact, in some areas Lumix is doing genuinely impressive work, especially with compact primes and value-focused zooms. The myth that Lumix lenses are “not good enough” in 2025 is exactly that, a myth.

But for my use case, travel-heavy, handheld, long days on my feet, Sony still makes more sense. The gap in key zooms is real. The weight savings compound. A few hundred grams here and there doesn’t sound dramatic until you add them up and carry them across airports, cities, and countries.

This comparison didn’t make me love Sony more. It just reminded me why I chose it in the first place.

Sometimes the smartest decision isn’t switching systems. It’s understanding the one you already own, and why it still works for you.

If you’re living in Bangladesh and dreaming of a career in Germany, you’re not alone. I searched “how to get a job in Germany from Bangladesh” 5 years ago — and found nothing useful. Today, even though there’s more information, a lot of it is outdated, vague, or flat-out wrong.

So, as someone who made it here and works as a senior software engineer, I want to break down realistic pathways, their pros and cons, and then focus on the most effective one: applying directly from Bangladesh for a Blue Card job.

Path #1: Master’s in Germany

This is still the most common route for young professionals.

Pros:

• Easier visa process with a university admission letter
• 18-month job-seeking visa after graduation
• Work part-time (up to 20 hrs/week) while studying
• Easier cultural transition

Cons:

• Time-consuming: usually 2–2.5 years
• Financial burden: ~11,000 EUR/year in blocked account (~13–14 lakh BDT)
• Limited income as a student
• No job guarantee after graduation

Best suited for recent graduates who can afford the time and cost.

Path #2: Opportunity Card (Chancenkarte)

A new visa launched by Germany allowing skilled people to enter without a job offer and search while staying in Germany.

Pros:

• Come without a job; search while living in Germany
• Based on a point system (age, skills, education, etc.)
• Allowed to work part-time while job hunting

Cons:

• You still need a blocked account (~17 lakh BDT)
• Only 1 year to find a job
• Competitive if you lack German fluency
• High cost without guaranteed outcome

Best suited for experienced professionals with savings who prefer to search locally.

The Best Option: Apply Directly for a Job (Blue Card)

This is how I came to Germany — no blocked account, no degree from Europe.
If you have the skills, you can apply for jobs directly from Bangladesh. When you get an offer, you apply for a Blue Card — a visa designed for highly qualified professionals.

Pros:

• No blocked account needed
• Employer usually pays for relocation (visa, flight, first month’s rent)
• Start earning from Day 1
• Blue Card is valid for 4 years, with a fast-track to permanent residency

Cons:

• It’s harder to get interview calls (initial rejections are common)
• Some companies may not sponsor non-EU applicants
• You need to stand out with skills and experience

Now let’s break down exactly how to land that job from Bangladesh:

Step-by-Step: How to Get a Job in Germany from Bangladesh

1. Build Strong Fundamentals

• Refresh core programming skills (DSA, problem solving)
• Start solving Leetcode Easy level problems regularly
• Become a domain expert — if you work in backend, master something like Node.js or Spring Boot

Tip: Work at least 1–2 years in Bangladesh before applying abroad — and specialize.

2. Start Applying Strategically

Getting interview calls is hard. Think of it like dating — rejections are normal.

• Focus on typical mid-sized companies, not just FAANG
• Use job boards like:
  • relocate.me
  • LinkedIn (filter for “visa sponsorship”)
  • Xing (popular in Germany)

Apply to 100 jobs if needed — 5 interviews can turn into 1 job.

3. Leverage Referrals

This matters more than anything. Even strangers will refer you if they believe in your work.

• Reach out to seniors and old colleagues
• Don’t be shy to ask — many companies give bonus for successful referrals (mine offered £300!)

4. Stand Out with Technical Blogging

• If you solve a rare problem at work, write a blog about it
• If someone abroad faces the same issue and finds your post — you’ve already made an impression
• Good content builds credibility and may lead to job offers

What to Expect in the Interview Process

Every company is different, but here’s the usual flow:

1. Intro Call – Casual discussion with recruiter/HR
2. Take-Home Assignment – Role-specific task (usually 5–7 days)
3. Technical Interview – Deep dive into your solution and thought process
4. Offer & Salary Discussion – Prepare to negotiate
5. Visa Process – Employer usually guides you through Blue Card steps

Some companies may skip the take-home and give 1–2 Leetcode questions. These are usually easier than FAANG-level.

Salary Negotiation & Visa

Some companies offer a slightly lower salary, assuming they’re sponsoring your visa. It’s okay.
Once you land in Germany and gain experience, you can easily switch jobs for higher pay — your past salary isn’t considered here.

Final Thoughts

Getting a job in Germany directly from Bangladesh isn’t easy, but it’s absolutely possible. I’ve done it. So have many others.

If you can:

• Master your core skills
• Stay persistent through rejection
• Apply strategically

...then you don’t need a European degree or 17 lakh in savings. You just need focus and consistency.

Just landed in Berlin, and it feels like there's a switch in my brain — I call it the Context Switch. The moment I arrive, it flips automatically, and suddenly I’m living a completely different life.

That’s the tricky part of living between two countries. But in a way, it’s also a gift — it lets me experience two parallel lives through a lens most people never get to look through.

That qualifies me to speak about the pros and cons in a neutral way. In this blog, I’ll share what that really feels like.

Why I Decided to Go Abroad

I graduated from MIST and worked at a startup for two years. I enjoyed it a lot, but I started thinking about financial stability and eventually joined Cefalo Bangladesh, a well-known tech company. Then COVID hit.

Though Cefalo is a great company that doesn’t usually lay off employees, I saw many clients leaving, and many of my friends from other companies lost their jobs. I come from a middle-class family and am the eldest son. The pressure was real.

At the same time, many of my university friends were moving abroad for MS or PhDs. Their Facebook photos made it look like life abroad was full of charm and adventure.

Looking back now, I think I made the decision partly out of jealousy and boredom. But I was also careful—I decided to move only if I could get a job abroad. That way, even if things didn’t work out, there would be no financial loss, and I could always return to Bangladesh. And so, I moved.

Pros of Living Abroad

1. Financial Stability
This was one of the biggest advantages. In Bangladesh, it’s very rare to find companies that pay over 3–4 lakh BDT a month and are also stable. Abroad, there are many opportunities. After paying rent and personal expenses, saving a few lakh taka each month is very possible.

2. Interesting Work Opportunities
In Bangladesh, it’s hard to find work on technically complex or exciting projects. Abroad, even startups work with modern technologies. You get the chance to work on things that actually challenge and grow your skills.

3. Job Security and Social Benefits
In Germany, for example, if I lose my job, the government will pay me 60% of my salary until I find a new one. I don’t need to worry about retirement either—my pension will be taken care of. These benefits simply don’t exist in Bangladesh.

4. Respect and Equal Treatment
Even if you earn a 6-digit salary in Bangladesh, people still ask questions like, “Preparing for BCS?” Unless you belong to a privileged family, life can be hard. There’s a constant pressure and sometimes even humiliation in everyday systems. Abroad, people are treated more equally.

5. Travel and Exposure
Europe and America are beautiful—clean, organized, and rich in culture. If you love exploring, you’ll enjoy life abroad. Meeting new people, experiencing different cultures, and learning new ways of thinking really broadens your perspective. You also learn to appreciate your own culture more deeply.

6. Quality of Life
Less corruption, fair systems, free healthcare, clean air—all of these make for a better life abroad.

So, Why Do I Still Stay 6 Months in Bangladesh?

Even with all these advantages, there are downsides.

1. Family
You’ll miss your family. You won’t find your mother abroad. No matter how many video calls you do, it’s not the same. This is the hardest part.

2. Food
Let’s be honest—German food is boring. After a long day of work, you won’t feel like cooking. I often eat out, and it has led to health issues. Finding good food like we have in Bangladesh is a real struggle.

3. Loneliness
People abroad are busy. Finding like-minded friends is tough. In Germany, if you don’t know the language, you won’t be able to connect with the locals easily. Back home, we are spoiled with social choices. Here, your options are either mixing with people you don’t vibe with or being alone. It may not sound serious, but it hits hard over time.

4. Daily Life Challenges
In Bangladesh, life is easier if you can spend a little. You’ll find help for household chores. Abroad, you have to do everything yourself. Hiring help is expensive. Also, the paperwork and bureaucracy—especially in Germany—can be frustrating.

5. The Feeling of Not Belonging
This is a tough one. Once you leave your country, you may never fully feel at home again. In Europe, no matter how long you stay, your skin colour and accent will always make you an outsider. Back in Bangladesh, people treat you like a visitor too. It often feels like you're just on vacation wherever you are.

So, What Should You Do?

There’s no single right answer. Don’t decide based on random people on the internet. Every life has its pros and cons. I just tried to share mine shortly, and honestly.

Thanks for reading.

I am a sony user now, but I love fuji.

I used to shoot with Fuji, then I left it for Sony due to Fuji's shitty autofocus system. Then I returned to Fuji again - for its colors. Eventually, I started using both systems—you can call me spoiled!

Now, I primarily shoot videos with Sony and photos with Fuji. But when I'm out shooting video, sometimes I want to take pictures as well. Here's the problem: I didn't bring my Fuji.

I miss the colors—the film simulations, Classic Chrome to be exact!

After some research, I found a solution that works for me on my Sony ZV-E1 and Sony A7C II. There are some tweaks you can do on your Sony camera to get a Classic Chrome look straight out of the camera (SOOC).

At first, I thought the "Creative Look" filters in Sony cameras were just a gimmick. However, by adjusting the settings, we can actually achieve a classic chrome look.

Here are the settings I used:

• Creative Look: IN
• Contrast: +2
• Highlights: 0
• Shadows: -2
• Fade: 0
• Saturation: -2
• Sharpness: 0
• Clarity: +3
• Tint: +1

And result?

Though it's not perfect, you can tell it's not classic chrome from the reds. But when I couldn't bring my fuji - or I need extra depth in a photo, but don't want to open lightroom - this works like a charm!

After seeing the police shoot Abu Sayed—a bright student from a poor family who was unarmed and posed no threat—I couldn't stay at home. When I watched the video of this unjust act, I cried and couldn't work anymore.

I had a tight deadline, but my body felt so tense that I couldn't type anything.

To those who are saying that students are protesting just to get government jobs and earn money through corruption—I have been working in a private job for eight years. I have never even bought a form for a government job exam. But first, I want those inhumane people to be brought to justice. Secondly, I want the quota system to be reformed.

This is simply a movement against injustice—not a protest for jobs. Please use common sense.

We've endured too much dictatorship; it must end now.

I'm a software engineer by trade—I write code all day. Never in my wildest dreams did I think I'd buy a camera.

My photography skills were so bad that my ex was often mad at me for taking so many terrible photos of her. So, imagine my surprise when I found myself landing my first gig on a video project.

A couple of days ago, a lady reached out to me after seeing some of my personal videos. She wanted help getting sponsors for kids who are eager to learn karate. She asked if I could create a video to support their cause.

I hesitated but ultimately decided to do it.

The Final Result

The Experience

It turned out that shooting for other people isn't as enjoyable as I thought it might be.

My main reason for getting into videography was to document my own life—to capture moments that are meaningful to me. But when I had to put in effort for someone else's project, the joy just wasn't there.

Don't get me wrong; I loved working with the kids—they were fantastic. But when I got home, editing the video was a pain in the ass.

This experience taught me something valuable: if you monetize your hobby, it stops being your hobby. It becomes work. And for me, that takes away the fun and passion that drew me to videography in the first place.

So, I've decided I won't spend much time trying to monetize my videography. I'd rather keep it as a personal passion, something I do for myself without any obligations or expectations from others.

When I realized all my recent tours were in cities, I knew I needed a change. I've always wanted to visit the Bavarian region of Germany, so I decided to take a tour of Königssee.

Since I've never been to Munich before, I set aside a day to explore the city. I don't particularly appreciate traveling like a typical tourist with a map and a checklist of things to cover. Instead, I prefer to wander around like a local, capturing photos just as I do in my city Berlin.

Enjoy some of the photos I've taken.

The pictures above were taken with my video camera, the ZVE1, and a Sigma 85mm f/1.4 lens. I usually dislike the SOOC Sony colors, but with a few small tweaks, I ended up liking the results more than those from my Fuji XT4, which is my dedicated street photography camera. I'm leaving some photos for comparison, taken with the XT4 and a 35mm f/2 lens.

These Fuji pictures are straight out of the camera without any edits, except for the one of the Man Vs Machine Coffee shop. For that, I changed the simulation to Reala Ace in Capture One since the XT4 doesn't have it.

Honestly, I'm really impressed with Sony. It's hard to admit that a camera with no viewfinder and only 12 MP took superior pictures compared to my retro Fuji. However, the experience and joy of taking pictures matter in the end, so I'm not abandoning my beloved Fuji anytime soon.

The instructions in this post are inspired by the original guide on accessing Nostalgic Negative on X-Trans bodies, initially shared by yayatosorus on dpreview. This post aims to simplify the process, allowing you to start using the Reala ACE film simulation quickly and efficiently.

Fujifilm and the Kaizen Concept

Fujifilm was once renowned for its "Kaizen" philosophy, continuously releasing firmware updates to enhance the user experience of its older cameras. However, this practice has waned recently, leaving many users longing for the latest features and film simulations available only on new camera models. Instead of giving in to the pressure of buying a new camera, let's explore how you can enjoy the new Reala ACE film simulation on your existing X-Trans camera.

Instructions

These instructions are tailored for macOS users. Windows users can refer to the original guide and use this post as a reference to adapt the steps accordingly.

Step 0: Install Capture One Pro

Download and install Capture One Pro from the official website. You can also use the Fujifilm RAW Converter if you don't have the paid version of Capture One Pro.

Step 1: Locate the Film Curves Folder

Open Finder, go to the menu bar, select Finder -> Go -> Go to Folder, and paste the following path:

/Applications/Capture One 22.app/Contents/Frameworks/ImageProcessing.framework/Versions/A/Resources/FilmCurves

Alternatively, navigate to the application folder, find Capture One 22, right-click to "Show Package Contents," and go to the specified folder. Note that this path may differ for other versions of Capture One.

Step 2: Copy and Rename the Reala ACE Files

Download the pre-packaged Reala ACE film simulation files. The files you need to locate in the "Film Curves" folder include:

• .fcrv files: Camera-specific
• .P1X files: Sensor-specific

Identify and select the 9 .P1X files and the .fcrv file related to Reala ACE. To simplify this process, use the following Python script to automate copying and renaming these files.

Python Script to Copy and Rename Reala ACE Files

Here's a Python script that automates the copying and renaming process. The script selects the FujiGFX100II files for "REALA" (case-insensitive) and renames them based on your input.

import os
import shutil

def get_reala_files(folder_path):
    reala_files = []
    for file_name in os.listdir(folder_path):
        if "reala" in file_name.lower() and ("FujiGFX100II" in file_name):
            reala_files.append(file_name)
    return reala_files

def copy_and_rename_files(folder_path, camera_name):
    reala_files = get_reala_files(folder_path)
    new_files = []
    for file_name in reala_files:
        new_file_name = file_name.replace("FujiGFX100II", camera_name)
        src_file = os.path.join(folder_path, file_name)
        dst_file = os.path.join(folder_path, new_file_name)
        shutil.copy2(src_file, dst_file)
        new_files.append(new_file_name)
    return new_files

def main():
    folder_path = input("Enter the path to the 'Film Curves' folder: ")
    if not os.path.exists(folder_path):
        print("The specified folder does not exist.")
        return
    
    camera_name = input("Enter the camera name (e.g., FujiXT4): ")

    new_files = copy_and_rename_files(folder_path, camera_name)
    
    if new_files:
        print(f"The following files have been created in {folder_path}:")
        for file_name in new_files:
            print(file_name)
    else:
        print("No REALA files found for FujiGFX100II.")

if __name__ == "__main__":
    main()

How to Use the Script

Save the Script:
Save the script to a file, for example, rename_reala_files.py.

Run the Script:

• Open a terminal or command prompt.
• Navigate to the directory where you saved the script.
• Run the script using python rename_reala_files.py.

Follow the Prompts:

• Enter the path to the "Film Curves" folder.
• Enter your camera name (e.g., FujiXT4).

Step 3: Apply the Film Simulation

Once you have copied and renamed the files, open Capture One Pro and import a RAW file taken by your camera. In the Base Characteristics panel, you should now see the option to apply the "Fujifilm Reala ACE" curve. Select it, and enjoy the new film simulation.

If everything goes alright - you should able to see the REALA ACE in the list of the simulations. Let me know if the script doesn't work.

I recently revamped my desk setup to create a more inspiring and efficient work environment, and I couldn't be happier with the results. In this blog post, I'll walk you through my current desk setup and share how each item enhances my daily work routine. The workstation is divided into two parts:  

My Online Corner

This is my primary workstation,

All the communication with the world is being done here. Apart from visible M1 Macbooks, Logitech MX master keyboard and mouse, bellow are some items I also used to make this setup

Caldigit TS3 Plus Docking Station

I was initially sceptical about investing in a high-priced dock like the CalDigit TS3 Plus. I had tried cheaper alternatives in the past, but I ended up returning each one I purchased due to compatibility issues. Some of them didn't work well with my webcam, and others had trouble with my Rode USB Mini microphone.

However, after numerous trials and tribulations, I decided to give the CalDigit TS3 Plus a shot. To my surprise, it has been serving me exceptionally well ever since. The investment was worth it, as it not only solved my connectivity issues but also added a level of convenience to my workspace that I hadn't anticipated.

Rode NT USB Mini

I use the Rode USB Mini. Working remotely often means keeping my MacBook closed during meetings, so having a reliable microphone is essential. The Rode USB Mini fits the bill perfectly. It's budget-friendly, yet it delivers excellent sound quality, ensuring that my virtual meetings are crystal clear and professional-sounding. It's a cost-effective solution that doesn't compromise performance.

MacBook Pro Stand from Humencentric

One of the first changes I made was investing in a MacBook Pro stand from Humencentric. This stand saves precious desk space and keeps my MacBook Pro safely secured when not in use. The silicone-lined inner edge ensures that my MacBook remains scratch-free, and I can easily connect it to an external monitor for a seamless desktop-like experience. It's a game-changer in terms of organization and convenience.

Fujifilm X100V Camera

Photography is a passion of mine, and having my Fujifilm X100V camera within arm's reach allows me to capture spontaneous moments throughout the day. Whether snapping photos for work or indulging in personal photography projects, this camera is an integral part of my creative arsenal.

Govee Hexa Light and Lightbar Behind Monitor

Good lighting is essential for a productive workspace. I've incorporated Govee Hexa Lights and a lightbar behind my monitor to set the perfect ambience. The customizable colour options and brightness levels let me tailor the lighting to suit my mood and task at hand, whether it's focused work or a relaxing break.

IKEA Plants and Bookshelf

Bringing a touch of nature into my workspace was another priority. I added some greenery with plants from IKEA, which not only enhances the visual appeal of my desk but also contributes to a healthier indoor environment. Additionally, an IKEA bookshelf provides a stylish way to keep my favourite books and reference materials organized and easily accessible.

Samsung U28R550UQP 28-inch 4K Monitor

The centrepiece of my desk setup is the Samsung U28R550UQP 28-inch 4K monitor. Its crisp display and quick response time make it perfect for both work and leisure. Whether I'm editing photos, watching videos, or multitasking, this monitor offers a fantastic visual experience.

Monitor Light Bar - Quintis (Budget Alternative to BenQ)

For improved task lighting, I added a monitor light bar from Quintis. It's a budget-friendly alternative to the popular BenQ light bars and helps reduce eye strain during long hours of work. The adjustable brightness and colour temperature settings ensure that my screen is evenly illuminated without any glare.

Sand Timer from Amazon

To boost productivity and manage my time effectively, I have a sand timer from Amazon. It's a simple yet effective way to stay focused on tasks and take short breaks when needed. The visual cue of the sand running out helps me maintain a healthy work rhythm.

An Offline Corner

This corner disconnects me from the internet. I use it for writing, mind mapping and trying to figure out the purpose of life.

It was kind of my dream and I am glad I did it. I feel happy here now.

Monitoring health checks in Slack, and getting a notification if something goes wrong seems simple and straightforward. Until it isn't.

Mainly because AWS uses the US-east-1 region to maintain the services related to route 53. Which makes things problematic if you use AWS services from other regions. In that case, you need to set up the infrastructure for the US region as well.

As of today, we can't trigger an alarm in our desired region (in my case it was the EU). So the idea is like this

1. Configure health check in route 53 [Global]
2. Attach an alarm into it [US region]
3. Attach a SNS topic to this alarm [US region]
4. Create a subscription, and attach a lambda there. This lamba can be any region.
5. Write the logic to parse the SNS topic (whether the state is healthy or unhealthy) and send a notification based on this.

We'll use AWS Cloudformation in this blog - but you can follow along to do it manually as well.

Prepare Configuration:

If a template for the US-east-1 region is absent, update your samconfig.toml file with relevant configuration details. This file helps streamline deployment processes.

[us-east-1]
[us-east-1.deploy]
[us-east-1.deploy.parameters]
stack_name = "your_stack_name"
s3_bucket = "your_s3_bucket"
s3_prefix = "whateveryouwant"
region = "us-east-1"
capabilities = "CAPABILITY_IAM CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM"
image_repositories = []

Set Up SNS Topic:

Create an SNS, its topic and its subscription. You can keep the endpoint blank for now, we'll update it later once we write our lambda.

AWSTemplateFormatVersion: "2010-09-09"

Resources:
  MySNSTopic:
    Type: AWS::SNS::Topic
    Properties:
      DisplayName: "MyGenericTopic"
      TopicName: "MyGenericTopic"

  MyLambdaSubscription:
    Type: AWS::SNS::Subscription
    Properties:
      Protocol: lambda
      TopicArn: !Ref MySNSTopic
      Endpoint: "arn:aws:lambda:REGION:ACCOUNT_ID:function:MyLambdaFunction"

Create Health Checks and Alarms

Craft health checks and associated alarms within a template specific to the US region (e.g., template.us.yaml).

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: US Stack


Resources:
  FooSNS:
    Type: AWS::Serverless::Application
    Properties:
      Location: {{path to your SNS resource}}

  HealthCheckFoo:
    Type: AWS::Route53::HealthCheck
    Properties:
      HealthCheckConfig:
        FailureThreshold: 1
        FullyQualifiedDomainName: www.example.com
        Port: 443
        RequestInterval: 30
        ResourcePath: /health
        Type: HTTPS

  HealthCheckAlarmFoo:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: HealthCheckAlarmFoo
      ComparisonOperator: LessThanThreshold
      EvaluationPeriods: 1
      MetricName: HealthCheckStatus
      Namespace: AWS/Route53
      Period: 60
      Statistic: Minimum
      Threshold: 1
      Dimensions:
        - Name: "HealthCheckId"
          Value: !Ref HealthCheckFoo
      AlarmDescription: "Foo Health check failed"
      AlarmActions:
        - !GetAtt FooSNS.Outputs.MySNSTopicArn
      OKActions:
        - !GetAtt FooSNS.Outputs.MySNSTopic

Quick knowledge: How this HealthCheckAlarmFoo is being attached to this HealthCheckFoo?

It’s by these lines.

   Dimensions:
        - Name: "HealthCheckId"
          Value: !Ref HealthCheckFoo

If you have different types of health checks e.g.: type calculate, you should use AlarmIdentifier in the health check config. If you try to use this AlarmIdentifier property for basic type healthcare (the one we’re creating, you will get a 400 error).

Now let’s create the lambda. In your template.yaml add the configuration for lambda

  AWSLambdas:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: {{path to your lambda config}}
      Parameters: { }

Now let’s configure the lambda:

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Lambda functions

Resources:
  SendSlackNotificationFunction:
    Type: AWS::Serverless::Function
    Architecture: x86_64
    Properties:
      Handler: pathToYourLambdaFunction/index.handler
      Runtime: nodejs18.x [Change it if you use other version]
      CodeUri: [path to the codebase for lambda]
      FunctionName: yourLambdaFunctionNameToSendSlackNotification
      Policies:
        - AWSLambdaBasicExecutionRole

# this is important, otherwise your SNS from US region can't invoke this
  AllowSNSInvoke:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !GetAtt SendSlackNotificationFunction.Arn
      Principal: 'sns.amazonaws.com'

Outputs:
  SendSlackNotificationFunctionArn:
    Description: "Lambda Function ARN for Slack Notifications"
    Value: !GetAtt SendSlackNotificationFunction.Arn

And then, let’s write the lambda code itself

const https = require('https');

const SLACK_WEBHOOK_URL = 'URL FOR SLACK WEBHOOK';

function getMessageFromTopic(topicName, alarmState) {
	// your logic to generate lamba URL 
}

function handler(event) {

	// Extracting topic name [in case you have multiple sns pointing out same Lambda
    const topicArn = event.Records[0].Sns.TopicArn;
    const topicName = topicArn.split(':').pop();
    const alarmMessage = JSON.parse(event.Records[0].Sns.Message);
    const alarmState = alarmMessage.NewStateValue;

    const message = getMessageFromTopic(topicName, alarmState);
    const postData = JSON.stringify({ text: message });

    const options = {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': postData.length
        }
    };

    return new Promise((resolve, reject) => {
        const req = https.request(SLACK_WEBHOOK_URL, options, (res) => {
            if (res.statusCode === 200) {
                resolve({ statusCode: 200, body: 'Message sent to Slack' });
            } else {
                reject(new Error(`Request to slack returned an error ${res.statusCode}, ${res.statusMessage}`));
            }
        });

        req.on('error', (e) => {
            reject(new Error(e.message));
        });

        req.write(postData);
        req.end();
    });
};

module.exports = {
    handler
};

Finally, for deploying you can use these commands

          sam build --template template.us.yaml --use-container
          sam deploy --config-file samconfig.toml --no-confirm-changeset --no-fail-on-empty-changeset --config-env dev-us-east-1 

So, there you go! Handling health check notifications across various parts of AWS doesn't have to be daunting. With SNS and Lambda, you're equipped to stay in the loop when issues arise.

Pro tip: You can also do some basic steps to recover your endpoint, may be restarting the server from lambda as well?

Problem: We have to find the maximum subarray sum.

Eg: Lets consider this array ⇒ -10, 5, -9, 1, 3, -2, 3, 4, 7, 2, -9, 6, 3, 1, -5, -4, the answer for maximum subarray sum is 19. (1, 3, -2, 3, 4, 7, 2, -9, 6, 3, 1)

Solution ⇒ Naive approach, brute-force. Generate all the arrays and get the maximum sum.

From this, we can generate subarrays like,

-10

-10, 5

-10, 5, 9

-10, 5, 9, 1

-10, 5, 9, 1 , 3

...

...

5

5, 9

5, 9, 1

5, 9, 1, 3

5, 9, 1, 3, 2

..

...

We can generate all the subarrays and take the maximum sum, in that case, our code will look like

// n*n solution
#include <vector>
using namespace std;

int notKadanesAlgorithm(vector<int> array) {
	int n = array.size();
	vector<int> sum;
	int res = INT_MIN;

	//Cumulative Sum
	sum.push_back(array[0]);
	for(int i = 1; i < n; i++)sum.push_back(sum[i-1] + array[i]);

	// Generate every pair and take maximum.
	for(int i = 0; i < n; i++) {
		for(int j = i; j < n; j++  ) {
			res = max(res, sum[j]-sum[i - 1]);
		}
	}
  return res;
}

But this has a complexity of O(n^2) we can reduce it to O(n) if we use Kadane's algorithm. Which uses dynamic programming. While traversing the array, we can keep track of what was the maximum number, if the array was ended here.

for example, if our array is -1, 2, 3, -4, we can generate another array which ith position will hold the maximum value if the array was ended here. We'll get -1, 2, 5, 1

. Let me explain how.

In any place, we have either 2 choices. Either we can add the current array item in our sum, or we can start a new array from here.

When i = 0, our maxEndingHere[0] = -1 ⇒ we don't have any option but to take the first element.

then i = 1, we get 2 as the current value of the array. Now we have 2 choices:

1. We can consider the subarray ends here (index 1, having value 2). The subarray is -1, 2, in that case, we can get our maximum subarray sum -1+2=-1
2. We can consider a new subarray starting from here. The subarray is 2, resulting in maximum subarray sum = 2

as the second option results in maximum value, we will go with it. So, maxEndingHere[1] = 2

After that when i = 2, we get the maximum subarray sum if we take 3, is 5, or we can start a subarray from here, which will give us 3. So our maxEndingHere[2] = 5

and finally, in the same procedure, we can get maxEndingHere[3] = 1( max( (5 -4), -4)))

So our resulted maxEndingHere array is ⇒ -1, 2, 5, 1

we can find the maximum number of this array, which is the result, for this example, 5.

Our code will look like this:

#include <vector>
using namespace std;

int kadanesAlgorithm(vector<int> array) {
	vector<int>maxEndHere;
	if(array.size()>0)maxEndHere.push_back(array[0]);

	for(int i = 1; i < array.size(); i++){
		int here = max(maxEndHere[i-1]+array[i], array[i]);
		maxEndHere.push_back(	here );
	}

// Finding the maximum array in this vector
	return *max_element(maxEndHere.begin(), maxEndHere.end());
}

Now it runs on O(n) but space complexity is still O(n) which we can reduce to O(1) but not store the whole array into maxEndHere. We can just declare an integer and keep the maximum value in it while traversing the array. But this task is for you to do. 😇

Lets take a look, nowadays, how a modern web app is displayed in browser. A typical response sent by an Angular app looks like this,

1. A bare , poor and sad HTML file

<!doctype html>
	<html lang="en">
	<head>
	   <title>Angular</title>
	   <base href="/">
	   <meta name="viewport" content="width=device-width, initial-scale=1">
	</head>
	<body>
	   <app-root></app-root>
	
	<script type="text/javascript" src="inline.f481c2f5e1589433c6b6.bundle.js"></script>
	<script type="text/javascript" src="polyfills.8135eb80f6191ae1578b.bundle.js"></script>
	<script type="text/javascript" src="main.7dd036568b70b6284d5d.bundle.js"></script>    
	
	</body>
	</html>

2. A rich main.js file, which is the life for that app.

Browsers take this main.js file and parse and render our app, it makes that bare HTML meaningful. But what if, the user disables Javascript on his browser?

Well, he will see this - an empty and dead page -

but wait? Seriously? Somebody will disable Javascript in their browser at 2020? Who is that dumb?

well, search engine crawlers are dumb. They will. When they want to index our webpage for search results, they will find a plain old HTML file who has nothing, and a big main.js file for which they don't have any time or respect. When they see that the javascript file is too big to parse, they will ignore it. So our Angular app performs poorly in terms of SEO.

What's the solution?

we can use a quick 3rd party-based solution, prerender.io(http://prerender.io/) . It checks the person who requested your webpage, is a bot or human. If it's a human, it sends the regular response - a plain HTML with a main.js file. But if it's a bot, prerender.io opens a browser in itself, renders the app there and then sends the contentful html files.

So the SEO problem can be solved. But-

1. It's not a good way
2. There are more problems to solve, the first meaningful paint problem

First meaningful paint measures when the primary content of a page is visible to the user. In the picture below we can see user had to wait for 8 seconds to see anything meaningful.

A big portion of this 8 seconds time used to -

1. Download that main.js file, if the user's internet is slow - this time will increase.
2. Parse and render that main.js file.

And user didn't see anything meaningful on the screen, recent study shows that user leaves any webpage that takes more than 3 seconds to load.

Server-side rendering solves both problems. Instead of sending the a dead blank HTML file, it renders our app in the server ( blessings of Node.js), and sends the HTML to the browser. Now users don't have to wait for downloading that big main.js file. It can show the server-rendered HTML immediately. So users will able to see some meaningful content very fast.

Now let's see how this SSR works:

1. The client makes a GET request to the server for the webpage
2. The server parses and renders an HTML file immediately
3. Client shows this HTML to the user, the user sees meaningful content but the app isn't ready yet
4. The server also sends the angular/react app (that main.js file)
5. Client downloads that file and loads our app background
6. Once everything is ready client-side, it seamlessly switches from showing the server-rendered pages to the client-side app. The server gives control to the client when it's ready.

As meaningful HTML is served to the user immediately, So first meaningful paint time improves significantly with SSR.

In the next post, we will learn how to implement Server Side Rendering with Angular, stay tuned.

Minor life update: I fulfilled one of my dreams, becoming a digital nomad.

I accepted an offer from a fintech start-up for a senior software engineer role, which will allow me to work from anywhere in the world.

I love to travel, I wanted to work from Paris one morning, Amsterdam another, and ghurte tired laagle Berlin

I've been looking for this opportunity for years, and finally bat e ball e milse.

Career-wise, I don’t know if I made the right choice, I've been spinning same old NODEJS microservices for years now, and maybe I should focus more on stability.

But but but at this very moment - this decision made me happy.

And perhaps that's what matters most at the end of the day.

Let’s assume, I have written some introductory sentences about what is unit testing and why it’s important. Let’s jump into main topic directly.

For writing unit test in .NET core applications we have some libraries like MSTest, NUnit , Xunit. In this post, I will be discussing about Xunit. For getting started, open your IDE and create a solution named HelloWorldUnitTest and add 2 projects, PrimeDetector and PrimeDetectorTest

Now, we’ll write a function first, and then write unit test by using xunit. Lets start by writing the function, Lets add a class in PrimeDetector project named PrimeDetectorModel.cs

    public class PrimeDetectorModel
    {
        public bool IsPrime(int n)
        {
            var isPrime = true;

            for (int i = 2; i < Math.Sqrt(n); i++)
            {
                if (n % i == 0) isPrime = false;
            }

            return isPrime;
        }

    }

Now we'll write unit test for the isPrime()method. Let's add a class named PrimeDetectorTest.cs in the PrimeDetectorTest project.

public class PrimeDetectorTest
{
 	[Fact]
        public void Test_If_It_Can_Detect_A_Prime_Number()
        {
           // Arrange
            var primeDetector = new PrimeDetectorModel();

            // Act
            var isPrime = primeDetector.IsPrime(29);

            // Assert
            Assert.Equal(isPrime, true);
        }
}

What's happening here?

With the [Fact]attribute, xUnit.net test runner identifies it's a unit test to execute. Here, we will test whether our isPrime() identify a prime number or not.

Every unit test has 3 parts:

1. Arrange: this portion will have code required to setup the test, in above example we need an instance of PrimeDetectorModel to call our isPrime() method.
2. Act: In this portion, we'll call the function which we want to test. Eg: here we called IsPrime() with a prime number
3. Assert: this portion will responsible to judge whether our expectations were met or not. Eg: here, we checked value of isPrime is true or not.

How can we run this test multiple times with different input?

The above example tests whether our isPrime()method works for 29 or not. Now we want to test it for more integers, let's say for 2, 5, 7, 19 and 23. Instead of copying and pasting the previous test function for 5 times, we can take advantage of [Theory] attribute. Our test function will now look like

	[Theory]
        [InlineData(2)]
        [InlineData(5)]
        [InlineData(19)]
        [InlineData(23)]
        public void Test_If_It_Can_Detect_Non_Prime_Numbers(int n)
        {


            // Arrange
            var primeDetector = new PrimeDetectorModel();

            // Act
            var isPrime = primeDetector.IsPrime(n);

            // Assert
            Assert.Equal(isPrime, true);
        }

If we run this test, we will see our test function ran 4 times with the values we have given with [InlineData(n)] attribute.

[Theory] attribute denotes a parameterised test, and by the help of the [InlineData] we provide the values for the parameter.

Summary: When we need to run the test once, we don't need any parameter to be passed through the test function, we'll use [Fact] attribute, otherwise we'll use [Theory] attribute.

There are some limitations with [InlineData] attribute, it works with only constants. What if we need to send an object as a parameter?

Let's add a PersonModel Class in PrimeDetector project.

 public class PersonModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

Now add HasPrimeId() method, bellow the isPrime() method. It will take an object of PersonModel and check whether the Id property is Prime or not.

        public bool HasPrimeId(PersonModel person)
        {
            return IsPrime(person.Id);
        }

Now, we'll write unit test for it. Go to the PrimeDetectorTest file and add this chunk of code.

    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { new PersonModel { Id = 5, Name = "Saadnoor" } };
        yield return new object[] { new PersonModel { Id = 7, Name = "Salehin" } };
    }

    [Theory]
    [MemberData(nameof(GetTestData))]
    public void Test_If_It_Can_Detect_Person_Has_Prime_Id_Or_Not(PersonModel person)
    {

        // Arrange
        var primeDetector = new PrimeDetectorModel();

        // Act
        var hasPrimeId = primeDetector.HasPrimeId(person);

        // Assert
        Assert.Equal(hasPrimeId, true);
    }

It will call the test function Test_If_It_Can_Detect_Person_Has_Prime_Id_Or_Not() two times with 2 different PersonModel object.

1. { Id = 5, Name = "Saadnoor" }
2. { Id = 7, Name = "Salehin" }

Note that, we have to set the return type of the GetTestData() method as IEnumerable<object[]> otherwise xUnit will throw an error. If we need 2 or more parameters in our test function, we can do that by adding it to the object[] array.

We can provide data with [ClassData] attribute also, but I'm skipping it in this post, to keep the post short and simple.

Now what if we have some dependencies to initiate our PrimeDetectorModel? How will we test it?

Moq will save us here. Let's assume, to initiate PrimeDetectorModel we have a dependency of PositiveDetectorModel (which helps us to determine whether a number is positive or not).

Our PrimeDetectorModel class will now look like:

    public class PrimeDetectorModel
    {
        public PositiveDetector positiveDetector { get; set; }

        public PrimeDetectorModel(PositiveDetector positiveDetector)
        {
            this.positiveDetector = positiveDetector;
        }

        public bool IsPrime(int n)
        {
            if (!positiveDetector.IsNumberPositive(n)) throw new Exception("Invalid Input");

            var isPrime = true;

            for (int i = 2; i < Math.Sqrt(n); i++)
            {
                if (n % i == 0) isPrime = false;
            }

            return isPrime;
        }

        public bool HasPrimeId(PersonModel person)
        {
            return IsPrime(person.Id);
        }
    }

Now our isPrime() function checks whether the given number is positive or not, if the number isn't positive, it throws an Exception.

It takes help from IsNumberPositive method, which comes from PositiveDetector model.

Now, while writing the test, we will create a mock of PositiveDetectorModel, and we are not bothered with isNumberPositive() method of this class, as we are writing unit test for isPrime() method, we'll assume that, isNumberPositive works properly, we'll mock it's result too. Our test function is now looks like this.

        [Theory]
        [InlineData(2)]
        [InlineData(5)]
        [InlineData(19)]
        [InlineData(23)]
        public void Test_If_It_Can_Detect_Non_Prime_Numbers(int n)
        {
            // Arrange
            var positiveDetectorMock = new Mock<PositiveDetector>();

            var primeDetector = new PrimeDetectorModel(
            positiveDetectorMock.Object
            );

            positiveDetectorMock
            .Setup(pd => pd.IsNumberPositive(n)).Returns(true);

            // Act
            var isPrime = primeDetector.IsPrime(n);

            // Assert
            Assert.Equal(isPrime, true);
        }

Here, all the inputs (2, 5, 19, 23) are positive numbers, so we are mocking the isNumberPositive() function by returning true for these input.

 positiveDetectorMock
            .Setup(pd => pd.IsNumberPositive(n)).Returns(true);

That's pretty much covers the basic of writing unit tests with xUnit and Moq, for more details you can go to the resources of the reference section, unfortunately xUnit's documentation sucks. Let me know if you have any feedback regarding this post by comments.

All my codes used here will be found here - https://github.com/saadnoor/UnitTestWithXunit

References:

1. https://hamidmosalla.com/2017/02/25/xunit-theory-working-with-inlinedata-memberdata-classdata/
2. https://andrewlock.net/creating-parameterised-tests-in-xunit-with-inlinedata-classdata-and-memberdata/
3. https://xunit.net/#documentation
4. https://github.com/Moq/moq4/wiki/Quickstart

For compiling c++, there are many compilers in the market, but 3 are very popular.

1. Visual C++
2. GNU Compiler Collection (GCC)
3. Clang

Among them, Visual C++ was developed by Microsoft, and they don’t support other platforms like Linux. (Typical Microsoft 😛).

GNU was a project, started by Richard Stallman in 1984, which eventually produced many popular open-source software tools like Make, Sed, and Emacs. GCC was one of them. GCC was used by all UNIX-based OS. Apple also used it for macOS. But over time, Apple wanted to add many features to C++ for their own requirements which weren’t accepted well by GNU developers. So Apple engineers made a separate branch for their own version of c++ the compiler, which was eventually called CLANG.

And that’s why some features we get in GCC but not in CLANG. Most competitive programmers include all possible header files that might be needed for writing that program. But if we are using macOS, it can’t recognise include<bits/stdc++.h.

To solve this problem,

1. open finder then click Go to folder

2. paste this address /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/

3. Create a new folder name bits

4. inside bits create a new file named stdc++.h. To create a file open terminal and inside that folder and type touch stdc++.h

5. paste the code written below inside that file.

/** @file stdc++.h
 *  This is an implementation file for a precompiled header.
  */


  using namespace std;


  // 17.4.1.2 Headers

  // C
  #ifndef _GLIBCXX_NO_ASSERT
  #include <cassert>
  #endif
  #include <cctype>
  #include <cerrno>
  #include <cfloat>
  #include <ciso646>
  #include <climits>
  #include <clocale>
  #include <cmath>
  #include <csetjmp>
  #include <csignal>
  #include <cstdarg>
  #include <cstddef>
  #include <cstdio>
  #include <cstdlib>
  #include <cstring>
  #include <ctime>

  #if __cplusplus >= 201103L
  #include <ccomplex>
  #include <cfenv>
  #include <cinttypes>
  #include <cstdbool>
  #include <cstdint>
  #include <ctgmath>
  #include <cwchar>
  #include <cwctype>
  #endif

  // C++
  #include <algorithm>
  #include <bitset>
  #include <complex>
  #include <deque>
  #include <exception>
  #include <fstream>
  #include <functional>
  #include <iomanip>
  #include <ios>
  #include <iosfwd>
  #include <iostream>
  #include <istream>
  #include <iterator>
  #include <limits>
  #include <list>
  #include <locale>
  #include <map>
  #include <memory>
  #include <new>
  #include <numeric>
  #include <ostream>
  #include <queue>
  #include <set>
  #include <sstream>
  #include <stack>
  #include <stdexcept>
  #include <streambuf>
  #include <string>
  #include <typeinfo>
  #include <utility>
  #include <valarray>
  #include <vector>

  #if __cplusplus >= 201103L
  #include <array>
  #include <atomic>
  #include <chrono>
  #include <condition_variable>
  #include <forward_list>
  #include <future>
  #include <initializer_list>
  #include <mutex>
  #include <random>
  #include <ratio>
  #include <regex>
  #include <scoped_allocator>
  #include <system_error>
  #include <thread>
  #include <tuple>
  #include <typeindex>
  #include <type_traits>
  #include <unordered_map>
  #include <unordered_set>
  #endif

save and exit. After that, it will work fine.