For a Bangladesh Tourist Visa, you need to fill up a Visa Application Form and have a copy of your ID photo, your air tickets (with return flight), and documents to support your purpose of travel. S$29 would be charged for a Single-visit visa.

Visa on Arrival

Please check with IATA Travel Center for up-to-date information on this.

Citizens of the USA, Canada, Australia, New Zealand, Russian Federation, China, Japan, Singapore, Malaysia, South Korea, UAE, Saudi Arabia (KSA). Qatar. Kuwait, Oman, Bahrain, and the countries of Europe can obtain a Visa on Arrival for Business/Tourism.

Although Singaporeans are eligible for the Visa on Arrival facility, we decided to apply for a Bangladesh Tourist Visa anyway for peace of mind.

Special Note: Citizens of the Philippines, Vietnam, Laos, Indonesia, etc do not have Visa on Arrival facilities. Citizens of countries not mentioned in the VoA list must apply for a Bangladesh Tourist Visa beforehand.

Whole Visa Application Process

1. Gather Documents, make hotel bookings and get air tickets.
2. Submit Visa Application at Embassy.
3. Collect your visa in 3-4 working days.

Necessary Visa Documents

1. A filled-up Visa Application Form. Please submit the visa application form online. Take a printout.
2. 1 copy of 35 mm x 45 mm color photograph of the applicant.
3. Air Tickets (with return flight).
4. Singapore NRIC / Employment Pass / S-Pass / Work Permit.
5. A copy of the Passport ID page, and last visa page.
6. Your actual passport.
7. A hotel booking or letter of invitation or letter of sponsorship.

If you're visiting the country and staying in a hotel, definitely make a booking online. You'll need a printed confirmation letter.

If you're staying at a (Bangladeshi Citizen) friend's home, get a signed letter of invitation from the friend. The letter of invitation should include,

• Your relationship with the sponsor
• The local address of your stay
• The local contact number of the sponsor
• Reason for your visit (i.e., meeting family, tourism)
• Means of funding for the trip (i.e, credit card, cash, sponsorship)
• The Passport numbers of the sponsor and the visitor
• NID Card Number of the sponsor
• If possible, include a copy of the Bangladesh NID card of the sponsor.

I have prepared a Bangladesh Tourist Visa Invitation letter template for your convenience. You may download it by clicking the button below.

Filling up the Visa Application Form

1. Visit visa.gov.bd.
2. Fill up your personal information and travel information.
3. On the payment step, leave the payment details empty as you'll pay at the High Commission.
4. In "Part 6 - Bangladesh Visa Office Information", choose Singapore. Leave the "Group / Order by" empty.
5. Review your information and submit it.
6. Take a printout.
7. Sign the application form on page 3.

The High Commission of Bangladesh in Canada created a video tutorial, you can follow this video as a guide. Remember to select Singapore instead of Canada during the application!

Submitting the Visa Application

Once you have everything printed and copied, put them in a folder. Make sure you have S$29 ready on your bank card. The High Commission of Bangladesh only accepts NETS payments. Cash is not accepted.

The High Commission is open on weekdays 9:30 AM - 12:30 PM for visa applications.

Head down to Jit Poh Building. Head to #04-00. Take a queue number from the machine.

Once it is your turn, submit your documents. They will provide you with a receipt after payment. You need to keep that receipt for passport collection. It will take 3-4 working days before the visa is ready. On the date specified on the receipt, visit the High Commission to collect your passport.

Checking Status

1. Please head over to https://www.visa.gov.bd/ViewStatus.aspx.
2. Enter your Username and Password from the online application.

Now, if it says Approved, well, it is approved. Congratulations!

However, Rejected doesn't mean Rejected. If the application is still being processed, sometimes it is shown as Rejected. Just visit the embassy on the day noted on your receipt.

Please feel free to comment if you have any questions.

TL;DR - By default, Hasura does not accept multiple JWKS URLs. Thus, write a lambda or a simple HTTP API to combine the JWKS keys of multiple tenants into a single JWKS endpoint. (Bonus: Buggy Auth0 fingerprint implementation)

Prelude

Before starting, please make sure to add the Auth0 Rule as mentioned in this support document. Test to make sure the Hasura Claim is present in the JWT issued by Auth0.

The Auth0 JWKS Bug

Thanks to a pretty weird bug in Auth0, if you have an old signing key generated on/before April 2020, the key has an invalid x5t fingerprint. Thus, Hasura will not work if you point it to a JWKS endpoint containing the old x5t fingerprints.

Thankfully, Auth0 has issued a fix, and all you need to do is rotate your signing keys.

Observing the JWKS response

The JWKS URL of your Auth0 Tenant will respond resembling the type declaration stated below.

(Hint: https://..auth0.com/.well-known/jwks.json )

export interface Key {
    alg: string;
    kty: string;
    use: string;
    n: string;
    e: string;
    kid: string;
    x5t: string;
    x5c: string[];
}

export interface RootObject {
    keys: Key[];
}

Thus, we just need to fetch the JWKS Key objects from all our tenants and merge them into a single keys array. Let's do it.

Building the Lambda

Let's list down all our JWKS endpoints in an array. Make sure to replace it with your Auth0 Domains.

const jwksUrls = [
    'https://foo.au.auth0.com/.well-known/jwks.json',
    'https://bar.au.auth0.com/.well-known/jwks.json',
    'https://baz.au.auth0.com/.well-known/jwks.json',
];

Next, time to parallelly download all the JWKs for merging. We'll be using axios.

const axios = require("axios");

const responses = await Promise.all(jwksUrls.map((url) => axios.get(url)));
const keySets = responses.map(response => response.data.keys)

Okay, we have to take a break here. Recall the Auth0 x5t bug? Yeah. It turns out, even if you rotate the key, for the sake of other microservices in your system, you may decide to keep the previous key still valid. Otherwise, the previously issued tokens would become invalid and your users wouldn't stay "logged in" anymore.

There is a tiny workaround. It is to remove the invalid keys with the invalid x5t signatures from the keySets. However, this does mean that your new Hasura system will only work with newly issued JWT tokens signed with your shiny new key. Thus, we will replace that last line with,

const keySets = responses.map(response => response.data.keys.filter(key => key.kid !== key.x5t));

Because in the faulty implementation, the kid and x5t are the same.

The final code for the Lambda

Pointing Hasura to the JWKs endpoint

You may choose to create a lambda or host this function any way depending on your preference. Finally, once you have the endpoint to the JWKS merging API, simply point Hasura to it. Update the HASURA_GRAPHQL_JWT_SECRET environment variable to,

{
  "type":"RS256",
  "jwk_url": "",
  "claims_format": "stringified_json"
}

The end!

When TraceTogether was rolled out in Singapore, I geeked out with the BlueTrace Protocol and the basics of how it worked. However, with my experience of volunteering for the migrant population, I knew that we needed translations, badly. We needed translations if we wanted to an effective deployment of TraceTogether in the vulnerable population.

With their little command over English, would most migrant of the migrant brothers be able to effectively use TraceTogether?

Tracing the Contacts

I immediately texted everyone I knew, working with GovTech or SingHealth. I contacted GovTech on a few channels to connect me to the right person. I was surprised at the speed they responded with contacts! Finally, along with active help from Sudesna, a recent NUS-grad young physician, I got a few contacts to move forward.

Meanwhile

I was anxious to get the translations rolled out. I needed to start translating by the time I reached the correct person-in-charge. So, as any sane human would do, I started a Google Sheet, and tried to type in text from the app interface. Soon however, I realised this was unsustainable as some of the hidden screens would remain untranslated.

So, I took the Android app, and started reverse-engineering. I used a tool named apktool to decompile the app, and looked for the file containing all the "strings of text" used throughout the app. Luckily, I did find the English resources file.

However, it was XML, and I needed to spit out a CSV/Excel file for it to be any good. Developers always try to automate everything. Spirited, I did write a simple Python script to convert this document into a CSV, uploaded to Google Sheets and started translating.

I was happy. I felt relieved. Now, all I had to do was to hand this over to the responsible team to be implemented.

The Contact!

Finally I found a person from the Hive Team coordinating UI/UX efforts of TraceTogether. They were delighted to see the efforts, however had to let me know that, the (then) current version of the app wasn't designed to be multilingual, and a new version with new strings would be released soon!

Altho, not all of TraceTogether was translated by individual contributors from the members of the public. My translations were partially accepted to some of the untranslated parts of TraceTogether. The Team was very aware of the need of the migrant population, and started their own effort of translation even before me! However, as people with hearts, they always did try to encourage us volunteers, and made opportunities for us to contribute here and there.

We started working to translate the newer features of the app. One of the first features I translated, was the SafeEntry check-in feature. I still get excited to see my translations on the app.

I believe allowing the public to participate is empowering us, giving us a feeling of achievement as we could contribute as much as we could, in helping to keep this tiny island we call home, safe. Thanks, the HIVE TEAM!

The Cool T

And, I got a cool TraceTogether T as a token of appreciation :')

I was blown away to know the had made the time to arrange this, out of their insanely busy schedules.

Seen those SafeEntry posters in Singapore, with instructions to "log in" to your neighborhood 7-Eleven? I have translated those into Bengali (Bangla) ahead of the reopening of Singapore, from the circuit breaker. These have been translated in the hope of protecting our migrant workers and the community amidst the uncertainty.

What is this?

SafeEntry is a simple contact tracing system used by the Government of Singapore as a measure to track the spread of COVID-19. Shops, malls, officers, and other public places put posters out instructing visitors on how to sign in. Those are now available in Bengali!

Download Posters

[Links removed as they are no longer relevant in Singapore]

If you are wondering why you cannot send Bengali text encoded in Unicode properly through the SSLWireless Push API in Python, well you are not alone. The solution is, encoding your UTF-8 text into UTF-16 (Big Endian) and then taking the hexadecimal value of it, transformed into uppercase.

def encode(message):
    return message.encode('utf-16-be').hex().upper()

Let's witness this step by step.

>>> message = 'আমার সোনার বাংলা'
>>> message
'আমার সোনার বাংলা'
>>> message.encode('utf-16-be')
b'\t\x86\t\xae\t\xbe\t\xb0\x00 \t\xb8\t\xcb\t\xa8\t\xbe\t\xb0\x00 \t\xac\t\xbe\t\x82\t\xb2\t\xbe'
>>> message.encode('utf-16-be').hex()
'098609ae09be09b0002009b809cb09a809be09b0002009ac09be098209b209be'
>>> message.encode('utf-16-be').hex().upper()
'098609AE09BE09B0002009B809CB09A809BE09B0002009AC09BE098209B209BE'

And that is how it is done. Hope it helped! N.B. The rest of the details about how to perform a request, are in the documentation you have received from SSLWireless.

I am a self-taught Software Engineer working in the industry for about 5 years. However, formal tertiary education has always been on my radar. This blog post describes my story, and why I chose a distance learning programme instead of an on-campus offering.

Unconventional Beginnings

So, here is the standard path for a Computer Science career - you pass high school, go to college to study CS, learn to code, intern at a company and then get a full time role at a Software company. I exactly didn’t follow this set standard.

I started coding in 8th grade. I had my first serious internship handling consumer services at 10th grade. I wrote Android system components and firmware at 12th grade. When I got admitted into a brick-and-morter university for a B.Sc, I already started developing globally distributed web crawling and news aggregation systems.

At it turned out, continuing my university classes with strict attendance requirements was becoming impossible as I positioned myself as one of the senior resources at my organization. I had taken more responsibilties, tougher challanges. I struggled to do well in my university exams, and grades plummetted. At one point, I was so far behind my peers, I couldn’t complete half of my course requirements in 3 years. Full time work and fighting through Mirpur (Dhaka) traffic meant, I stayed outdoors from 7 AM - 8 PM.

Bad grades, not being able to attend classes became an issue. Although my employer had no issue with me taking classes during work hours, I felt that I deprived my employer of my precious work hours. I had to do something to get back my results, get more time to study and be fair with my employer.

My Options

I essentially had four options at hand.

1. Continue as it is. Graduate in 3 more years (totalling 6) with terrible grades while risking my performance at work.
2. Getting admitted into another local university where an evening CSE programme is offered.
3. Leaving my emloyment, becoming a full-time student and passing in 1.5 - 2 years.
4. Enrolling into an accredited and respected distance learning programme to continue my education alongside my professional work.

My family had not been in a position to support my education without any income contribution from me. Number 3 could be crossed off. Considering Dhaka traffic, the reputation of universities offering evening programmes, I decided to back off of number 2. Number 1 was just impractical, leaving me with number 4.

Taking the plunge

I researched a lot. Foreign degrees are valued in foreign currency, most beyond the reach of my income level. Many were affordable, but were questionable and not as respected. After a few months of research, I stumbled upon the programmes offered by the University of London. After some digging, I found that the university has a track record of successful distance learning programmes.

I myself was skeptical. Many of my well-wishers from the academia and industry reminded of the grey area status of distance learning programmes. I had to make a choice. I chose to continue with distance learning. I had already built a comparatively successful portfolio of work and past experiences working for major organizations and products. My target was to tick the degree checkbox.

I understood that my degree from Bangladesh would bear comparatively little value for my resume. I consulted a few foreign ministries to check the recognition of the distance learning programmes of the Uniersity of London. Namely, Ministry Of Manpower (Singapore). To my surprise, it was ranked higher than all of the Bachelors degrees offered from Bangladeshi universities (public and private).

I knew I was probably on the right track. I had more confidence. I applied. I got an offer, accepted and started the programme. I transferred from NSU to UoL.

So this is my story in short. Please remember that, distance learning programmes aren’t accepted everywhere. Do your homework before you decide to commit. I am in no way an educational consultant, just an average human sharing my story. If you want to hear more about this, or maybe how I applied and other stuff - leave a comment to let me know.

If you are seeing my website instead of the one you're supposed to see, this post is for you. I sharing a hosting server with several hundreds of people. That server had a hardware failure, and backups are being restored as I speak.

Why are you seeing my site?

My Domain starts with the letter A. Thus, it was copied to the server from a backup first. Even before the default file, as it starts with D. So, for a brief period, you saw my site. Till that default got copied over.

I didn't hack you.

Please contact your hosting provider.

I always tend to organize every aspect of my experiments with organizers as useful as Pipeline. However, one shouldn't be passing continuous variables into a OneHotEncoder or vice versa for Scalers. The solution is, split your data, treat them in separate pipelines before merging them together again. Inspired by Scikit Learn Examples.

Identifying the Columns / Features

The first step, definitely, is to identify which columns are categorical and which are numeric.

numeric_features = ['salary', 'zone_count', 'staff_count']
categorical_features = ['rank', 'district']

I found a super cool way to achieve this automatically (I forgot the source, will mention it once I find it).

categorical_feature_mask = df.dtypes==object
categorical_features = df.columns[categorical_feature_mask].tolist()

numeric_feature_mask = df.dtypes!=object
numeric_features = df.columns[numeric_feature_mask].tolist()

This again works on the belief that categorical features are not being represented by numbers. However, often numbers can be categorical features! Be careful while using this neat trick and do consider whether all your apparently numerical features are numeric after all!

Setting up Numeric and Categorical Pipelines

First, I am setting up my pipeline for the categorical data I have. (Yeah with one step!)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder(handle_unknown='ignore')),
])

Next up, let's setup the pipeline for our numeric values.

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
])

And we are done with this phase. Let's move on and combine these two pipelines!

The Great Join

We'll be using a ColumnTransformer for this bit. Let's combine these transformation pipelines.

from sklearn.compose import ColumnTransformer

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ]
)

Awesome! And we have the separated pipelines being used from a ColumnTransformer now.

Constructing the Main Pipe

Now, the part you've been waiting for, actually using everything we've done to feed into a Classifier, Regressor or something else.

from sklearn.ensemble import RandomCityClassifier

clf = Pipeline([
     ('preprocessor', preprocessor),
     ('clf', RandomCityClassifier())
])

Now use the pipeline as usual, fit your data, predict on test data, do benchmarks, and maybe deploy!

Thanks for reading through! If you liked this simplified and broken down explanation, please do not forget to share it with your friends. Why not leave your thoughts in the comments below?

I found myself the problem of counting the occurrence of specific "days of the week" between two dates; for, of course, generating features for a predictive analysis task. For example, the number of Fridays and Saturdays between 2019-01-01 and 2019-01-15. And thankfully, good old PostgreSQL came to the rescue!

Introducing generate_series

SELECT * FROM generate_series(1, 5);

generate_series 
            1
            2
            3
            4
            5
 (5 rows)

And, if we want to spice it up by setting the interval, we can do that too! Let's make a list of all the ODD numbers between 1 and 10 (inclusive).

SELECT * FROM generate_series(1, 10, 2);

generate_series 
            1
            3
            5
            7
            9
 (5 rows)

generate_series but with Dates

Let's try just plugging in Date Strings.

SELECT * FROM generate_series('2019-01-01', '2019-01-15');

[42725] ERROR: function generate_series(unknown, unknown) is not unique Hint: Could not choose a best candidate function. You might need to add explicit type casts.

Clearly, something is off. Ah, we didn't cast those values as Dates. Of course. Let's do it.

SELECT * FROM generate_series('2019-01-01'::date, '2019-01-15'::date);

[42883] ERROR: function generate_series(date, date) does not exist Hint: No function matches the given name and argument types. You might need to add explicit type casts. Position: 15

Okay that did identify our value as a date, but it still isn't working. The thing is, we need to provide the interval explicitly. Let's do it!

SELECT *
FROM generate_series('2019-01-01'::date, '2019-01-15'::date, '1 day'::interval);

generate_series     
2019-01-01 00:00:00+06
...
2019-01-15 00:00:00+06
(15 rows)

Alright! That worked like a charm! Of course, let's make it a bit prettier.

SELECT s::date
FROM generate_series('2019-01-01', '2019-01-15', '1 day'::interval) s;

     s      
  2019-01-01
  ...
  2019-01-15
 (15 rows)

Sweet! We can now generate the ranges required.

The Week of Day

I'll let the query and the results talk in this bit.

SELECT
       s::date,
       extract(DOW from s),
       to_char(s, 'day')
FROM generate_series('2019-01-01', '2019-01-15', '1 day'::interval) s;

      s      | date_part |  to_char  
 ------------+-----------+-----------
  2019-01-01 |         2 | tuesday  
  2019-01-02 |         3 | wednesday
  2019-01-03 |         4 | thursday 
  2019-01-04 |         5 | friday   
  2019-01-05 |         6 | saturday 
  2019-01-06 |         0 | sunday   
  ...
  2019-01-14 |         1 | monday   
  2019-01-15 |         2 | tuesday  
 (15 rows)

Starting to make sense now? We can get a numeric value for the day of the week by extracting DOW from the interval. And getting the string representation is just as easy as calling to_char. Let's put a weekend constraint now. Check the mapping of days of the week on the table posted above. That's how we got 5 and 6; representing Friday and Saturday.

SELECT s::date,
       extract(DOW from s),
       to_char(s, 'day')
FROM generate_series('2019-01-01', '2019-01-15', '1 day'::interval) s
WHERE extract(DOW from s) in (5, 6);

      s      | date_part |  to_char  
 ------------+-----------+-----------
  2019-01-04 |         5 | friday   
  2019-01-05 |         6 | saturday 
  2019-01-11 |         5 | friday   
  2019-01-12 |         6 | saturday 
 (4 rows)

That's super cool! Now, let's COUNT!

SELECT COUNT(*)
FROM generate_series('2019-01-01', '2019-01-15', '1 day'::interval) s
WHERE extract(DOW from s) in (5, 6);

Voila!

With a Table

SELECT id,
       SUM(CASE WHEN extract(dow from s) IN (5, 6) THEN 1 ELSE 0 END)
FROM tbl
JOIN generate_series(
        tbl.starts_on,
        tbl.ends_on,
        '1 day'::interval) s ON true
GROUP BY id;

So this was my clumsy implementation, that I came up with. I am pretty sure there are better ways to pull this off. Why don't you leave your thoughts and solutions in the comments? And please don't forget to share if you learned anything new! Thanks for dropping by.

Although something like Flask's globally accessible request object is considered a terrible way of writing code (explicit is better than implicit), sometimes it makes sense to use it. For example, while passing a Correlation-ID to track a request's life cycle through your micro-services.

You can memorize the Correlation-ID throughout the lifecycle of a request without explicitly passing it around like juggling balls. This is actually a good approach as the Correlation ID is not a core business logic - just a distraction. We'll see how we can implement such a request-bound "global" context in Sanic, and how to setup a simple Correlation ID implementation.

aiotask-context

This nifty Python module can maintain a distinct context against each asyncio Task. Which means, each request can have an associated context we can use to store and pass around passive details.

$ pip install aiotask-context

from sanic import Sanic
from sanic.response import json

# import aiotask-context
import aiotask_context as context

app = Sanic()

# hook aiotask-context
@app.listener('after_server_start')
async def hook_context(app, loop):
    loop.set_task_factory(context.task_factory)

@app.route("/")
async def test(request):
    return json({"hello": "world"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Now we have a simple Sanic app with the context hooked up.

Implementing Correlation ID Generation and Passing

Now, let's grab the correlation ID if it comes with the request, or generate our own otherwise. Afterwards, we need to save that value to the context for future use in other parts of the code (i.e. logging, requests to other microservices and so on).

from uuid import uuid4
import aiotask_context as context

@app.middleware('request')
async def handle_correlation_id(request):
    cid = request.headers.get('X-Correlation-ID') or str(uuid4())
    context.set('cid', cid)

And throughout the code, if you need the cid or any context value you have set, simply use context.get(key).

And the last step is definitely all about responding with the Correlation ID. We'll be sticking to the middleware for this too. We just need to update the response object from the context.

@app.middleware('response')
async def insert_correlation_id(request, response):
    response.headers["X-Correlation-ID"] = context.get('cid')

Great! Now we don't have to write spaghetti code and get lost in passing CIDs from functions to functions. Cheers!