DEV Community: David Armendáriz

Creating a Discord bot with discord.js, Typescript and Heroku

David Armendáriz — Wed, 11 May 2022 17:21:23 +0000

Hi! So, some months ago, I was interested in creating a bot for Discord. I searched for tutorials and they were not too good. Worst of all, they taught you how to deploy it to Repl.it. As a senior software dev, I was like: what? Repl.it is the last thing I would think about to deploy anything.

I started coding the bot and the documentation again was not good. They even have wrong information on their docs so I had to ask people on the official discord.js server to clear some doubts. Sometimes people are nice, sometimes they aren't. They have concepts like cached guilds and uncached guilds that took me some time to grasp because they do weird things in Typescript.

Anyway... I gathered all of that knowledge and decided to make a course in Udemy and Skillshare. Here you will learn a lot of things:

Typescript
Reply to messages
Create slash commands
Create buttons and links
Create message collectors
Create embeds
Create reactions collectors
Create sub commands
Get information about a user and its roles
Add options to commands
Add simple tests
Deploy to Heroku and connect it to GitHub for CD
Permissions
Best practices

Among other things...

This is the link with the coupon code: https://www.udemy.com/course/building-a-discord-bot-w-discordjs-typescript-and-heroku/learn/lecture/31964864?couponCode=DISCORDBOT#overview

TikTok logo with CSS only

David Armendáriz — Sun, 25 Jul 2021 19:31:54 +0000

Never do this in Python!

David Armendáriz — Sat, 24 Jul 2021 22:48:27 +0000

Do you know what happens if you pass a mutable object as a default argument in Python? What can go wrong?

JavaScript tips: The labeled statement

David Armendáriz — Sat, 29 May 2021 15:47:36 +0000

What if you type in the console something like this?

label: {}

You won't have any errors. This is valid JS!

It turns out you can reference loops in Javascript. This was something I did not know a few days ago, but is a really cool and helpful feature in Javascript. In the following video, I explain you with examples how to use labeled statements.

Trying to make Webstorm like VSCode (Part 1)

David Armendáriz — Thu, 04 Mar 2021 02:33:44 +0000

Hi folks! I recently needed to install PHPStorm as I am working on a complex PHP project and VSCode was not that good for PHP...
I am trying to make a smooth transition, because I have always used VSCode for basically everything. I also downloaded Webstorm, so I am experimenting on Webstorm so that I can apply what I learned later on PHPStorm.

Unstaged files

I think VSCode has a great and simple Git integration. Before you add a file to the stage you have the file like this:

I like that "plus" button, and managed to add it:

Just go to Settings (Ctrl + Alt + S) > Appearance & Behavior > VCS Local Changes Toolbar

You can add the "Add" button by clicking on the "Add actions..." and searching for the "Add" action inside Version Control Systems > Git (sorry for that tongue twister 😂)

Now, you can add the "Add" button to stage a file. I mostly use this functionality for when I don't want to add all files in the stage by using the terminal (i.e. git add .).

Staged files (??)

When the file is staged, you have a button to unstage a file in VSCode:

However, I don't see this option in Webstorm. Neither there is a separation between "staged" and "unstaged" file in the Commit tab in Webstorm nor PHPStorm. Do you know how to achieve this or if this is possible?

Thanks in advance.

Best way to handle lots of logic inside React Class Components

David Armendáriz — Mon, 22 Feb 2021 23:14:12 +0000

Context

We have a (very huge) application where sometimes there are files with 1000+ lines of code. What makes these files big are the logic of some methods. Wether we have too much logic on our component or not is not something I would like to discuss, at the end of the day, this is a production app and we have limited resources and limited time, so we need to find the best way to optimize the codebase while meeting deadlines (welcome to the real world!).

For example, suppose I have something like this:

class MyComponent extends Component {
    constructor() {
        // Lots of bindings
    }

    myHugeMethod1() {
        // Lots of logic that depends on this.props and probably other (hopefully smaller) class methods
    }

    myHugeMethod2() {
        // Lots of logic that depends on this.props and probably other (hopefully smaller) class methods
    }

    render() {
        // the render
    }
  }

Our approach

We have obviously thought about lots of things: utility functions, static methods and classes with a single method. I personally find the last one the best approach. And this is what we have agreed to be the best approach (although we are not 100% sure):

import MyHelperMethod1 from "./MyHelperMethod1";
import MyHelperMethod2 from "./MyHelperMethod2";

class MyComponent extends Component {
    constructor() {
        // Lots of bindings
        const myHelperMethod1 = new myHelperMethod1(fixedProperties);
        const myHelperMethod2 = new myHelperMethod2(fixedProperties);
    }

    myHugeMethod1() {
        myHelperMethod1.setVariableProperties(variableProperties)
        myHelperMethod1.help()
    }

    myHugeMethod2() {
        myHelperMethod2.setVariableProperties(variableProperties)
        myHelperMethod2.help()
    }

    render() {
        // the render
    }
  }

The variableProperties variable is probably an object. And probably this.props is going to be included inside of this object. It can feel odd, but that's how I do it.

How do you do it?

I want to hear about your approaches to handle these situations.

My first LeetCode problem with GoLang

David Armendáriz — Mon, 22 Feb 2021 00:40:36 +0000

Hi everyone!
I am learning Go and I find it an awesome programming language. I solved my first LeetCode problem using this language:

This is my identity number validator package (NPM)

David Armendáriz — Sun, 21 Feb 2021 15:36:27 +0000

Some time ago, I released an extremely simple project, yet extremely useful: an identity number validator package.
In my country (Ecuador) we have a simple algorithm to validate if an identity number (we call it "cédula") is valid or not. I have worked in many projects where we need to validate this, and I had to re-write the algorithm every time. So why not make it public?

https://www.npmjs.com/package/identity-number-validator

Do you have something similar in your country? If yes, would you like to contribute?

If programmers were writers...

David Armendáriz — Fri, 19 Feb 2021 02:48:39 +0000

We as programmers can learn a lot from writers.

1. The first draft has a high chance to suck

It doesn't matter if you are an expert in Django or Express or React or whatever. The first version of your code will suck. But don't worry, it's perfectly normal. And you will be refactoring that code later, won't you?

2. You have to proofread your own work

Other people proofread your work via pull requests. But you need to also proofread your code before doing that pull request! This is what I normally do. Start creating a pull request, but don't create it. Just look at the changes on those beautiful UIs in GitHub, Bitbucket or GitLab. Did you accidentally include a console.log? Don't worry, just remove it and start proofreading your work again. Start asking yourself questions. Should I move this variable to a constant? Should I move this piece of code to its own method? After you think your code is perfect, create that pull request!

3. Let others proofread your work

Ok, this one is pretty obvious. Your code needs to be reviewed before going to production right? Well, I just want to add something else here: never, ever, take a pull request personally. Pull requests are there for you to be better, not to harm your ego.

4. There will be a second or third draft

This is related to point 1. Remember I told you to refactor your code? Well, as Nike says: just do it. And if you are touching someone else's code, be that guy in the team to leave the house clean. That means, refactor other people code if necessary!

5. A finished piece is better than a perfect WIP

Again, just do it. If you are seeking perfection and never deploying code, then why are you writing code? Code will never be perfect. Just push that damn code to production already.

6. Keep a cohesive narrative

Write code as if you were writing a predictable yet exciting tale. In software development, predictable is in some sense good. You are writing your React app with class based components? That's fine. But please, don't start mixing functional components and class based components because YOLO.

Just wanted to share this with you. Bye, bye! And also, don't forget to subscribe to my channel: YouTube Channel

JavaScript Primitives have methods and properties! Wait what?

David Armendáriz — Sun, 14 Feb 2021 16:33:25 +0000

Hey guys! How are you?

Last time, I was discussing with a colleague that everything in Python was an object. Even numbers. To show this, I just did the following:

print((2).__add__(2)) # should print 4

That is, numbers have methods.
The same is true for other programming languages like Ruby.
However, in basically every other programming language (including JavaScript) we do have primitives. How do we create them? Well, with single or double quotes, like this:

let a = "foo"

If we take the type of this variable it will be of type string:

console.log(typeof a) // "string"

How do we create string objects? Like this:

let b = new String(a)
console.log(typeof b) // "object"

Thus, if we compare the values of a and b we will get:

console.log(a == b) // true
console.log(a === b) // false

As you know, the == operator will compare for equality after doing any necessary type conversions. The === operator won't do any conversion. And as a and b are of different types, then we get false.

We can also get primitives from String calls in a non constructor context. That means, called without the new keyword).

let c = String(a)
console.log(typeof c) // "string"
console.log(a == c) // true
console.log(a === c) // true

As you see, this time the === operator returns true because a and c are both primitives.

But then, why we can call methods of primitives?

Certainly, we can do something like this:

console.log(a.length) // 3
console.log(a.toUpperCase()) // "FOO"

We can get the length property of a primitive and call a toUpperCase method. Wait what? How can a primitive have properties and methods?

Well, they don't. It depends on the context.

When a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.

The same happens with the other primitives in JavaScript:

Number
BigInt
Boolean
Symbol

To get the primitive value from these objects, just call the valueOf() method. For example:

let d = b.valueOf()
console.log(a == d) // true
console.log(a === d) // true

Pretty cool!

6 things we can learn from writers

David Armendáriz — Thu, 04 Feb 2021 02:16:53 +0000

TL; DR

Your first draft always sucks
Proofread your own work
Let others proofread your work
There will probably be a second or third draft
A finished piece is better than a perfect work in progress
Keep a cohesive narrative

Sorting comparator

David Armendáriz — Tue, 02 Feb 2021 02:41:52 +0000

In Javascript, we have the sort method for arrays. If "a" is less than "b" by some ordering criterion, then we return -1. If "a" is greater than "b" by the ordering criterion, we return 1. This is the basic idea to sort things. We can do the same for Python. In this video, I solve the problem of sorting by a score in descending order and then by name in ascending order.