Forem: Marcelo Pena

Shading in Google Docs: Complete Guide

Marcelo Pena — Thu, 06 Feb 2025 22:34:05 +0000

Google Docs offers several shading options to customize your documents, improve readability, and highlight important information. This article explores the eight main types of shading available, including where to find them in the menu and the corresponding keyboard shortcuts.

1. Page Background Color

This option changes the background color of the entire page, useful for differentiating documents or enhancing visual presentations.

Where to find:

Menu: File > Page Setup > Page Color
Shortcut: There is no specific shortcut

Example:

2. Text Background Color

This option allows you to apply shading directly behind the selected text, helping to highlight important information.

Where to find:

Menu: Toolbar > "Highlight Color" icon (marker symbol)
Shortcut: Ctrl + Alt + H

Example:

3. Paragraph Shading Background Color

Unlike text shading, this option adds a colored background to the entire paragraph.

Where to find:

Menu: Format > Paragraph Styles and Spacing > Background Color
Shortcut: There is no specific shortcut

Example:

4. Table Background Color

This option applies shading to an entire table, helping to visually organize information.

Where to find:

Menu: Format > Table > Table Properties > Table Background Color
Shortcut: There is no specific shortcut

Example:

5. Specific Cell Shading in Tables

This feature allows you to highlight individual cells within a table with different colors.

Where to find:

Menu: Table > Cell Properties > Background Color
Shortcut: There is no specific shortcut

Example:

6. Border Shading (in paragraphs, tables, or cells)

This feature lets you color the borders of elements like paragraphs and tables for a more structured visual effect.

Where to find:

Menu: Format > Borders and Shading
Shortcut: There is no specific shortcut

Example:

7. Image or Shape Shading

This option adds shadow effects to highlight images or shapes inserted in the document.

Where to find:

Menu: Insert > Drawing > Select Image/Shape > Shadow Options
Shortcut: There is no specific shortcut

Example:

8. Text Box Shading

When you insert a text box in Google Docs, you can apply shading to the background of the text.

Where to find:

Menu: Insert > Drawing > Text Box > Background Color
Shortcut: There is no specific shortcut

Example:

These shading options in Google Docs allow you to customize your documents and enhance the visual presentation of your information. Experiment with the different possibilities to make your texts more organized and attractive!

MapReduce Simplified: Understand Distributed Processing with the Same Logic as SQL

Marcelo Pena — Sun, 02 Feb 2025 21:58:24 +0000

MapReduce Simplified: Understand Distributed Processing with the Same Logic as SQL

If you’ve worked with relational databases, you're probably familiar with operations like SELECT, GROUP BY, and JOIN. These operations are powerful for manipulating and analyzing structured data. But what happens when the data is so large it doesn't fit on a single server? This is where MapReduce comes in: a programming model that allows for processing large volumes of data in a distributed manner. And guess what? The logic behind MapReduce isn’t much different from the queries you’re already writing in SQL!

In this article, we’ll break down MapReduce and show you how it can be understood with the same mindset you use when writing SQL queries. Let’s dive in!

1. The MAP Step: Similar to SELECT

In SQL, the SELECT operation allows you to choose and transform data from a table. In MapReduce, the Map step does something similar: it takes input data, processes each record, and emits key-value pairs.

Consider the following sample dataset:

Salesperson	Sale Amount	Department
John	100	Electronics
Mary	200	Clothing
Peter	150	Electronics
Anna	300	Clothing
John	50	Electronics
Mary	100	Clothing

If we want to select the salesperson's name and sale amount in SQL, we would write:

SELECT salesperson, sale_amount FROM sales;

Result:

Salesperson	Sale Amount
John	100
Mary	200
Peter	150
Anna	300
John	50
Mary	100

In MapReduce, the Map step does the same thing: it processes the records and emits key-value pairs. The Map function in pseudocode would look like this:

def map(record):
    salesperson = record['salesperson']
    sale_amount = record['sale_amount']
    emit(salesperson, sale_amount)

Map Output:

('John', 100)
('Mary', 200)
('Peter', 150)
('Anna', 300)
('John', 50)
('Mary', 100)

2. The REDUCE Step: Similar to GROUP BY + Aggregation

In SQL, the GROUP BY operation groups data and allows you to apply aggregation functions like SUM(), COUNT(), or AVG(). In MapReduce, the Reduce step receives the key-value pairs from Map, groups them, and performs a final operation, like summing the values.

For instance, if we want to calculate the total sales per salesperson in SQL, we would write:

SELECT salesperson, SUM(sale_amount) AS total_sales
FROM sales
GROUP BY salesperson;

Result:

Salesperson	Total Sales
John	150
Mary	300
Peter	150
Anna	300

In MapReduce, the Reduce step would look like this (in pseudocode):

def reduce(salesperson, values):
    total_sales = sum(values)
    emit(salesperson, total_sales)

Reduce Output:

('John', 150)
('Mary', 300)
('Peter', 150)
('Anna', 300)

3. MapReduce with Grouping by Department

Now let’s group the sales by department and calculate the total sales per department. In SQL, we would write:

SELECT department, SUM(sale_amount) AS total_sales
FROM sales
GROUP BY department;

Result:

Department	Total Sales
Electronics	300
Clothing	600

In MapReduce, the process would look like this:

MAP Step

First, we emit key-value pairs where the key is the department and the value is the sale amount.

def map(record):
    department = record['department']
    sale_amount = record['sale_amount']
    emit(department, sale_amount)

Map Output:

('Electronics', 100)
('Clothing', 200)
('Electronics', 150)
('Clothing', 300)
('Electronics', 50)
('Clothing', 100)

REDUCE Step

Then, we sum the values for each department.

def reduce(department, values):
    total_sales = sum(values)
    emit(department, total_sales)

Reduce Output:

('Electronics', 300)
('Clothing', 600)

4. How MapReduce Works in a Distributed Way

Now, imagine that the data is too large to fit on a single server. MapReduce allows us to split the data across multiple servers and process it in parallel.

Example: Let’s split the sales between two servers.

Server 1:

Salesperson	Sale Amount
John	100
Mary	200
John	50

Server 2:

Salesperson	Sale Amount
Peter	150
Anna	300
Mary	100

Step 1: MAP Step (in parallel)

Each server processes its data locally and emits key-value pairs.

Server 1:

John → 100
Mary → 200
John → 50

Server 2:

Peter → 150
Anna → 300
Mary → 100

Step 2: Shuffle and Sort

The data is shuffled and sorted so that all sales for the same salesperson are grouped together and sent to the correct server.

Grouped Data:

John: [100, 50] → Sent to Server A
Mary: [200, 100] → Sent to Server B
Peter: [150] → Sent to Server A
Anna: [300] → Sent to Server B

Step 3: REDUCE Step (in parallel)

Each server processes the grouped data and calculates the total sales per salesperson.

Server A:

John: 100 + 50 = 150
Peter: 150 = 150

Server B:

Mary: 200 + 100 = 300
Anna: 300 = 300

Step 4: Final Output

The partial results from each server are combined to generate the final result.

Salesperson	Total Sales
John	150
Mary	300
Peter	150
Anna	300

Conclusion

With these examples, it becomes clear that MapReduce follows a similar logic to SQL, but is designed to process large datasets in a distributed and parallel manner. The Map step works like SELECT, and the Reduce step is similar to GROUP BY. The power of MapReduce lies in its ability to split large tasks across multiple servers, speeding up processing and allowing the system to scale as data grows.

Now that you understand the connection between MapReduce and SQL, are you ready to apply this knowledge in distributed projects? Feel free to share your questions or experiences in the comments! 😊

Git Branch default Naming: main vs master

Marcelo Pena — Mon, 01 Jul 2024 22:07:53 +0000

Since October 1, 2020, GitHub has set the default branch to "main" for new repositories, while many existing repositories still use "master". This change is part of an effort to use more inclusive language and avoid terms with negative historical connotations, opting for a more neutral term. "Main" is considered a better choice because it is short, easy to remember, and translates well across languages.

On the other hand, Git, the underlying version control system, is an open-source project maintained by a diverse community. Changes in Git require consensus from contributors and users to ensure broad agreement and compatibility across various workflows and tools. As of now, the default branch name in Git remains "master" because changing it involves a complex and slower process compared to a single platform like GitHub. While discussions about changing the default branch name in Git have occurred, reaching a consensus in open-source projects takes time.

As a result, many organizations and individuals have chosen to rename the default branch from "master" to "main" or some other neutral term. This change is not a requirement, but rather a choice made by individual users or organizations based on their values and preferences.

Upon investigating, I learned the previous exposure above and this experience highlighted the importance of staying informed about industry updates and platform-specific changes. It also underscored broader discussions in the tech community regarding terminology and inclusivity in software development practices.

Moving forward, adjusting to GitHub's default settings improved my project integration and enhanced my understanding of Git workflows. If you encountered similar challenges with Git, I will detail what I did to resolve the issue:

I renamed the local branch via the following line command:
git branch -m master main
I pushed the renamed branch to the remote repository:
git push -u origin main
In addiction, and because after the version git 2.28 we can set a global config with the default branch name allowing now and whenever we create a new git local repo using any default branch name, I run the following line command:
git config --global init.defaultBranch main

Here you go. From now on, the branch names in the local and remote repository will be the same, preventing push and pull going to a different repository than expected.