DEV Community: Jessica Alves

Editing a message of a pushed commit

Jessica Alves — Fri, 04 Aug 2023 20:27:33 +0000

This is a quick post for those situations where you just pushed a commit to your branch and then realized the commit message is not clear, or there's some misspelling. Whatever is the reason you want to edit it, here are two quick steps.

Make sure you're in the intended branch and first run:

git commit --amend -m "Your new commit message"

Then run:

git push --force

Done.

If you run git log you'll be able to check your updated commit message.

Don’t amend public commits
"Amended commits are actually entirely new commits and the previous commit will no longer be on your current branch. This has the same consequences as resetting a public snapshot. Avoid amending a commit that other developers have based their work on. This is a confusing situation for developers to be in and it’s complicated to recover from."
(Atlassian's tutorial)

See more

Read the GitHub docs for more information or this tutorial from Atlassian.

My experience deploying a Next.js application on Netlify (using Next App Router)

Jessica Alves — Thu, 29 Jun 2023 21:59:36 +0000

My motivation to write this article

A few weeks ago I built a Next.js application and deployed it on Netlify.
I enjoyed working with Next.js but a few issues came up after the deploy on Netlify - main issues that will definitely be considered for future projects - and I decided to share them with the community in case someone’s been facing similar problems. So feel free to comment and share any thoughts/suggestions that can help me to have a better understanding of these issues :)

I had already created the project using the Pages Router when I decided to create a layout component and other server side components, and then I realized that the new App Router would be a better approach for what I was building. The App Router (or app directory) is still in experimental stages so clearly there’s a list of improvements to be done. But since I believe the idea is at some point having the old pages directory overridden by the app directory in a near future - so it made even more sense to me to use its latest features instead of sticking to the old pages router.

So I made the migration to the App Router and deployed on Netlify. Well, a few “surprises” along the way. Here are the challenges I faced.

Issue #1: 500 Internal Server Error

After migrating from Pages to App Router and deploying on Netlify that was the first issue I got. When trying to access specific URLs typing them directly instead of accessing them by navigating on the interface and clicking on the respective links, I started to get a 500 error. Or if I refreshed that page I also got the error. All the rest was working fine apparently but when trying to debug I found this discussion on Netlify Support forum describing a possible cause for what I was getting. After implementing the workaround suggested by the community, which is a prebuild script to set the env var __NEXT_PRIVATE_PREBUNDLED_REACT, the 500 error was gone.

It's not clear for me yet if the issue is related to Next.js, Netlify or even to React (see the discussion here).

Issue #2: Trailing Slash

Next.js has a trailingSlash option in next.config.js which we can set to true so that the URLs without trailing slashes are redirected to their counterparts with trailing slashes. And that worked for me running locally, it worked building locally, but it didn’t work properly when I deployed the application on Netlify. Even setting the trailingSlash option to true in Next.js and having the 'Pretty URLs' enabled on Netlify, it didn’t work for me for all pages. So I started to search about the issue and figured out that other people were having the same issue on Netlify and making a long story short: "it's a behaviour resulting from the logic on the Netlify CDN aimed at keeping site performance high by maximizing the cache hit rate".

So adding an edge function was the only workaround I found. Apparently it's an issue they're working on and I think it should be set as high priority since trailing slashes matter for SEO.

UPDATE: Netlify solved the issue on v5 release of Next.js runtime.

Issue #3: The 'prefetch' issue when using Next Link

This was from far the most annoying issue I faced during this project. Not only spent hours trying to debug and figure out what exactly was going on but also couldn’t find related issues or someone describing exactly the same issue I was having. Except for this discussion here that helped me a lot to understand on how to reproduce the bug. So basically I was on the home page and after clicking on a link, going to another page, clicking to go back to the home page, I was being kicked to the previous page that I just clicked after scrolling the home page. And I was so sure it was related to scrolling the page that it took me a long time to figure out that what was actually triggering the kicking behaviour was hovering any Next Link (or showing a Next Link in the viewport as I saw later in the Github discussion I found).

After many different tries I disabled the prefetch for all Next Links and that made the problem go away. But since I wasn't sure about the side effects of having prefetch={false} for the Next Links I decided it wasn't a viable solution. So I gave up on that approach and ended up removing the generateStaticParams for one of my page components. Issue was gone as well as generating static pages for that component on the server side which made me rethink about the point of using Nextjs. 😑

Issue #4: Preloaded CSS files not used within a few seconds

When importing a font from 'next/font/google' and using it in the layout component, the console in the browser starts triggering several warnings - and I mean it: several - saying 'The resource <URL> was preloaded using link preload but not used within a few seconds from the window's load event. Please make sure it has an appropriateasvalue and it is preloaded intentionally'. I realized removing the mentioned import made the warning go away. The warning was coming not only in dev but also in prod environment. And you can also find it on Next.js website, if you open the console you'll see the warnings coming. So I found a discussion on GitHub and an open issue related to it. Apparently there's no solution for that yet but I believe they're working on it considering the open issue progress.

My final impression and considerations

After all that buggy journey I found myself at the final week of the project rethinking my decision about migrating to the Next App Router. Or using Netlify instead of Vercel. And it's been a bit frustrating to be honest because I thought creating this simple application would be a smooth journey - and perhaps it would have been if the decisions along the way had been different. Because of all that I'm not sure if I'll use Nextjs + Netlify while the App Router is still in experimental stages. Or maybe not even to consider using the two technologies together in another project again.  I had a great time learning and using Next.js but there's still a lot to be improved for the App Router and maybe it's more reliable to use it only when deploying on their ecosystem (Vercel), at least for now.

Using `git bisect` to find the faulty commit

Jessica Alves — Sat, 13 May 2023 21:46:21 +0000

Introduction

Yesterday I was working on a task and I made changes in a few files. When committing the changes, right before pushing them to a remote branch, I added a couple of more small changes, created a few more commits and done, pushed all the commits. When running the application again I got an error, which I couldn't identify which of the changes or commits was related to.
And that's when git bisect came across while I was trying to debug.

What does the `git bisect` command do?

git bisect is a command in Git that helps find the commit that introduced a bug or caused a regression in your codebase. It uses a binary search algorithm to efficiently narrow down the range of commits to be examined. By marking specific commits as “good” or “bad”, git bisect automatically selects the next commit for testing until it identifies the exact commit that introduced the issue. This process helps identify the faulty commit more quickly and efficiently, enabling developers to pinpoint and fix the problem more effectively.

An example on how to use it

Using the GitLens extension in VSCode I picked one of the previous commits guessing it didn’t contain any errors (you can use git log to do that as well), and to make sure it was working fine I checked out to that commit and ran the application from that point, checking if the error was there or not. Once it hasn’t any errors I decided to pick that commit to start to bisect.

So I started the git bisect with the flawed commit id - which was my last commit - to indicate it’s a bad commit:

git bisect start <flawed_commit_id>

Git will mark it as a bad commit and then expect for the id of a good commit. So I copied and pasted the id of that commit I ran previously to make sure it wasn’t broken in order to run the following command:

git bisect good <good_commit_id>

Git will now automatically checkout a commit in the middle of the range between the known good commit and the bad commit. This commit represents the midpoint of the binary search. So I was able to run my application using the returned commit to test if the application was already crashed or not, so that I could tell Git to mark the commit as good or bad using git bisect good or git bisect bad.

Repeat the process: Git will continue selecting commits for testing based on the binary search algorithm. You repeat the previous step by testing the code and telling Git to mark it as good or bad commit until you narrow down to the exact commit that introduced the bug.

Finish the bisect: Once you identify the faulty commit, you can run git bisect reset to exit the bisect mode and return to the latest commit.

Conclusion

By systematically cutting down the range of commits through binary search, git bisect helps efficiently locate the faulty commit in your code history.

Array.sort(): defining the sort order

Jessica Alves — Sun, 26 Mar 2023 23:41:10 +0000

The sort() method in JavaScript

"The sort() method sorts the elements of an array in place and returns the reference to the same array, now sorted. The default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.", according to MDN Documentation.

Defining the sort order

Let's say you want to sort some data, a list of users for example, based on the status of each user (if they're online or offline), and based on the alphabetical order of the user's first name and last name, in that order respectively.

type User = {
  firstName: string,
  lastName: string,
  status: 'online' | 'offline'
}

const users: User[] = [
  { firstName: 'Rafael', lastName: 'Nadal', status: 'online'},
  { firstName: 'Fernando', lastName: 'Alonso', status: 'offline'},
  { firstName: 'Daniel', lastName: 'Ricciardo', status: 'online'},
  { firstName: 'Daniel', lastName: 'Brühl', status: 'online'},
];

To do that we can use an optional sort() parameter compareFn which takes a function as an argument to define the sort order. This function has two parameters (a and b) that take the two elements of comparison as arguments. The return value r depends on the comparison result between the elements, according to the following logic:

// r > 0 if a > b
// returns a number greater than zero if a > b

// r = 0 // a === b
// returns zero if a === b

// r < 0 // a < b
// returns a number less than zero if a < b

So if we want to write a function to sort our list considering the two mentioned elements (status and alphabetical order), we could write something like this:

const sortUsersByStatusAndName = users.sort((a, b) => {
  if (a.status === b.status) {
    if (a.firstName === b.firstName) {
      return a.lastName.localeCompare(b.lastName);
    }
    return a.firstName.localeCompare(b.firstName);
  }
  if (a.status === 'online') {
    return -1;
  }
  return 1;
});

console.log(sortUsersByStatusAndName);

/* expected output:
[{
  "firstName": "Daniel",
  "lastName": "Brühl",
  "status": "online"
}, {
  "firstName": "Daniel",
  "lastName": "Ricciardo",
  "status": "online"
}, {
  "firstName": "Rafael",
  "lastName": "Nadal",
  "status": "online"
}, {
  "firstName": "Fernando",
  "lastName": "Alonso",
  "status": "offline"
}] 
*/

Note that we want to sort by bringing first all the online users (in alphabetical order), and finally the offline users (in alphabetical order as well).

Using uuid in Knex.js and PostgreSQL

Jessica Alves — Fri, 17 Mar 2023 19:44:03 +0000

I've been working on a personal project using Node.js and PostgreSQL. I also decided to use Knex.js (a SQL query builder) to run migrations and build schemas. So when creating a table which I wanted to replace a simple incremental id with uuid I had to search a little bit more than just reading Knex and Postgres documentation. I found a few comments on GitHub issues and Stack OverFlow answers that were very helpful and decided to share this short post in case someone faces the same situation.

Scrolling the documentation

So that's the relevant piece of documentation from Knex related to using uuid when creating a schema in Knex migrations:

Although there is no example of how to use it, I also found the documentation related to the uuid-ossp extension in Postgres, which has a function called uuid_generate_v4(). And that's the extension and function you should use to write your schema in Knex when creating a table that has an uuid column.

How to use it

So after creating a new Knex migration, let's say you want to create a new table whose primary key will be a uuid column.
Here's an example of how to do it:



import { Knex } from "knex";

export async function up(knex: Knex): Promise<void> {
    await knex.schema.raw('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"')
        .createTable("table_name", (table) => {
            table.uuid("id", {primaryKey: true}).defaultTo(knex.raw("uuid_generate_v4()"));

//scheme continuation...

    });
}

Note: as stated in Knex documentation you can set the useBinaryUuid to true so that binary(16) is used instead of the default char(36).
Like that:



table.uuid("id", {primaryKey: true, useBinaryUuid: true}).defaultTo(knex.raw("uuid_generate_v4()"));

Also note that the notNullable() is not necessary in this case since we're setting the primaryKey option to true, which in Postgres doesn't allow nullable values.

Abstraction, reusability and flexibility in software design

Jessica Alves — Tue, 14 Mar 2023 14:51:32 +0000

These three concepts are very important to keep in mind as well as good practices to have when it comes to software design. In programming we should be always trying to increase the level of all these design principles when writing code.

Abstraction

Abstraction is the opposite of concrete. So trying to increase the abstraction of your code means trying to keep it as generic as possible in terms of complexity and readability. Abstracting code can make it easier to read and understand, as it can help to eliminate unnecessary details and focus on the core functionality.

Below is an example of a not very abstract code vs a more abstract code. Let's say you want to calculate the area of a rectangle.

# not very abstract code
length = 10
width = 5
area = length * width
print(area)

# more abstract code
def calculate_area(length, width):
    area = length * width
    return area

print(calculate_area(10, 5))

So keeping the code abstract helps to make it more modular, readable, maintainable, reusable and flexible.

Reusability

Reusability refers to the ability to reuse existing code in different contexts, rather than writing new code every time a similar task needs to be performed. Reusable code saves time and effort (which in turn increases productivity in most cases), facilitates collaboration once you're not the only one that can reuse the code, and avoids code repetition.

As an example we can think in a visual component such as a React component that will be used in many different pages or components. The idea is to make this component just once and reuse it wherever is needed, right? So keeping the code reusable also helps to make it more modular and maintainable since if a change is requested you can change it in just one place, in one piece that will reflect in the other pieces that are being reused.

Flexibility

The idea here is trying to go against practices that make your code highly coupled and trying to make good use of the previously mentioned practices above, because they are also responsible for increasing the code's flexibility. This one allows us to make changes to software without having to completely rewrite it from scratch, which saves time and effort especially when there are new user needs or new business requirements. It's an important aspect of programming that can help ensure that software remains adaptable, scalable, integrable, maintainable, and user-friendly over time.

Good practices to increase the flexibility of your code: avoiding hard-coded code (which means using variables and constants), using functions to help modularize the code, increasing the cohesion, increasing the abstraction and the reusability as mentioned above.

Conclusion

In software design, abstraction, reusability, and flexibility are closely related concepts that are essential for building high-quality, scalable, adaptable and maintainable software.

Cohesion in software design

Jessica Alves — Sun, 12 Mar 2023 00:59:54 +0000

What is cohesion in programming?

Cohesion in software design is a term used to describe the degree to which the elements of a module or component are related to each other and serve a common purpose. In simple words is keeping related things together and unrelated things out.

Usually in programming you want to increase cohesion. And what does that mean? It means when designing a program if you organize the code in a high cohesive way it's much better to manage it, finding the source of bugs and locate what you want based on the functionalities organization you defined.

For example, let's say you create two different modules or components and each of them is responsible for a different functionality in your program. So increasing the cohesion of your software would be to concentrate everything related to a specific functionality within the module or component responsible for that functionality.

In small programs the cohesion might not seem so relevant but as the scale changes and the code becomes larger, so does the importance of having a cohesive code. Keeping the cohesion in your code is also an important habit even when writing small pieces of code such as naming a function or a variable that is related to what the function actually does or to what the variable actually stores.

Once cohesion can exist in many different levels that can be related based on distinct criteria, following are some examples of different types of cohesion.

Types of cohesion

The types are ordered by strength or weakness of cohesion forms, with the strongest at the top of the list and the weakest at the bottom of the list.

Functional: this one is related specifically to functions and it comes to writing functions with no side effects. An example of that is writing functions respecting the function scope and not using global keywords, such as global variables. This is the highest level of cohesion and is generally considered to be the most desirable.
Layer: this type of cohesion refers to the situation where elements are organized into layers or tiers. It's often used in software design to organize complex systems into manageable parts, where each layer is responsible for a specific aspect of the system's functionality and it has its related services. For example, the concept of having models, views and controllers in a program can be considered layer cohesion, once we have a strong hierarchy between each layer where high level features access low level features, never the opposite - it's a one way flow.
Communicational: what acts on the same data should be kept together, so the elements are related by the data they share. An example of that are classes or instances of a class, and they all have methods acting on the same data.
Sequential: this type of cohesion occurs when elements are arranged together in a specific order and depend on each other to complete a task. The output of one element is typically the input to the next element. An example of that could be processing some data before using it (such as a big text block or a spreadsheet of numbers), and let's say that requires many steps of data treatment and formatting. So the result of each step is an input for the next.
Procedural: this case is similar to sequential once the elements are related by the sequence in which they are executed, but they do not necessarily perform a single, well-defined computation. They're not necessarily working on the same data (as in the sequential example) yet the procedures order is still relevant and the reason why we should group them all together.
Temporal: this is considered a weaker form of cohesion (in comparison to the previous ones) and the elements are related by the time at which they are executed. For example,
Utility: finally when you have some unrelated code and it's hard to find some relation to group them, you can try to group them by utility, which means if they don't have anything in common and they're not directly related to anything or to each other, so this is already something they have in common. So you can group them, such as helper functions you group in a utils file.

Conclusion

Cohesion in software design can exist on many different levels (such as modules, classes, files, functions, etc) and have different types depending on the criteria that was chosen to relate them.

A high cohesion is an important aspect of creating maintainable, reusable, and understandable code.

Divide and Conquer approach

Jessica Alves — Sat, 11 Mar 2023 15:24:57 +0000

Image from Unsplash

Breaking the problem into smaller pieces

The idea behind the divide and conquer concept is breaking down a problem into smaller sub-problems, solving each sub-problem independently, and then combining the solutions to obtain the final solution to the original problem. The concept is based on the idea that if we can break down a problem into smaller pieces, it becomes easier to solve each sub-problem individually.

Divider and conquer algorithm

This technique is useful and powerful for solving problems that are too large or complex to solve using traditional brute-force methods. By dividing the problem into smaller sub-problems, we can reduce the amount of computation needed to solve the problem, making it more manageable.

So it's more efficient in comparison to brute-force methods and it's usually easier to understand and maintain. It can also be used to solve a wide variety of problems, from simple sorting problems to complex optimization problems. Some well-known algorithms are based on the divide and conquer approach, such as sorting algorithms and binary search.

The steps in a practical example

Let's say we want to sort an array of integers whose length can be a very large number. We can use a sorting algorithm to do that. Once this algorithm is based on the divide and conquer approach, the main steps would be:

Dividing the problem into smaller sub-problems: finding the base case, breaking the input into subarrays (sub-problems) instead of trying to sort a long array (original problem) at once. In other words, finding smaller instances of the same problem.
Conquering the sub-problems: sorting the subarrays recursively.
Combining the solutions to the sub-problems: merging the sorted subarrays in a sorting problem to get the final sorted array.

Conclusion

Divide and conquer approach is a powerful technique that can be used to solve complex problems efficiently.

A short explanation of compilers and interpreters in Python code

Jessica Alves — Thu, 02 Mar 2023 17:12:54 +0000

Introduction

Compilers and interpreters are part of the implementation of a programming language, and compilation and interpretation are two stages that make up the code execution process. This article is about compilers and interpreters in Python context.

What is a compiler?

It's a program that takes your code (the code you, human, wrote it), a high level language, and turns it into another language, in Python's case, into bytecode (or a lower level language). Compilers are going to make sure the syntax of your code is correct, that it's formatted properly, that Python's indentation is perfect. Once all checks are done, that means the code is translated and compilers are making sure the code is ready to be run and executed by the interpreter.

And what is an interpreter?

It's a program that will read the compiled code and execute it line by line. In summary, the interpreter is also converting the compiled code into a language that CPUs can understand so that your code can be executed and run by the machine. It translates code into target machine code during execution. Or in simple words, the interpreter is enabling your code to be run.

Compilation errors x runtime errors

Compilation errors are errors that happen during the compilation stage, the first stage I described above. That means while the compiler was trying to "translate" your code to bytecode it found an error, e.g. syntax errors, formatting errors or indentation errors, so it crashes.

The runtime errors happen during the interpretation stage, the second stage I described above. They are errors that happen during the execution process of the code, e.g. errors in the logic of a function, or logic errors in an if statement, or zero division errors, or type errors (trying to divide an integer by a string), etc.

Conclusion

The process described above is usually what happens for most modern languages, including Python. You can find some differences like in Java ou C++, where the compilation stages are much more complex and advanced than in Python. That's why you hear people saying that Java and C++ are compiled languages and Python is an interpreted language. That doesn't mean Python doesn't have a compilation step, but in Python most of the effort is being done during the interpretation stage.

LeetCode Daily Challenge: House Robber solution using dynamic programming

Jessica Alves — Fri, 16 Dec 2022 13:00:25 +0000

Introduction

This is an article to discuss a LeetCode challenge solution.
If you want to see the full challenge description with examples click on the following link:
198. House Robber

The problem

"You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police."

Using dynamic programming over recursion

I first solved this problem using a recursive function. However when submitting the solution there was a time limit exceeded for longer inputs. So I had to optimize my solution using dynamic programming. My recursive solution looks like this:

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]
        return max(nums[0] + self.rob(nums[2:]), self.rob(nums[1:]))

The solution above consists on checking and treating the base cases (when there is no houses to rob or when there's only one house in the list) and, if the list includes more than one house, we get the max amount between including the first house and not doing it.

When using dynamic programming to optimize the solution above, the logic behind it consists of creating a table which we can store the max amount for each position from start to the Nth position (we're gonna call this variable moneyBag). So we iterate over the input list and for each iteration we calculate the max amount the robber can get from the first position until that current position. To do that we need to consider the max amount from start to two houses (positions) before the current position, and the max amount from start to the previous position. To calculate the max amount for the current position we get the max between the max from two positions before plus the current value and the max from the previous position.
The max possible amount the robber can get will be last element of the moneyBag.

class Solution:
    def rob(self, nums: List[int]) -> int:
        moneyBag = [0, 0]
        for num in nums:
            moneyBag.append(max(num + moneyBag[-2], moneyBag[-1]))

        return moneyBag[-1]

If you want to optimize even more this solution you can replace the moneyBag list with two variables (here we're gonna call them bag1 and bag2) once we're only using the two previous positions in each iteration.

class Solution:
    def rob(self, nums: List[int]) -> int:
        bag1 = 0
        bag2 = 0
        for i, num in enumerate(nums):
            currentBag = max(num + bag1, bag2)
            bag1 = bag2
            bag2 = currentBag

        return bag2

The runtime complexity for this last solution is O(n) and the space complexity is O(1) which makes it the optimal solution.

LeetCode solution: Determine if Two Strings Are Close

Jessica Alves — Fri, 02 Dec 2022 17:45:58 +0000

Introduction

I was developing a solution for LeetCode today's challenge and decided to write this article to present a Python solution for the problem: 1657. Determine if Two Strings Are Close.

The problem

"Two strings are considered close if you can attain one from the other using the following operations:
Operation 1: Swap any two existing characters.
For example, 'abcde' -> 'aecdb'.
Operation 2: Transform every occurrence of one existing character into another existing character, and do the same with the other character.
For example, 'aacabb' -> 'bbcbaa' (all a's turn into b's, and all b's turn into a's).
You can use the operations on either string as many times as necessary.
Given two strings, word1 and word2, return true if word1 and word2 are close, and false otherwise."

Check the link in the Introduction section if you want to see the complete problem statement with examples.

Note

Reading the problem statement might lead you to think that you need to implement the two operations to solve the challenge. However there are a few checks you can do instead of starting to implement and execute the operations described in the problem statement.

What to check to solve the problem

The first check is simple and easy: you need to make sure both strings word1 and word2 have the same length as neither operation would work correctly if they had different lengths.

The second check is: you need to check if the occurrences of each characters frequency are the same for both strings.
For example, word1 = 'aabbcccc' and word2 = 'aabcbcaa' have the same number of occurrences in their character frequencies or, in other words, the same frequency of frequencies:

    # word1
    # chars frequency:
    {'c': 4, 'a': 2, 'b': 2}
    # frequency of frequencies:
    {2: 2, 4: 1}

    # word2
    # chars frequency:
    {'a': 4, 'b': 2, 'c': 2}
    # frequency of frequencies:
    {2: 2, 4: 1}

The third and last check is that all existing characters in one string must also exist in the other string.
For example, word1 = 'aabbzzzz' and word2 = 'aabcbcaa' attend the second check related to the chars frequency. However the strings are not composed of the same characters ('z' doesn't exist in word2 just as 'c' doesn't exist in word1) and this is something that none of the operations described in the problem statement can solve.

My first solution

Following is the first solution I wrote to solve the problem:

class Solution:
    def closeStrings(self, word1: str, word2: str) -> bool:        
        dict1 = dict()
        dict2 = dict()

        if len(word1) == len(word2):
            for char in word1:
                dict1[char] = dict1.get(char, 0) + 1
            for char in word2:
                dict2[char] = dict2.get(char, 0) + 1

            return sorted(dict1.values()) == sorted(dict2.values()) and set(dict1) == set(dict2)

        return False

Cleaning up and optimizing the solution

I did a few optimizations and also cleaned the code a little bit including the Counter module in my solution and tried to replace the sorted (which turns the complexity of the code into a nlog(n)) with some other way to improve the runtime complexity.
So I managed to optimize a little bit by rewriting it like this:

from collections import Counter

class Solution:
    def closeStrings(self, word1: str, word2: str) -> bool:        
        dict1 = Counter(word1)
        dict2 = Counter(word2)

            return (
                len(word1) == len(word2) and 
                Counter(dict1.values()) == Counter(dict2.values()) and 
                set(dict1) == set(dict2)
            )

And if you want to go a little further and try to turn the solution into something even shorter, you can try this:

from collections import Counter

class Solution:
    def closeStrings(self, word1: str, word2: str) -> bool:           
        return (
            len(word1) == len(word2) and
            Counter(Counter(word1).values()) == Counter(Counter(word2).values()) and
            set([*word1]) == set([*word2])
        )

Doing those changes improve the code runtime complexity which now is O(n).

Conclusion

To see more details about runtime and space complexity check out this same solution published on LeetCode The Hard Way.

A short summary of my first Hacktoberfest 🎃 🎉

Jessica Alves — Fri, 04 Nov 2022 17:02:44 +0000

Hacktoberfest ended earlier this week and it was the first time I registered for the challenge as well as the first time I made open source contributions. This post is for all open source beginners contributors :)

Where I found projects to contribute 👾

There's not much of a secret on how to find open source projects to contribute. Probably many of the softwares and technologies you use are open source and you can pick one of them to contribute. Specifically for Hacktoberfest challenge you can search for "hacktoberfest" or "hacktoberfest-2022" topic on GitHub Topics page.

One of the effective ways I've also found to search for projects to contribute was the Hacktoberfest Discord channel. I think this option was even better than the first one because there were so many people sharing their projects - from small projects to bigger ones - and looking for contributors.

Contributing to open source for the first time 🌱

As I said that was my first time contributing to open source. And that can be kinda intimidating at first especially because in almost all cases you're not familiar with the project and the code. Or even when you want to contribute to a repository because you use or like the product but you never used the programming language they've chosen to write their code. Or you just find open issues that are not good first issues.
All that can make the experience seem even more intimidating, but you can start contributing to super easy and simple tasks such as translations and documentations. And this is what I did.

I found a few repos needing Portuguese translations and made my first contribution. Then I also found a cool repository whose purpose is to contain all possible solutions to LeetCode challenges so I decided to contribute writing a few solutions while learning to solve such problems.
Then I contributed to a few more projects from creating PR template to doing more translations. Simple but still a contribution :)

My impressions and learnings from this experience 💭

Overall the experience of contributing was very positive. And it made me feel motivated to do it more often and not just during October. The event organization was good, the Discord channel was very helpful as I said already. I know that the motivation of many people comes from getting the swags, t-shirts, stickers, etc. But for me it was more about doing it for the first time. In my opinion the Holopin's digital badges were a nice idea of a simple effort recognition and progress tracking. You can find more about Holopin badges in this post: Introducing Holopin - The Digital Badge Platform for Developers.

Aside from all the positive matters related to the experience, the only note I would make is: don't get frustrated if your PR is not approved in time to complete the challenge. I mean some of the contributions I made in addition to those required to complete the challenge were approved after the challenge ended and one of them hasn't been reviewed yet. Not all repositories have maintainers that can dedicate a lot of time reviewing all PRs and issues so be patient. Everyone is doing their best to contribute ;)

The experience was really nice and for those who have never participated, or never contributed to open source I strongly recommend that you do. Looking forward to the next one!

DEV Community: Jessica Alves

Editing a message of a pushed commit

See more

My experience deploying a Next.js application on Netlify (using Next App Router)

My motivation to write this article

Issue #1: 500 Internal Server Error

Issue #2: Trailing Slash

Issue #3: The 'prefetch' issue when using Next Link

Issue #4: Preloaded CSS files not used within a few seconds

My final impression and considerations

Using `git bisect` to find the faulty commit

Introduction

What does the git bisect command do?

An example on how to use it

Conclusion

Array.sort(): defining the sort order

The sort() method in JavaScript

Defining the sort order

Using uuid in Knex.js and PostgreSQL

Scrolling the documentation

How to use it

Abstraction, reusability and flexibility in software design

Abstraction

Reusability

Flexibility

Conclusion

Cohesion in software design

What is cohesion in programming?

Types of cohesion

Conclusion

Divide and Conquer approach

Breaking the problem into smaller pieces

Divider and conquer algorithm

The steps in a practical example

Conclusion

A short explanation of compilers and interpreters in Python code

Introduction

What is a compiler?

And what is an interpreter?

Compilation errors x runtime errors

Conclusion

LeetCode Daily Challenge: House Robber solution using dynamic programming

Introduction

The problem

Using dynamic programming over recursion

LeetCode solution: Determine if Two Strings Are Close

Introduction

The problem

Note

What to check to solve the problem

My first solution

Cleaning up and optimizing the solution

Conclusion

A short summary of my first Hacktoberfest 🎃 🎉

Where I found projects to contribute 👾

Contributing to open source for the first time 🌱

My impressions and learnings from this experience 💭

What does the `git bisect` command do?