Forem: Kartik Budhiraja

Figuring it out no matter what ~ Leo Lima

Kartik Budhiraja — Mon, 22 Feb 2021 13:29:18 +0000

Bringing you the next episode of Everyone Sucks, I (Kartik Budhiraja) had the honour to have Leonardo Lima as the guest for this episode. Leo is from Brazil and is currently working as a Senior Software Engineer at a crypto marketplace company.

His story of being in development is really fascinating, as he studied journalism but pivoted into software development later. He talks about how many challenges he faced not being from a computer science background and how he was able to find what he loves and gets better at it.

Some key takeaways:

Never complain

Leo provides us all with an example of making the best of our resources without complaining. For his very first internship interview (which he got by sending a cold-email to the founder of the company), he was given a coding assignment. Fortune playing its usual role, Leo was moving at that time and ended up being without an internet connection at his place with an assignment to do in a programming language he did not have experience in ( If you’re a developer, you can imagine how hard can that be). But instead of complaining, Leo actually spent his days at the public library as they had internet and finished the assessment on time.

Talk about finding a way out no matter what.

Build and use the support network around you

When asked about his way of handling the pressure of moving into tech and dealing with the imposter syndrome, he talks about the importance of having a support network around oneself. He mentions how he used to talk with his best friend and other people around him openly about the challenges he’s facing and the doubts he has.

He puts it in a really impactful way by saying that “You do not have to fight alone. Help people around you and ask for help when you need it.”

Transform self-doubt to fuel

At his first development job, Leo talks about how he always felt the pressure to prove himself. Not being from a computer science background, the self-doubt added additional pressure as one could imagine. Leo turned that self-doubt around and started using that as fuel for more focus. He talks about how he ended up taking his work with intense focus and putting in more hours just because he knew he had something to prove. It’s not to say that the pressure is good, it’s more to show that everyone feels that self-doubt, but the only thing we need to do with it eradicates it by focusing on what we can do i.e get after it and work with more focus.

It’s always a people business

“No matter what your role is, you have to remember it’s always a people business” ~ Leo

Leo tells how calling people as resources make him a bit uncomfortable as people are human, no matter what happens. He explains how important is it to remember this whether you’re a developer or in any other job. At the end of the day you are still working and communicating with people, so behave like one.

Focus on what other person requires, not what you want to offer

When asked about his favourite failure, he talks about the importance of understanding other people’s needs. Through his own experience where he tried to help an intern by providing what he thought would be the best for them. He explains how that backfired and reminded him that every person is different, just because you think that one thing would benefit that person, does not mean they would agree with you.

If you’re in a management role, take a step to figure out what your team wants first, and then work on providing them. Do not put the cart in front of the horse.

Bonus Tip: Coming from Journalism, writing is a major part of Leo’s life. He uses writing down the problem and its prospective solution to break it down into chunks and suggests everyone give it a shot.

Please feel free to reach out to Leo if anyone needs any guidance. You can find Leo online on Twitter at @leocavia.

We talked about a lot of other cool stuff, join us on youtube, Spotify, and every other place you get your podcast from. (Search for Everyone Sucks)

Spotify: https://open.spotify.com/episode/6sm92aEs2vO8ES3KfegM3E?si=oHd4uv6qROKk5MBxH6pcdg

A journey of resilience with Jeffrey Chang

Kartik Budhiraja — Thu, 10 Dec 2020 14:08:44 +0000

This weekend I got an opportunity to chat with @Jeffrey Chang about his journey.

From working at a bakery to working at an auto shop to becoming a software developer at Telus Digital, he walks us through all of the ups and down’s he went through.

To me personally, Jeffrey’s story stands out as a journey of resilience. A prime example of what determination and grinding it out can do in life.

Some key takeaways:

Give yourself a shot and take a leap of faith (Jeffrey decided to invest $10,000 for the Bootcamp even when his financial situation was not that easy)
Stick with it until it clicks, and trust me, it will click soon enough ~ Jeffrey
Find the positive out of the negative (Jeffrey talked about his “failed” tech interview, which he turned into a positive as it provided him with the desire to learn)
“Be a sponge and soak up all the knowledge you can” ~ Jeffrey Chang 😛

Some special advice for new grads/juniors:

Contribute to open source as much as you can. Ask yourself “What can I do to make this project better?”( Additional perk: Get your code reviewed by Senior dev’s around the world for free 😎 )
Don’t spread yourself too thin, focus on one thing at a time. No more trying to learn docker and Vue.js at the same time.

And finally my favourite quote from the conversation:

“You’re not an idiot, you just do not understand it at the moment” ~ Jeffrey

Please feel free to reach out to Jeffrey if anyone needs any help. He provides his email in the conversation.

We talked about a lot of other cool stuff, join us on youtube, Spotify, and every other place you get your podcast from. (Search for Everyone Sucks)

Spotify: https://open.spotify.com/episode/7tJlRnv4x9wKC0RbKCAYlg?si=4RHIGYp7Rnu450zoFtBkLg

Apple Podcasts: https://podcasts.apple.com/ca/podcast/everyone-sucks/id1477730495?i=1000501827490

Create horizontal scroll list with ScrollSpy in React

Kartik Budhiraja — Fri, 08 May 2020 14:01:48 +0000

A horizontal scroll list can be implemented easily, thanks to the flexbox. The tricky and fun part is not only highlighting the active heading as well as bringing it into view as the user scrolls down the page.

In this blog, we will discuss how to get this user experience.

Libraries used: react-scroll

Let's assume we have a row of headings.

These headings are embedded in Link from react-scroll and scroll down to respective part on click.

React Scroll has the following prop which would make it super easy to set an active category:

onSetActive — invoke whenever link is being set to active

The issue to solve inside this prop is to get the active category to be visible on the screen if the user scrolls down to it.

To get an element into the view, we would use:

Element.scrollIntoView()

To get access to the DOM element of the active category, we will use refs. It’s the recommended way of getting to access DOM nodes or React elements created in the render method.

We need to store the ref to the
item, and then call
scrollIntoView() on the element when the user reaches that category.

As we have multiple categories, we would need to store refs in an array. But as I experimented with it, I found out for some reason, refs get wiped out when stored in an array.

With some research I found this comment:

Source → (Array of references)

Storing each ref as string worked, but considering the comment was made in 2014, and react has evolved a lot since I was a bit skeptical.

And even though it worked, I got the following warning in console:

Warning: A string ref, “1”, has been found within a strict mode tree. String refs are a source of potential bugs and should be avoided. We recommend using useRef() or createRef() instead. Learn more about using refs safely here: https://fb.me/react-strict-mode-string-ref

Also in the documentation for refs, it is clearly stated:

We advise against it because string refs have some issues, are considered legacy, and are likely to be removed in one of the future releases.

The array does not work, and storing string ref is not an elegant solution.

So I thought of creating refs for each category heading using React.createRef() in the constructor.

And it worked like a charm, we can access the element in the following way in the callback of setting active category:

And the refs can be added to the respective DOM element like this:

And Voila!! 🤩

🥳 There we have our horizontal scroll list, scrolling the active heading into view as the user scrolls down.

This is the code sandbox for a working example:

Thank you for reading. If you have any questions or suggestions, please let me know in the comment box.

How to connect Go with MongoDB using official mongodb-go-driver!

Kartik Budhiraja — Sat, 23 Mar 2019 11:22:19 +0000

On December 13, 2018 MongoDB released its official Go Driver into beta, ready for the wider Go and MongoDB community to put it into test.🤩 MongoDB GO driver is pretty easy and quick to set up and is still WIP but is improving functionalities and features day by day. This tutorial is based on the official tutorial released by MongoDB, but I tried to make it as simple as possible along with a working reference.

TLDR: The source code can be found here with CRUD operations

In this tutorial, we will cover:

Install the MongoDB Go Driver
Connect the MongoDB using the Go Driver
Use of BSON Objects in Go
Perform CRUD Operations

Installing the MongoDB Go Driver

The MongoDB Go Driver is made up of several packages. If you are just using go get, you can install the driver using:

go get github.com/mongodb/mongo-go-driver

The output of this may look like a warning stating something like package github.com/mongodb/mongo-go-driver: no Go files in (...). This is an expected output.

If you are using govendor package manager, you need to install the main mongo package as well as the bson and mongo/options package using the following commands:

govendor fetch github.com/mongodb/mongo-go-driver/mongo

govendor fetch go.mongodb.org/mongo-driver/bson

govendor fetch go.mongodb.org/mongo-driver/mongo/options

All of the required packages should get installed, now let's build up a connection to Mongo.

2. Setting up the connection

Once the MongoDB Go Driver has been imported, we can connect to a MongoDB deployment using the Client.Connect(context).We need to set up a new client, we need to pass the URI of our mongo database while setting up the client. Then we just need to call client.Connect(context) with the context, which will set up our connection.

The following code sets up a connection for us:

For keeping it simple, I would only be providing the code snippets of the functions being used, you may find the complete source code here.

//Set up a context required by mongo.Connect
ctx, cancel := context.WithTimeout(context.Background(), 10\*time.Second)

//To close the connection at the end
defer cancel()

//We need to set up a client first
//It takes the URI of your database
client, error := mongo.NewClient(options.Client().ApplyURI("your\_database\_uri"))

if error != nil {
 log.Fatal(err)
}

//Call the connect function of client
error = client.Connect(ctx)

//Checking the connection
error = client.Ping(context.TODO(), nil)
fmt.Println("Database connected")

3. Using BSON Objects in Go

JSON documents in MongoDB are stored in a binary representation called BSON (Binary-encoded JSON). Unlike other databases that store JSON data as simple strings and numbers, the BSON encoding extends the JSON representation to include additional types such as int, long, date, floating point, and decimal128. This makes it much easier for applications to reliably process, sort, and compare data. The Go Driver has two families of types for representing BSON data: The D types and the Raw types.

The D family of types is used to concisely build BSON objects using native Go types. This can be particularly useful for constructing commands passed to MongoDB. The D family consists of four types:

D: A BSON document. This type should be used in situations where order matters, such as MongoDB commands.
M: An unordered map. It is the same as D, except it does not preserve order.
A: A BSON array.
E: A single element inside a D.

Here is an example of a filter document built using D types which may be used to find documents where the name field matches either Alice or Bob:

bson.D{{
 "name", 
 bson.D{{
 "$in", 
 bson.A{"Alice", "Bob"}
 }}
}}

4. CRUD Operations

For CRUD and other operations, we need to use the collection object, which we can create by referencing to our respective collection in our database like:

BooksCollection := client.Database("test").Collection("books")

Insert

For create, we can use collection.InsertOne() for individual entry or could use collection.InsertMany() which takes in the slice of objects.

/\*\*
\* Create - Adding a new book
\* res -\> the insert command returns the inserted id of the oject
\*/

res, err := BooksCollection.InsertOne(ctx, bson.M{"name": "The Go Language", "genre": "Coding", "authorId": "4"})

if err != nil {
log.Fatal(err)
}

In collection.InsertOne(), we can either pass a string object through bson.M{} or we could create an object of our respective type struct and pass that object.

Read

For finding documents, we need a filter document as well as a pointer to a value into which result can be decoded. To find a single document, use collection.FindOne(). This method returns a single result which can be decoded into a value. The filter object specifies what are we looking for.

filter := bson.D{{"name", "Book 1"}}

// create a value into which the result can be decoded
var result bookType

err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
 log.Fatal(err)
}

fmt.Printf("Found a single Book: %+v\n", result)

To find multiple documents, use collection.Find(). This method returns a Cursor. A Cursor provides a stream of documents through which we can iterate and decode one at a time. Once a Cursor has been exhausted, we should close the Cursor.

cur, error := BooksCollection.Find(ctx, bson.D{{}})

var allbooks []\*bookType

//Loops over the cursor stream and appends to result array
for cur.Next(context.TODO()) {
var booksResultHolder bookType

err := cur.Decode(&bookResultHolder)

if err != nil {
log.Fatal(err)
}

allbooks = append(allbooks, &booksResultHolder)
}

//dont forget to close the cursor
defer cur.Close(context.TODO())

// Loop over the result array and perform whatever required
for \_, element := range allbooks {
book := \*element
fmt.Println(book)
}

If you get empty results back, check your fields of type structures, you must export fields of structs, else they are ignored by the mongodb-go-driver package. (Each field should start with Capital letter, specifying go that it could be exported)

type users struct {

User string bson:"user" json:"user"

Data string bson:"data" json:"data"

}

By default when a struct value is transformed/stored/retrieved from MongoDB, the field name is used. If you want to use different names, you may use tags to tell what names should the fields map to.

If your documents have automatically generate id’s, at the moment you won’t be able to get those id’s through mongodb-go-server , this is because the id’s are strings wrapped around in custom objects, and at the moment, the driver does not support them. More detailed info can be found here.

Update

The collection.UpdateOne() method allows you to update a single document. It requires a filter document to match documents in the database and an update document to describe the update operation. These can be built just how we made the filter object while reading.

/\*\*
\* Update
\* Collection has functions like UpdateOne and UpdateMany
\* Returns the Matched and Modified Count
\*/

filter := bson.D{{"name", "Book 1"}}

// Need to specify the mongodb output operator too
newName := bson.D{
{"$set", bson.D{
{"name", "Updated Name of Book 1"},
}},
}

res, err := BooksCollection.UpdateOne(ctx, filter, newName)

if err != nil {
log.Fatal(err)
}

updatedObject := \*res

fmt.Printf("The matched count is : %d, the modified count is : %d", updatedObject.MatchedCount, updatedObject.ModifiedCount)

Delete

Finally, we can delete documents using collection.DeleteOne() or collection.DeleteMany(). Here we can pass nil as the filter argument, which will match all documents in the collection or any other specific argument. We could also use collection.Drop() to delete an entire collection.

filter = bson.D{{"name", "Updated Name of Book 2"}}

deleteResult, error := BooksCollection.DeleteOne(ctx, filter)

Next Steps

The source code for this tutorial can be found here.

Documentation for the MongoDB Go Driver is available on GoDoc. You may be particularly interested in the documentation about using aggregations or transactions.

Hope this tutorial made things a bit simpler for you, Happy coding everyone!👨🏽‍💻🍻