DEV Community: Nilesh

AWS re:Invent 2024

Nilesh — Tue, 10 Dec 2024 05:35:46 +0000

Introduction

AWS re:Invent is the tech world’s grandest stage for cloud innovation. As a proud recipient of the All Builders Welcome Grant, I attended this year’s event in Las Vegas from December 4–6, 2024. This grant is designed for technologists early in their careers, providing an all-expenses-paid trip, including airfare, accommodation, and a conference pass.

How to Apply for the ABW Grant
Eligibility for the grant includes:

Having less than five years of experience in a cloud-related career.
Demonstrating a keen interest in AWS technologies.

Applications open in the summer and are shared on the AWS re:Invent website. Start early and craft a strong application showcasing your passion for cloud computing.

Day-by-Day Highlights

Day 1: Immersing in Innovation
The day began with insightful sessions on Cloud DevOps + AI and Physical AI, where futuristic AI integration ideas were discussed. A standout was the session on integrating Amazon Bedrock foundation models into serverless applications, followed by a Chalk Talk on AI-powered document workflows—both incredibly relevant to my professional interests.

Day 2: Learning the Business Side
I attended the Technical Product Management meetup, which offered a behind-the-scenes view of how product managers thrive at Amazon. The emphasis on technical depth and cross-functional collaboration was inspiring.

Day 3: Personal Growth and Networking
This day was packed with opportunities for skill-building and career advice, including:
An Observability Workshop, emphasizing effective monitoring in cloud environments.
A Speed Mentoring Session and a Career Navigation Workshop with Amazon’s Solutions Architects and Developer Advocates, which were perfect for career insights.

Key Takeaways from the Event

Networking Matters: The ABW lounge was a haven for connecting with other grant recipients and AWS mentors. Conversations here broadened my horizons.

Knowledge is Power: Chalk Talks and workshops offered practical insights into cloud innovations.

Be Authentic: Being open and approachable enhanced my interactions with attendees and speakers alike.

My Experience as a Grantee

The ABW grant was more than financial support—it was a gateway to community and mentorship. AWS went above and beyond with perks like professional headshots and networking events. The closing reception with AWS leadership was a moment of gratitude and reflection, emphasizing AWS’s commitment to diversity.

Final Thoughts

Attending AWS re:Invent 2024 as an ABW grantee was transformative. The experience enriched my technical knowledge and professional network, reinforcing my drive to excel in cloud technologies. If you’re considering applying for the ABW grant, don’t hesitate—it’s a once-in-a-lifetime opportunity to learn, grow, and connect.

Day 4

Nilesh — Fri, 18 Feb 2022 04:54:25 +0000

Well today was a very longgg day, I had:

1 long 10 hour shift from 8:00 AM till 6:00 PM
Right after my shift, I had to rush to my Applied Artificial Intelligence course COMP-6721 which was till 8:15 PM
And then I had a lab under the same course till 10:20 PM Damnn... I am really tired up right now, but equally psyched to share and re-comprehend what I learned today in my lecture and also to share some personal insights ;)

COMP-6721-Applied Artificial Intelligence:

LeetCode: Plus One Solution

Nilesh — Wed, 16 Feb 2022 15:33:08 +0000

Okay fellas,

Let's get on to some coding problems now!!

Problem Statement:

You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading 0's.

Increment the large integer by one and return the resulting array of digits.

Example 1:

Input: digits = [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.
Incrementing by one gives 123 + 1 = 124.
Thus, the result should be [1,2,4].

Example 2:

Input: digits = [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.
Incrementing by one gives 4321 + 1 = 4322.
Thus, the result should be [4,3,2,2].

Example 3:

Input: digits = [9]
Output: [1,0]
Explanation: The array represents the integer 9.
Incrementing by one gives 9 + 1 = 10.
Thus, the result should be [1,0].

Constraints:

1 <= digits.length <= 100
0 <= digits[i] <= 9
digits does not contain any leading 0's.

Approach:

Convert to string, then to number, then add one to the resulting converted number and then again do the inverse conversion. Problem? The test cases have few input numbers in the array which are of BigInteger data type (which means it is greater than Long), now BigInteger does not support .parseInt() method and hence, this approach will fail for these test cases.

Important thing to note here is that the result array size is dynamic, which means that, if we have a last element in the array which is 9, then a carry has to be taken.
Now, this carry will increase the array size and hence we have to think something around using a dynamic array and we all know that a dynamic array best friend is an ArrayList, so let's use it :')

Using ArrayList: //Base case If there are no elements in the passed array, then return a temporary array which has an element {1}.

`class Solution {
public int[] plusOne(int[] digits) {
ArrayList result = new ArrayList();
if(digits == null || digits.length == 0){
int[] temp = {1};
return temp;
}

// What the heck*1?

    int carry = 0;
    for(int i= digits.length -1; i>=0; i--){
        if(i == digits.length-1){
            carry = carry + digits[i] + 1;
        }
        else
            carry = carry + digits[i];

// What the heck*2?

        result.add(0, carry%10);
        carry = carry /10;

    }
    if(carry == 1){
        result.add(0,1);
    }

//What the heck*3?
int[] resultArray = new int[result.size()];
for(int i=0; i<result.size(); i++){
resultArray[i] = result.get(i);
}
return resultArray;
}
}`

Explaining the hecks*i:

Heck1:
We are traversing our array "digits" from the end, because remember that we have to add 1 at the LSB and also, what if, we have a number 9, at LSB? Then we have to make another variable called "carry" which will hold our carried integer.
Now, what our first "if" is doing is, that it is taking up the last element of the array and it will run only one time,
It is calculating the carry (if any) and adding it to itself.

Heck2:
Remember, the add operation of ArrayList DO NOT replace the value specified at a certain index, rather it just adds it there and shifts the old element to right.
Thus, we will keep on adding carry, at the index position 0, that way, at the end, we will have our first element from digits array at the first index of result arrayList.
Also, for reference;
a%b == a modulus b == gives the REMAINDER
Ex: 32%10 = 2
Whereas,
a/b == gives the QUOTIENT
Ex: 32/10 = 3

We very commonly use "/" operation to take out a certain value at the "1x"th position where x can be 0, 00, 000, 0000, anything.

Heck3:
Because we want to return the result in the array format, hence we are creating a new array called resultArray[] which has the same length as of ArrayList result and then, we are just populating the values in this result[] array.

That's pretty much all for this problem. :)

Day 3

Nilesh — Wed, 16 Feb 2022 15:31:57 +0000

Hello fellas,

Today I was able to solve the following problems and study a bit more about Image Processing and Artificial Intelligence.

Here's the summary and links which might be useful:

Problem1:
https://dev.to/nilesh_aggarwal/leetcode-plus-one-solution-496m

Problem2:

Enjoy your day!!!

Happy hacking ^_^

Day 2

Nilesh — Tue, 15 Feb 2022 08:22:07 +0000

Let's have some Image Processing today:

So I have this course, COMP 6721 which covers the fundamental of Image Processing and today I learnt a few concepts of Image Transformation and Image Filtering.

Image Transformation Operations

Image Transformation can be done in following two major ways:

Spatial Image Transformation
Histogram Image Transformation

In the previous lecture, I covered basic concepts of Image Transformations, like image rotation, scaling, translation, flip, affine transformation, wrap/swirl.

What's a Spatial Image Transformation?

A spatial transformation of an image is a geometric transformation of the image coordinate system.
There are certain ways we can perform Spatial Image Transformation, to list some of these:

Linear Point Transformation
Log Transformation
Gamma Transformation
Piece-Wise Linear Transformation

Log transformations are mainly used in the MRI and Gamma transformation uses a Gamma function to convert the image to dark or light depending on the Input Intensity Levels.

What is Histogram Transformation?

A histogram transformation is a pixel-by-pixel intensity transformation defined by five parameters in PixInsight: Clipping points.
Now we can define the transformation using the Bars also.
Ex: Consider an image of 64x64 pixel values, then each pixel will have different pixel value from 0...255.
Here, value of pixel 0 means --> darkest
and value of pixel 255 means --> brightest

Now, let's say we have 2 pixels who has value of 0, then we will make a bar in the graph, where:
x-axis = pixel value (Ex: x-axis --> 0)
y-axis = frequency of that pixel (Ex: y-axis --> 2)

And hence, simply plot the graph now.

We call, each of these bars created as BINS. These bins not necessarily have to store only the fixed value, rather it can store the range of the pixel values.
Example: pixel values in the range 0-15 can be in Bin b1, and pixel values in the range of 245-255 can be in bin b16 and so and so forth.

What is a Contrast?

Contrast is the difference in luminance or color that makes an object distinguishable from other objects in the same field of view.
A low contrast image has the objects which are hard to identify in the image and hence we sometimes do an auto-contrast function to fix the image contrast and make the objects in the image clearly distinct-able.

Now Contrast Enhancement can be done by two ways:

Linear method
- Contrast Stretching
Non-Linear method
- Histogram Equalization
- To enhance the image's contrast, it spreads out the most frequent pixel intensity values or stretches out the intensity range of the image.
- Gaussian Stretch

Image Filtering

When we talk about Image Filtering then we are talking about images in the spatial domain, and hence we will deal with pixels here.

So to filter an image, we filter every pixel of the input image and to do so, we use filters which are known as Kernel Filters or we also call them as Spatial Filters.
This filter has to be unique across rows and columns and it looks like following:

(It is usually an odd dimension m x n, where m=n=2n+1)

Example:

Input image --> 8x8 image
[0, 65,231, 87, 2, 7, 255...m8]
[nk ... mk]
[n8 ... m8]
Kernel --> 3x3 matrix
[1,0,1]
[2,0,2]
[1,0,1]

And to calculate the output image, just multiply the Kernel with the input image pixels over that dimension with a stride of 1.
What's stride?
Stride is basically how many pixel values you will be jumping/traversing in each calculation.

So basically, we have image kernels, which determine the output of the image and depending on the kernel we are using, we will get a certain output.

And there are certain set of kernel values already defined using which we can generate the "Convolved Image".

Major operations in Image Filtering are:

Image Smoothing using Low-Pass Filters
- Box Filter
- Gaussian Filter
Image Sharpening using High-Pass Filters
- Laplacian Filter

... to be continued to day 3

What's next?
I will be completing this lecture along with the code examples.
And we will solve few coding problems as well (Arrays, Strings, HashMaps)

Thank you!

Happy hacking ^_^

Day 1

Nilesh — Mon, 14 Feb 2022 04:19:37 +0000

Problem 1:

(Intersection of Two Arrays)
Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.

Example 1:

Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]

Example 2:

Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [4,9]
Explanation: [9,4] is also accepted.

Approach:
Brute Force --> Use two for loops to iterate over both the loops and find out the common element and store them in a different array.
Time - O(n*n) | Space - O(n)

Note: If you are using an array list, then make sure, that you have a method in your solution called "listToArray()"

private int[] listToArray(List<Integer> list){ int[] result = new int[list.size()]; for(int i =0; i< list.size(); i++){ result[i] = list.get(i); } return result; }

Two Pointer --> Sort the two arrays and iterate over to find out the intersections. Use an array list because we want to space some space and hence we will dynamically update the array list every time we find an intersection.

Ref: https://medium.com/@punitkmr/intersection-of-two-arrays-ii-ffb26f04dfd1

Using HashMap:

Populate the hashmap with first array with the keys as the numbers and it's frequency as the count
Create an array list
Iterate over the second array and find the common elements
Imp: Make sure you are reducing the count from the map, so that ONLY the INTERSECTION is getting returned.
Return the matched values in the array list
Convert this array list to array using custom listToArray() method, in which you are just feeding every element from the array list to this array and return it.

Code (HashMap):

`class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
if(nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0){
return new int[0];
}
HashMap map = new HashMap<>();

    //populating the hash map with the array 1 values
    for(int num: nums1){
        if(map.containsKey(num)){
            map.put(num, map.get(num)+1); // if value is repeated, then save the value, but increment the key count, that's why "get()+1".
        }
        else
            map.put(num, 1);
    }
    //create an arrayList to store the result

    List<Integer> result = new ArrayList<>();

    //iterate and match with nums2 now;
    for(int num: nums2){
        if(map.containsKey(num) && map.get(num) > 0){
            result.add(num); //adding the matched value in the array list -- intersection operation
            int count = map.get(num);
            count--;
            map.put(num, count);
        }
    }
    return listToArray(result);
}
private int[] listToArray(List<Integer> list){
    int[] result = new int[list.size()];
    for(int i =0; i< list.size(); i++){
        result[i] = list.get(i);
    }
    return result;    
}

Intro

Nilesh — Sun, 13 Feb 2022 07:07:45 +0000

Hey folks,

This being my first ever blog, I will briefly tell about who I am, what I am doing and what I am planning to do.
I won't be writing about coding each day, but some development that I did today and also some outdoor fun, as I love going out and exploring new places!!
So here it goes... ^_^

About me:
Final Year Masters student in Computer Science at Concordia University, Montreal, Quebec, Canada.

What I am doing:
Coding | Development | Artificial Intelligence | Deployment.
Basically everything from development till deployment :)
My tech stack includes Java, React, AWS, Docker, Python for AI
Currently learning about Terraform, Kubernetes, SalesForce, ServiceNow

PS: If you are preparing for a certain certification and looking for a prep buddy, loop me in, as I am also planning to do some in coming few months.

Planning to do:
Equipping myself each day with some technical, business, investment knowledge.
I want to learn and grow each day.

Happy Hacking ^_^