DEV Community: Charlie Barajas

UNION in SQL Postgre

Charlie Barajas — Thu, 01 Jan 2026 00:32:42 +0000

When using UNION, I came to Udacity's course on Intro to SQL to learn what it takes to be a data anaylst.

When appending data using UNION, UNION ALL against two instances and selected columns will bring columns from differing tables. The requests from two SELECT statements are brought together.
UNION is great when dealing with multiple tables and you don't want to use five subquery SELECT statement. Here's an example;

SELECT *
FROM accounts

UNION ALL

SELECT *
FROM accounts

Why Precedence Matters 🤓

Charlie Barajas — Sun, 14 Sep 2025 00:03:55 +0000

Let's look at a simple example. What do you think the value of result would be here?

C++

int x = 5;
int y = 10;
int z = 2;
int result = x + y * z;
If you just go from left to right, you might think the calculation is 5 + 10 = 15, and then 15 * 2 = 30. But the correct answer is 25. Why? Because the multiplication operator (*) has higher precedence than the addition operator (+). So, the expression is evaluated as y * z first, which is 10 * 2 = 20, and then x + 20 is calculated, giving you 5 + 20 = 25.

A Simple Breakdown 📋
C++ has many operators, but some of the most common ones you'll encounter, from highest precedence to lowest, include:

Postfix operators (), [], ->, . (e.g., function calls, array access)

Unary operators ++, --, !, ~, * (dereference), & (address of)

Multiplicative operators *, /, %

Additive operators +, -

Shift operators <<, >>

Relational operators <, <=, >, >=

Equality operators ==, !=

Logical AND &&

Logical OR ||

Assignment operators =, +=, -=, *=, etc.

The Role of Associativity 🔄
What happens when you have two operators with the same precedence? This is where associativity comes in. It determines the direction of evaluation. For most binary operators, like addition and subtraction, the associativity is left-to-right. For example, in a - b + c, the expression is evaluated as (a - b) + c. However, some operators, like the assignment operators, have right-to-left associativity, so a = b = 5 is evaluated as a = (b = 5).

The Best Practice: Use Parentheses () 📝
While it's good to know the rules, relying on operator precedence can make your code harder to read and prone to subtle bugs. The simplest and most effective solution is to use parentheses () to explicitly control the order of evaluation.

Instead of x + y * z, write x + (y * z). This makes your intention crystal clear to anyone reading the code, including your future self! Parentheses can make your code more robust and much easier to maintain. They are your best friend when it comes to controlling operator precedence. Happy coding!

Provide an example of complex operator precedence.

Explain operator associativity in more detail.

What are some common pitfalls with operator precedence?

Azure NSG Routes

Charlie Barajas — Thu, 04 Sep 2025 23:26:30 +0000

Azure Network Security Groups: Your Cloud's First Line of Defense 🛡️
Azure Network Security Groups (NSGs) are essential building blocks for securing your cloud infrastructure. Think of them as virtual firewalls that control network traffic to and from your Azure resources! 🔒
What Are Network Security Groups? 🤔
NSGs contain security rules that allow or deny inbound and outbound network traffic based on:

📍 Source and destination IP addresses
🚪 Port numbers
🌐 Protocol (TCP, UDP, ICMP)
⬆️ Direction (inbound/outbound)

Key Features ✨
🎯 Granular Control

Filter traffic at the subnet or network interface level
Apply different rules to different resources
Create custom security policies

📊 Default Rules
Every NSG comes with built-in rules:

✅ Allow inbound traffic within VNet
✅ Allow inbound traffic from Azure Load Balancer
❌ Deny all other inbound traffic
✅ Allow all outbound traffic to internet

🔄 Stateful Filtering

Automatically allows return traffic for established connections
No need to create separate rules for response traffic

Best Practices 💡
🚫 Principle of Least Privilege

Start with deny-all and only allow what's necessary
Regularly audit and remove unused rules
Use service tags instead of IP ranges when possible

🏷️ Use Service Tags
Popular service tags include:

Internet 🌍
VirtualNetwork 🏠
Storage 💾
SQL 🗃️
AzureLoadBalancer ⚖️

📋 Naming Conventions
Use descriptive names like:

Allow-HTTP-Inbound
Deny-SSH-Internet
Allow-DB-Subnet

Common Use Cases 🎪
🌐 Web Applications
Priority 100: Allow HTTP (80) from Internet
Priority 110: Allow HTTPS (443) from Internet

Priority 120: Allow SSH (22) from Admin subnet only
Priority 130: Deny all other inbound traffic
🗄️ Database Tier
Priority 100: Allow SQL (1433) from App subnet only
Priority 110: Allow management from Admin subnet
Priority 120: Deny all internet access
🔧 Management Access
Priority 100: Allow RDP (3389) from corporate IP ranges
Priority 110: Allow SSH (22) from jump box subnet
Priority 120: Block all other management protocols
Advanced Features 🚀
🔍 Application Security Groups (ASGs)

Group VMs by application role
Simplify rule management
Make policies more readable

📈 Flow Logs

Monitor and analyze network traffic
Troubleshoot connectivity issues
Detect security threats

🎯 Augmented Security Rules

Use multiple IP ranges in single rule
Combine service tags with IP addresses
More flexible rule definitions

Monitoring & Troubleshooting 🔧
📊 Key Metrics to Watch

Packets blocked/allowed
Security rule hit counts
Flow log analysis

🐛 Common Issues

❌ Conflicting rule priorities
❌ Overly broad allow rules
❌ Missing return traffic rules for stateless protocols

Security Tips 🔐

Regular Audits 📅

Review rules quarterly
Remove unused/outdated rules
Check for overly permissive access

Documentation 📝

Document rule purposes
Maintain change logs
Create architecture diagrams

Testing 🧪

Test rules in development first
Use Network Watcher for validation
Monitor after changes

Conclusion 🎯
Network Security Groups are fundamental to Azure security architecture. When properly configured with the principle of least privilege, they provide robust protection for your cloud resources while maintaining operational flexibility.
Remember: Security is not a one-time setup—it's an ongoing process! 🔄

Ready to secure your Azure environment? Start with NSGs and build a strong foundation for your cloud security! 💪

Regex Checker

Charlie Barajas — Sun, 24 Aug 2025 16:07:25 +0000

I decided to develop a regular expression checker that allows users to input text to determine if the characters match a regular expression and their associated Unicode values. Here's a link to my Codepen account, where you can also find flags for i and g regex.

https://codepen.io/VoXelo/pen/raOvrLO

The softmax() function in Machine Learning

Charlie Barajas — Thu, 21 Aug 2025 22:25:20 +0000

Hello there! If you've ever trained a neural network for classification, you've likely come across the log_softmax() function. While it may seem like a simple operation, it's actually a crucial mathematical tool that prevents your model from breaking down.

Let's explore its construction and why it's so powerful.The Problem: When Softmax BreaksThe standard Softmax function takes a vector of raw model outputs, known as logits, and converts them into a probability distribution. For a vector of logits z = [z_1, z_2, ..., z_K], the probability of the i-th class is given by the formula:sigma(z)_i = e^z_i / (e^z_1 + e^z_2 + ... + e^z_K)This formula is beautiful in theory, but it can be unstable in practice. If a logit z_i is a large positive number (e.g., 1000), the term e^z_i can become so massive that it exceeds a computer's floating-point capacity, causing an overflow. Conversely, if a logit is a very small negative number (e.g., -1000), e^z_i becomes so tiny it's rounded to zero, causing numerical underflow.

In both cases, your probabilities are corrupted.The Solution: Logarithms to the RescueTo solve this, we don't compute the probability and then take its logarithm. Instead, we use a numerically stable identity to compute the logarithm of the softmax result directly. This is the Log-Sum-Exp Trick, and it's the core of how log_softmax() works.The log_softmax operation is defined as the natural logarithm of the softmax function. We can break down the math using a simple property of logarithms: log(a/b) = log(a) - log(b).log_softmax(z)_i = log( sigma(z)_i )= log( e^z_i / (e^z_1 + ... + e^z_K) )= log(e^z_i) - log( e^z_1 + ... + e^z_K )Using another property that log(e^x) = x, we can simplify the first term. The second term, log(sum(e^z_j)), is computed using a special function that handles the large and small numbers without causing overflow or underflow.So, the final numerically stable formula for log_softmax() is:log_softmax(z)_i = z_i - log( e^z_1 + ... + e^z_K )

This method operates on the original logit values, preventing any intermediate steps that could result in computational errors. It allows you to work with a much more stable range of values.Why It's Paired with NLL LossThis is where the magic happens. The output of log_softmax() is perfectly suited for use with the Negative Log Likelihood (NLL) Loss. This loss function is defined as the negative logarithm of the predicted probability for the correct class.For a true class label y, the NLL Loss is a single, simple operation:L_NLL(z, y) = - log_softmax(z)_y

Because the output of log_softmax() is always a negative number (since it's the log of a probability between 0 and 1), taking the negative makes the loss a positive value. Minimizing this loss is equivalent to maximizing the log probability of the correct class. This pairing ensures that your model's predictions are not only accurate but also numerically stable throughout the entire training process.

MNIST Data Set (OpenCV

Charlie Barajas — Thu, 21 Aug 2025 20:46:57 +0000

Why Your PyTorch Model Needs to Get to Know Its Data

Ever wonder what goes on behind the scenes before a neural network can start learning from images? One of the most critical—and often overlooked—steps is understanding the data's pixel values. This little snippet of PyTorch code does just that, calculating the average and standard deviation of every single pixel across an entire dataset. It's a key part of a process called normalization, and it's essential for training better, faster models.

The Setup: Loading the Raw Data 💾

First, let's look at the beginning of the code:

import torch
from torchvision import datasets, transforms

# Load the Fashion MNIST dataset (without normalization)
dataset = datasets.FashionMNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())

This part is all about getting our hands on the Fashion-MNIST dataset. We use datasets.FashionMNIST to download the data, and crucially, we apply a single transformation: transforms.ToTensor().

Why is this important? It takes the raw images—which have pixel values from 0 to 255—and converts them into a PyTorch tensor. At the same time, it scales those values down to the more manageable floating-point range of 0.0 to 1.0. This initial scaling is important, but it’s just the first step.

The Aggregation: Gathering Every Single Pixel 🧺

Next, we have the most fascinating part of the code:

all_pixels = torch.cat([img.view(-1) for img, _ in dataset])

Here, we are literally grabbing every single pixel from all 60,000 images in the training set and putting them into one massive tensor.

for img, _ in dataset: This loop iterates through every image-label pair in the dataset. We only need the image (img) and can ignore the label (_).
img.view(-1): This is the magic. Each image is a 28x28 grid of pixels. The .view(-1) method "flattens" this grid, unrolling it into a long, single-row tensor with 784 elements.
torch.cat([...]): Finally, torch.cat() (short for concatenate) takes the list of 60,000 flattened tensors and joins them all together into one colossal tensor. The result is a single tensor with over 47 million pixel values!

The Payoff: Calculating Mean and Standard Deviation 📈

With all our pixel data in one place, the final two lines are simple but powerful:

mean = all_pixels.mean().item()
std = all_pixels.std().item()

print(f"Mean: {mean:.4f}, Std: {std:.4f}")

We call the .mean() method to get the average of all those millions of pixels and .std() to get their standard deviation. The .item() function simply extracts the single numerical value from the resulting tensor.

The output will look something like this:
Mean: 0.2860, Std: 0.3529

These numbers might seem small, but they hold the key to the next step.

Why It Matters: The Power of Normalization 💪

The mean and standard deviation we just calculated are used to normalize the dataset. The idea is to transform the data so it has a mean of 0 and a standard deviation of 1.

You can do this using a transforms.Normalize function, which applies the following formula to every pixel:

$x_{normalized} = (x - \text{mean}) / \text{std}$

This normalization process helps neural networks in two key ways:

Faster Convergence: When your data is centered and scaled, the optimization process (training) becomes much more stable and can converge on a solution much more quickly.
Improved Performance: Normalization helps prevent certain layers in the network from getting stuck and allows the model to learn more efficiently, leading to better final accuracy.

So, while it may seem like a small detail, this kind of data preparation is a fundamental practice that can make the difference between a sluggish, underperforming model and a lean, powerful one.

Call Stack in Java

Charlie Barajas — Wed, 06 Aug 2025 04:31:13 +0000

Hello,

So I want to be brief and explain that I never knew what "call stack" was supposed to mean. I assumed some fancy, high-class programming jargon that would take years to learn. However, Java uses the call stack as merely a data structure that keeps readily accessible methods/classes for use by the IDE/JVM. The JVM or java virtual machine uses this stack for availability and convenience instead of using RAM memory for every function and var. Although string types have a memory address, objects will always be stored in the call stack.

CodeCademy provides a short, free course just on recursion algorithms. https://www.codecademy.com/courses/java-algorithms

The while loop in Java

Charlie Barajas — Wed, 30 Jul 2025 20:26:18 +0000

I've been taking Codecademy's Introduction to Java course and so far I've really loved the straigtforward and hands-on approach they have to coding. Here's a snippet i wrote using main method.

class Coffee {

public static void main(String[] args) {

// initialize cupsOfCoffee
int cupsOfCoffee = 1;
// add while loop with counter


while (cupsOfCoffee <= 100) {
  cupsOfCoffee++;
  System.out.println("Fry drinks cup of coffee #" + cupsOfCoffee);
}

}

Although basic, it builds a strong foundation for their course material, which also includes career paths with ISC2 partnerships and more.

The compare() method in Java

Charlie Barajas — Tue, 29 Jul 2025 16:59:21 +0000

When we use the compare() or equal() methods, we primarily use them to define the equality of two or more objects that are instances of a class such that Class class_1 = new Class(); would be compared to another instance like class_2. The equality operator (==) cannot be used for objects because of both instance fields and multiple primitive data types being inside each method.

JAVA UML and Why Its Important

Charlie Barajas — Sat, 26 Jul 2025 17:35:17 +0000

The Java UML or Unified Modeling Language allows us to visualize class structure and field data types. Examples of common formatting are (+) for public and (-) for private vars.

setAge(newAge: int): void ---> public void setAge(int newAge)
calculatorTax(): double ---> private double calculatorTax()
getName(): String ---> public String getName()
count: int ---> public static int
getCount(): int ---> public static int getCount()

These are more examples but this is the essential JAVA UML notation.

RAG Systems Model (MongoDB)

Charlie Barajas — Tue, 22 Jul 2025 03:38:16 +0000

RAG systems Utilize a vector search algorithm that searches a mathematical space in a database where chunks store vectors.

These vectors have many dimensions, with each representing a parameter such as V(Param_k) represents k number of params. High dimensionality is good for accuracy but increases latency. Atlas Search Query uses an embedding model that needs a path that can be configured using PyMuPDF or similar Py packages.

Cliques / Independent Sets

Charlie Barajas — Sun, 15 Jun 2025 21:34:24 +0000

Today, I took a module on Udacity's "Theoretical Computer Science" course and would recommend it to programmers, DevOps, data scientists, and network technicians alike, as it provides challenging concepts. These concepts include advanced runtime concepts, traceability, basic graph theory, and runtime equations.

https://www.udacity.com/dashboard