15 posts tagged with "medium"

This blog post is the continuation of my previous blog Demystifying Google’s Secret Hiring Challenge-I, where I shared How I got invited to the Google’s Foobar challenge.

In this blog, I will share about what were the actual challenges How I solved them, and most importantly did I make it to the end of this challenge. Keep reading to find out.

If you haven’t read my previous blog, to sum up

The Foobar challenge consists of five levels of algorithmic and pattern problems 9 in total, that can be completed in either Python or Java. Level 1 & 5 has one problem each, Level 2 & 4 has two problems each, and Level 3 has three problems

This challenge allows the use of Python or Java as the programming, I am quite familiar with Python and have been using it quite often recently, so I chose it as my programming language of choice.

So the first problem of this challenge was Braille Translation. Here’s the First problem description

Braille Translation (Problem1, Level 1)​

"Braille, Translation!
===========
Braille is a writing system used to read by touch instead of by sight.
Each character is composed of 6 dots in a 2x3 grid, where each dot can
either be a bump or be flat (no bump). You plan to translate the signs
around the space station to Braille so that the minions under Commander
Lambda's command can feel the bumps on the signs and "read" the text with
their touch. The special printer which can print the bumps onto the signs
expects the dots in the following order:
1 4
2 5
3 6

So given the plain text word "code", you get the Braille dots:

11 10 11 10
00 01 01 01
00 10 00 00

where 1 represents a bump and 0 represents no bump. Put together, code becomes
the output string 100100101010100110100010.

Write a function solution(plaintext) that takes a string parameter and returns
a string of 1's and 0's representing the bumps and absence of bumps in the
input string. Your function should be able to encode the 26 lowercase letters,
handle capital letters by adding a Braille capitalization mark before that
character, and use a blank character (000000) for spaces.
All signs on the space station are less than fifty characters long and use only
letters and spaces.

Short description of the problem​

Given a string input with letters and underscores, convert it to a braille-encoded string.

Picture showing braille alphabets from pharmabraille.com

Taking a quick look at the Braille alphabets, it is evident that they do not follow any pattern which means we will need to store the mapping of letters in an array.

The key thing to remember is that, “Braille distinguishes capital and small letters by adding a special character before the alphabet, represented as Dot 6 meaning the 6th dot will be raised which is equivalent to “000001” in our code”. Since the input will only contain alphabets and space, we only need to handle the case for uppercase letters using ASCII value.

With this code, all the test cases pass and we head on to level 2

Bunny Worker Locations (Problem1, Level 2)​

Bunny Worker Locations
======================
Keeping track of Commander Lambda's many bunny workers is starting to get
tricky. You've been tasked with writing a program to match bunny worker IDs
to cell locations.

The LAMBCHOP doomsday device takes up much of the interior of Commander
Lambda's space station, and as a result the work areas have an unusual
layout. They are stacked in a triangular shape, and the bunny workers
are given numerical IDs starting from the corner, as follows:

| 7
| 4 8
| 2 5 9
| 1 3 6 10

Each cell can be represented as points (x, y), with x being the distance from
the vertical wall, and y being the height from the ground.
For example, the bunny worker at (1, 1) has ID 1, the bunny worker at (3, 2)
has ID 9, and the bunny worker at (2,3) has ID 8. This pattern of numbering
continues indefinitely (Commander Lambda has been adding a LOT of workers).

Write a function solution(x, y) which returns the worker ID of the bunny at
location (x, y). Each value of x and y will be at least 1 and no greater
than 100,000. Since the worker ID can be very large, return your solution
as a string representation of the number.

Short description of the problem​

The problem states that “given input (x, y), the program should return the number in that location e.g (4, 5) should return 32

This problem also seemed easy since I could see the pattern, but it took me almost a day to pass all the test cases, only because I missed an important detail in the problem.

The given sequence in the problem is an indefinite pattern expanding on top of the given pattern, it would look like the below,

The diagonal lines indicate the numbers increasing diagonally (pattern 1)

There are two important patterns to notice

1. the numbers are increasing along the diagonal of the matrix.
2. The difference between two elements in the same row is increasing by a constant and that constant increases for each position along x. e.g notice elements in row 3, 4 + 4 = 8, 8 + 5 = 13, 13 + 6 = 19 and so on

I used a naive approach and allocated a matrix of size (x+y, x+y), filled the values of the max(x, y) size of the matrix, and then tried returning the result. However, with this approach, some of the test cases were failing. I was pretty confident that the matrix was right. The comment at the bottom of the code shows the matrix formed

I reread the problem and this was the crucial part of the problem that I was missing “Each value of x and y will be at least 1 and no greater than 100,000.” I realized that space complexity was the issue. Because I was still occupying [x+y] X [x+y] size of the matrix, this means if a particular element in the matrix takes 4 bytes of memory (since int takes 4 bytes) then for a large input in the worst case x = 100,000 we are allocating 200,000 x 200,000 size of the matrix

Which would roughly take 200,000 x 200,000 x 4 bytes of memory which is approximately 160 GB 🤯

So allocating a matrix is not a good approach and would never work at all, But since we know the pattern in the matrix, we can keep track of the position traverse through the target positions, and keep track of the result.

The picture shows the traverse path for location(6,5)

The idea was pretty simple we would traverse the first row until x+y+1, because the pattern of numbers we know is along the diagonal so to find any number x, y we have to at least travel (x+y+1) along X. e.g if we were to figure out position (6, 5) we would traverse 12 locations on the first row and traverse our way up (in a staircase fashion) until we reach our target y = 5 and decrease our result by 1 for every step up, until we reach x = 6. This is how our traverse path would be for input (6,5)

Traverse along X: 1— 12, until we reach (12, 1)

Step up: Step up and step back along the diagonal until we reach target Y=5(repeat) (11,2), (10, 3), (9, 4), (8, 5),

Traverse back along X until X= 6: (7, 5), (6,5) stop when we reach the target.

During this traverse, we keep track of the result and the current location, with this approach the code passed all the test cases and did not have any overhead in terms of memory.

Power Hungry (Problem 2, Level 2)​

"Power, Hungry!
===========
Commander Lambda's space station is HUGE. And huge space stations take a LOT
of power. Huge space stations with doomsday devices take even more power.
To help meet the station's power needs, Commander Lambda has installed solar
panels on the station's outer surface. But the station sits in the middle of
a quasar quantum flux field, which wreaks havoc on the solar panels. You and
your team of henchmen have been assigned to repair the solar panels, but you'd
rather not take down all of the panels at once if you can help it, since they
do help power the space station and all!

You need to figure out which sets of panels in any given array you can take
offline to repair while still maintaining the maximum amount of power output
per array, and to do THAT, you'll first need to figure out what the maximum
output of each array actually is. Write a function solution(xs) that takes a
list of integers representing the power output levels of each panel in an
array, and returns the maximum product of some non-empty subset of those
numbers. So for example, if an array contained panels with power output
levels of [2, -3, 1, 0, -5], then the maximum product would be found by
taking the subset: xs[0] = 2, xs[1] = -3, xs[4] = -5, giving the product
2*(-3)*(-5) = 30. So solution([2,-3,1,0,-5]) will be "30".

Each array of solar panels contains at least 1 and no more than 50 panels,
and each panel will have a power output level whose absolute value is no
greater than 1000 (some panels are malfunctioning so badly that they're
draining energy, but you know a trick with the panels' wave stabilizer that
lets you combine two negative-output panels to produce the positive output
of the multiple of their power values). The final products may be very large,
so give the solution as a string representation of the number.

Languages
=========

To provide a Python solution, edit solution.py
To provide a Java solution, edit Solution.java

Test cases
==========
Your code should pass the following test cases.
Note that it may also be run against hidden test cases not shown here.

-- Python cases --
Input:
solution.solution([2, 0, 2, 2, 0])
Output:
    8

Input:
solution.solution([-2, -3, 4, -5])
Output:
    60

-- Java cases --
Input:
Solution.solution({2, 0, 2, 2, 0})
Output:
    8

Input:
Solution.solution({-2, -3, 4, -5})
Output:
    60

Short description of the problem​

Given an array, we have to find a subset of the array such that the product is maximum, the catch here is the resulting array elements do not necessarily have to be a consecutive subset. e.g. for the given test case [2, 0, 2, 2, 0] the subset is 2 resulting in 8.

In the best-case scenario when the array contains all positive integers then our subset would be the product of all elements in the array. But the challenge here is to handle cases when the array contains zero and negative numbers.

Let us handle the negative case first, We know multiplying an even number of negative numbers would give a positive result, so if the array contains an even number of negative numbers we don’t have to do anything, and the approach of multiplying all the numbers would work, But for the case when the number of negative numbers is odd we need to remove one negative number from it and we would choose the one with max value (min in magnitude) e.g. if xs = [-2, 5,0, 7, 8, 0, -1, -10], we would remove -1.

resulting in xs = [-2, 5, 0, 7, 8, 0, -10]

And for zeros, we can simply ignore them, because multiplying a zero, would bring down our result to zero.

Now as we multiply our product will abruptly fluctuate between negative and positive, so we keep track of max and min products and choose the maximum of max_product, min_product, and xs[i]

With this approach, Level 3 unlocks!

Bomb Baby (Problem 1, Level 3)​

"Bomb, Baby!
===========
You're so close to destroying the LAMBCHOP doomsday device you can taste it!
But in order to do so, you need to deploy special self-replicating bombs
designed for you by the brightest scientists on Bunny Planet. There are two
types: Mach bombs (M) and Facula bombs (F). The bombs, once released into the
LAMBCHOP's inner workings, will automatically deploy to all the strategic
points you've identified and destroy them at the same time.

But there's a few catches. First, the bombs self-replicate via one of two

distinct processes:
- Every Mach bomb retrieves a sync unit from a Facula bomb; for every Mach
bomb, a Facula bomb is created;
- Every Facula bomb spontaneously creates a Mach bomb.

For example, if you had 3 Mach bombs and 2 Facula bombs, they could either
produce 3 Mach bombs and 5 Facula bombs, or 5 Mach bombs and 2 Facula bombs.
The replication process can be changed each cycle.

Second, you need to ensure that you have exactly the right number of Mach and
Facula bombs to destroy the LAMBCHOP device. Too few, and the device might
survive. Too many, and you might overload the mass capacitors and create a
singularity at the heart of the space station - not good!

And finally, you were only able to smuggle one of each type of bomb - one Mach,
one Facula - aboard the ship when you arrived, so that's all you have to
start with. (Thus it may be impossible to deploy the bombs to destroy the
LAMBCHOP, but that's not going to stop you from trying!)

You need to know how many replication cycles (generations) it will take to
generate the correct amount of bombs to destroy the LAMBCHOP. Write a function
solution(M, F) where M and F are the number of Mach and Facula bombs needed.
Return the fewest number of generations (as a string) that need to pass
before you'll have the exact number of bombs necessary to destroy the
LAMBCHOP, or the string "impossible" if this can't be done! M and F will be
string representations of positive integers no larger than 10^50.

For example, if M = "2" and F = "1", one generation would need to pass,
so the solution would be "1". However, if M = "2" and F = "4", it would not
be possible.

Languages
=========

To provide a Java solution, edit Solution.java
To provide a Python solution, edit solution.py

Test cases
==========
Your code should pass the following test cases.
Note that it may also be run against hidden test cases not shown here.

-- Java cases --
Input:
Solution.solution('4', '7')
Output:
    4

Input:
Solution.solution('2', '1')
Output:
    1

-- Python cases --
Input:
solution.solution('4', '7')
Output:
    4

Input:
solution.solution('2', '1')
Output:
    1

Short description of the problem​

The problem states that given target values of Mach and Facula Bomb, the output should return the number of cycles required to reach the target. At any instance of the cycle, we must do the following

• For every Mach bomb, a Facula bomb is created;
• Every Facula bomb spontaneously creates a Mach bomb. we need to start with initial values of m = 1 and f = 1 increase m and f as per the condition and stop when the target is reached.

We do a reverse approach we start with a target and reduce it down as per the conditions. By reduction if we reach m =1 and f =1 that means the target can be reached, and if at any point if either m < 1 or f < 1 that means we cannot reach the target.

Queue to do (Problem 2, Level 3)​

You're almost ready to make your move to destroy the LAMBCHOP doomsday device,
but the security checkpoints that guard the underlying systems of the LAMBCHOP
are going to be a problem. You were able to take one down without tripping any
alarms, which is great! Except that as Commander Lambda's assistant, you've
learned that the checkpoints are about to come under automated review, which
means that your sabotage will be discovered and your cover blown
-- unless you can trick the automated review system.

To trick the system, you'll need to write a program to return the same
security checksum that the bunny trainers would have after they would have
checked all the workers through. Fortunately, Commander Lambda's desire for
efficiency won't allow for hours-long lines, so the trainers at the
checkpoint have found ways to quicken the pass-through rate.
Instead of checking each and every worker coming through, the bunny
trainers instead go over everyone in line while noting their worker IDs,
then allow the line to fill back up. Once they've done that they go over
the line again, this time leaving off the last worker. They continue doing
this, leaving off one more worker from the line each time but recording
the worker IDs of those they do check, until they skip the entire line, at
which point they XOR the IDs of all the workers they noted into a checksum
and then take off for lunch. Fortunately, the workers' orderly nature causes
them to always line up in numerical order without any gaps.

For example, if the first worker in line has ID 0 and the security checkpoint
line holds three workers, the process would look like this:

0 1 2 /
3 4 / 5
6 / 7 8
where the trainers' XOR (^) checksum is 0^1^2^3^4^6 == 2.

Likewise, if the first worker has ID 17 and the checkpoint holds four workers,
the process would look like:

17 18 19 20 /
21 22 23 / 24
25 26 / 27 28
29 / 30 31 32

which produces the checksum 17^18^19^20^21^22^23^25^26^29 == 14.

All worker IDs (including the first worker) are between 0 and 2000000000
inclusive, and the checkpoint line will always be at least 1 worker long.

With this information, write a function solution(start, length) that will
cover for the missing security checkpoint by outputting the same checksum
the trainers would normally submit before lunch. You have just enough time
to find out the ID of the first worker to be checked (start) and the length
of the line (length) before the automatic review occurs, so your program must
generate the proper checksum with just those two values.

#### Languages

To provide a Java solution, edit Solution.java
To provide a Python solution, edit solution.py

#### Test cases

Your code should pass the following test cases.
Note that it may also be run against hidden test cases not shown here.

-- Java cases --
Input:
Solution.solution(17, 4)
Output:
    14

Input:
Solution.solution(0, 3)
Output:
    2

-- Python cases --
Input:
solution.solution(0, 3)
Output:
    2

Input:
solution.solution(17, 4)
Output:
    14

Short description of the problem​

Given an integer start and the length of the queue in the pattern we have to find the xor of all the numbers on the left of the forward slash

17 18 19 20 / 21 22 23 / 24 25 26 / 27 28 29 / 30 31 32 e.g for the above pattern start = 17 , length = 4 the output should be xor of 17^18^19^20^21^22^23^25^26^29 resulting in 14

This seemed like an easy problem compared to the problems we have solved so far, We know the starting number and the length of the first row, so at first I tried to loop through each queue length(4, 3, 2, 1) and xor the numbers one by one but this approach again ran into time complexity issue (As it has always been😕), since each number could be as large as “2000000000".

When I think I have found a solution to the problem, Optimization hits in face.

I looked for some online resources to efficiently XOR an array of consecutive numbers (each queue at a time) and found that the XOR of a range of numbers follows a pattern.

result of 0 - 0: 0
result of 0 - 1: 1
result of 0 - 2: 3
result of 0 - 3: 0
result of 0 - 4: 4
result of 0 - 5: 1
result of 0 - 6: 7
result of 0 - 7: 0
result of 0 - 8: 8
result of 0 - 9: 1
result of 0 - 10: 11
result of 0 - 11: 0
result of 0 - 12: 12
result of 0 - 13: 1
result of 0 - 14: 15
result of 0 - 15: 0
result of 0 - 16: 16
result of 0 - 17: 1
result of 0 - 18: 19
result of 0 - 19: 0
result of 0 - 20: 20
result of 0 - 21: 1
result of 0 - 22: 23
result of 0 - 23: 0
result of 0 - 24: 24

1. A number 1 less than multiples of 4 always returns 0
2. Numbers divisible by 4 have the same result meaning if we would XOR a range 0–4 i.e 0 ^ 1^ 2 ^ 3 ^ 4 results would be 4, similarly 0–12 would be 12, and so on
3. A number 1 greater than multiples of 4 always returns 1 i.e XOR of range 0-1,0-5,0-9,0-13, and so on results in 1
4. A number 2 greater than multiples of 4 always returns number + 1 i.e XOR of 0–6 = 7, 0 — 10 = 11, 0 - 14 = 15, This pattern will allow us to find the XOR of a range in O(1) and save tonnes of computation. But, you might be wondering How we would use this information to find the XOR of a range of numbers that don’t start with 0.

e.g in our problem, we have to find the XOR of our first queue 17–20, So the idea is to XOR the result of XOR(0–16) and XOR(0–20), But, You might ask if you will,

Because the XOR operator ^ follows two important properties,

1. XOR property: A ^ A = 0 for any number A. In other words, XORing a number with itself results in 0.
2. Associative property: The XOR operation is associative, meaning the order in which you XOR a set of numbers does not affect the result. e.g (A ^ B) ^ C = A ^ (B ^ C).

so if you were to find XOR of (0 - A-1) ^(0 — A+10) then the range (0– A-1) would cancel out resulting in 0, and you would get the XOR of the range (A - A+10), That’s why the XOR of the ranges 0–16 and 0–20 gives you the XOR of the numbers in the range 17–20.

Apparently, Had I known these facts about bit manipulation, this would have saved me a couple of days. But this test is evident a Google search never hurts.

With this, I reached the last problem of level 3

Fuel Injection Perfection (Problem 3, Level 3)​

### Fuel Injection Perfection
=========================
Commander Lambda has asked for your help to refine the automatic quantum antimatter fuel injection system for the LAMBCHOP doomsday device. It's a great chance for you to get a closer look at the LAMBCHOP -- and maybe sneak in a bit of sabotage while you're at it -- so you took the job gladly.

Quantum antimatter fuel comes in small pellets, which is convenient since the many moving parts of the LAMBCHOP each need to be fed fuel one pellet at a time. However, minions dump pellets in bulk into the fuel intake. You need to figure out the most efficient way to sort and shift the pellets down to a single pellet at a time.

The fuel control mechanisms have three operations:

1) Add one fuel pellet
2) Remove one fuel pellet
3) Divide the entire group of fuel pellets by 2 (due to the destructive energy released when a quantum antimatter pellet is cut in half, the safety controls will only allow this to happen if there is an even number of pellets)

Write a function called solution(n) which takes a positive integer as a string and returns the minimum number of operations needed to transform the number of pellets to 1. The fuel intake control panel can only display a number up to 309 digits long, so there won't ever be more pellets than you can express in that many digits.

For example:
solution(4) returns 2: 4 -> 2 -> 1
solution(15) returns 5: 15 -> 16 -> 8 -> 4 -> 2 -> 1
Quantum antimatter fuel comes in small pellets, which is convenient since the many moving parts of the LAMBCHOP each need to be fed fuel one pellet at a time. However, minions dump pellets in bulk into the fuel intake. You need to figure out the most efficient way to sort and shift the pellets down to a single pellet at a time.

The fuel control mechanisms have three operations:

1) Add one fuel pellet
2) Remove one fuel pellet
3) Divide the entire group of fuel pellets by 2 (due to the destructive energy released when a quantum antimatter pellet is cut in half, the safety controls will only allow this to happen if there is an even number of pellets)

Write a function called solution(n) which takes a positive integer as a string and returns the minimum number of operations needed to transform the number of pellets to 1. The fuel intake control panel can only display a number up to 309 digits long, so there won't ever be more pellets than you can express in that many digits.

For example:
solution(4) returns 2: 4 -> 2 -> 1
solution(15) returns 5: 15 -> 16 -> 8 -> 4 -> 2 -> 1

Languages
=========

To provide a Python solution, edit solution.py
To provide a Java solution, edit Solution.java

Test cases
==========
Your code should pass the following test cases.
Note that it may also be run against hidden test cases not shown here.

-- Python cases --
Input:
solution.solution('15')
Output:
    5

Input:
solution.solution('4')
Output:
    2

-- Java cases --
Input:
Solution.solution('15')
Output:
    5

Input:
Solution.solution('4')
Output:
    2

Short description of the problem​

Give an input number as a string, find the fastest way to reduce it to 1. You can only do one of the following operations in each step add 1, subtract 1, or divide by 2. e.g 15 can be reduced to 1 in 5 steps 15 -> (15+1)16 ->(16/2) 8 ->(8/4) 4 -> (4/2) 2 -> 1

The difficulty of this problem is not to find a solution but to get the solution running within the time limit in short to optimize it.

Note that using this solution the problem is still running with an 87-character long input when our input program should be capable of handling 309 digits long input.

this was an incorrect approach

It's been almost 4 days now and the solution is still stuck with this approach only 5/10 tests are passing.

Dividing the number is the fastest way to reduce it to 1

32- >16->8-> 4 -> 2 -> 1

so if a number is even we directly divide it, but when a number is odd we have to decide whether to add or subtract 1, this decision should be based on how close the number is to the power of 2.

But, this was the wrong approach, for instance, consider n = 13, it is close to 16 so we would add 1

13 = 13+1 =14 -> 14/2 = 7 -> 7+1 = 8 -> 8/2 = 4 -> 4/2 = 2 ->2/2 = 1 => 6 steps

But actually, it should be reduced in 5 steps 13 = 13–1 = 12 -> 12/2 = 6 -> 6/2 = 3 -> 3–1 = 2 -> 2/2 = 1 => 5 steps

When a number is even it is obvious we will only divide the number into half, the challenge here is only with odd numbers whether to add or subtract,

So I turned to bit manipulation to solve this problem, Take a look at these binary numbers and their corresponding bitwise AND operation with the next consecutive number

0     0  => 00 & 1=0
1     1  => 01 & 2=0
10    2  => 02 & 3=2
11    3  => 03 & 4=0
100.  4  => 04 & 5=4
101   5  => 05 & 6=4
110.  6  => 06 & 7=6
111   7  => 07 & 8=0
1000  8  => 08 & 9=8
1001  9  => 09 & 10=8
1010  10 => 10 & 11=10
1011  11 => 11 & 12=8
1100  12 => 12 & 13=12
1101  13 => 13 & 14=12
1110  14 => 14 & 15=14
1111  15 => 15 & 16=0
10000 16 => 16 & 17=16
10001 17 => 17 & 18=16
10010 18 => 18 & 19=18
10011 19 => 19 & 20=16
10100 20 => 20 & 21=20
10101 21 => 21 & 22=20
10110 22 => 22 & 23=22
10111 23 => 23 & 24=16
11000 24 => 24 & 25=24
11001 25 => 25 & 26=24
11010 26 => 26 & 27=26
11011 27 => 27 & 28=24
11100 28 => 28 & 29=28
11101 29 => 29 & 30=28
11110 30 => 30 & 31=30
11111 31 => 31 & 32=0
None

If you notice here the bitwise AND of two consecutive numbers where one of the numbers has all their bit set (1) is 0

e.g 3 = “11”, 3 & 4 = 0, 7 = “111”, 7 & 8 = 0, 15 = “1111” , 15 & 16 = 0

Our goal is to divide the number as many times as possible meaning trying to convert the odd to even by adding/ subtracting the number by 1, we decide this based on the bitwise AND with its neighboring number, in order to get more trailing zeros. e.g we have n = 13. In binary, this is represented as “1101” ,

• n+1 = 14, which is 1110 in binary.
• n-1 = 12, which is 1100 in binary.
• n-2 = 11, which is 1011 in binary.

Calculate (n+1 & n):13 & 14 is 1101 & 1110, which is 1100= 12 Calculate (n-1 & n-2):12 & 11 is 1100 & 1011, which is 1000 = 8 Now, compare the two results: 12 > 8 so we check whether adding 1 or subtracting 1 results in more trailing zeros, Because every time we divide the number by 2 we lose a trailing zero.

I understand this might be a bit confusing and perhaps difficult for me to put into words, If you would prefer a video explanation this youtube video (In Hindi) is a great resource for understanding this behavior of binary numbers

On completing level 3, You will be prompted to share your personal details which will be shared with the Google Staff Recruiter.

Again sharing these details does not guarantee an interview. If there is a suitable position that fits your skills and interests the recruiter may reach out to you.

After submitting the details I moved to level 4, But the problem seemed pretty difficult to understand in the first place and definitely time-consuming. I also felt I spent enough time and could not take it further. So I gave up on level 4. But regardless the challenges were fun to solve, It gave me a good idea of where I stand and helped me learn a few topics I was unaware of. (Problem statement for level 4 on my Github)

Key Takeaways​

Things that I learned from this Foobar challenge.

1. Don’t always code to solve, everyone can do it, code to optimize.
2. Don’t forget the basics, Bit manipulation is a great way to optimize.
3. Look for patterns everywhere with eyes and mind wide open.
4. What looks simple from the outside is fairly complicated on the inside.
5. We will never be prepared, when the opportunity knocks just take it.
6. Take the challenge without worrying about the end result.
7. Don’t try to fit into a role you are incapable of, It’s unfair to you, It is unfair to the employer.

You can find all the solutions with the problem statements on my Github.

Happy Coding!

If you have ever applied to tech jobs you must be familiar that the process is fairly common, You visit the company's website look for a job that best fits your interests and skills, and apply there. If the employer finds your profile is a match they will most likely reach out to you with a coding assessment. This is also true for the tech giant Google. But they also have a "secret" way of hiring developers around the world, It is called the Foobar Hiring Challenge. I heard about this challenge for the first time sometime back during my undergrad(at least 3 years ago). But never really researched about it, until I experienced it myself last week. There is no official info from Google regarding this but only from folks who have shared their experiences on the internet.

So for those who are hearing about this challenge for the first time, this is what I could collect from the internet and based on my experience regarding this challenge as of Oct 2023.

Google Foobar is a secret hiring process that Google uses to hire developers from around the world. The challenge is designed to evaluate and recruit potential engineers for Google. This challenge is unlocked to folks who have been searching some specific coding related terms on Google

This happened last week, on a bright Sunday morning when I was studying a topic for school and I did a regular Google search, the term was "Genetic Algorithm" and as the search executed, My Google Search results Page collapsed flat backward and I was taken to this black screen with a shell-like interface and I couldn't believe it for a minute.

The web URL looked genuine and to confirm again I did another Google search just to see what exactly is the foobar challenge and the search results convinced me that I actually landed on the Foobar challenge. I didn't waste a lot of time and I signed in with Google to ensure the invite doesn't get lost.

Now it was about giving my best, I had tried Google's coding challenges like Codejam, during my undergrad and gave up because they were too tough for me to solve, and I was convinced I was not there yet to even compete. But now since the challenge showed up itself, I tried to give it a shot and I was prepared to give up again because I still have that notion that the Google coding challenges are extremely difficult to solve.

So now I have this unix-like shell on my screen, so seeing this black screen I know what needs to be done, ask for "help"

and with this information, we exactly know what needs to be done to request a new problem using the command request, running this command a new directory was mounted at the root changing into that directory I was presented with the first coding challenge. As I said even at this point I was prepared that this question would be extremely difficult and I would give up again, But to my surprise the question was pretty easy and I think I was able to solve it in less than half an hour.

Solving the first challenge would present you with a bunny jumping across the screen. So to summarize this challenge

• Google Foobar is an invite-only challenge.
• The challenge consists of five levels of algorithms 9 problems in total that can be completed in either Python or Java. Level 1 & 5 has one problem each, Level 2 & 4 has two problems each, and Level 3 has three problems
• The first two levels are relatively easy, but the difficulty increases as the levels progress.
• Each challenge needs to be completed within 168 hours (7 days)
• After completing level 3, players are asked if they're interested in hearing from a Google recruiter. Those who clear the challenge are offered direct interviews for positions that match their qualifications.

After hearing some experiences from folks on the internet it seems completing these challenges does not guarantee an interview with Google, But regardless the challenges are definitely fun to solve per se.

I am currently in the midst of these challenges, If you would like to read more about what were the exact problems? And How I solved them stay tuned for my upcoming blog post.

Edit: I have published a continuation of this blog post where I shared the challenges from foobar and the approach I used to solve them.

Happy Coding!

So far all of my blog posts have revolved around widgets, flutter, Open Source, and software development. But this time I am taking a different direction, it's about an algorithm I studied as part of my master's course work Artificial Intelligence. I have had the privilege to study many different algorithms throughout my academics and work and have used them day in and day out, But I find this algorithm fascinating, and interesting for its nature, It is inspired by the phenomenon of Natural selection. The same phenomenon on which evolution is based. Brace yourself because this will be a lengthy blog post and probably difficult to understand, But I will try my best to keep things simple.

Introduction​

Genetic Algorithm is a problem-solving strategy inspired by the way living things evolve and adapt over time. It's a computer-based method used to find good solutions to HARD problems, especially when finding the very best answer is really hard. Going forward I will clarify what exactly I meant by HARD problems.

We have all heard the popular phrase "Survival of the Fittest"

species of animals and plants that are best adapted to their environment survive and reproduce, while those that are less well adapted die out.

We understand this fittest theory in terms of evolution and you will see this behavior being perfectly applied in the genetic algorithm for the Travelling Salesman problem. The concept will evolve as you read along and everything will start to make sense, This is not Philosophy this is Evolution.

The Problem​

The problem states

Given a list of cities and the distances between each pair of cities, what is the shortest possible route that visits each city exactly once and returns to the origin city?

This problem is not as straightforward as it sounds, This is an NP-hard problem meaning there is no standard polynomial time algorithm that would solve every instance of this problem. In simple terms, as the number of cities increases it gets exponentially difficult and time-consuming to find a solution to this problem. Hence the Genetic Algorithm (A solution to this Optimization Problem).

The Algorithm​

The above problem described can be solved using the genetic algorithm, This algorithm guarantees a solution that is close to the optimal but not necessarily optimal. It uses a stochastic approach to reach the near-optimal solution. I found a simple yet easy-to-understand analogy to understand this algorithm. I confess this analogy is not mine but it helps explain genetic algorithms in simple words.

"Finding the Best Recipe Imagine you're trying to find the best recipe to make a delicious sandwich. You have lots of ingredients (like bread, cheese, meat, veggies), but you're not sure which combination is the tastiest.

Here's how a genetic algorithm could help:

1. Create Recipes: First, you make a bunch of different sandwich recipes by randomly mixing ingredients. These recipes are like solutions to your sandwich problem.

2. Taste Test: You taste each sandwich and give them a score based on how yummy they are. Higher scores mean better-tasting sandwiches.

3. Mix Recipes: Now, you take the recipes (sandwiches) with the best scores and mix them together. You combine the recipes to create new ones.

4. Add a Twist: Sometimes, you make tiny changes in the new recipes to keep things interesting. This is like adding a pinch of creativity or randomness.

5. Repeat: You repeat these steps many times, keeping the best recipes and making new ones. Over time, the sandwiches get tastier and tastier because you're always choosing the best ones and mixing them.

6. Yummiest Sandwich: After doing this for a while, you end up with a super yummy sandwich recipe because the genetic algorithm keeps improving the recipes based on what tastes best."

Similarly, we apply the GA to the Travelling Salesman problem. Let's understand the algorithm steps before we dive into solving the problem. Before that, it is important to clarify some of the terms that might be confusing.

'Population' denotes the collection of paths (with a size of populationSize), and terms such as 'parent' and 'offspring' refer to individual elements within this population, specifically referring to a path of cities, And genes refer to each individual city within this path.

1. Initialization: Create an initial set of population(paths) of possible solutions. Each population(path) represents a possible route that visits all cities exactly once with the start and end city being the same.
2. Fitness Calculation: Evaluate the fitness of each path. The fitness is determined by the total distance of the route. Shorter routes have higher fitness.
3. Selection: Select parents from the current population based on their fitness. The higher-fitness population should have a higher chance of being selected.
4. Crossover: Apply crossover (recombination) to the selected parents to create offspring. This can be done using various crossover techniques such as order crossover, partially mapped crossover, or cycle crossover.
5. Mutation: Apply mutation to the offspring. This involves making small random changes to some of the genes (cities) in the population.
6. Replacement: Replace the old population with the combined population of parents and offspring.
7. Termination: We repeat steps 2–6 for a certain number of generations or until a stopping criterion is met (e.g. a sufficiently good solution is found or if we have iterated the number of generations).

Implementation​

Now that we have these steps to solve this problem in place, Let's take a problem instance to understand this better. Do not worry if the above steps do not make any sense. The problem instance we will discuss will help us go through each step in detail and make things clear. This problem instance is from my coursework assignment. (I swear this blog is being posted after the assignment's due date 🙂.)

Our Goal here is to find the shortest path among these 10 cities such that we start from City A, visit every city exactly once, and return back to City A with the shortest path.

Screenshot of the deployed app

A graph of 10 Cities along with their coordinatesWe are given with coordinates of these 10 cities as shown on the above scale e.g. A (X: 100, Y: 300) B (X: 200, Y: 130) C (X: 300, Y: 500), and so on.

We will start by implementing a Graph data structure to store this data and some helper functions that will help us along the way.

In the above Graph class following are the class members

• nodes_len is the number of nodes that will be stored in a graph

• roots is a dictionary that acts as an adjacency matrix to store the connections of nodes in a graph.

• nodes is a dictionary that stores the coordinates of the node

• start_city a configurable field to choose the start city in our TSP

• directed decides whether the graph is directed or not.

  and the member functions

• addEdge: is a function that takes two nodes and a weight (distance) between two nodes

• addNode: is a function that takes a node and the coordinates of the node (x,y)

• distance: A helper function to calculate the distance between two nodes

• vertices: A helper function to return the list of nodes in the graph Note that addEdge and addNode both are only added for convenience if we have distance between each pair of cities we can directly use addEdge.

  Now let's implement the Genetic Algorithm Class

I will explain these class members in short here, if you find difficulty understanding the below terms that's totally fine. It is not uncommon to not understand them at this point, it will only get clearer when we look at each step of the algorithm in detail.

• population_size: Determines the possible number of solutions to the problem in each generation which will be optimized further to obtain a near-optimal solution.
• generations: The number of generations/iterations the algorithm should go through. Each generation involves the evaluation of the fitness of individuals in the population, the selection of parents for reproduction, crossover, mutation, and the creation of a new population.
• tournamentSize: The tournament size is the number of individuals participating in each tournament during tournament selection during the crossover.
• mutationRate: The mutation rate is a parameter that determines the likelihood of mutation occurring for each gene.
• fit_selection_rate: This parameter represents the rate or proportion of the fittest individuals(shortest path is fittest) in the population that will be directly carried over to the next generation without undergoing crossover or mutation. It's a form of elitism, preserving some of the best solutions.

The program begins here in find_fittest_path we will leave this method here for our reference and go through this method one step at a time to get a clear picture.

we start by first generating a list of random cities (The list of possible solutions) for our TSP. Note that I am calling it a possible solution, As I mentioned above this is an optimization problem, generation 1 may/may not have the near-optimal solution. If it does, then it will be carried forward (Survival of the fittest) to newPopulation and if it doesn't then the new offspring generated from the fittest parents will give rise to the near-optimal solution. Let's go through the steps of the algorithm we defined above

Initialization​

The randomizeCities method is responsible for generating a list of initial populations. It works in a way that it randomizes all the vertices except the start*city and then appends the start_city at the beginning and end of the generated population. Remember in TSP the salesman must return to the _original city (start city).

The output at the end of the code shows the output generated by this function

The output at the end of the code shows the output generated by this functionOnce we have generated the initial population, Our next work would be to select the fittest population and retain them as part of Generation 1. Each generation must have a population of population_size

But the question is

In the context of the Travelling Salesman problem, fitness is basically the distance of the path (in other problems it would mean different e.g. in the Sandwich recipe the taste score given to each sandwich implies the fitness value). We intend to achieve the shortest path in TSP. So, the population with the shortest path would be deemed fit. And to select the number of fits we have already defined a fit factor called fit_selection_rate (in the range 0-1) to avoid overflow).

Fitness Calculation​

So we calculate the fitness of our entire population using computeFitness and add the number_of_fits_to_carryover number of population from the current generation to newPopulation.  But the newPopulation we generate in each generation must have a population of size population_size. So the remaining population (population_size - number_of_fits_to_carryover) will be generated in our next step of the algorithm using crossover and mutation.

Selection​

CrossOver is a process to produce offspring by combining the traits of parents. But,

We do this with the help of Tournament selection, This is the selection step in GA that determines which parents to select from the existing population for reproduction, This is an important step since selecting the right parent ensures the fit traits/genes are passed on to the next generation. Tournament Selection is a commonly used method for selecting the parents who will participate in the tournament. 

This step is pretty much simple, we run a tournament among a subset of the population (of tournamentSize). This subset is randomly selected and the tournament selection is executed multiple times until the number of parents participating in the crossover are selected. The selection criteria is basically to select the most fit individual among the subset of the population.

Crossover​

Now Once we have two parents participating in crossover we need to decide how the crossover takes place to produce the offspring that is as fit as its parents. The idea of crossover is to select genes from both parents and add them to the offspring ensuring the genes in the offspring are unique. The goal is to generate diverse offspring with a combination of genetic material from both parents, potentially leading to improved solutions in the search space. There are multiple methods of crossover such as partially mapped crossover, order crossover, etc with one-point and multiple-point crossovers.

1. Partially Mapped CrossOver (PMX)

Let's say we have these two parents from the Tournament selection

Parents participating in Crossover

Parents participating in Crossoverand we want them to cross over to produce offspring. The steps for this cross-over are

1. Select the points to cross over we can choose a single point or two points to divide the array into halves, let's select two points for our case the choice of selection is random (computed using computeTwoPointIndexes method in the source code)

Two-point indexes to copy the genes to offspring

2. Copy the genes between the two points from parent 1 to the offspring at the same location as the parent

genes copied from parent 1 to Offspring

3. Look for genes that have not been copied in the corresponding segment of parent 2, starting at the first position in the crossover point. Gene I is the first uncopied Gene from parent 2( …, I, B, F, …) Copy I to Offspring at the location where E appears in Parent 2.

The next gene in (… I, B, F … ) is B, but since it is already present in Offspring we will skip it,

The next gene is F, It should be copied to the position occupied by B in parent 2, But that position is already occupied by C in the Offspring, so F will be copied to the position occupied by C in parent 2.

With this change, our Offspring will be

4. The remaining elements of offspring are copied from parent 2 in the same order as they appear in parent 2.

The final Offspring generated after crossover is 'IGHECBFDJ'

2. Order Crossover (OX1) : The order crossover is simpler than partially mapped crossover we choose multipoint crossover indexes generally more than two. We will choose two cross-over indexes for simplicity and choose the same example as the previous

Parents Participating in Order Crossover

1. Select the points to cross over we must choose two or more points to divide the array into multiple halves. We will select the same indexes for simplicity, the choice of selection is random.

Two-point indexes to copy the genes to offspring

2. Copy the genes within the crossover indexes to Offspring in the same position as they appear in parent 1

3. Now for each element in Parent 2 copy the missing genes to Offspring in the same order as they appear. e.g. The first element not present in Offspring from parent 2 is G so G appears in the first position of Offspring, the second missing element is H so it appears next, and so on. So the newly generated Offspring is

Generated Offspring after Order Crossover

coming back to our implementation we will use Order Crossover to keep things simple.

Notice the crossover implementation we are keeping the Offspring_length short by 2 to eliminate start_city from the start and end of the path. And adding it back once the offspring is generated (before return).

Mutation​

The last step of the Genetic Algorithm for the current generation is Mutation, The idea of mutation is to make some random changes in the genes of the new Offspring. The primary purpose of mutation is to maintain diversity in the population. Without mutation, the genetic algorithm might get stuck with a local optimum where all individuals are quite similar.

And then for each iteration, we replace our old population with newPopulation obtained to achieve a better solution with every iteration. But there will be a point where the algorithm will converge even after introducing randomness in mutation, meaning Further iterations/generations cannot give a better solution so we stop the generations with the converged solution.

Output​

Putting it all together we will get the following output

The smaller values of population size and generations are only used to keep the output short

If you have made it to the end thank you so much for reading, hope this algorithm helped you understand the genetic algorithm and more importantly it gave you an idea of how it can be used to solve hard problems.

You can find the complete source code for this problem here.

Thanks for reading!

Choosing the right background and surface colors in your app is always challenging and plain backgrounds are boring, especially when you are building apps with Flutter. Flutter was built to create beautiful experiences so why spend time building boring apps?

I have been working on a mobile app that supports different color schemes along with dark mode (thanks to Material 3 support for Flutter) to cater to the needs of the user and adapt to user preferences. But one thing that really makes the experience bland is the plain backgrounds and surfaces. We could have used Linear, Radial Gradients but choosing the right color to support multiple color themes and the dark mode is tedious and limited, Ultra gradient opens up a wide spectrum of colors and makes the content visible well, even in the dark mode.

By the end of this blog post, you will learn to create this animating ultra gradient in Flutter.

I came across this tweet the other day, which shows how to add ultra gradients in Figma I took that approach to flutter and the result turned out to be beautiful.

At first glance it might seem challenging to implement this type of gradient without any third-party asset, However, if we follow the breakdown of intricacies provided by Mans in his tweets, achieving it becomes much more feasible.

So let's dive into the code and bring it into practice. We first start with a new flutter project with the usual counter app.

Now Since we are trying to create a background for our app we Should make the code reusable so we will create a Background Widget let's name it UltraBackground that takes a widget as input. An UltraBackground may need access to the default material colors so we will use Material Widget on top.

Since the ultra gradient is basically a layer beneath our widgets we will use a Stack to layout widgets on top of each other. With this change, your code should look something like this (Although no change in the output so far)

To start we need some background color to be painted for the ultra gradient to show up when the blobs are painted. So We will paint a background with a “black” Color. We can do this with the help of CustomPainter class.

This should make the entire screen black making the content invisible and that is fine for now

Now let's draw Some Abstract Shapes that we want to paint in the background, We will draw one abstract shape using a bezier curve and a square.

Now Apply a blur to these shapes using

paint.maskFilter = MaskFilter.blur(BlurStyle.normal, 100);

Add the above line before we paint these two shapes for the blur effect to be applied to them. With the above implementation, we should see these two shapes drawn with a blur effect.

Now let's add some Contrasting shapes to the canvas, For simplicity we will draw an ellipse, A circle, and a Triangle.

With the above change, you should see the below output.

Now let's apply a blur effect to these shapes and set the blend mode to overlay for these three shapes and we should see the Ultra Gradient in effect. We can do this by just adding the two lines in drawContrastingBlobs

void drawContrastingBlobs(Canvas canvas, Size size, Paint paint) {
    paint.maskFilter = MaskFilter.blur(BlurStyle.normal, 30);
    paint.blendMode = BlendMode.overlay;
    drawCircle(canvas, size, paint);
    drawTriangle(canvas, size, paint);
    drawEllipse(canvas, size, paint);
  }

And we should see the following gradient on the Screen.

The result of the effect is totally dependent on the choice of colors and the Opacity. Let's take this a bit further and pair it with animation to make the effect dynamic. If we move the shapes around we should see different colors blending together to produce a dynamic gradient.

For that, we first need to decide the path these shapes will travel around we will draw a bezier curve for these shapes to smoothly move around.

so let's paint some paths on the screen to get a clear picture of their trajectory. The purple path is for Ellipse, Orange is for Circle and Green is for Triangle, These three shapes will move to and fro along this path.

So the last part we need to do is we need to change the position of these shapes along the path, But How do we identify the position of these shapes at a particular instance? Fortunately, flutter provides us with ComputeMetrics Api which basically gives us the details about the path and we can use it to find the offset of a widget where it lies along the path at a particular instance and pair it with animation to smoothly move it along the trajectory. Putting it all together you should see the shapes moving this way.

We will also apply a blur effect between the canvas and the child for the generating colors to smoothly blend well together.

And finally applying the mask and the blur effect we should see this output

The complete code sample is available in a Github gist. Don't forget to explore the entire open-source project on Github for a deeper understanding. Additionally, you can experience the app firsthand on the Playstore.   Thanks for taking the time to read hope this helps you create stunning backgrounds for your app. Happy Fluttering!

Flutter to Netlify: Seamlessly Deploy Your App with Continuous Deployment Delight!

Developing apps can feel overwhelming and take up a lot of time. On top of that, deploying web applications can be an added challenge. As developers, our focus should be on creating and improving our products, not getting stuck in the complexities of deployment. In this blog post, I’ll walk you through a straightforward process of deploying your Flutter app on Netlify using GitHub actions. For those who are not aware

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline

Whether you’re using Flutter or any other web framework, this post will provide you with simple steps to effortlessly deploy your app without any hassle.

We will be using Netlify actions which will run the Github workflow for every commit and deploy our web app. We will be deploying this flutter-palm project which is basically a chat app powered by the Google Palm Api.

The app is available for use here https://palmchat.netlify.app

Screenshot of the deployed app

To set up Continuous deployment in your project first you need to create a new site on Netlify https://app.netlify.com/start or you may also use the Netlify CLI, if you feel comfortable with it. Go to your team's Sites page, open the Add New Site menu, and create a new site it should be pretty straightforward if you feel stuck see https://docs.netlify.com/welcome/add-new-site/ There are multiple ways of creating a site

• Import an existing project from a Git repository
• Select a prebuilt site from Netlify Templates
• Deploy local project files manually using Netlify's deploy Dropzone

Once you have your site created we need two things

1. OAuth Token is required to authorize workflow (which we will create in a moment) to deploy your site. Visit the Oauth access token and create a new token.
2. Site Id to identify unique to your site you can find your site id under Site Settings -> General -> Site details -> Site id

We will need to provide these tokens to our workflow site. Don't worry we won't directly hardcode them in the script rather we will make use of Github secrets to store them and use them as variables in our workflow script. Go to your project repository under Settings -> secrets and variables -> actions -> create a new repository secret 

And we will store our Netlify Oauth token and SiteId here.

The screenshot shows three secrets added in my repository API_KEY, Token, Site id

Once you have your secrets added note down the names of your secret because we will use them in our workflow script.

Now it's time to set up the Github workflow.

1. In the root of your project create a workflows directory under .github, for me the directory path will be palmchat/.github/workflows
2. Create a file named workflow.yml (name it whatever you like)
3. Paste the below workflow script, most part of it is self-explanatory, But I will still try to explain whats cooking

name: Deploy to netlify on merge
"on":
  push:
    branches:
      - main
jobs:
  build_and_deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: subosito/flutter-action@v2
        with:
          # flutter-version: '3.3.10'
          channel: "stable"
      - run: flutter clean
      - run: flutter pub get
      - run: flutter pub run build_runner build --delete-conflicting-outputs
      - run: flutter build web --release --dart-define=API_KEY=${{secrets.API_KEY}}
      - name: Deploy to Netlify
        uses: nwtgck/actions-netlify@v1.1
        with:
          publish-dir: "./build/web"
          production-branch: main
          github-token: ${{ secrets.GITHUB_TOKEN }}
          deploy-message: "Deploy from GitHub Actions"
          enable-pull-request-comment: false
          enable-commit-comment: true
          overwrites-pull-request-comment: true
        env:
          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
          NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
        timeout-minutes: 1

1. The above script (named "Deploy to Netlify on merge") executes every time we make a commit on the main branch.
2. It gets a stable version of flutter SDK (since we are trying to build a flutter app) using this action subosito/flutter-action@v2.
3. It runs the flutter commands required to clean and build the release.
4. We then run the actual part which this blog post is about deploying to Netlify

- name: Deploy to Netlify
        uses: nwtgck/actions-netlify@v1.1
        with:
          publish-dir: "./build/web"
          production-branch: main
          github-token: ${{ secrets.GITHUB_TOKEN }}
          deploy-message: "Deploy from GitHub Actions"
          enable-pull-request-comment: false
          enable-commit-comment: true
          overwrites-pull-request-comment: true
        env:
          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
          NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
        timeout-minutes: 1

The important part here is to check your production-branch name and path to publish-dir where your release build will be, after running the build in the previous step (flutter build web … in this case)

And finally, we define the env environment variables basically the secrets we added to Github to be used in this script.

Once we have this setup try making a commit to your repository and you should see your Github actions workflow running.

Previous workflow runs and their status

Once the workflow succeeds you should see your website deployed to your domain specified in Netlify (https://palmchat.netlify.app in this case If it ever fails you can always look at the logs to figure out the error.

Additionally, if you want to handle your web app urls see https://github.com/flutter/flutter/issues/89763#issuecomment-925040018

I hope this blog post will help you grab a coffee while this workflow is busy deploying your web app to Netlify, if you have any questions or have problems deploying your web app feel free to write your queries in the comments and I would be happy to help.

Thanks for reading and have a happy time deploying :)

Curious about How to deploy a flutter web app to Github Pages check out my other blog here Deploying your Flutter WebApp to GitHub Pages

When building software Productivity depends on various factors, including typing speed and accuracy. However, there are also many repetitive and mundane tasks that can be automated to save time. Using plugins and extensions in your IDE can help you work more efficiently. Among these, Visual Studio Code (VSCode) is a highly customizable editor that offers a wide range of useful extensions. While the hacks mentioned in this post are specific to Flutter, they can also be applied to other programming languages and frameworks in general.

Here are the 4 ultimate vscode hacks to make you highly productive at work.

1. Shortcuts for Code Snippets​

Often when writing code, we write a lot of Boilerplate and repetitive code, Writing such code can be time-consuming, irritating, and boring too. So to deal with this vscode allows you to create code snippets that you can preconfigure and fetch by writing some preconfigured keywords.

To do this you will need to define code snippets in dart.json by pressing cmd/ctrl + shift + p -> User snippets-> dart.json

Here's a sample code snippet in dart.json to create a new widget, Notice the snippet also has $1, $2 as TabStops meaning when the code snippet is pasted the cursor (can be multiple) will be shown in order first at $1 and pressing Tab will shift to $2

"New Stateful widget" :{
    "prefix": "newwidgetsample",
    "body":[
        "class NewPage$1 extends StatefulWidget {",
            "const NewPage$1({Key? key}) : super(key: key);",
            "",
            "@override",
            "State<NewPage$1> createState() => _NewPage$1State();",
            "}",
            "",
        "class _NewPage$1State extends State<NewPage$1> {",
            "@override",
            "Widget build(BuildContext context) {",
               "return $Material(",
                  "child: Container(",
                     "color: Colors.red,",
                  "),",
               ");",
             "}",
         "}",
         "",
      ]
},

Here's the output of the above code snippet

You can read more about creating your own code snippets here

2. Run tasks on project startup​

Often when we open a project in vscode it is very likely that we will run the application, And it is always better to get rid of the previous build output and execute a fresh build.

So we do multiple things like

• clean the project
• fetch dependencies
• Run build runners (if any)
• Start building the app

if you were to run these repetitive commands you would spend a significant amount of time or if the previous build could give an incorrect output at a time and you would spend time debugging the non-existing bug. So we can do a clean build. Even though the above tasks take a couple of seconds but imagine if you had a project which requires you to run some scripts or commands when running and if that is time-consuming then this hack can save you time. As soon as you launch the project in vscode you can just focus on the project and the chore tasks will keep running in the background.

To automate this vscode has a built-in feature to run pre-configured commands. All you have to do is create a file called tasks.json under .vscode folder at the root of your project, which is basically a script of a set of commands to do the chore work.

Here's a sample tasks.json file which is executed when you open a flutter project (Assuming this file is located at .vscode/tasks.json)

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "flutter",
      "command": "flutter",
      "group": "none",
      "args": ["clean"],
      "label": "flutter: flutter clean",
      "runOptions": {
        "runOn": "folderOpen"
      },
      "problemMatcher": []
    },
    {
      "type": "flutter",
      "command": "flutter",
      "group": "build",
      "dependsOn": ["flutter: flutter clean"],
      "args": ["pub", "get"],
      "label": "flutter: flutter pub get",
      "detail": "",
      "runOptions": {
        "runOn": "folderOpen"
      }
    },
    {
      "type": "flutter",
      "command": "flutter",
      "dependsOn": ["flutter: flutter pub get"],
      "args": ["build", "web"],
      "group": "build",
      "label": "flutter: flutter build web",
      "detail": "",
      "runOptions": {
        "runOn": "folderOpen"
      }
    }
  ]
}

Here's the sample output of the above tasks.json file, which runs when I open the flutter project.

*  Executing task: /Users/mahesh/Documents/flutter/bin/flutter clean
Cleaning Xcode workspace...                                      2,616ms
Cleaning Xcode workspace...                                      2,654ms
Deleting build...                                                    0ms
Deleting .dart_tool...                                               7ms
 *  Terminal will be reused by tasks, press any key to close it.
*  Executing task: /Users/mahesh/Documents/flutter/bin/flutter clean
Waiting for another flutter command to release the startup lock...
Running "flutter pub get" in vocabhub...                         1,041ms
 *  Terminal will be reused by tasks, press any key to close it.
💪 Building with sound null safety 💪
Compiling lib/main.dart for the Web...                             19.7s
 *  Terminal will be reused by tasks, press any key to close it.

3. Hide unwanted project files from your project​

In large projects accessing code gets pretty difficult and there are always some meta files that you rarely or never touch, You may want to hide such files when you open the project in vscode. You could do that by defining a settings.json file in your root project .vscode/settings.json

Note that this settings.json applies only for this particular project to apply these settings to all projects you need to modify the global settings.json available via command palette (cmd+shift+p)

Here's a sample settings.json file that shows folders to exclude from Explorer.

{
  "files.autoSaveDelay": 3000,
  "files.exclude": {
    "test": true,
    ".*": true,
    "web": false,
    "build": true,
    "windows": false,
    "macos": false,
    "ios": false
  }
}

4. Using Multiple versions of flutter SDK​

Sometimes we want to switch between multiple versions of flutter, This is especially helpful to flutter folks when you want to try out the new features or when contributing to open source without messing up your dev environment, For that, you might want to use fvm, But in case you don’t want to install any tool and would like to switch versions directly in your vscode then you could do that by installing multiple versions of the SDK and adding the path to the environment variable. The detailed steps for Linux, Windows, and Mac can be found in this stackoverflow answer

Following the steps in the StackOverflow link will allow you to switch between flutter versions by simply tapping at the bottom of the vscode window.

That's all from this post, Hope this helps you to be productive and adds some value.

Happy Fluttering!

This blog post covers 5 things you should take care of when using the BottomNavigationBar to enhance the user experience.

When there are multiple important and highly accessed sections of the app, We generally make use of the BottomNavigationBar. This is a very common widget and we all have seen and used it, day in and day out. This material design widget allows easy access to the important sections of our app with a single tap. Each section of the app may have subsections deeply nested and in such scenarios adding just a simple BottomNavigationBar is not enough. When you have Nested Widgets to show inside a NavBar you should take care of a few things to make the end user’s experience better.

Going forward we will interchangeably use the below terms to keep things simple.

Navbar for BottomNavigationBar NavbarItem for BottomNavigationbarItem And NavbarDestination for the content of the NavBarItem. Take a look at this video demo to understand, what to expect out of this blog post

BottomNavigationBar demo

If you look closely at the video above, here are the five things that this blog post will cover

1. Maintain the state of the BottomNavigationbar across tabs
2. Hide NavBar during scroll for a larger content area
3. Nested Navigation within BottomNavigationbar
4. Add Transitions when switching between NavbarDestinations
5. Double-tap the back button to exit on Android

Before we take a look at implementing each of the above points. Let's write the minimal boilerplate that renders BottomNavigationBar on the screen.

The above code snippet will render a BottomNavigationBar with three tabs, with each tab being a simple stateful widget. This is how the output looks

The issue with the current code sample is, that the state of the widget is lost on changing the tab, if you noticed in the above output the scroll position and the entered text in the TextField are lost on changing the tab. This is because on changing the index of Navbar, we are replacing the body of the Scaffold with a widget. So to deal with it, this brings us to the first point mentioned above

1. Maintaining the state across Tabs​

To maintain the state of each BottomNavigationBarItem we will make use of IndexedStack which is basically a Stack that shows a single child from a list of children.

Now with this small change, BottomNavigationBar maintains the state of the widget across tabs, The scroll Position of the text entered in the TextField is not lost and this is the output.

2. Hide BottomNavigationBar during scroll​

If you look at the previous output, around 20% of the viewport is covered by AppBar and the BottomNavigationbar. This is still fine on larger devices, But on small screen devices this percentage may be higher and the experience may be terrible due to the small content area. Also, note that the Navbar is only for changing tabs, and most of the time users will be interacting with the NavbarDestination so it makes sense to hide the Navbar when it is not required.

So the idea is to hide the Navbar when Scrolling downward and reveal it when Scrolling upward. This wouldn’t affect if the content isn’t scrollable.

So for this, we will write a wrapper around the BottomNavigationbar widget to handle the animation. We will call it AnimatedNavBar, which takes in a NavBarNotifier object to notify the change in the state of Navbar, List of children menuItems, and onItemTapped callback to update the Navbar state.

A wrapper around BottomNavigationBar

And this is the NavbarNotifier class, basically, a changeNotifier that maintains the state and updates the navbar on changes.

Changenotifier to handle the state of the Navbar

So now, let us modify the widget tree a bit and use the AnimatedNavBar widget.

At this point, the Navbar is well equipped to animate nicely But before we see this in action we will have to work on the last piece, the idea we discussed above

So the idea is to hide the bar when Scrolling downward and reveal it when Scrolling upward. This wouldn’t affect if the content isn’t scrollable.

For this, we will have to add a scrollListener to your scrollable content and update the Navbar state during scroll.

Listen to the scroll changes and update the Navbar state accordingly

So the above code sample is pretty simple and self-explanatory, which basically listens to the scroll changes and updates the Navbar’s hidden state based on the scroll direction. With these changes, we should see the Navbar smoothly hiding off the viewport.

Demo showing a listview of feeds and the navbar hiding on scroll

3. Nested Navigation with BottomNavigationbar​

Our app so far works well, But it is uncommon to think that each NavbarItem will only have a single page. Because in our example where we have a list of items the user would want to tap on the item and navigate to another NavbarDestination keeping the Navbar intact and visible.

Here's a rough diagram of How the pages are nested with each NavbarItem

To implement Nested Navigation we have to wrap three of the NavBarDestinations in a Navigator and assign them a key. (we will need this key for handling the nested routes).

So the HomeMenu which looked like this before the Nested Navigator

is now wrapped within a Navigator with its subroutes, We will do the same for the other two NavbarDestinations (ProductsMenu and ProfileMenu)

We will also make use of this navigate function which will be pretty handy while navigating and to decide whether we want to navigate to a nested route or push a route on top of the main Navigator using the parameter isRootNavigator.

Now that we have the nested routes in place, on launching the app each of the Navigator will navigate to /(the respective initial route of the Navigator). To navigate to a nested route from the initialRoute we will provide isRootNavigator:false in the navigate method specified above.

onTap: () {
   navigate(context, FeedDetail.route, isRootNavigator: false,
   arguments: {'id': index.toString()});
},

at this point (after Navigating to nested route) if we press the back button all the routes will be popped and the app will exit. So to handle this we will make use of WillPopScope which will notify us when the back button on the Android device is pressed.

Whenever the back button is pressed, you will get a callback at onWillPop, which returns a Future. If the Future returns true, the screen is popped.

So now we will wrap the NavigationHandler in WillPopScope to receive back button pressed events and handle them in NavbarNotifier class.

class NavbarHandler extends StatefulWidget{
 ...
 ...
@override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () async {
        final bool isExitingApp = await _navbarNotifier.onBackButtonPressed();
        if (isExitingApp) {
          return true;
        } else
          return false;
      },
      child: Material(
      ...

And in the NavbarNotifier class, we will implement the definition for onBackButtonPressed, which will basically pop the route from the NestedNavigator using the key based on the current index of the Navbar and returns true if the rootNavigator will be popped and false otherwise, this ensures that the app will only get closed when we are at the root of the Nested Navigator stack.

With the above implementation, we can pop routes using the physical back button on Android.

Nested Navigation similar to Instagram​

When the routes are deeply nested, going to the base route (first route)of the Navigator stack would require multiple back button clicks, to solve this issue we can implement a feature similar to Instagram where pressing on the same NavbarItem would take us to the base route. For this, we will add another function to our NavbarNotifier class which will basically pop all the routes in the navigator stack except the first based on the current index of the Navbar to pop the routes from the appropriate Navigator.

Method to Pop all routes from the Nested Navigator stack based on the Index

And we can invoke this function when the user taps on the current tab

child: AnimatedNavBar(
         model: _navbarNotifier,
         onItemTapped: (x) {
           // User pressed  on the same tab twice
           if (_navbarNotifier.index == x){
              _navbarNotifier.popAllRoutes(x);
           }
           else {
             _navbarNotifier.index = x;
           }
         },
         menuItems: menuItemlist
      ),

Navigate to the base route from a deeply nested route

4. Transition between NavbarDestinations​

With the current implementation, if you try to switch the Navbar tabs, The tabs are being switched abruptly, we can improve this by smoothly fading between the NavbarDestinations using FadeTransition. So to implement this we will declare the animationController and the animation in the _NavBarHandlerState class

 ...
class _NavBarHandlerState extends State<NavBarHandler> with SingleTickerProviderStateMixin {
...
 late Animation<double> fadeAnimation;
 late AnimationController _controller;
 @override
 void initState() {
   super.initState();
  _controller = AnimationController(
    vsync: this,
     duration: const Duration(milliseconds: 700),
   );
  fadeAnimation = Tween<double>(begin: 0.4, end: 1.0).animate(
    CurvedAnimation(parent: _controller, curve: Curves.fastOutSlowIn),
   );
  ...

And then We will wrap each NavBarDestination in the FadeTransition inside the IndexedStack as below

...
IndexedStack(
  index: _navbarNotifier.index,
  children: [
    for (int i = 0; i < _buildBody.length; i++)
      FadeTransition(
        opacity: fadeAnimation, child: _buildBody[i])
   ],
),
...

And finally, we will start the animation every time the NavBar’s current index changes

child: AnimatedNavBar(
  model: _navbarNotifier,
  onItemTapped: (x) {
  // User pressed  on the same tab twice
    if (_navbarNotifier.index == x) {
      _navbarNotifier.popAllRoutes(x);
    } else {
      _navbarNotifier.index = x;
      _controller.reset();
     _controller.forward();
    }
 },

And here's the result

Fading between NavbarDestinations

This brings us to the last part of this blog post

5. Double-tap the back button to exit on Android​

At this point, if you try to press the back button when on the base route of the Navigator stack, you will notice that the app closes, which is expected. But this doesn’t give a good user experience. To solve this we could implement the double-tap to close the app feature as found in most of the native android apps. This should be pretty straightforward to implement since we already have a willpopScope to track the back button press events. We just have to check if the time difference between two consecutive keypress events is less than the desired time Duration then exit the app. And this can be implemented as below.

And we get this desired result to warn users before exiting the app.

So with this, we are at the end of the blog post. I hope this was fun reading and it will help you create great experiences in your flutter app.

Source code for the demo app can be found here: https://gist.github.com/maheshj01/894922ccb67f5fdc4ffb652e41916fa2

Try the sample app in dartpad: https://dartpad.dev/?id=894922ccb67f5fdc4ffb652e41916fa2

Edit: This has been published as a package on pub.dev as navbar_router to handle all the boilerplate.

If you have any questions or have any suggestions feel free to write them in the comments and I will definitely check them out.

Thanks for reading and Happy Fluttering 💙.

When it comes to drawing custom shapes in flutter we have custom paint and it works great. But what if you want to paint only a particular section of a widget? That's where ClipPath comes handy

ClipPath allows you to paint only a particular portion of your widget specified by the path

The path can be of any shape as long as your math skills go hand in hand with your imagination to draw the custom desired shape. You don't have to be a polymath to build some cool stuff, we can still build amazing things with basic Geometrical shapes.

Image is taken from dribble for demonstration purpose only, owned by Dan Stosich

To demonstrate some cool examples with ClipPath, we will add some dynamic content by redrawing frames and adding nuances of Animations. Because Static is Boring.

If you have no idea what the heck ClipPaths does then you should consider watching this video, Since No docs can explain you much better than this short Widget of the week video from the Flutter team. Also, Remember the above definition because we will leverage the definition of the ClipPath as we move along.

Now that you have some understanding of ClipPath Lets dive in

"We understimate ClipPaths in flutter "

The reason I say this is because of some of the examples that may look very complex or one would not ever imagine that they would use ClipPaths for such use cases. We will explore the use cases of ClipPath with the help of three examples.

ClipPaths in action​

Example 1: Torch effect (aka The Harry Potter effect)

Of course, we do not have a magic wand to build this but we do have ClipPath lets break down how we can easily build this cool effect. There are three things here

1. the background which is the hidden image (visible in a circle)
2. The foreground which is the counter app (greyed out to reduce focus)
3. And a Circle that exposes the background Now forget what we just saw so far and come back to basics, what do we do when we have to show two widgets on top of each other?

We use a STACK​

Stack(
  fit: StackFit.expand
  children:[
    ImageWidget(),
    CounterApp(),
  ]
)

cool! that was the first step, and with this, we would get this output

I know it just looks like we have loaded a regular counter App but there's a ImageWidget underneath trust me 😀. if you don't believe me let's bring in ClipPath to shade some light on it to actually make it visible. so let's wrap the CounterApp with a ClipPath and give it a simple circular path as the clipper.

ClipPath(
  clipper: CircleClipper(
   center: Offset(500, 400),
   radius: 100,
  ),
  child: const CounterApp()
),

The CircleClipper is a simple class extending from CustomClipper which takes in a center, radius, and returns the circular path

CircleClipper({required this.center, required this.radius});
final Offset center;
final double radius;
@override
Path getClip(Size size) {
  return Path()..addOval(
      Rect.fromCircle(radius:radius,center: center));
  }
@override
bool shouldReclip(covariant CustomClipper<Path> oldClipper) {
  return true;
 }
}

and that's it with that you can see this is the output and with that, it should be clear that there is actually an image below the counter app. Remember the definition "ClipPath only paints the required portion of the widget in this case it's the CounterApp".

Now, the only part left is to move the circle with the pointer. The movement is basically shifting the center of the circle. So as the mouse cursor moves we have to set the center of the circle to the coordinates of the mouse. And we can easily do this with the help of MouseRegion (A widget that tracks the movement of mice.) So by just wrapping the whole stack in a MouseRegion, you should get mouse events when the mouse is moved and you can update the position of the circle and that should be it.

void _updateLocation(PointerEvent details) {
  setState(() {
    dx = details.position.dx;
    dy = details.position.dy;
  });
}
Widget build(BuildContext context) {
  return Scaffold(
    body: MouseRegion(
     cursor: SystemMouseCursors.click,
     onHover: _updateLocation,
     child: Stack(
       alignment: Alignment.center,
        fit: StackFit.expand,
         children: [
           ImageWidget(),
           ClipPath(
            clipper: CircleClipper(
              center: Offset(dx, dy),
              radius: 100,
           ),
             child: const CounterApp()),
         ],
       )
   )
 );
}

This gif may look laggy as the recorded gif runs at 15 fps but the original app is much smoother

Example 2: Telegram dark theme animation​

If you have used the telegram app you must be familiar with the cool animation effect when switching themes in telegram. The gif on the left shows you this animation. At first look, this might look complex but if we break it down again we can easily nail it. And of course we will implement this using ClipPath. The above transition is pretty much straightforward since you know how example 1 was built. If we break down the telegram animation.

1. It has a widget in dark mode.
2. A widget in a light mode
3. both overlapped on top of Each other

And on toggling the theme we are just painting the top widget using the ClipPath. So this is how roughly the body part of our widget tree looks

Stack(
children: [
 _body(1),
 ClipPath(
  clipper: CircularClipper(
  radius, position),
  child: _body(2)),
 ],
);

Both the widgets (_body) at any given point will be the same except for their theme. So To identify them I am passing index values 1 and 2. And the position is basically the offset Indicating the Center point of the CircularClipper.

ThemeData getTheme(bool dark) {
  if (dark)
    return ThemeData.dark();
  else
    return ThemeData.light();
}
Widget _body(int index) {
  return ValueListenableBuilder<bool>(
    valueListenable: _darkNotifier,
    builder: (BuildContext context, bool isDark, Widget? child) {
      return Theme(
        data: index == 2
          ? getTheme(!isDarkVisible)
          : getTheme(isDarkVisible),
        child: widget.childBuilder(context, index, GlobalKey()));
      });
   }

And then wiring this up with animationController you get this cool animation effect.

This gif is running at 30 fps and is not the exact representation of animation the actual animation is way more smoother at 60 fps

In order to reuse this animation effect, I wrote a wrapper widget around this which makes it pretty easy to use. You can find the complete source code to this widget on Github with example usage.

Example 3: Circular Navigation effect​

If you have guessed it, This will be the same animation as example 2 just that instead of changing the theme we will change the routes. To make the route transition simpler flutter provides us with PageRouteBuilder class, which you can directly import in your Widget and animate between routes. Below is the method I used to animate using a ClipPath.

Route _pushRoute(Widget child) {
  return PageRouteBuilder(
  transitionDuration: const Duration(milliseconds: 400),
  reverseTransitionDuration: const Duration(milliseconds: 400),
  opaque: false,
  barrierDismissible: false,
  pageBuilder: (context, animation, secondaryAnimation) =>  child,
  transitionsBuilder: (context, animation, secondaryAnimation, child) {
  final screenSize = MediaQuery.of(context).size;
  Offset center = Offset(screenSize.width / 2, screenSize.height / 2);
  double beginRadius = 0.0;
  double endRadius = screenSize.height * 1.5;
  final tween = Tween(begin: beginRadius, end: endRadius);
  final radiusTweenAnimation = animation.drive(tween);
  return ClipPath(
    clipper: CircleRevealClipper(
    radius: radiusTweenAnimation.value, center: center),
    child: child,
    );
  },
 );
}

You can invoke a route transition as simple as this

Navigator.push(context, _pushRoute(YourWidget()));

and this is the output you get with the above transition.

And that's a wrap. You can find the complete source code on Github

Thanks for reading!

This post is mainly to share my experience about how I used GitHub actions to deploy my open-sourced flutter web app without exposing any secrets or API keys that are crucial to my application. This approach can be used for any frontend framework and not just flutter.

Building the frontend of your application seems much interesting but once you start integrating with your backend or services like firebase or supabase etc, You need to manage API keys, JSON files, or secrets for your app, and we often end up either hardcoding those confidential keys by some kind of encryption or even the pros hardcode it as plaintext and commit it to a public repo😆, which might put your application at risk.

I wanted to develop a vocabulary app that is open-sourced and at the same time, I wanted it to be secure and wanted to make sure the app gets deployed without exposing the keys. This vocabulary app uses supabase in the backend, which is a open-sourced firebase alternative that provides a serverless solution that can get up and running in less than 2 minutes. In order to access the supabase database, it provides us with few keys which are unique to your application basically anyone with those keys could access the database, So you have to make sure those keys are safely stored.

Problem There were two challenges to make the project publicly available on Github

I have stored all those confidential keys into my flutter app in a constant file and the application can fetch those keys from that file and the app works fine locally, But the problem comes when we want to push the code to GitHub, since we cannot expose the keys publically.

Another problem is that the app uses flutter-action by subosito which is basically a CI solution using GitHub actions that automatically runs a script and deploys my flutter webapp on each commit by running some build commands, You can find the complete script here. But it is obvious that the build would fail if it finds if any of the pieces of the code are missing from the repository (Our secret keys in this case)this means the app won’t get deployed.

Image showing the build script running on each commit on a master branch

Basically, these two things wouldn’t allow my app to be deployed securely.

Solution​

So for this Github Encrypted Secrets comes to the rescue if you go to any repository under settings you will see an option called secrets which basically allows you to store any sensitive information in your organization, repository, or repository environments which can be accessed in GitHub Actions workflows.

But there is another problem​

The problem is you cannot access those encrypted secrets in your application, had it been the case the problem would have been solved and I would have called it a day 👋🏻. I searched a little about it but couldn’t find any solution which will allow you to access the encrypted secrets but since we have been using this amazing Q&A platform for devs called “StackOverflow” which helped me get an answer. Here is that stackoverflow question that I asked and I got a simple and amazing answer to that. Thanks to this user Xamantra for the solution.

Tell me the solution​

The solution is to

1. encode your confidential file to base64 and store the encoded output to GitHub secrets.
2. In your GitHub workflow decode the encrypted secret and convert it back to a file and then run your build scripts.

It's that simple

Now you can add your confidential files to .gitignore and never push it to the repository since now you have GitHub encrypted secrets.

Show me how it's done​

Here is how we do it step by step

1. convert your secret file to base64 the file can be of any type. I had a dart file which has the api keys stored so convert it to base64 using this command

base64 lib/path/to/secrets.dart

This will give you a base64 string copy that string and add it to GitHub secrets as shown in the below picture.

2. Now in your workflow script before you run the build command decode the base64 and convert it back to file with the path where it needs to be created.

run: echo $YOUR_SECRET_KEY | base64 -d > lib/somedirectory/secrets.dart env: YOUR_SECRET_KEY: ${{ secrets.YOUR_SECRET_KEY }}

And that's it, gentlemen ! that is it! you will see your build running successfully and the app getting deployed to the web, safe and secure with open-sourced code.

But there is one more problem what if you delete your local repository how do you get back those keys which you never pushed to Github?

That is still a mystery to me apart from the manual decoding let me know if you have a solution to this problem. More on this later sometimes if I find a solution.

Here is a link to the repository in case you would want to check it out.

Repository:https://github.com/maheshj01/vocabhub

Successful Builds : https://github.com/maheshj01/vocabhub/actions

Thanks for reading till the end.

Have a great day!

flutter logo taken from flutter.dev

Lots of apps require support for multiple languages inorder to have engagements with different kinds of users and we don't want to miss our customers just because of a language barrier.

I just googled and found that (As per a 2017 report) out of 7.8 billion people only 1.35 billion people speak English so that's approx 1/7 th of the population that means if you developed a software that targets humans only 1 out of 8 people will be able to understand it. Whether they would like it or would be interested in your app that's a different question 😂? If you develop something with all the effort and if people don't understand it, it's of no use. So you have to make sure your app supports the language of your targeted regions, so for this, we have to make use of L10N (aka LOCALIZATION).

So coming to the point since this post is specific to Flutter our goal is to implement localization in our flutter app and The flutter team has well documented it here about it and also there are tonnes of other blog posts and videos which explains it very nicely. But there's a problem, All those approaches suggest you to hardcode the static strings in the app.

But what if you have to make some changes to those Strings after you have deployed the app to stores?

Or

what if you want to add support for a new language or remove an existing language support?

In such cases we will need to make changes in the code and even with a single character change in the code, you will have to rebuild and redeploy your app as flutter doesn't support hot update as of today, so updating an app seems daunting.So In this post, I am gonna show you How I solved this problem using the approach shown below in one of the production apps and wanted to share it with you. The approach I will show you is less of a solution and more of "naive" workaround, If you know how to work with HTTP Requests and maintain the state of the app with a provider, This would be a piece of cake for you. This will get the work done without making a single line of change in code once it is implemented(unless you want to add new localized Strings to the app). Unfortunately, I cannot show you that mobile app, but don't worry I have a sample application built for this blog post that uses this approach. To Give you a test of the sample application this is how it looks.

Lets Approach the solution​

The things that we localize in an app are basically strings, we Identify each string uniquely with a key, So basically the data that has to be dynamically changed is a JSON object. This JSON data would lie somewhere in your backend which could fetch using network request. You could also store it locally on your phone but remember we want a dynamic solution to update the languages during runtime. 

If we were to localize the app in Spanish the json object would look something like this.

{
  "Hi": "Hola",
  "grateful": "Gracias"
}

if we had multiple languages we could just change the values and keep the keys the same. And our consolidated JSON object would look like this.

{
"es":{ /// json object for spanish
  "Hi":"Hola",
  "grateful": "Gracias"
  },
"en":{ // json object for english
  "Hi":"Hi",
  "grateful": "grateful"
  },
"
/// few other languages if any
...
}

Alternatively, we could just have one JSON object in a single response, and to get a correct translation we could just pass a query param in a request to let the backend know that we are requesting a JSON object of a particular language and it would return you the correct translation object. so once we have this JSON object ready we could just make an HTTP request decode the response and display it on the UI, problem solved right? No. Also, don't forget the variables, we also have variables within our static strings which could be numbers, dates, and other types.

for instance, consider this flutter code

String toolKit = 'flutter';
String platform =. 'MacOs'
@override
Widget build(BuildContext context){
   return Center(
      child:Text("Hey, This app is built using $toolKit for $platform")
   );
}

so for such strings, we need to make sure these variables go within those translations strings coming from the JSON object in the right place. so for this, I wrote a simple function that does this given an input it produces the respective output.

input: Hey, This app is built using ${toolKit} for ${platform}.

Here's the function that does this for us.

so for the above input, we would invoke this method like this

localize(input,[toolKit,platform]);

Then it would return the output

output:Hey, This app is built using flutter for MacOs.

Also, remember the order of the arguments in the Argument list List<String> should be the same as they appear in the translation sentence.

And the last thing to remember is we should fetch these translations before the app starts in order to prevent any issues And show a loader or the app splash screen whatever you prefer. You can also make use of the shared preferences to store the user's language preference which can be used to fetch the correct language on the next app launch.

Let's build the sample app​

Now that you understand the approach (I assume) let's build the sample app. Since you are looking for a solution for localization I assume you know how to build layouts in flutter so I won't be covering that part. so let's create the flutter project and run this command in your terminal

flutter create .

Now add these dependencies in your pubspec.yaml, I have used the json_annotation and dev_dependencies just to generate the toMap and FromJson methods but these dependencies are not mandatory.

dependencies:
  flutter:
    sdk: flutter
  http: ^0.12.0+2
  json_annotation: ^3.1.1
  provider: ^4.3.3
  shared_preferences: ^2.0.4
dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^1.10.13
  json_serializable: ^3.5.1

Now in the main.dart we need to import provider and wrap the MaterialApp in a consumer so as to rebuild the whole app when we change the language.

The LocaleModel class contains everything about localization which we are interested in and the Settings Class contains code related to changing the theme of the app, So let's focus on the LocaleModel class.

class LocaleModel with ChangeNotifier {
LocaleModel() {
   fetchTranslations();
}
Map<String, dynamic> _translations = {};
Map<String, dynamic> _selectedTranslation = {};
Locale locale;
Locale get getlocale => locale;
Map<String, dynamic> get translations => _selectedTranslation;
set translations(Map<String, dynamic> map) {
  _selectedTranslation = map;
  notifyListeners();
Future<void> fetchTranslations({String language}) async {
   try {
     language = await getLanguagePreferences();
     final response = await http.get(Uri.parse(translationsApi));
     if (response != null) {
        if (response.statusCode == 200) {
            final Map decoded = json.decode(response.body);
            _selectedTranslation = decoded[language ?? 'en'];
            _translations = decoded;
            notifyListeners();
         }
     }
   } catch (_) {
     print(_.toString());
     }
   }
  }
}

the constructor at the top invokes this function as soon as the app starts. Remember we have a multiprovider wrapped around in main.dart that's where this call comes from.

LocaleModel() {
   fetchTranslations();
}

This function basically makes a network request and stores the translations in the state of the app in these two Map Objects _translation and _selectedTranslation. The _translation holds the consolidated Map object (with All languages) that we discussed above and _selectedTranslation holds the strings of the current translation being shown in the app. we need _translation in order to fetch the translation on changing the language this prevents us from making an extra API call, we directly fetch it from the state and refresh the app without making the user to wait for the changes to take effect. Now let's see how we are making use of these translations

Let's take a look at the description for the User which has three parameters in city, state, country

red underlined variables used in the description of the user.

The description that we receive in the API response looks like this

And this is how we access this map object from _selectedTranslation. considering we have already instantiated localeModel like this in initstate to access the objects of LocaleModel class.

/// initialized in initstate
_localeModel = Provider.of<LocaleModel>(context, listen: false);

access the description in the widget using _localeModel.

localize(_localeModel.translations['description'],[user.location.city, user.location.state, user.location.country]),

And this is how the description widget looks.

And thats how we can localize the entire app,The syntax might look bit ugly but we can always simplfy it. And we can change the language of the app like this

_localeModel.changelocale(Locale('es')); // changing to spanish

And you can see few more additional things done in the source code like storing and fetching the current locale for the next launch using sharedPreference. And thats it we are at the end.

Summing up​

This approach allows you to

• Dynamically edit the translation files.

• Add/ Remove support for a new language. both without making a single line of change in your flutter app.

• No hassle with generating arb files and maintaining static translations Things it lacks: Numbers,Dates and Currencies translation but we can always have custom functions for these or this could also be backend driven within the same translation object. That said we are at the end of this blog post hope you like this approach, And if you have any questions or critiques feel free to drop them below in the comments I would love to discuss. And don't forget to smash the 👏🏼 button until it warns.The more you clap the more it inspires me to bring some great blog posts. And you can always

• play with the source code here

• checkout the demo app here.

Thank you for taking the time to read this long post and keep fluttering 💙.

Hello everyone in this post I will be implementing a search in Flutter, search is basically a basic requirement where you have a lot of content available and you want your users to get access to the content easily and efficiently. We won't be using any packages for this app except HTTP to make network requests. before we begin let me show you what we will be implementing by the end of this post.

Pardon me for this ugly-looking Grid I will invest some more time to make it look good later, this post is mainly focused only on the search functionality as of now.

This blog post assumes you have a high level understanding of streams, But I have still tried to explain the basic working of it through the diagram below

I think it would be better to make you understand through a diagram how is data being loaded into the UI and how the search actually works before actually jumping into code. for this search, I will be making use of streams 😬.

Don't worry if you are afraid of streams because they are built for the Good.

so lets look at How the first part works How the UI is being loaded through streams and then we will jump to the main topic, if you are aware about streams and can understand the diagram feel free to skip this section and move on to the second one.

If you see in the UI I have a tab bar on screen, so once I click on Random Users I am calling a function called fetchRandomUsers() which looks like this,

which basically just makes a http request decodes the json and converts to list of RandomUserModel and the Last line above adds totalUsers to stream, I have wrapped the Grid UI in streamBuilder which means it will rebuild the UI whenever something has been added to stream in this case totalUsers is being added and the list will be received to UI in the form of snapshot.just remember the rule sink is where you add data, stream is where it is fetched out.

if you see the highlighted code above thats where you receive your list(List<RandomUserModel> totalUsers) in the snapshot.we pass that snapshot to randomUsers Widget to build the Grid UI with that data. so thats how the data is being loaded using streams now lets come to the actually work.

LET'S IMPLEMENT THE SEARCH.​

In the UI we have a textfield it possesses a method called onChanged(), lets make use of it, this method will be called every time you type in a letter in it and it provides you with the text present in the search field,I will be calling another function _searchUser to apply our search logic. Like this

onChanged: (searchQuery) => _searchUser(searchQuery),

This is what the _searchUser method looks

Lets break it into steps to get this smooth

1. I need a List<RandomUserModel> to store our searched List so lets create one,Note that I will be creating the list inside the method because we want our list to show only the current search result as this function is getting called every time we have an empty list.

void _searchUser(String searchQuery) {
List<RandomUserModel> searchResult = [];

2. Next I am adding null to the stream that is because while the search is going on meanwhile I want to show some loading indicator, if you see above in streambuilder we have said when snapshot is null show loading,

userBloc.userController.sink.add(null);

3. Also remember that we also want to handle a conditions when the textfield is empty and when it is not, we want to show the complete list to the user when it is empty, remember that we have a list called totalUsers where all our data from network resides we can simply add it to stream and show the complete list and we don't want to process further.

if (searchQuery.isEmpty) {
   userBloc.userController.sink.add(totalUsers);
   return;
}

4. Now when the search field is not empty and has some text in that case we will apply the search logic believe me its very simple, dart 🎯 is super friendly to apply even the complex logic with built-in functions and loops,the main task is to

search in totalUsers[] ==> store in searchResult[]

I want to apply search on users name (firstName and LastName) and if the search query contains that simply store the model in searchResult

totalUsers.forEach((user) {
   if (user.first.toLowerCase().contains(searchQuery.toLowerCase())    ||user.last.toLowerCase().contains(searchQuery.toLowerCase())) {
   searchResult.add(user);
   }
});

Notice that I am converting both searchQuery and user firstName or LastName to lowercase in case user searches for a user using Uppercase,it wouldn't match.

5. that's it once our searchResult array is ready just add it to stream to show the result.

userBloc.userController.sink.add(searchResult);

And Boom 🔥 it works on the fly as you type, That's all from this blog hope this helps you in building a search for your next awesome app, if you get stuck or don't understand or feel I can improve leave a comment below, I would love to hear from you and if this post helped you in any way would you please give a clap 👏And don't forget to check out the source code here.

Cheers 😃! Have a great day and Happy Fluttering.

BDD testing using Cucumber​

I will try to keep things as simple as possible, Before we dive into the topic, I think it is important to understand a few terms and clear some misconceptions. This post is going to be quite long so bear with me, By the end of this postm I will make sure you get something valuable out of it. By the end of this post you will understand, How we can use BDD to write the specifications of the product's behavior. That means these specifications act as test cases to ensure the product behaves as expected. By just reading these specifications you will be able to understand what this app is supposed to do. The way it differs from normal Integration testing is, these specifications are in plain English texts which anyone could understand.

BDD is not a Testing Technique​

The common mistake most people make is, they think BDD/TDD are testing techniques but the thing is,

It is the process of approaching your design and forcing you to think about the desired outcome and API before you code. So that you are clear about what you are building and these tests make sure the product behaves the way it is supposed to.

In other words, BDD is about testing the behavior of your product, you still don't understand what I am talking about 😇?

Don't worry as we write test cases you will get an idea of what I am talking about. Let's First Understand the underlying things.

Cucumber and Gherkin's language​

I am certainly not talking about this Cucumber 🥒 (Bad Joke😬)

Cucumber is a tool that supports Behaviour-Driven Development(BDD). In Cucumber, the BDD specifications are written in plain, simple English which is defined by the Gherkins language. In other words, Gherkin is a language that Cucumber understands. Gherkin presents the behavior of the application used, from which Cucumber can generate the acceptance test cases.

To give you a little taste this is how gherkin's language looks

Feature:check if button tap takes to homepage
  Scenario:When the button is tapped
    Given I have "button" on screen
    When I tap the 'button'
    Then I should see 'homepage' on screen

Writing Gherkin's feature file​

We write the test specifications for our app in gherkins language in a feature file(file with .feature extension). The file must be written in a syntax that the cucumber understands. Here are some of the minimal keywords you need to know to start writing the specifications. As you read each keyword, I recommend you to look at the above example of gherkin's language for better understanding.

Feature: The first primary keyword in a Gherkin document must always be aFeature, followed by a : and a short text that describes the feature. You can add free-form text underneath Feature to add more description.

These description lines are ignored by Cucumber at runtime but are available for reporting.

*Scenario:*The keyword Scenario is a synonym of the keyword Example. You can have as many steps as you like, but it is recommended to keep the number at 3–5 per example. your examples are an executable specification of the system.

Examples follow this same pattern:

• Describe an initial context (Given steps)
• Describe an event (When steps)
• Describe an expected outcome (Then steps)

Step Definition: Step definitions are the coded representation of a textual step in a feature file. Each step starts with either Given, Then, When, And or But. Given: Given steps are used to describe the initial context of the system - the scene of the scenario. It is typically something that happened in the past.

When: When steps are used to describe an event, or an action. This can be a person interacting with the system, or it can be an event triggered by another system.

Then: Then steps are used to describe an expected outcome, or result. And,But: If you have several Given's, When's, or Thens, you could use And or But wherever required e.g

Example: Multiple Givens
  Given one thing
   And another thing
     And yet another thing
       When I open my eyes
       Then I should see something
       But I shouldn't see something else

that's all you need to write the feature file and get started, again this is not the complete guide to feature file I am just introducing you to the minimal syntax which gets your work done and optimal for this post too, you can learn more about gherkin's syntax here

Now that you know the essential stuff lets get to work I will be writing test specifications for this sample app source code at the bottom of this post.

did you miss that word "Test Specifications" it simply means test cases for the app that we write to fail the app, and if it passes the case that means our app behaves as it is supposed too.

To give you a little idea about this app,As you can see below this sample app takes email and password, if email is in a specified format(abc@xyz.com) and password with a special character (*,/,_)then we can go to next page on pressing the login button. And on the next page the thumbs up button of an item increases the claps and thumb_down button decreases the claps and on pressing the favourate icon the favourate elements gets added to the favourate tab bar thats a simple working of this sample app.

Now lets start working on writing specifications by gathering the things we need

Installation​

1. Add the Gherkin's plugin to the pubsec.yaml

dependencies:
  flutter_gherkin: ^1.0.5

2. add the flutter_driver dependency in dev _dependencies

dev_dependencies:
  flutter_driver:
    sdk: flutter

3. Create a directory as test_driver in the root folder of your project.

4. Create two more directories with name features and steps in test_driver we will only be writing specifications and feature files and everything will happen in the test_driver directory. the feature directory contains all the .feature files and steps directory contains all the .dart files which implement the specifications written in the feature files.

5. Create two files called app.dart and test_config.dart in the root of test_driver steps folder. oops a lot of files and folders take a deeeep breath its done and you did a great job.And make sure your files and folders are located in this way so that everything further works fine. your_project_directory 📁

  ...
  ...
  test_driver 📁
     feature 📁
        Login_test.feature 📄
     steps 📁
        test_steps.dart 📄
   app.dart 📄
   test_config.dart 📄

Enable flutter driver extension​

Add the following code to enable the flutter driver and specify which class to test.I have specified the MyApp() class from main.dart the first page of this app.

 import 'package:flutter_driver/driver_extension.dart';
 import 'package:counter_app/main.dart' as app;
 void main() {
   // This line enables the extension.
   enableFlutterDriverExtension();
   runApp(MyApp());
 }

Now is the time to write the specifications in feature and implement them in steps class lets start first with the feature files.

Creating a Test Scenario​

First try to understand the scenario,I have two textfields and a button on screen what it does is simply checks if the email and passwords are in desired format,if so then you can go to next page by clicking on the login button.Remember I told you we will be writing test cases to make our app fail.This is what I meant.

So this is How I want my tests to go through

check if email textfield is present on Screen
check if password textfield is present on Screen
add a input to email field in specified format
add a input to password field in a specified format
when I click on Login button
I should see home screen

Now to interact with each widget on screen we need to give them an identity "Key" almost every widget in flutter has this key property which helps the widget to be uniquely identified, so just go to all the widgets and give them a unique key. e.g for email text field I have added as

TextField(
  key: Key("emailfield"),
  ....
  ....
)

Writing the Feature File​

Now to implement above steps I have added the below code in my feature file so my feature file kind of looks like this ,if you are using vs code the editor senses the feature file and asks you to download the feature file plugin from market place,I recommend installing one. for a better formatting by clicking (ctrl+shift+i on linux) and (alt+shift+f on windows).

Note that the identifier in quotes(" ") are the widget keys with which the flutter driver interacts.

Now that we have added the steps,its time to implement them, open your test_steps.dart and add the below code. To implement the first step from the feature file(on line no 4).

Given I have "emailfield" and "passfield" and "LoginButton"

this step checks if these three widgets are present on screen, you need to look for two things in any step before implementing that step

1. Type of statement (Given/Then/When)
2. how many widget keys or identifiers in statements and their types

(e.g in above step we have 3 widget keys of type string each) so while implementing the step my class will extend from a class Given3WithWorld<String, String, String, FlutterWorld> so the step file looks someting likes this lets take a look at each step

import 'package:flutter_driver/flutter_driver.dart';
import 'package:flutter_gherkin/flutter_gherkin.dart';
import 'package:gherkin/gherkin.dart';

class CheckGivenWidgets extends Given3WithWorld<String,String,String,FlutterWorld> {
 @override
 Future<void> executeStep(String input1, String input2, String input3) async {
    // TODO: implement executeStep
    final textinput1 = find.byValueKey(input1);
    final textinput2 = find.byValueKey(input2);
    final button = find.byValueKey(input3);
    bool input1Exists = await FlutterDriverUtils.isPresent(world.driver, textinput1);
    bool input2Exists = await FlutterDriverUtils.isPresent(world.driver,textinput2);
    bool buttonExists = await FlutterDriverUtils.isPresent(world.driver, button);
    expect(input1Exists, true);
    expect(input2Exists, true);
    expect(buttonExists, true);
}

 @override
 // TODO: implement pattern
 RegExp get pattern => RegExp(r"I have {string} and {string} and {string}");
}

As you can see the class inherits from When3WithWorld and specifies the types of the three input parameters. The fourth type FlutterWorld is a special Flutter context object that allows access to the Flutter driver instance within the step. Then we have to override the executeStep method and find the widgets by key using a finder.

final loginfinder = find.byValueKey(loginbtn);

similarly for other widgets and now we use the flutter driver to actually see if the widgets are present on screen by passing in the finder and the driver as input to the FlutterDriverUtils.isPresent() since these are all asynchronous tasks and are not immediately executed so we will make use of async and await.

await FlutterDriverUtils.isPresent(world.driver, textinput1);

and at last the Regular Expression is same as in feature file, But just indicating the type of the input parameters instead of the key or value. Also make sure the Regular Expression is exact as defined in feature file

RegExp get pattern => RegExp(r"I have {string} and {string} and {string}");

it is important to note that we dont need to implement steps(using Flutter Driver) like add text in textfield or open a drawer etc, These are already predefined so below two steps will be automatically executed.

When I fill the "emailfield" field with "myemail@gmail.com"
And I fill the "passfield" field with "passwordwith_@"

so what we need to implement now is a tap function on a widget with key "LoginButton" i.e the login button on screen.

Then I tap the "LoginButton" button

so I will add a new class in the same tests_step.dart file. I would suggest you to look closely at this file and try to relate with the previous class file explanation it is kind of similar.

class ClickLoginButton extends Then1WithWorld<String, FlutterWorld> {
    @override
    Future<void> executeStep(String loginbtn) async {
    // TODO: implement executeStep
        final loginfinder = find.byValueKey(loginbtn);
        await FlutterDriverUtils.tap(world.driver, loginfinder);
    }

    @override
    RegExp get pattern => RegExp(r"I tap the {string} button");
}

so if you still didn't get it the statement is of type "Then" with 1 paramter of type String so its extends from Then1WithWorld<String, FlutterWorld> then we found the widget using its key in the input parameter and told the driver to tap on the widget.

await FlutterDriverUtils.tap(world.driver, loginfinder);

Now that we have a feature file ready and also implemented it in a step file its time to put to test.

But wait how will the flutter driver know where to start for the execution 🤔? for this we need to add a config file that tells the driver to execute classes in order as specified so add the below code to test_config.dart.

import 'dart:async';
import 'package:flutter_gherkin/flutter_gherkin.dart';
import 'package:gherkin/gherkin.dart';
import 'package:glob/glob.dart';
import 'steps/test_steps.dart';

Future<void> main() {
    final config = FlutterTestConfiguration()
    ..features = [Glob(r"test_driver/features/**.feature")]
    ..reporters = [ProgressReporter()]
    ..stepDefinitions = [CheckGivenWidgets(),ClickLoginButton()]
    ..restartAppBetweenScenarios = true
    ..targetAppPath = "test_driver/app.dart"
    ..exitAfterTestRun = true;
    return GherkinRunner().execute(config);
}

Let us try running the test by running the command

dart test_driver/test_config.dart

you can see the console for the test results, it should look something like this

One more last step for this post is to check when we have tapped on the login button are we really on the homepage. Well, I would live this to you as an exercise as this post is getting too long. Heres the result of some additional tests that I have added

References:

• Flutter Gherkin's plugin and Documentation
• Code Open Sourced on Github
• Gherkin Reference:Cucumber

Thank you very much for investing your time in reading this post I hope I was able to provide you something valuable. If this post really helped you out give a 👏🏻 and do you know you can clap more than once, the more you clap the more it inspires me to learn new things and share some great content. Cheers, and Have a great day 😊.

Hasta la vista, baby😎!

Taking Flutter Beyond Mobile​

In my previous post, I did show you How you can build your First Flutter Webpage. Now that once you developed your beautiful webpage it's time to deploy it. Here's my Flutterweb page by the way linked to my portfolio on GitHub Pages.

There are several ways and places to deploy the web page but what could be the best place to showcase your work other than GitHub pages? Well before you deploy it, if you have been following my previous post there's one more thing left to do.

Go ahead to the root of your project and use the following command to do a production build to your app

flutter build web

what this basically means is the dart2js compiler converts the dart code into javascript(That's what most of the modern browsers understand) that can run in a browser. You can read more about the dart2js compiler here.

In the root folder of your project, you will see a build folder containing a web directory that contains all your release files.

Now It's the time to set up the Github pages

If you already have a GitHub page skip the First and the second step and go to the third step.

1. Head over to Github and create a new repository named username.github.io, where the username is your username (or organization name) on GitHub.

Note: If the first part of the repository doesn't exactly match your username, it won't work, so make sure to get it right.

2. Once you have created the repository push your files and folders under the build/web directory using git. Once you have pushed your files to yor repository your webpage will be available at this URL. 😃

http(s)://<username>.github.io/

and you don't need to follow any further steps that is all 😃.

3. But If you already have a Github page running then you need to develop a Project page site, that means your web app will be available at a URL which looks like this http(s)://<username>.github.io/yourwebapp

So, for this, you just need to create a new folder in the root of your repository.

The red underlined folders are flutter web apps deployed on github pagesNote that this folder name will point to your webapp so name it wisely

Now commit your files from your build/web folder(locally) into this newly created folder and cheers your web app will be available at the below URL.

A Project Pages site for a personal account is available at http(s)://<username>.github.io/<your newfolder name>. A Project Pages site for an organization account is available at http(s)://<orgname>.github.io/<your folder name>.

Congratulations on Publishing your first FlutterWeb App

Now that you have your web app live and running, I hope you must be happy now. 😃 Why not give me a Clap and make me happy too 😃. And also leave your web app links in the comments, I would love to see what you guys build.

By the way here are a few links to the web apps that I have deployed using this approach

• Generative art
• New Year 2020 animation
• Flutter clock contest entry
• Neumorphic Design Tool
• A WIP Paint App

If this post helped you deploy your web app then don't forget to smash that Clap button, And yes you can click it more than once.

Thanks for taking the time to read and have a great day love💙.

Taking Flutter Beyond Mobile​

Flutter is a great way to build mobile apps for iOS and Android from a single codebase. But did you know that Flutter is expanding beyond mobile to run on desktop, web, TV, smartwatch and almost any device you can think of?

Yes you read that right even on a smart Watch!! with some little hacking and play around And I hope we will soon get Flutter across all of these devices with a stable build. Well this post is only limited to Web so let us stick around with the topic and get started. Here are few things you need to Build your Flutter Web Page

Requirements

• Flutter 1.5.4
• Dart 2.3
• Dart Plugin V.3.0.0
• Flutter Plugin V3.0.0

Additionally, you may need to upgrade your IDE, I am using Vs Code and I am on the latest version 1.33.1

Installing tools that come handy with dart and flutter SDK (optional for this post )

And I would also recommend you to install some tools that come handy with flutter sdk, so that they can be accessed directly from the command line. We wont be using them right now but will require it later.

we will be setting the path for the pub tool in the environment variable in Windows (ofcourse)

Pub: Pub is the package manager for the Dart programming language, containing reusable libraries & packages for Flutter, AngularDart, and general Dart programs. Go to the location where you have installed your dart sdk for me it is C:\Users\mahesh\AppData\Local\Temp\dart-sdk\2.2.0\dartsdk-windows-x64-release.zip\dart-sdk\bin copy the path and add to the path environment variale and you should be ready to use the pub tool in the command prompt.(restart cmd if it already running). and hit pub on the command line you should get some results.

Now that you have pub installed 😃 and ready to run. you need to install a webdev tool 😟

webdev : A command-line tool for developing and deploying web applications with Dart. dont worry its easy to install and take only few seconds 😅 simply run this command pub global activate webdev

Once you are all set We are ready to get this party Started 😎

open VS Code hit ctrl+shift+p to open the command Pallete and choose Flutter New Web Project

Choose a Name For your project in lower case

Wait for it to download the required dependencies and hit F5 to run.

Alternatively to run from the command line,go to the root of the project folder and run the command

webdev serve

and open chrome browser at specified port number (e.g localhost:8080 by default)

Boom 🚀🚀 !! your app is running in the browser​

Here are a few things I want you to consider using Flutter for Web there are few problems with it as of today (09th May 2019)

• Web support for Flutter is not yet stable, it's in technical preview and you may encounter lags and break things and may not work as expected.
• Not all Flutter APIs are implemented on Flutter for the web yet. So you cannot expect to have all - Flutter Widgets ready for the web too. The Flutter Web is designed to work only on Chrome Browsers as of today.

I tried a few basic things that aren't working and need a 🔧. here are some of the snapshots

As you can see in the above images, Icons on Button not visible. I added a Drawer on the left and a floating action button on the right.

Some Important Links for your reference

• Flutter Beyond Mobile announcement Google IO19
• Flutter For Web Docs
• Flutter For Web

I hope this post helped you out thanks for taking your 🕐 to read. If this post helped you out in any way, please feel free to give a 👏 and this will encourage me to write more… 😄

Heres How to deploy your Flutterweb app to Github Pages.

Bye for now and keep fluttering 😄

This is my first Story on Medium and it's about Flutter, If you are reading this, it probably means you must have heard about Flutter. Well for those who are not aware of it

Flutter is Google's new Mobile Sdk that helps you build beautiful, crossplatform, high performant apps with a Single code base real quick. Flutter is changing the way we use and experience building apps.

The coolest mobile apps so far we have seen has clicks, touches, gestures double taps and adding these features in a mobile app was so painful. You will feel the pain if you have built Apps using Native Android. But Flutter comes to the rescue and helps you build the most Beautiful app experiences across different platforms with the same codebase. You can experience one of the most Beautiful apps and My favourate app of all developed by Flutter team, its called The History of Everything. Well, my Post is not about what flutter is, if you would like to know more about Flutter, I recommend checking out the official flutter website, which will give you a good overview of its capabilities.

In this story, I will show you How to implement different Cupertino Pickers in Flutter by the end of this story we will be implementing this,

This is a basic flutter app that adds a "Hello World" text in the center of the screen

Scaffold(
  body: Container(
    color: Colors.blueGrey,
    child: Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Text("Hello World")
        ],
      ),
    ),
  ),
);

basic flutter widget with a hello world in the center of the screen.

Now let's remove the Text Widget and add a MaterialButton that opens an empty BottomSheet when Pressed, We will use this Button to show a CupertinoDatePicker.

CupertinoDatePicker​

The CupertinoDatePicker is capable of Showing the DateTime, or the Date or only Time on the Picker as shown below.

MaterialButton(
  child: Text(
    "Cupertino date Picker",
      style: TextStyle(color: Colors.white),
    ),
    color: Colors.redAccent,
    onPressed: () {
      showModalBottomSheet(
        context: context,
        builder: (BuildContext builder) {
          return Container(
            height: MediaQuery.of(context)
            .copyWith().size.height / 3,
          );
       });
    },
 ),

This code adds a simple Material Button and opens a ModalBottomSheet onpress the height of the Bottom Sheet is indicated by the height attribute that takes in 1/3 rd height of the Device.

Now let us add the child to the Container of the BottomSheet Now we will add the actual CupertinoDatePicker as the child it takes in a couple of Arguments and it's mandatory to pass in the onDateTimeChanged argument

Required Arguments​

onDateTimeChanged: this is a Callback called when the selected date and/or time changes, and it must not be null, it takes in an Argument of type DateTime that gives the changed DateTime every time this method is called. In simple words, this gets called every time the picker is scrolled.

onDateTimeChanged: (DateTime newdate) {
    print(newdate);
},

watch out the DebugConsole it should print the selected DateTime every time you scroll the picker.

Optional Arguments​

initialDateTime: the time that is selected when the picker is shown you can set it to current date and time by assigning it to DateTime.now().

use24hFormat: Takes in a Boolean Value either or True or False to set The 24 hr Time Format depending on the value.

maximumDate: The Maximum date you can Scroll the Picker Specified by the type DateTime(), e.g new DateTime(2018,12,30), would allow us to scroll until Dec 30 2018 ,you can also specify the time on that Date separated by Commas DateTime(2018,12,30,11,30). The DateTime() class takes in following arguments

DateTime(int year,[int month = 1,int day = 1,int hour = 0,int minute = 0,int second = 0,int millisecond = 0,int microsecond = 0])

Note that the arguments in [] are Optional

minimumYear: takes in the minimum year in Integer you wanna scroll from

maximumYear: takes in the Maximum year in Integer you wanna scroll up too.

minuteInterval: The interval between two successive minute pickers should be an integer factor of 60, e.g minuteInterval:2 would increment minute picker by 2

mode: The format of the Picker, whether you want to show only Date or DateTime or only Time on the Picker, you can provide one of the following options

CupertinoDatePickerMode.dateAndTime,
CupertinoDatePickerMode.date
CupertinoDatePickerMode.time

Container(
  height: MediaQuery.of(context).copyWith().size.height / 3,
  child: CupertinoDatePicker(
    initialDateTime: DateTime.now(),
    onDateTimeChanged: (DateTime newdate) {
          print(newdate);
    },
    use24hFormat: true,
    maximumDate: new DateTime(2018, 12, 30),
    minimumYear: 2010,
    maximumYear: 2018,
    minuteInterval: 1,
    mode: CupertinoDatePickerMode.dateAndTime,
));

CupertinoTimerPicker​

The TimePicker Widget shows only time on the picker

required Arguments​

onTimerDurationChanged: Callback called when the timer duration changes. It gets called every time you scroll the TimePicker and the changed value is received in the arguments of type Duration. SetState to reload the Widget tree when the updated state has to be rendered on the screen.

onTimerDurationChanged: (Duration changedtimer) {
    SetState((){});
}

if you want the timer to retain the timer previously scrolled you need to create a variable of type Duration and keep reassigning the value.

Duration initialtimer = new Duration();

And then set the value of initalTimerDuration to initialtimer which holds previously scrolled value, everytime the onTimerDurationChanged is called we store the changedtimer (i.e current selected value) in initialtimer. now if you scroll the timer and then again open the picker you should see the timer selected to previously scrolled value.

initialTimerDuration: initialtimer,
onTimerDurationChanged: (Duration changedtimer) {
  SetState(() {
    initialtimer = changedtimer;
  });
}

Optional Arguments​

mode: the Format of the Picker which displays the picker in one of the following formats

1. hours minutes seconds
2. hours minutes
3. minutes seconds

   CupertinoTimerPickerMode.hms
   CupertinoTimerPickerMode.hm
   CupertinoTimerPickerMode.ms

minuteInterval: the difference between two successive minute pickers should be a positive integer factor of 60. secondInterval: the difference between two successive second pickers should be a positive integer factor of 60. initialTimerDuration: The time Duration that is displayed when the picker is shown you can initialize it to zero by assigning Duration.zero or assigning it to a duration variable to retain the previous timer.

Note: the initialtimer is a variable of type Duration and is used to retain the previous timer.

CupertinoPicker​

This Widget helps us Creates a picker from a concrete list of children. and provides quite a few customizations. and we can add different widgets to our pickers.

required Arguments​

itemExtent: specifies the height of each Widget child in the picker, must not be null and must be positive. onSelectedItemChanged: An optional callback when the currently centered item changes.Value changes when the item closest to the center changes.

Optional Arguments​

diameterRatio: Relative ratio between this picker's height and the simulated cylinder's diameter. Smaller values create more pronounced curvatures in the scrollable wheel.

backgroundColor: The background color of the picker magnification: to magnify the size of the widget 1.0 indicates the original size, looping: The looping argument decides whether the child list loops and can be scrolled infinitely. If set to true, scrolling past the end of the list will loop the list back to the beginning. If set to false, the list will stop scrolling when you reach the end of the beginning.

Scaffold(
  appBar: AppBar(
    title: Text(
          "CupertinoPicker",
    textAlign: TextAlign.justify,
    ),
    backgroundColor: Colors.teal,
    actions: <Widget>[
    IconButton(
      icon: Icon(Icons.send),
      onPressed: () {},
    )],
    ),
    body: Container(
    child: CupertinoPicker(
      magnification: 1.5,
      backgroundColor: Colors.black87,
      children: <Widget>[
      Text(
        "TextWidget",
         style: TextStyle(
          color: Colors.white, fontSize: 20),
       ),
    MaterialButton(
      child: Text(
       "Button Widget",
        style: TextStyle(color: Colors.white),
      ),
    color: Colors.redAccent,
    ),
    IconButton(
    icon: Icon(Icons.home),
    color: Colors.white,
    iconSize: 40,
     onPressed: () {},
     )
    ],
      itemExtent: 50, //height of each item
      looping: true,
      onSelectedItemChanged: (int index) {
      selectitem = index;
      },
      ),
    ));
   });
   },)
  ],),
),),
);

You can find the complete source code here of the demo app that we just built If you have any questions feel free to comment below and if you liked this story and found this helpful don't forget to appreciate by a clap :)

Since This post got a good response I tried implementing a custom Timepicker using the CupertinoPicker. You can find the source code to this here

Thanks for taking the time to read. And if you have any questions or you think something is not right or could be improved feel free to drop a comment I would love to discuss it. Happy Fluttering