DEV Community: gabygalv

Death by a Million Recursions

gabygalv — Sat, 22 Apr 2023 00:27:56 +0000

Serialize rules can be an incredibly useful tool for making sure that only the necessary information is displayed in a serialized object. However, there are times when using serialize rules can lead to recursion errors.

Recursion errors occur when there is an infinite loop of serialization, where an object is being serialized repeatedly because it is a property of another object. This can happen when two objects have a many-to-many relationship and both objects contain the serialized representation of each other.

Let's look at an example,

In the case of our three tables, Pizza, Restaurant, and RestaurantPizza, we can see how recursion errors might occur. Let's say we want to serialize all the Pizza objects, but we also want to include all the Restaurant objects that have a relationship with each Pizza. We might define our serialize rules for Pizza to include the Restaurant objects:

class Pizza(db.Model, SerializerMixin): serialize_rules = ('-restaurants', '-restaurant_pizzas', '-created_at', '-updated_at')

But since Restaurant also has a relationship with Pizza, we might define our serialize rules for Restaurant to include the Pizza objects:

class Restaurant(db.Model, SerializerMixin): serialize_rules = ('-pizzas', '-restaurant_pizzas', '-created_at', '-updated_at')

This creates a recursion error because both Pizza and Restaurant are trying to include each other in their serialized representations.

To avoid recursion errors, we need to be mindful of how we use serialize rules. In some cases, we might need to exclude certain relationships altogether. In other cases, we might need to include only a subset of related objects, rather than all related objects.

In our example, we might decide to exclude the Restaurant objects from the serialized representation of Pizza:

class Pizza(db.Model, SerializerMixin): serialize_rules = ('-restaurant_pizzas', '-created_at', '-updated_at')

This way, we only include the RestaurantPizza objects that relate to each Pizza, rather than including the Restaurant objects themselves.

Alternatively, we might decide to include only a subset of the Pizza objects in the serialized representation of each Restaurant. For example, we might only include the Pizza objects that are the most popular:

class Restaurant(db.Model, SerializerMixin): serialize_rules = ('pizzas', '-restaurant_pizzas', '-created_at', '-updated_at') @property def pizzas(self): return sorted(self.pizzas, key=lambda pizza: pizza.popularity)[:3]

In this case, we define a property that returns only the three most popular Pizza objects for each Restaurant, and we include only this property in the serialized representation of each Restaurant.

By being mindful of our use of serialize rules and taking care to avoid recursion errors, we can use this powerful tool to create clean, concise serialized representations of our database objects.

Serialize rules are a powerful tool for creating serialized representations of database objects in SQLAlchemy. By using serialize rules, we can control which properties of each object are included in the serialized representation, and we can exclude properties that are not relevant or that might cause recursion errors.

In this article, we looked at an example of how to use serialize rules in SQLAlchemy to create serialized representations of three tables with a many-to-many relationship. We also discussed some best practices for using serialize rules, including being mindful of recursion errors and using properties to include only a subset of related objects when necessary.

With these best practices in mind, we can use serialize rules to create clean, concise serialized representations.

Did you say "Pythonic"?

gabygalv — Fri, 24 Mar 2023 17:56:21 +0000

Python is a popular and versatile programming language that has many features and benefits. But not all Python code is created equal. Some code follows the best practices and conventions of the Python community, while some code just gets the job done.

I'll be explaining what pythonic code is and a few ways to make your code more "pythonic".

What Does Pythonic Mean?

According to Packt Hub, Pythonic means:

When people talk about pythonic code, they mean that the code uses Python idioms well, that it’s natural or displays fluency in the language. In other words, it means the most widely adopted idioms that are adopted by the Python community.

Pythonic code is code that follows the principles and philosophy of Python, such as simplicity, readability, elegance, and expressiveness. It can also be described as code that makes the best use of the language features and the standard library.

It's not just about syntax or style, but also about logic and design. Pythonic code avoids common pitfalls and anti-patterns, such as unnecessary complexity, repetition, or "hack-y" work arounds.

How to Write Pythonic Code

Writing Pythonic code is not something that you can learn overnight. It requires practice and familiarity with the language and its idioms. Luckily, there are some general tips and guidelines that can help you improve your Python skills and write more Pythonic code.

Here are some of them:

Use List Comprehensions

List comprehensions are one of the most distinctive and powerful features of Python. They allow you to create new lists from existing iterables (lists, tuples, sets, dictionaries, etc.) in a concise way.

For example, if you want to create a list of multiples of 2 for the numbers from 1 to 10. You could do it with a for loop like this:

by_two = []
for x in range(1, 11):
by_two.append(x * 2)

This works, but a more Pythonic way to do it is with a list comprehension like this:

by_two = [x * 2 for x in range(1, 11)]

This is much shorter and clearer than the for loop version. It also avoids the inefficiency of creating an empty list and appending to it.

List comprehensions can also have conditions to filter out unwanted elements. For example, if you wanted to create a list of even squares from 1 to 10. You could do it with a list comprehension like this:

even_squares = [x ** 2 for x in range(1, 11) if x % 2 == 0]

This will only include the squares of even numbers in the new list.

List comprehensions can also be nested to create lists of lists or other complex structures. If you want to create a list of lists that represents a multiplication table from 1 to 10. You could do it with a nested list comprehension like this:

table = [[x * y for x in range(1, 11)] for y in range(1, 11)]

This will create a list of 10 lists, each with 10 elements that are the products of two numbers from 1 to 10.

You can also use list comprehension for other types of collections such as sets or dictionaries. If you wanted to create a set of unique words from a sentence. You could do it with a set comprehension like this:

sentence = "This is a sentence with some repeated words"
words = {word.lower() for word in sentence.split()}

This will create a set of lowercase words from the sentence without any duplicates.

Use built-in data structures and functions

Python has a set of built-in data structures and functions that can help you solve many common problems. You can use lists, tuples, dictionaries, sets, strings, numbers, booleans, etc. to store and manipulate data. You can also use functions like len, max, min, sum, sorted, map, filter, zip, etc. to perform operations on data.

Using built-in data structures and functions can make your code more concise, efficient and readable (some might even say.. pythonic?). Instead of writing a loop to iterate over a list and check if an element is in another list, you can use the in operator:

#bad
def check_element(element, list1, list2):
for x in list1:
if x == element:
if element in list2:
return True
return False

#good 
def check_element(element, list1, list2):
return element in list1 and element in list2

Don't we just love turning a 6 line loop into a single line? chefs kiss

Use meaningful names and consistent style

One of the most important aspects of writing readable and maintainable code is using meaningful names for your variables, functions, classes and modules. Meaningful names can help you and others understand what your code does and why. They can also help you avoid errors or bugs by making your code more self-documenting.

You should also follow a consistent style for your naming conventions. For example, you should use lowercase letters with underscores for variables and functions (my_variable, my_function), AKA snake case.

Python has quite an extensive style guide which can be found here.

Are you feeling Pythonic?

Well, now that we've all read the word pythonic 15 times and covered a few ways to improve our code we know that it's not just about following some rules or conventions, writing pythonic code is a philosophy. I'll leave you with a few of my favorite thoughts from the Zen of Python:

Beautiful is better than ugly.
Simple is better than complex.
Complex is better than complicated.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
If the implementation is hard to explain, it's a bad idea.

You can access the full Zen of Python guidelines by typing import this in your interpreter or going here.

Getting started with React

gabygalv — Thu, 09 Mar 2023 17:45:32 +0000

In the last 2-3 weeks of learning React, I've bounced around between loving it and hating it. Today I'm feeling more on the love side of the spectrum but that's not without the help of understanding a few of the core concepts of what makes React such a popular framework (or is it a library?).

Before we get into the whirlwind of React concepts, lets talk about imperative vs declarative programming.

Imperative programming: Explicitly describes the actions a program should take each step of the way and describes how a program should go about doing those actions.

Declarative programming: Describes what a program should accomplish (or what the end result should be). Leaves the determination of how to get to the end result up to the program.

Components

One of the main building blocks of React and likely the first concept to grasp is the idea of components. As opposed to Vanilla JS where your entire single page application lives on one long index.js file, React's main ideology is breaking your code up into independent components that each render separately.

Having only used Vanilla JS, the challenge for me was deciding when to create a new component and most importantly why?? Luckily, React has a great article on Thinking in React, one bit I found especially helpful was the idea of single responsibility components.

One such technique is the single responsibility principle, that is, a component should ideally only do one thing. If it ends up growing, it should be decomposed into smaller subcomponents

Read more here: Thinking in React Documentation

Let's look at the example below:

Each item is labeled as an individual component and what children components would live within them.

The parent/root component, the main responsibility of this component is to hold the header and list logic components (aka it's children)
This component's only responsibility is to display the header text
Container components are just as important in react, this components simply holds it's two children components
To-do input, accepts user input
This component is a container for the todos items
Finally, this component renders the individual to-do items

Okay.. we get React now, right? Wrong! Now that we have each of these individual components that each handle one individual part of your application.. how do you pass information through each one?

Props

Once you wrap your head around components, you start to think about data flow. Where is it coming from? Where is it going? This is where props come in to the picture, props is short for properties, individual pieces of data that are being passed in to components.

It's important to remember that props can be passed from parent to children components, but not to sibling components. Props can be objects, arrays, or even attributes, they must be passed by the parent component, and also accepted by the child component. What does that mean?

Lets say Profile is the parent component, here we're passing down 2 props to Avatar: the person object (name and imageId) and size.

Avatar is accepting person and size, and now they're available to sue in the component.

Props are read-only snapshots in time: every render receives a new version of props. So what if we have props that change based on user input? That's where State comes in!

State

State can be described as a component's memory, you can store information in state, set that information, and also give it a default value.

One simple example is, a search input:

You'll likely want the default value of of the search input to be an empty string

Once a user starts typing, you'll want to set the value of the search to the input value

Then you'll want the component to keep that input so can use that value to filter some data

Final thoughts

There are many many more concepts to consider but learning these felt like the big 3 that helped me go from hating React to kind of enjoying it! Getting used to JSX and the syntax definitely contributed to the painful journey of React but much easier to grasp!

If you're finding yourself struggling to learn React, take a look at some of their documentation here.

VS Code Shortcuts for Beginners

gabygalv — Fri, 10 Feb 2023 19:10:39 +0000

Learning to code is famously, not easy. Aside from learning new languages, you're learning to navigate a whole new toolset that you've likely never even heard of. As a beginner, using VS Code, GitHub, and even Terminal can feel like having keys to a Ferrari but you have no clue where it's parked. Frustrating, right?

Learning to take advantage of shortcuts and extensions helps streamline your process and may even result in better coding! Below I’ll be sharing some of the VS Code shortcuts I’ve found most useful as a new developer.

Full list of VS Code shortcuts: Windows/Mac.

Show/Hide Terminal

Mac: Control + `

Windows: Ctrl + `

Discovering this shortcut was what made me want to look for more shortcuts to increase my productivity. The first time I ever opened VS Code, the integrated terminal was already open but having to look for it the next time took me a few minutes.

Show/Hide Sidebar

Mac: Command + b

Windows: Ctrl + b

This shortcut is mostly a preference, you can definitely toggle the sidebar by simply clicking any of the buttons on the sidebar but I prefer not leaving my keyboard whenever possible.

Split Editor

Mac: Command + \

Windows: Ctrl + \

When writing functions that rely on syntax used in the HTML file, it's a huge time saver to be able to see both files at the same time! Using split editor not only helps speed up my coding, but also stops me from getting distracted by flipping through different tabs. Keep in mind you can add multiple tabs, my current set up for most projects is 3 editors: the ReadMe file, Javascript file, and an HTML or CSS file.

Word Wrap

Mac: Option + z

Windows: Alt + z

Another very easy fix to an annoying newbie issue. Typing out pseudocode really helps me to problem solve and decide what to code next. Doing so (especially with split editors) can get messy quickly, using word wrap solves this pesky nuisance! Don't quote me on this but I believe you only need to set this option once, and it should stick as your default setting.

Find and Replace

Mac: Command + f

Windows: Ctrl + f

This one took me a surprising amount of time to discover.. it's my go-to for skimming articles and when using word editors, but I didn't automatically assume it would be a function of a code editor! Incredibly helpful for typos or renaming multiple elements at once, as shown in the gif above.

Multiple cursors

Mac: Option + Right-click

Windows: Alt + Right-click

Being able to add multiple cursors is an invaluable tool! Sometimes find and replace isn't exactly what you need, if you're looking to make just a few h2 elements into h3, you wouldn't want to replace all of them but you can highlight the ones you need and replace the select few at the same time.

Duplicate Line

Mac: Shift + Option + up/down

Windows: Shift + Ctrl + up/down

When you're writing code that is repetitive, or adding multiple list items as shown above, being able to duplicate a line is so nice! It can help prevent syntax errors or simply save your fingers from extra typing. As long as your cursor is on the line you want to duplicate, this shortcut will take care of the rest.

Zen Mode

Mac: Command + k then z

Windows: Ctrl + k then z

Zen mode removes all distractions from your editor and shows you your code full screen (including any split editors you might have). I've found this useful when I'm really trying to focus or debug tricky code. To exit zen mode, simply hit ESC.

Open shortcuts

Mac: Command + k then Command + s

Windows: Ctrl + k then Ctrl + s

Finally, if you want to see all of the shortcuts available in VS Code and don't want to go searching for the PDFs (linked here) you can simply use this command within the program and browse what's available to you! You can even edit the pre-programmed shortcuts and add your own.