DEV Community: Grace Valerie

How analysts translate messy data, and Dashboards into actions in Power BI

Grace Valerie — Mon, 09 Feb 2026 16:22:13 +0000

The main goal for data analysts is to make sense of data and express findings to respective stakeholders. The analyst imports into Power BI from different sources, upon examining it is not prepared for analysis.
Simple mistakes such as columns with string data types containing numeric rows, columns containing errors and null values, duplicated unique identifiers can make the data unusable.

Data Cleaning and Preparation

Power BI offers Power Query which is powerful for preparing and cleaning data. Clean data is beneficial for:

Producing more accurate results when performing calculations
Finding data more intuitively due to better organization
Simpler navigation and effective use of slicers.

Steps for cleaning data

First step is transforming your imported data to ensure it is suitable for use. Open Power Query editor by clicking on transform data in the queries section of the menu.

Power Query will only modify a view of your data and not your original data.

Next is to identify column headers and names. In the case of the example below, column names are non-descriptive making it hard to understand what each column represents.

When you go to transform data, the correct column names are displayed as the first row. Select the table home icon as shown and on the dropdown, click on Use first Rows as header.

Its also possible to change the header from the menu.

Now the correct headers will be displayed

Verify that the column names are correct by removing spelling errors, and ensuring the naming convention is user friendly. In this case column names are capitalized, if using snake case or any other convention, ensure all columns are consistent.
To rename a column, right click the column name and select rename. In this case we can rename the Location column to Order Location.

You can also remove any column you find unnecessary by going to

Every time you make a change when transforming data, it will be displayed on the properties tab.

You can easily undo a change by clicking on the X.

Duplicates

Remove duplicates from columns to only keep unique names for selected columns. We have identified that each transaction should be unique and no two transactions can share a transaction id. In this example, we remove duplicate transactions by right clicking transaction id and selecting remove duplicates.

Incorrect data types

When importing data, some column data types are incorrectly interpreted such as numeric data saved as text. In this case, data formatted on the left implies it is text while numeric data will be formatted on the right.

When you click a specific column name the data type will also be displayed in the menu as follows

Click on the dropdown to select the appropriate data type.
Incorrect data types can prevent you from creating hierarchies, performing calculations, or forming proper relationships with other entities.

In this example we transformed the following columns data types into whole numbers, decimal and date types

Replacing nulls, Errors and blanks

These types prevent you from performing calculations and summarization on data.

Power query uses find and replace to find the values in a row you want to replace and change to the specified value.

Replace errors and blanks with unknown.

Use column distribution in the view tab to detect anomalies in your data.

Once you are done with cleaning and preparing your data in power query, you can click on close and apply.

Data Analysis Expressions

These are functions and operators that can be combined to build formulas in Power BI

Common DAX Functions

Aggregation Functions

SUM - adds all the numeric values in a given column and returns a decimal number.

= SUM(column)

We can find the total revenue by summing all orders

AVERAGE - Returns the average mean of all numeric values in a column. Null values may cause the average to result in an error.

AVERAGE(column)

In an example you can calculate the average of customers loyalty score as shown

The above is achieved by creating a new measure which is a dynamic calculation on data that is created using DAX.
We can view the result of the measure using a card in report view.

COUNT - Used to count the number of rows in the specified column which and NON-BLANK

COUNTROWS - This is used when you want to count the number of rows in the specified table defined by an expression

Total Electronic Products =
CALCULATE(
    COUNTROWS(Products),
    Products[Category] = "Electronics"
)

The above COUNTROWS example returns the count of only products in the electronics category

SUMX - evaluates the expression for each row in a table then returns the sum. It is referred to as an iterator function and only counts numeric rows.

SUMX(
    Table,
    Expression
)

Filter Functions

Powerful functions that let you manipulate data context
CALCULATE - used to evaluate an expression
FILTER - returns a subset of a different table as a new table
INDEX -
RANGE
RANK

Date and Time Functions

CALENDAR - returns a new table with a single column of a set of dates.

= CALENDAR (DATE (2024, 7, 1), DATE (2026, 7, 31)

DATE - returns the date in datetime format.

DATE(yyyy, mmm, dd)

DATEVALUE - converts text value to date in datetime format.

Dashboards in Power BI

Dashboards are used in power bi to tell a story about the data through visualizations. It highlights the important details that can be reviewed in the report
Here is a simple example of a dashboard

Conclusion

To get the most out of data we need to transform it, perform calculations and create intuitive dashboards that summarize all the insights from the data. Power BI is a powerful tool to achieving this. Understanding and following the right steps will help data analysts to analyze data efficiently.

Data Modelling in Power BI

Grace Valerie — Mon, 02 Feb 2026 06:53:36 +0000

Data modelling helps to define the relationship between sources of data. Organizations work with large amounts of data which require modelling, before building reports. This article is a practical guide for building performance optimized data models in Power BI.

Data models in Power BI are referred to as semantic models. The data model is where you describe and organize your data.

** How to build relationships

Modelling Approaches

There is a sequence of steps followed when creating a data model. These include:

Identifying all the object entities and attributes in your data model.
Identifying the relationships between entities in your data model.
Deriving the best modelling approach from the entities and relationships.
Optimizing your model for performance

Star Schema

This type of modelling approach is widely adopted for relational data. It consists of one central table known as a fact table connected to another table or tables known as dimension tables. The star schema ensures data is denormalized to improve performance by reducing the number of joins needed to retrieve data. Fact tables mainly contain quantitative data while dimension tables describe entities.

Types of Relationships

Every relationship is represented by its cardinality type:

One-to-one
One-to-many
Many-to-one
Many-to-many

The star schema is best represented by the one-to-many cardinality because the fact table connects to multiple dimension tables.

Data Denormalization

This technique is used to improve query performance in star schemas. All redundant data are added to the fact table to maintain one single source of truth.

Snowflake Schema

In this type of schema data is normalized into multiple related sub-dimension tables. This avoids data duplication and is more suitable for complex data. This schema is more suitable for hierarchical data and data that changes often. Snowflake schemas also save storage space since data is normalized.

Conclusion

Star schemas are preferred when building data warehouses since they are optimized for better performance by reducing the number of queries and need for joins. For

Useful Linux Commands For Data Engineers

Grace Valerie — Mon, 26 Jan 2026 00:58:05 +0000

Linux servers dominate as the most preferred compute environment for large scale data systems. Mastering Linux helps data engineers to efficiently manage data pipelines and process data.

This article is a deep dive into the most useful Linux commands that are relevant for data engineering tasks.

Prerequisites

Setup a Linux server environment for testing purposes.
Should be familiar with the command line

File and Directory Operations
File System and Storage Management
File Attributes and Permissions
User and Group Management
Networking and Security
File Compression and Encryption
Editors
File transfer commands

File and Directory Operations

These commands are used for navigating and manipulating the Linux file system. They emulate CRUD operations, but on the file structure.

# returns the current working directory
pwd

# lists directory contents including files and subdirectories
ls 
# includes hidden files in the list
ls -a
# changes the current working directory // cd /path/to/directory
cd 
# deleting files and directories 
rm
# creating a file
touch
# returns the contents of a file 
cat 
# quickly view the first or last lines of a file without opening the entire file.
head / tail

Data engineers can use these commands to inspect logs and raw data dumps.

File System and Storage Management

The file system partitions, organizes and stores data on disk.

/dev ~ directory representing actual storage disks
sd ~ the storage disk
a ~ the first disk 
1 ~ first partition on the disk

cat /proc/partitions ~ view all storage disks and partitions recognized by the system
fdisk /dev/sda ~ create, manage and delete partitions on /dev/sda
sudo mkfs.xfs /dev/sdb1 ~ install a filesystem on partition /dev/sdb1
sudo mount /dev/sdb1 /myfolder ~ attach storage space to myfolder directory which acts as the mount point
df -f /myfolder ~ verify the storage space exists
pvcreate /dev/sdb1 ~ initialize a physical volume to use with the Logical Volume Manager

As data engineers work on systems with intensive data, they need to skillfully manipulate partitions and filesystems to prevent losing data. Backing up data is recommended before running these commands.

File Attributes and Permissions

Linux file permissions offer a security mechanism for determining who can read, write or execute files on a system.

# returns file metadata including file permissions
ls -l 

# makes a file immutable
chattr +i 

# list file attributes
lsattr 

# add or remove execute permissions
chmod +x or -x 

# set Read/Write for owner, read for group/others
chmod 644 myapp.py
# change file ownership
 chown

Using these commands, a data engineer will be able restrict access to sensitive file data and protect files from accidental modifications by setting strict permissions.

User and Group Management

Use the useradd command to create a new user

sudo useradd username

#create new group
sudo groupadd groupname

# -m ~creates the home directory for the user
sudo useradd -m username

# assign the user to a specific group
sudo useradd -G groupname $username

View user information with

id username
# returns UID and GID

To add a password for the new user, run:

sudo passwd username

All existing users will be listed in the /etc/passwd file

cat /etc/passwd

Switch to a different user with

su -h username

In order for data engineers to maintain least privilege access to resources, they need to properly implement user and group management. It is recommended to use user accounts instead of the root user to minimize access.

Networking and Security

At the center of Linux are four key components that block malicious access - Firewalls filter traffic, Encryption encrypts data in transit, Authentication verifies user identities, Monitoring analyzes traffic.

Using UFW which is a firewall interface for iptables, you can check the currently registered profiles with

sudo ufw app list

To enable an application profile, RUN

sudo ufw allow appname

There is a rule that allows you to specify the port instead of the profile name

# check if ufw is running
sudo ufw status

# allow ssh
sudo ufw allow 22

# specify port ranges (apply with specific protocol)
sudo ufw allow 6000:6009 /tcp

# allow connections from IP address
sudo ufw allow from 201.8.139.4

With the rules applied you can enable firewall with:

sudo ufw enable

use sudo ss --tulnp|grep to show listening ports and ping to test connectivity.

File Compression and Encryption

Compressing a file reduces the amount of storage needed and will help speed up data transfer.

Use gzip to compress a single file as:

# results in filename.gz
gzip filename

The process of archiving will combine multiple files into a single file archive. create a simple archive using tar package

# -cf creates and names the archive
tar -cf myarchive.tar app.py main.py project/

To extract an archive use the command:

tar -xf myarchive.tar

Encryption will ensure that you can safely transit the data over the internet. Use GPG or openssl for encryption

# File encrypted using passphrase
gpg -c filename.txt

# AES encryption
openssl enc -aes-256-cbc -in data.txt -out data.enc

Data engineers can compress raw log files to save space, then encrypt data archived files before uploading to cloud storage.

Editors

The most popular text editors on Linux are Nano and Vim.

nano file.txt

vi file.txt

Both commands will create if not exists, then open file.txt

File transfer commands

These commands can be used to handle file transfer either locally or remotely.

# Secure File Transfer Protocol ~ used for transferring files
sftp username@ip_address/hostname

# copy files and directories locally
cp file1.txt /backup/file1.txt

# move or rename files
mv filename/ renamedfile/

# transfer files remotely over ssh
scp data.csv username@ip_address:/data

#synchronize directories remotely for incremental updates
rsync -avz /backup/log username@ip_address/hostname

A data engineer will be able to efficiently sync files on the local server to a remote server.

Conclusion

This article covers several categories of Linux commands and how data engineers use them.

References

How to Manage Linux Storage
Linux file permissions explained
Differences between archiving and compression

Basics of using Git

Grace Valerie — Sun, 18 Jan 2026 09:16:55 +0000

In this article, we'll cover the basics of using git, how version control systems work, and how to push and pull code.

What is version control?

Version control is a system that keeps track of changes made to your codebase over time. It is like keeping a digital copy of your files somewhere on the internet where other people can make changes to those files. It allows developers to collaborate effectively, with the freedom of knowing every change to the repository can be easily reverted.

Why use version control?

Version control comes with a lot of benefits that make it easier for projects to exist long term:-

A history of all changes made to a codebase are maintained making it easy to manage different versions of the same software.
It can easily identify incompatible changes made to a codebase and help you rectify before causing any permanent damage.
It helps distributed teams to coordinate their work in fast paced software delivery workflows.

Types of Version Control Systems

Centralized Version Control
There is one centralized repository which hosts different versions of the code. Every User commits directly to the main branch. A developer can lock a file that contains a piece of code they are working on to avoid conflict with other developers. This system is more suitable for small teams working with huge binary files. Instead of downloading the entire codebase, they can just download a subset of what they need. The downside to this system is it creates a single point of failure such that, when the repository server is down no one can access their codebase. Examples of centralized version control tools include perforce and subversion.
Localized Version Control
This system operates entirely on one server and does not require any remote connection. This is more ideal for personal projects or single user contributions. A structured revision of history is still maintained to enable rollbacks after accidental file modifications that are causing errors. The most widely used local version control tool is known as revision version control. It stores the differences between file versions known as patch sets and allows you to recreate any file versions by applying patches.
Distributed version control
Every contributor download a local copy of the repository which fully mirrors everything in the central repository. This allows developers to work offline and later synchronize changes. This system helps development teams to set up strong workflows. developers can easily sync their code and maintainers can set up code review processes to maintain code quality. Examples of tools include Mercurial, Bazaar and Git.

The Journey From Git Init

This section covers the basics of using git to work with a repository. It covers:

How to create a repository
How to push code to a repository
How to pull a repository version
How to track changes made to a repository We will work solely with the command line to achieve this.

Prerequisites

Have git bash installed
Setup ssh key for GitHub

Follow these next steps to successfully track your project with git

Initialize your repository The first step is to navigate to the project directory you are working on as

cd path/to/project/myproject

In the root directory of this project is where you want to initialize git.

git init

This command creates a new subdirectory .git which contains all repository files.

To start tracking your files with git use the git add command. This command tells git which specific files you want to track

git add . // track all files
git add filename //track only specified filename
git add *.py // track all files with the .py extension e.g file1.py, file2.py

Run git status to see which specific files are being tracked.

# Crafting a commit message

The next step is to run git commit which takes a snapshot of the current file version that you are tracking. The default git commit message will contain the latest output of git status.
To override the message with a custom one send

git commit -m "This is my first commit"

. A good commit message is useful for future reference and for other developers using the project. There are a few commit message conventions to follow for uniformity and readability. These include capitalizing the first letter of the message and using flags such as fix, refactor, style to categorize a commit.
The message also needs to be descriptive of the changes you made. Read more about this on freecodecamp article

git commit -m "docs: Added instructions on how to..."

Run git log to view commit history

Working with remote repositories

You need remote repositories to push and pull data from them when sharing your work. Its possible to add remote repositories, remove invalid ones. To add a remote repository run the command
git remote add <shortname> url. For example on github we can add a remote repo as git remote add firstproject https://github.com/username/firstproject. You can add multiple remote repositories to your project just by changing the shortname and url.

Git Branching

Branches in git emulate a movable pointer that points to a particular commit. Every commit in a particular branch pushes that branch closer to the HEAD. HEAD in git is a symbolic reference that points to the most recent commit in the currently checked-out. branch. This way developers can view which branch has the latest changes and which ones are still behind.
Branching helps developers to test their code in staging branches to verify that the code is Ok before pushing to production.
The default branch is known as master which can be overwritten with the command:

git branch -M main

Its possible to create a new branch with

git branch <branchname> //create new branch
git checkout <branchname> //switch to branch

Pushing your changes

This is the step where we push our code to the remote repository. There are different servers where you can push your code such as GitHub, GitLab and BitBucket.

To push your codebase to a remote repository:

git push <remote_name> <branch>
# An example could be 
git push origin main
# or
git push backup master

This makes it possible to push to different origins and different branches. You can also merge branches using git merge.

You can also create a new branch and push to its remote using one command:
git push -u <remote_name> <new_branch>

You can push a single specific tag which will create a snapshot of a particular release point version that you may want to deploy

Before pushing we need to create the tag as:

git tag -a v1.0 -m "First release version v1.0"

Then push with

# push only v1.0 tag
git push <remote_name> v1.0 

# push all existing tags
git push <remote_name> --tags

Pulling The Latest Version

git pull is the command used to fetch from remote branches and integrate with your local environment

Summary Of Commands Used

# initialize repository
git init 
# track all files in repo
git add . 
# check tracked files status
git status
# take snapshot of files with message
git commit -m "My message"
#view commit history
git log
# add remote repo
git remote add remote origin https://<URL-to-remote
# Overwrite default branch
git branch -M <branch_name>
# Push to remote
git push -u origin main

LDAP (Lightweight Directory Access Protocol

Grace Valerie — Sun, 13 Oct 2024 16:03:26 +0000

LDAP is the standard TCP/IP stack protocol that is used to store and query information from a hierarchical directory. It is an alternative to X.500 Directory service protocol which is more resource-intensive. LDAP is often used for SSO authentication and storage. By standard LDAP uses TCP port 389 for unencrypted communication and TLS port 636 over an encrypted channel.

How Does LDAP work?

Client starts an LDAP session through the dedicated TCP port.
(Optional) Read and modify the session option values.
Establish a connection to the LDAP server or explicitly bind to the server with a privileged authenticated client using one of the binding functions.
Submit a query to an email server or establish a connection to a printer. The server receives the query and returns the corresponding information to the user.
After completion, close the connection to the LDAP server.

LDAP unlike most modern http-based protocols, uses persistent connections which can live for days when communication with a directory server.

Advantages of Using LDAP

It is a mature protocol which keeps on evolving. It is a critical component of most large enterprises therefore the need to maintain revisions and update standards of the protocol.
LDAP is a lightweight version of the X.500 protocol but is also very lightweight compared to other modern day protocols.
LDAP is secure and is often used to store usernames, passwords and other sensitive information. But its security is subject to its implementation. It is important to follow best practices when adopting this protocol such as:
- establishing an access control policy.
- maintaining multiple copies of the directory data.
- encrypting sensitive information such as passwords.

Components of LDAP

Attribute: the data in the LDAP system is stored in key-value pairs known as attributes. You can set an attributes value by separating the name and the value using a colon and a space. e.g.

mail: johndoe@gmail.com

Use an equal's sign to refer to an attribute and its data without setting it. e.g.

mail=johndoe@gmail.com

The most commonly used attributes include:
- ou: Organizational Unit
- _ dn_: distinguished name
- cn: common name
- description
- dc: domain component
- givenName: first name
- mail: e-mail address
- sn: surname

Entries: an entry is a collection of attributes which are associated to or describe something. An entry could be a user in your system. Think of it as a row in a relational database. Each entry consists of:
- a distinguished name (uniquely identifies a specific entry in the DIT hierarchy
- a collection of attributes (they hold the data for the entry)
- a collection of object classes (they indicate what kind of object an entry represents e.g. information about a device or person)

dn: ou=Users,dc=example,dc=com,uid=jd001
objectClass: EntUsers
cn: Jane Doe
sn: Doe
mail: jdoe@example.com
uid: jd001

Search Filters: used to define the criteria for identifying entries that contain certain kinds of information.
LDAP URLS: this URL contains different pieces of information that can reference a directory server or a search criteria.

Primary Operators of LDAP

Add: Insert a new entry into the directory.
Modify: change existing directory entries.
Bind: authenticate and connect the LDAP client to the server.
Delete: Remove directory entries.

LDAP is used by Microsoft's Active Directory and other directory servers such as OpenLDAP and Red Hat Directory Server. To setup LDAP within an enterprise, you need a directory server, users with different permissions, directory data that can be queried and an LDAP client application.
-

ProxyChaining

Grace Valerie — Wed, 31 Jul 2024 14:09:12 +0000

In a world where digital privacy is a myth, achieving total anonymity has been a top concern for many organizations and individuals. One technique that enables this is using proxychains. The real identity of your original machine is obfuscated by bouncing your internet traffic through multiple proxy servers.

Definition Of Proxy Chaining

Proxy chaining is a more intensive masking technique that involves hiding a proxy behind another proxy and using as many proxies in the chain as needed.

Benefits of using Proxychains

Use of proxychains can make it possible to bypass firewall restrictions and access to resources when conducting reconnaissance without being detected.
Proxychains in combination with other applications such as Nmap and pivoting tools like metasploit can be used to scan networks that are connected to a compromised network.

Using Proxychains

This is a walkthrough on how to set up proxychains on a Kali Linux system. We will be using proxychains-ng instead of proxychains which is an enhanced proxychains project with improved functionality.

Installation

Proxychains-ng comes pre-installed on kali-linux machines. You can confirm this with the command

$ proxychains4

If you get the following response then proxychains is already installed on your machine.

You can also install it using apt with the following command:

sudo apt install proxychains4

Configuration

You can use nano or vi to edit the configuration. In this case we will be changing the chain option and adding some proxies to the chain.

Open the configuration file using the command

sudo nano /etc/proxychains4.conf

sudo vi /etc/proxychains4.conf

The editor opens. Scroll down to "dynamic_chain" option and uncomment it then further down to "strict_chain" and comment it. This will enable the dynamic_chain and disable strict_chain.

Chaining Options

~ Dynamic chain: the proxies used when routing requests changes dynamically and skips non-functional proxies.
~ Strict chain: all specified proxies are used in the order in which they are chained.
~ Round Robin: the chain assumes a circular connection between all proxies. With each request, the next proxy in the list is connected to until all the proxies in the chain are utilized. When the end of the chain is reached, then the next request connects to the first proxy in the list.
~ Random chain: you can specify the number of proxies to use in the request and the chain creates a random combination of proxies for the request.
Scroll down to the bottom of the file to add proxies to your proxychain. You will find an existing loopback address using SOCKS4
which you need to comment out before adding new proxies. The proxies are specified in the sequence

<type> <host> <port> [username password]
// some proxies do not have usernames or passwords
// types include SOCKS4, SOCKS5, HTTP/HTTPS

Exit from the editor and you are now ready to use the proxychain. Test if its working with the command

$ proxychains4 curl ipinfo.io
$ // returns public ip address of the connected proxy as response

To connect to a browser, run the command:

$ proxychains4 firefox google.com

The Ultimate CSS Testing Toolbox

Grace Valerie — Sun, 24 Sep 2023 14:24:49 +0000

Introduction

Frontend testing is not often considered during the development process. It can be challenging to test front-end interfaces and style-sheets but regardless this process will ensure you create quality interfaces.
There are four types of testing techniques commonly used, namely:

Syntax testing.
Regression testing/ Reference Testing.

This article covers the different types of testing techniques and how to use different tools.

Prerequisites

Familiarity with HTML, CSS and JavaScript.
Have npm (node package manager) installed locally on your editor.

Regression Testing / Reference Testing

This type of testing is generally used in software development and is applied to modified code to check if bugs and errors are introduced in the codebase. CSS regression testing tests for breaking changes on your interface when CSS style is modified.

Regression Testing Tools

There are a number of available tools that are used to automate CSS regression tests.

BackstopJS

BackstopJS is an automated visual regression testing tool for web user interfaces. It compares DOM elements screenshots over time. Backstop can be integrated with the playwrite engine and pupetteer.

How To Use BackstopJs

Install the globally available backstopjs package.

$ npm install -g backstopjs

Create a default configuration file in your current working directory.

$ backstop init

The above command creates a backstop.json file in your root folder. When BackstopJS is invoked, it looks for this file. a folder named backstop_data is also created. It contains playwrite and puppeteer scripts in subfolders.

Configuration file (backstop.json) content properties.

{
  "id": "backstop_default",
  "viewports": [
    {
      "label": "phone",
      "width": 320,
      "height": 480
    },
    {
      "label": "tablet",
      "width": 1024,
      "height": 768
    }
  ],
  "onBeforeScript": "puppet/onBefore.js",
  "onReadyScript": "puppet/onReady.js",
  "scenarios": [
    {
      "label": "BackstopJS Homepage",
      "cookiePath": "backstop_data/engine_scripts/cookies.json",
      "url": "https://garris.github.io/BackstopJS/",
      "referenceUrl": "",
      "readyEvent": "",
      "readySelector": "",
      "delay": 0,
      "hideSelectors": [],
      "removeSelectors": [],
      "hoverSelector": "",
      "clickSelector": "",
      "postInteractionWait": 0,
      "selectors": [],
      "selectorExpansion": true,
      "expect": 0,
      "misMatchThreshold" : 0.1,
      "requireSameDimensions": true
    }
  ],
  "paths": {
    "bitmaps_reference": "backstop_data/bitmaps_reference",
    "bitmaps_test": "backstop_data/bitmaps_test",
    "engine_scripts": "backstop_data/engine_scripts",
    "html_report": "backstop_data/html_report",
    "ci_report": "backstop_data/ci_report"
  },
  "report": ["browser"],
  "engine": "puppeteer",
  "engineOptions": {
    "args": ["--no-sandbox"]
  },
  "asyncCaptureLimit": 5,
  "asyncCompareLimit": 50,
  "debug": false,
  "debugWindow": false
}

id: Used for naming screenshots that you want to share reference files with teammates.
viewports: This property is an array of screen sies that your DOM objects will be tested against.
scenarios: This is the setup for your actual tests. It should contain a label and URL. Other sub-properties are optional. The URL is an absolute path to your webpage or local path. The label is a screenshot name identifier.

Define a scenario

The scenario property is an array where you modify your tests. CSS selectors are mostly used where you can specify click and hover events. Consider the following scenario:

"scenarios": [
    {
      "label": "Login Page",
      "url": "http://localhost:3000/login",
      "referenceUrl": "https://anypay-28455.web.app/login",
      "delay": 30,      
      "clickSelector": ".btn",
      "selectors": [
        ".formStyle"
      ],
      "selectorExpansion": true,
      "misMatchThreshold" : 0.45,
      "requireSameDimensions": true
    }

  ]

Specifying a referenceUrl helps to create a reference file over which your test file is tested against. The refence URL can be a production environment URL. Otherwise leave the value as empty to set the url value as reference value by default.
Run the following command to create a reference file.

$ backstop reference

A bitmaps_reference file is created.
After the reference file is created, run the test.

$ backstop test

When the test is done, results for number of passed and failed tests are return. Results can also be viewed on the browser.

Use the scrubber tool to view the difference when the red vertical line is moved.

If satisfied with the results, approve the test scenario reports. Your test batch images will now be used as the reference points.

$ backstop approve

Learn more about Backstop from their GitHub page.

Other regression testing tools include CSSCritic, Spectre, Wraith, Gemini and Reg-cli.

Syntax Testing

Syntax testing analyzes your CSS code to flag errors that break any syntax rules, which may in turn break the styling for your web page. Linting tools are used for this purpose.

Advantages of Using CSS Linting Tools

Error detection: CSS linters helps to identify such as incorrect selector syntax, misspelled property names and invalid selector values.
Enforcing coding standards: CSS linters can be configured to follow specific standards according to your preferred guidelines.

Simple Command Line CSS Linting Tool

Install csslint from your command line.

$ npm install -g csslint

Change directory to the folder where your css file is.

$ cd your_folder_name

Run "csslint" command on your CSS file.

  $ csslint css_file_name.css

A list of potential issues are returned in the command line.

Example

Potential Issues Identified

Too many font-size declarations.
Don't use IDs in selectors.
Heading (h3) should not be qualified.
Rule doesn't have all its properties in alphabetical order.
Fallback background-color (hex or RGB) should precede RGBA background-color.

When CSS lint identifies these issues, it's easier to fix and adhere to the correct syntax.

Stylelint

This is a powerful linting tool as it can:

automatically fix issues
support shareable configurations
be customized to your fit your preferences. Stylelint can be installed using npm with the following command:

$ npm init stylelint

A new config file is created named ".stylelintrc.json".

Run stylelint with:

$ npx stylelint "**/*.css"

A list of errors that violate the syntax rules are displayed on the command line such as:

After running Stylelint, proceed to customize its configuration to best suit your needs.

Conclusion

Testing CSS code can be valuable to your web development workflow as it improves CSS code quality and consistency. To achieve comprehensive test coverage, combine regression testing tools with the syntax testing tools and also perform manual tests. Consider integrating tests into your Continuous Integration pipeline to run them automatically when changes are made.

Git Branching Strategies: How To Manage Your Codebase Effectively

Grace Valerie — Wed, 13 Sep 2023 06:27:13 +0000

In modern software and DevOps teams, version control systems are the powerhouse when it comes to delivering software. they are capable of managing source code changes and tracking code change history. As much as version control systems are effective, working on big teams with simultaneous activity can make it difficult to create branches or even merge code. This is why we need a branching strategy.

A branching strategy is used by software development teams to design a proper way in which branches are created and code is merged.

Prerequisites

The only requirement before reading this article is that you have a fair understanding of version control, git and branching in git.

Sub-topics

Why should you implement a branching strategy
Factors to Consider When Choosing a Branching Strategy.
Types Of Branching Strategies.

Why should you implement a branching strategy?

A branching strategy is essential for any large-scale project as it improves collaboration and accelerates the delivery process and business value. Distributed version control systems such as git gives you the flexibility to use different branching strategies, unlike centralized systems.

Factors to Consider When Choosing Branching Strategy?

The branch strategy you use will mainly be influenced by the project requirements. When picking a strategy, ask yourself the following questions:

How big is the size of the team?
What is the complexity and size of the project?
How often do you make deployments?
Will your development workflow fit in with the strategy?

In the following section, I will cover the different types of strategies that are commonly used. Remember that whichever strategy you choose it is not fixed, and you can refine it as your project needs change.

Types of Branching Strategies.

We have two most commonly used branching strategies namely, feature branching and trunk-based development. There are other types as well such as gitflow, github flow, release branching and more.

Feature-branching

Feature branching method requires the developer to create a new feature branch for every new feature and bugs. In this way you can isolate your work in progress from your completed work in the main branch. This technique makes it easy to access and review the history of changes made after writing commits and opening pull requests. Here's how to implement this workflow:

Identify and assign features for developers to work on. Consider if the developers can work on these features independently with minimal conflict.
Let each developer create a feature branch based off the main/master branch. Developers can now work on their respective features in the branches they created without interference from others.
Implement code review in your workflow whenever a pull request or merge request is made.
After code review and merge is done, the feature branch should be deleted to keep the repository clean.
Repeat the process for each feature. as best practice, use a naming convention for your feature branches.

Trunk-Based Development

This branching strategy enforces continuous integration where changes can be released frequently, and automated tests run after each commit. Trunk based development encourages developers to merge changes to the trunk (master) as often as possible thus eliminating the need for long lived branches that can cause merge conflicts.

Best Practices

Small incremental changes - commits should be made daily which requires short lived branches. When teams break down work into smaller sections it makes it easier to commit daily and review quickly.
Feature toggles - by creating feature flags, developers can deactivate unfinished features and still make changes then activate the feature when done.
Automated testing and code reviews - implement a code review system where committed changes are reviewed as fast as possible. In any modern software project, regular testing is part of the continuous integration process. It helps teams to discover and resolve bugs early, which can lead to technical debt.
Delete inactive branches or once a branch is merged. Ensure that there are no more than three branches in your repository.

Trunk based strategy is suitable for any team size and complex projects. Its success will solely depend on how it is implemented and if developers embrace it.

Gitflow Branching Strategy

Gitflow strategy is a way for developers to work in parallel and away from the master branch by using feature branches. This workflow consists of five different branches.

Master branch: This is the main branch that is created at the start of the project. Commits made in this branch are tagged with a version number.
Develop: This branch is also a master branch where changes from the feature branch are integrated. Feature branches are branched off the develop branch.
Feature branch: Feature branches are where developers create and develop new features.
Release - This branch is created off the develop branch when you are ready to release new features.
Hotfix - used for emergency bug fixes.

Gitflow is most suitable for software that are explicitly versioned to allow for roll backs. All versions are in production which means they need continuous support. This strategy can be used when developing operating systems or packages but not web applications.

The Ultimate Chrome Tutorial

Grace Valerie — Sat, 09 Sep 2023 18:03:13 +0000

Chrome is a cross-platform created by google that hosts search engines which are used to search for information over the internet which is then returned as a list of web pages that match the search uery.

How to Choose a Search Engine In Chrome

On the top right side of the screen click the three dots to go to settings.
a left side menu appears on the settings page, click on search engine option.

Select your preferred search engine from the drop down list as indicated in the diagram.

How To Search

To successfully search for any information on the internet via a web browser, you will need an internet connection.

On the new tab, type the text you would like to search for in the input section.

Press enter to view your search results.
The search engine tries as much as possible to give to the best matching results.

Your search results will display a list of websites with the keyword you typed for. Through search engine mechanisms the displayed information will also contain additional information as provided by a specific website. This way you can determine if the result is the one you are looking for before opening the website.

Example.
On the search bar enter the input text appwrite.
The search results will come in different formats and you can choose which format you want. By default you will have the all results option selected.

DEV Community: Grace Valerie

How analysts translate messy data, and Dashboards into actions in Power BI

Data Cleaning and Preparation

Steps for cleaning data

Duplicates

Incorrect data types

Replacing nulls, Errors and blanks

Data Analysis Expressions

Common DAX Functions

Aggregation Functions

Filter Functions

Date and Time Functions

Dashboards in Power BI

Conclusion

Data Modelling in Power BI

Modelling Approaches

Star Schema

Types of Relationships

Data Denormalization

Snowflake Schema

Conclusion

Useful Linux Commands For Data Engineers

Prerequisites

Table of Contents

File and Directory Operations

File System and Storage Management

File Attributes and Permissions

User and Group Management

Networking and Security

File Compression and Encryption

Editors

File transfer commands

Conclusion

References

Basics of using Git

What is version control?

Why use version control?

Types of Version Control Systems

The Journey From Git Init

Prerequisites

# Crafting a commit message

Working with remote repositories

Git Branching

Pushing your changes

Pulling The Latest Version

Summary Of Commands Used

LDAP (Lightweight Directory Access Protocol

How Does LDAP work?

Advantages of Using LDAP

Components of LDAP

Primary Operators of LDAP

ProxyChaining

Definition Of Proxy Chaining

Benefits of using Proxychains

Using Proxychains

Installation

Configuration

Chaining Options

The Ultimate CSS Testing Toolbox

Introduction

Prerequisites

Regression Testing / Reference Testing

Regression Testing Tools

BackstopJS

How To Use BackstopJs

Configuration file (backstop.json) content properties.

Define a scenario

Syntax Testing

Advantages of Using CSS Linting Tools

Simple Command Line CSS Linting Tool

Example

Potential Issues Identified

Stylelint

Conclusion

Git Branching Strategies: How To Manage Your Codebase Effectively

Prerequisites

Sub-topics

Why should you implement a branching strategy?

Factors to Consider When Choosing Branching Strategy?

Types of Branching Strategies.