DEV Community: Sean Coughlin

Understanding CI/CD: Streamlining Software Deployment

Sean Coughlin — Thu, 30 Nov 2023 16:08:56 +0000

In the ever-evolving landscape of software development, Continuous Integration and Continuous Deployment (CI/CD) have emerged as key practices that enhance efficiency and reliability.

Let's delve into the world of CI/CD, its importance, historical evolution, and some notable platforms that facilitate these processes.

What is CI/CD?

Continuous Integration (CI) involves the practice of automating the integration of code changes from multiple contributors into a single software project. It's a crucial part of modern software development practices that helps detect and fix bugs quicker, improve software quality, and reduce the time it takes to validate and release new software updates.

Continuous Deployment (CD) extends CI by automatically deploying all code changes to a testing and/or production environment after the build stage. This practice ensures a faster and more streamlined deployment process, enabling organizations to release new features, fixes, and updates rapidly and efficiently.

The Evolution of CI/CD

Traditionally, software deployment was a manual and infrequent process. Developers would write code for weeks or months and then merge their changes into the main branch. This often led to conflicts and bugs, which were time-consuming and costly to fix.

The introduction of Agile methodologies marked the beginning of more iterative and incremental software development. CI/CD evolved as a natural extension of Agile, focusing on frequent, small, incremental changes to code and automatic testing and deployment.

Historical Shift:

Pre-CI/CD Era : Manual code integration, infrequent releases, and high potential for errors.
Post-CI/CD Adoption : Streamlined processes with automated testing and deployment, leading to more frequent and reliable software releases.

Key Benefits of CI/CD:

Faster Release Rate : Automates the software release process, enabling more frequent and reliable deployments.
Improved Code Quality : Continuous testing identifies defects early in the development cycle.
Increased Efficiency : Reduces manual intervention, leading to a more efficient development process.

When is CI/CD Important?

Rapid Development Environments : In fast-paced sectors where software needs to be updated frequently.
Large Teams : Facilitates coordination and integration of changes made by different developers.
High Availability Systems : Ensures continuous delivery and deployment with minimal downtime.

Popular CI/CD Platforms

Several platforms have emerged to support CI/CD practices. Some of the widely used ones include:

Jenkins : An open-source automation server that provides hundreds of plugins to support building, deploying, and automating any project. Jenkins Documentation
GitLab CI/CD : Integrated into GitLab, it offers a web-based CI/CD service for software development through the GitLab repository. GitLab CI/CD Documentation
CircleCI : Known for its ease of setup and maintenance, CircleCI is a cloud-based system that supports various programming languages and integrates with GitHub and Bitbucket. CircleCI Documentation
Travis CI : A hosted continuous integration service used to build and test software projects hosted on GitHub and Bitbucket. Travis CI Documentation
AWS CodePipeline : A continuous integration and continuous delivery service for fast and reliable application and infrastructure updates. AWS CodePipeline User Guide
GitHub Actions: An automation suite built right into GitHub. It can be used to run many types of automation including CICd pipelines. GitHub Actions documentation

Conclusion

The adoption of CI/CD is a game-changer in the software development process. It not only speeds up the development and deployment cycles but also significantly enhances the quality of the software produced.

By automating the integration and deployment process, CI/CD allows developers to focus more on developing features and less on the process of integrating and deploying them.

For software engineers and teams looking to stay ahead in the fast-paced tech world, embracing CI/CD methodologies is not just an option, but a necessity. With the plethora of tools and platforms available, implementing CI/CD has never been more accessible.

Originally published at https://blog.seancoughlin.me.

jsdom vs happy-dom: Navigating the Nuances of JavaScript Testing

Sean Coughlin — Thu, 30 Nov 2023 04:16:16 +0000

Introduction

JavaScript testing is a crucial part of ensuring that web applications work correctly across different environments. In this context, tools like jsdom and happy-dom are incredibly valuable. They both provide ways to simulate a browser-like environment for testing purposes. Let's dive into what each of these tools is and how they compare.

Understanding Server-Side DOM in Web Development

Before we can dive fully into these tools we need to briefly discuss the DOM.

When we talk about the DOM or Document Object Model, the immediate association is with client-side JavaScript in a web browser. It's a critical concept for web developers, as it represents the page's structure, style, and content, and allows scripts to interact with and modify it.

However, there's another side to this: the server-side DOM. Lets explore what this means and why it's important in modern web development.

The Idea of a DOM Outside a Client (Server-Side DOM)

The Document Object Model (DOM) is typically thought of as the model that the browser uses to turn an HTML document into a visible website. However, the DOM standard can be implemented in pure JavaScript to run outside of a browser on a server.

One of the primary uses of a server-side DOM is in the context of testing web applications. In traditional scenarios, testing a web application's functionality requires rendering pages in a browser. However, with a server-side DOM, developers can simulate a browser environment on the server.

This approach is extremely useful for automated testing, allowing scripts to interact with a simulated DOM without the overhead of a real browser. The GUI of a browser is very nice for human usability but has terrible performance. Stripping out the browser overhead enables fast JavaScript unit testing.

Tools for Server-Side DOM

In the JavaScript world, tools like jsdom and happy-dom are prime examples of server-side DOM implementations. They create a simulated browser-like DOM environment within a server context.

This means JavaScript code, which typically runs in a client-side browser, can be executed on the server. This simulation can include creating and manipulating DOM elements, handling events, and sometimes even emulating browser-specific behaviors and CSS support.

What is happy-dom?

happy-dom is a relatively new entrant in the world of JavaScript testing. It's a lightweight, high-performance server-side DOM implementation. happy-Dom is designed to emulate a web browser's environment, allowing you to run and test your JavaScript code in a simulated browser-like environment on the server.

One of the key features of happy-dom is its speed and efficiency. It's built to be fast, which makes it an excellent choice for high-speed DOM operations and tests that require quick execution. This can be particularly beneficial in a continuous integration/continuous deployment (CI/CD) pipeline where speed is crucial.

What is jsdom?

jsdom, on the other hand, is a more established tool in the JavaScript world. It offers a robust simulation of a web browser's environment. JSdom allows you to create a virtual DOM on the server-side, enabling the testing of JavaScript intended for client-side execution in a Node.js environment.

jsdom is known for its comprehensive emulation of the web browser's environment. It includes a wide range of browser features, making it a go-to choice for tests that require detailed emulation, including CSS support, layout, and more complex DOM manipulations.

When to Use jsdom or happy-dom

Choosing between jsdom and happy-dom often depends on your specific testing requirements:

The rough rule of thumb is happy-dom might be faster (depending on your use case) and jsdom might be more complete (simulates more of what a browser would).

Example Use Case

Vitest supports the use of different DOM rendering tools. You could choose to use either happy-dom or jsdom depending on your preference.

export default defineConfig({
    plugins: [svelte()],
    test: {
        environment: 'jsdom', // could pass in jsdom or happy-dom
    },
})

Feel free to learn more about Vitest in one of my earlier posts.

Conclusion

In conclusion, both JSdom and Happy-Dom offer valuable solutions for testing JavaScript in a non-browser environment. Your choice between the two should be guided by your project's specific needs. If you require detailed browser emulation, jsdom is your go-to tool. For rapid testing, particularly focused on DOM operations, happy-dom is an excellent choice.

As JavaScript continues to evolve, tools like these play a crucial role in ensuring the reliability and performance of web applications. As a software engineer, staying informed about these tools and understanding their strengths and weaknesses can significantly enhance your testing strategy and overall development workflow.

Originally published at https://blog.seancoughlin.me.

Publishing a SvelteKit App to GitHub Pages

Sean Coughlin — Sun, 08 Oct 2023 14:08:35 +0000

Learn the step-by-step guide to effortlessly deploy your SvelteKit application to GitHub Pages and make your web project accessible to the world.

What is SvelteKit?

SvelteKit is a framework for building web applications that are built on top of Svelte, a modern JavaScript UI library. Unlike traditional frameworks that operate mainly on the client side, SvelteKit provides a unified approach to building apps that can be rendered on the server, statically generated at build time, or even rendered client-side. It comes with built-in features like routing, layouts, and server-side rendering (SSR), making it a comprehensive solution for building everything from small, static websites to large, complex web applications. With a focus on performance and a simplified developer experience, SvelteKit aims to streamline the process of building robust and scalable web apps.

Build a SvelteKit App!

This tutorial just spells out how to configure and deploy a SvelteKit web app to GitHub Pages. If you never have created a Svelte application before, the docs are great!

Configuring SvelteKit for GitHub Pages

Build your application using Svelte and SvelteKit

GitHub Pages is a static site host. Therefore, we need to install the Svelte static site adapter.



# NPM install
npm i -D @sveltejs/adapter-static
# YARN install
yarn add @sveltejs/adapter-static --dev

After installing the static adapter, at that to your svelte.config.js.



import adapter from '@sveltejs/adapter-static';
import { vitePreprocess } from '@sveltejs/kit/vite';

/** @type {import('@sveltejs/kit').Config} */
const config = {
    kit: {
        appDir: 'app', // Required as the default is _app
        adapter: adapter()
    },
    preprocess: vitePreprocess()
};
export default config;

Add an app directory output to the svelte.config.js. The typical output is _app so I think something like app makes sense but this can be anything without an underscore. GitHub Pages cannot serve content from directories with special characters like underscores.

If you are deployed to https://[username].github.io that is all that is required for configuration. If you are deploying to https://[username].github.io/your-repo-name you will need to supply a paths.base. See the SvelteKit docs for more details.



import adapter from '@sveltejs/adapter-static';

const dev = process.argv.includes('dev');

/** @type {import('@sveltejs/kit').Config} */
const config = {
    kit: {
        adapter: adapter(),
        paths: {
            base: dev ? '' : process.env.BASE_PATH,
        }
    }
};

Add an empty .nojekyll file in your static folder to prevent GitHub Pages provided Jekyll configurations from managing the site.

Manually build and push your output directory to GitHub or use a tool like gh-pages.

Configure GitHub pages to deploy your app with the repo settings.

Originally published at https://blog.seancoughlin.me.

Deploying to GitHub Pages using gh-pages

Sean Coughlin — Sat, 07 Oct 2023 19:26:50 +0000

Effortlessly Deploy Your Static Websites to GitHub Pages with the gh-pages NPM Package.

What is GitHub Pages?

GitHub Pages is a static site hosting service offered by GitHub that takes files straight from a repository on GitHub and publishes them as a website. It's designed to host your personal, organizational, or project pages directly from a GitHub repository. GitHub Pages supports static HTML, CSS, and JavaScript files, as well as Jekyll, a static site generator that converts Markdown files to HTML. The service is commonly used to host personal portfolios, project landing pages, documentation, and blogs, offering a simple way to turn code repositories into publicly accessible websites.

What is gh-pages?

gh-pages is a Node.js package that provides a simple command-line utility for publishing files to a GitHub Pages branch in your repository. It automates the process of pushing your static assets to the gh-pages branch of your GitHub repository, which is then automatically published by GitHub Pages. This package is often used in combination with site generators or build tools to simplify the deployment process for static websites or client-side web apps.

gh-pages can easily be used to automatically release and deploy any client-side rendered code. React, Angular, Svelte, plain HTML/CSS/Javascript, etc they all work!

Using gh-pages

Setup your GitHub Pages Repo

Open Terminal or Command Line : Navigate to the directory where you want to initialize a new Git repository.
Initialize Git Repository : Run the following command to initialize a new Git repository in that directory:



 git init

Add Files to the Repository : You can add files to be tracked by Git with the following command:



 git add .

Commit Changes : Commit these changes to the repository:



 git commit -m "Initial commit"

Create a Remote Repository : If you haven't already, create a new repository on GitHub. Do not initialize it with README, license, or .gitignore files if you're planning to push an existing repository.
Add Remote Repository : Back in your terminal, run the following command to link your local repository to the remote one:



 git remote add origin [Your GitHub Repo URL]

Verify Remote : You can verify that the remote URL has been added by running:



 git remote -v

Setup and Configure gh-pages

Download the gh-pages package : you can use your favorite node package manager for this step. This module requires Git >= 1.9 and Node > 14.



#NPM installation
npm install gh-pages --save-dev
# YARN install
yarn add gh-pages --dev

Update your package.json scripts : add a predeploy and deploy script. The predeploy setup handles building the static content. The predeploy script will automatically run when the deploy script runs.



// NPM
"scripts": {
    "predeploy": "npm run build",
    "deploy": "gh-pages -d build",
}
// YARN
"scripts": {
    "predeploy": "yarn run build",
    "deploy": "gh-pages -d build",
}

Push the app to the GitHub repository : once again you can use your favorite package manager tool.



#NPM
npm run deploy
# YARN
yarn run deploy

Check the GitHub repo to make sure the code was pushed to remote : gh-pages should have pushed the code to a branch named gh-pages.

Configure GitHub Pages

Navigate to the GitHub Pages on the GitHub repository site
Configure the Build and deployment settings.

I've previously written about Github Pages configurations in one of my very first blog posts. Feel free to check that out to learn more.

That's all! GitHub Actions should automatically use these configurations to take your site live to the internet.

Originally published at https://blog.seancoughlin.me.

Time to Rebrand! Designing a Personal Site with SvelteKit

Sean Coughlin — Sat, 07 Oct 2023 18:04:12 +0000

Site Background

Who am I announcing this to? I'm not sure. It's a total vanity project, but we all need a vanity project or two!

I originally published my site seancoughlin. me around two years ago. At the time, I used a basic Bootstrap resume template. I used raw HTML and CSS with a little plain JS.

I filled out my details, deployed to Github pages, and called it a day. The page saw a few content updates, some under-the-hood optimizations for SEO and Lighthouse, and the addition of minor UI tweaks like Font Awesome icons.

Things were fine, but I felt the site had started to feel dated and didn't reflect my current skills. So I went on the hunt for new ideas.

Finding Inspiration

I am an engineer by trade and CS geek by night. As hard as I try, graphic design just isn't my strong suit. However, people are kind and open-source is awesome! If you ever lack inspiration, search out the community. Just remember to cite the helpful people who contribute to your work :).

After some hunting, I arrived at this cool freeCodeCamp tutorial! This guy was great a great teacher and I learned a lot from this tutorial. I typically work with React so this was my first Svelte introduction. I would say this is a good place to start.

https://youtu.be/-2UjwQzxvBQ?si=mM1Fzy3J8zlaHDwS

I took his great design and made some tweaks such as adding my details, a skills section, and custom links.

If you want to check out the original tutorial code you can find it here. If you want to check out my source code you can find that here.

The Outcome

Please go check out the new site or view some of these fun screenshots.

Cheers!

Originally published at https://blog.seancoughlin.me.

A Comprehensive Guide to AWS DynamoDB vs. Redshift for Databases and Data Warehouses

Sean Coughlin — Sat, 09 Sep 2023 20:13:06 +0000

Unlock the Full Potential of Your Data: An In-Depth Comparison of AWS DynamoDB and Redshift for Streamlined Data Management and Analytics

The topics of databases and data warehouses are central to the modern data landscape, and Amazon's offeringsDynamoDB and Redshiftare standout products in their respective categories. Here's a detailed comparison:

Database vs. Data Warehouse

DynamoDB

Amazon DynamoDB, launched by AWS in 2012, is a fully managed NoSQL database service designed to provide seamless scalability and reliable performance. Built to handle high-velocity data and offer single-digit millisecond latency, DynamoDB supports key-value and document data models, making it well-suited for a variety of applications, including real-time analytics, mobile backends, and serverless architectures. With features like auto-scaling, in-memory caching, and multi-region replication, DynamoDB has become a cornerstone in the AWS ecosystem for developers requiring a highly available and low-latency data store.

Use Cases :

High-velocity data like IoT event streams.
Serverless applications.
Real-time big data analytics.
Mobile applications needing a backend.

Technical Features :

Offers single-digit millisecond latency.
Supports key-value and document data models.
Can be set up for multi-region replication.
Auto-scaling, in-memory caching, backup, and restore functionalities.

AWS Redshift

AWS Redshift, introduced in 2012, is a managed data warehouse service built on a Massively Parallel Processing (MPP) architecture. Based on PostgreSQL, Redshift is engineered for complex query processing and offers robust performance for large datasets by utilizing columnar storage and data compression techniques. Designed to serve the needs of OLAP (Online Analytical Processing) workloads, it integrates seamlessly with a variety of Business Intelligence tools and can handle structured and semi-structured data. As a staple in the AWS service suite, Redshift caters to enterprises and data analysts looking for scalable, fast, and flexible solutions for their analytics needs.

Use Cases :

Business intelligence.
Data analytics.
Batch data processing.
Complex SQL queries over large datasets.

Technical Features :

Columnar storage.
Data compression to improve query performance.
Massively Parallel Processing (MPP) architecture.
Integration with various BI tools and data lakes.

Next Steps

If you're interested in DynamoDB start with AWS's free tier offer for DynamoDB. Then dive into AWS's extensive DynamoDB documentation and sample projects before experimenting with different DynamoDB features like Streams and Global Tables.

If you're interested in Redshift utilize the AWS free trial for Redshift! Then explore the integrations between Redshift and other AWS services like S3, Kinesis, and SageMaker for a more comprehensive data solution.

Originally published at https://blog.seancoughlin.me.

Delete Duplicate Emails

Sean Coughlin — Sat, 09 Sep 2023 19:45:03 +0000

Eliminating Duplicate Emails Efficiently: A Comprehensive Guide to Data Cleanup Using Pandas and SQL

The Problem

With this article, I will be covering the delete duplicate emails Leetcode problem.

Leetcode describes this problem as easy. That's a super reasonable evaluation as the solution requires only basic SQL or Pandas knowledge.

The problem description is as follows:

Write a solution to delete all duplicate emails, keeping only one unique email with the smallest id.

For SQL users, please note that you are supposed to write a DELETE statement and not a SELECT one.

For Pandas users, please note that you are supposed to modify Person in place.

After running your script, the answer shown is the Person table. The driver will first compile and run your piece of code and then show the Person table. The final order of the Person table does not matter.
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| id | int |
| email | varchar |
+-------------+---------+
id is the primary key (column with unique values) for this table.
Each row of this table contains an email. 
The emails will not contain uppercase letters.

The Solution

Pandas

Pandas is a great Python tool for data analysis and manipulation. Built into that library is the drop duplicates function. Please note that the problem statement asks us to do this in place.

Using the Pandas library this can be achieved by first in-place sorting by the id field and then dropping the duplicates from email. We want to keep at least the first duplicated element.

def delete_duplicate_emails(person: pd.DataFrame) -> None:
    person.sort_values(by='id', inplace=True)
    person.drop_duplicates(subset='email', keep='first', inplace=True)

Voila! I love these simple questions.

SQL

In SQL we want to run a delete query. We will grab two copies of the person table and match them based on the email. To keep at least one of the solutions we only delete the entry with the higher id value. This keeps the email associated with the smallest id.

DELETE p1 
FROM person p1, person p2 
WHERE p1.email = p2.email AND p1.id > p2.id;

As with many problems, there are multiple ways to solve them. These Pandas and SQL solutions are but one way of approaching the delete duplicate question.

Originally published at https://blog.seancoughlin.me.

Understanding Amazon Route 53: An In-depth Guide

Sean Coughlin — Fri, 08 Sep 2023 14:46:40 +0000

Introduction

In today's cloud-centric world, one of the most crucial services often overlooked is the Domain Name System (DNS). A robust DNS service is foundational to ensure that your web applications are scalable, secure, and highly available. One such leading service in this space is Amazon Route 53, part of Amazon Web Services (AWS). This blog post aims to provide a comprehensive guide on what Amazon Route 53 is, its history, how it compares with other services and its myriad use cases.

A Glimpse into the Past: The Background of Amazon Route 53

Amazon launched Route 53 in December 2010, and it has since become a cornerstone of AWS offerings. The name "Route 53" is a reference to TCP and UDP port 53, where DNS server requests are addressed. Amazon created this service to provide an extremely reliable and cost-effective way to route end-user requests to various endpoints, such as an Amazon EC2 instance or an S3 bucket, in a globally distributed manner.

How Does Route 53 Compare to Other Services?

To truly understand the value that Amazon Route 53 brings to the table, it's useful to compare it to other comparable DNS services:

Google Cloud DNS: This is Google Cloud's offering, designed to provide high-performance and premium networking.
Azure DNS: Microsoft's DNS offering for Azure provides seamless integration with other Azure services.
Cloudflare: Apart from offering DNS services, Cloudflare provides a range of additional features, such as DDoS protection and CDN services.
Dyn: Acquired by Oracle, Dyn offers a feature-rich DNS service that focuses particularly on performance and uptime.
NS1 (IBM): A less conventional but highly flexible service that provides data-driven DNS routing capabilities.

Unveiling the Multiple Use Cases of Route 53

Amazon Route 53 offers a plethora of functionalities that go beyond basic domain name registration and DNS routing. Below are some key use cases:

Domain Name Management - Whether you want to register a new domain name or transfer an existing one, Route 53 has you covered. It offers domain registration services, including various domain name extensions such as .com, .org, and .net.
DNS Record Management - Route 53 provides a simple way to manage DNS records, including A Records, CNAMEs, and MX Records. You can point these to your preferred AWS resources easily through the AWS Management Console.

Side note - DNS record types

A - maps a hostname to an IPv4 address

AAAA - maps a hostname to an IPv6 address

CNAME - maps a hostname to a hostname

MX - mail exchange servers

Etc

Health Checks and Monitoring - Amazon Route 53 can perform health checks on your application and its various components. If an endpoint becomes unavailable, Route 53 reroutes traffic to a healthy endpoint, ensuring high availability.
Load Balancing - Route 53 integrates well with AWS Load Balancers, enabling you to distribute incoming application traffic across multiple targets, such as EC2 instances, in multiple Availability Zones.
Geographical Routing - With geolocation routing, you can route traffic according to the geographic location of your users, optimizing latency and improving user experience.
Private DNS Records for AWS Resources - For internal AWS resources, Route 53 allows you to configure private DNS records, making internal routing simpler and more secure.
Advanced Application Routing - The service can also be used for advanced application-level routing, like A/B testing or blue-green deployments, through DNS queries.

Conclusion

Amazon Route 53 is more than just a DNS service; it's a complete cloud DNS web service designed for developers and businesses alike. From domain registration to advanced DNS routing techniques, Route 53 offers a suite of features that cater to different needs. Given its importance in the realm of cloud computing, having a good grasp of Amazon Route 53 is beneficial for anyone involved in web development, IT management, or cloud services.

Whether you're just getting started with AWS or looking to optimize your existing cloud infrastructure, Route 53 is an invaluable tool that deserves a closer look.

Originally published at https://blog.seancoughlin.me.

How to validate a Sudoku board

Sean Coughlin — Thu, 07 Sep 2023 15:30:52 +0000

The Problem

With this article, I will be covering the valid sudoku Leetcode problem.

Leetcode describes the problem with the following:

Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules :

Each row must contain the digits 1-9 without repetition.

Each column must contain the digits 1-9 without repetition.

Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.

Note:

A Sudoku board (partially filled) could be valid but is not necessarily solvable.

Only the filled cells need to be validated according to the mentioned rules.

Leetcode ranks this problem as a medium. I think that is an appropriate rating. The solution is feasible but does require some out-of-the-box reasoning.

The Solution

    def isValidSudoku(self, board):
        seen = set()
        for i in range(9):
            for j in range(9):
                number = board[i][j]
                if number != ".":
                    row = str(number) + "row" + str(i)
                    column = str(number) + "column" + str(j)
                    block = str(number) + "block" + str(i / 3) + "/" + str(j/3)
                    if row in seen or column in seen or block in seen:
                        return False
                    seen.add(row)
                    seen.add(column)
                    seen.add(block)
        return True

Solution Description

seen = set(): Creates an empty set named seen to keep track of numbers that have already appeared in rows, columns, and 3x3 blocks.
Two nested loops for i in range(9) and for j in range(9) iterate through each cell of the 9x9 board.
number = board[i][j]: Stores the current cell's value in the variable number.
if number != ".":: Checks if the cell is not empty (a dot indicates an empty cell in this context).
row = str(number) + "row" + str(i): Creates a string like 1row0 to indicate that the number 1 is in row 0.
column = str(number) + "column" + str(j): Creates a string like 1column0 to indicate that the number 1 is in column 0.
block = str(number) + "block" + str(i / 3) + "/" + str(j/3): Creates a string like 1block0/0 to indicate that the number 1 is in the top-left 3x3 block.
if row in seen or column in seen or block in seen:: Checks if any of these strings already exist in the seen set. If so, the board is not valid and the function returns False.
seen.add(row), seen.add(column), seen.add(block): Adds the newly created strings to the seen set so that they can be checked against future cells.
If all cells are valid, the function returns True, indicating a valid Sudoku board.

Big O Analysis

Assuming n is the side length. We have a double for-loop so that is at least O(n^2). Inside the nested loops, the operations (like adding to a set, creating strings, and checking for membership in a set) are O(1) operations. Therefore, the overall runtime is O(n^2).

Originally published at https://blog.seancoughlin.me.

How to Find First and Last Position of Element in Sorted Array

Sean Coughlin — Tue, 05 Sep 2023 23:18:35 +0000

The Problem

With this article, I will be covering the Find First and Last Position of an Element in a Sorted Array problem.

Leetcode describes the problem with the following:

Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value.

If target is not found in the array, return [-1, -1].

You must write an algorithm with O(log n) runtime complexity.

Example:

Input: nums = [5,7,7,8,8,10], target = 8

Output: [3,4]

Leetcode ranks this problem as a medium. I think that is an appropriate rating. The solution is feasible but does require some algorithmic understanding.

Naive Approach and Its Limitations

The naive approach for solving this problem would be to scan through the array linearly to find the first and last occurrence of the target value. This involves looping through the array once to find the first occurrence of the target and marking that index as the starting position, then looping through it again to find the last occurrence and marking that as the ending position.

While this approach works, it takes O(n) time to solve, which doesn't meet the constraint of O(log n) runtime complexity. Therefore, it would become inefficient when dealing with large datasets.

The Solution

To achieve a runtime complexity of O(log n), we can use binary search. A binary search is possible because the array is already sorted. In this optimized approach, we will perform two binary searches:

Finding the Leftmost Position : The first binary search will find the leftmost or the first occurrence of the target value.
Finding the Rightmost Position : The second binary search will find the rightmost or the last occurrence of the target value.

Here's how each binary search would work:

Leftmost Position : Initialize left to 0 and right to n - 1 (where n is the length of the array). In the while loop, calculate the middle index as (left + right) // 2. If target > nums[mid], set left = mid + 1. Otherwise, set right = mid - 1. After the loop, check if nums[left] is the target to confirm.
Rightmost Position : Initialize left to 0 and right to n - 1 again. This time, if target >= nums[mid], set left = mid + 1. Otherwise, set right = mid - 1. After the loop, check if nums[right] is the target to confirm.
Finally return [-1, -1] if the location of the left and right position overlap.

Notice that the key difference between the left and right searches is the use of the greater than or equal to check on the right search.

class Solution(object):
    def searchRange(self, nums, target):
        left, right = 0, len(nums) - 1
        while left <= right:
            mid = (left + right) / 2
            if target > nums[mid]: 
                left = mid + 1
            else: 
                right = mid - 1
        left_to_return = left

        left, right = 0, len(nums) - 1
        while left <= right:
            mid = (left + right) / 2
            if target >= nums[mid]: 
                left = mid + 1
            else: 
                right = mid - 1

        if left_to_return <= right:
            return (left_to_return, right) 
        else:
            return [-1, -1]

Time Complexity

Each binary search has a time complexity of O(log n), and since we are performing two binary searches, the overall time complexity remains O(log n).

This optimized approach not only meets the problem's algorithmic constraint but also efficiently finds the target's starting and ending positions in the array.

Originally published at https://blog.seancoughlin.me.

UIUC MCS - CS 513 Review - Theory and Practice of Data Cleaning

Sean Coughlin — Tue, 05 Sep 2023 02:45:31 +0000

Overview

TLDR: 513 won't teach you very much, and what you will learn is highly outdated, but it's an easy 500-level course.
Difficulty: Very easy
Opinion: Disliked
Weekly workload: 2 hours
Semester: Summer 2023

Class Content

Lecture Content

Every week consisted of about an hour of lectures. The topics covered included data validation, profiling, relational models, Datalog, SQL, Workflows, Provenance, and YesWorkflow. I could not figure out exactly when these lectures were recorded, but I'm guessing they are close to a decade old. Ideally, they should all be rerecorded at this point and factor in newer material.

I'm not sure why the course title includes 'theory' as the lectures focused entirely on data-cleaning practices. But each week had links to data cleaning papers, and those contained good resources. A diligent student who consumes all those external papers could learn a lot and cover a lot of theory ground. The course doesn't have any mechanism for enforcing reading.

Assignments

As with most MCS courses, there were weekly quizzes. The quizzes allowed for unlimited attempts and never took more than a few minutes to complete.

There were six homework assignments. In order they were Regular Expressions, OpenRefine, Datalog, SQL, Provenance, and Python. None of these assignments took more than two to three hours to complete. They all were basic implementation and programming assignments with autograders.

The class did not have any exams. Instead, it concluded with a two-phase group project. Groups consisted of three people. The setup of the project did not require much collaboration, and my team corresponded entirely over Teams messages without any synchronous meetings.

The project required cleaning some given datasets. Then you had to write a paper analyzing essentially how dirty the dataset was before and how much you were able to clean or improve it through your process. You also had to submit documentation about your cleaning process and write up some potential benefits of the cleaning. There was not any difficulty with the project.

My Takeaways

This class is ridiculously easy. It does not feel adequate at the graduate level and certainly should not be a 500-level course. I can see how many would be disappointed by the lack of rigor in what is an otherwise challenging program. If you are paying by the credit hour, it makes sense that you would want a considerable knowledge return on investment. I simply don't think this class offers that.

I think the biggest disappointment is data cleaning is a crucial skill for all data science or software engineer jobs. The content is so important that the class deserves to be good! If the content was updated and some of the assignments swapped this class could be something special. Unfortunately, the execution is not there right now.

All that being said, there are not many 500-level options, so you will probably need to take this class. Additionally, the low difficulty did make for a very well-balanced semester when paired with CS 416. I would recommend pairing this class with something else, and you'll still have a decently challenging semester.

Banner Credit

The banner was generated using the UIUC LinkedIn Banner Generator. It is an awesome tool if you need an Illinois-themed banner for anything.

More Reviews

Check out uiucmcs.org for more reviews of MCS courses. I don't know who maintains this site, but it's a good review collection from many semesters.

I have also written up a CS 427 review, a CS 435 review, a CS 498 Cloud Computing review, and a CS 416 review.

Originally published at https://blog.seancoughlin.me.

UIUC MCS - CS 416 Review - Data Visualization

Sean Coughlin — Tue, 05 Sep 2023 01:51:05 +0000

Computer Science 416 covers computer graphics, psychology, and human perception.

Overview

TLDR: 416 is a fun, laid-back class with two major assignments, a midterm, and a final. I had fun and did not have to stress very much.
Difficulty: Easy
Opinion: Enjoyed
Weekly workload: 5 hours
Semester: Summer 2023

Class Content

Lecture Content

The course had weekly lectures. Topics included data types, human perception, psychology, integrating data into web pages, interactive visualization, narrative visualization, and declarative visualizations. There were one to two hours of lectures per week. The lectures could easily be watched at 1.5 speed if necessary.

I found the lectures to be a nice change of pace from many other computer science courses. They covered technical concepts but focused on humans and how to design for people. For example, there were a few videos on optical illusions. The optical illusions were used to introduce various quirks of the human eye and how to design visualizations that leveraged those human features.

Assignments

Every week of the course had an associated quiz. The quizzes were all released ahead of schedule which made time management a breeze. Thankfully, each quiz could be taken as many times as desired, so this was a nice review and an easy class grade.

The class also had two major projects. The first was a visualization dashboard that you had to build with Tableau. The second was a narrative visualization website that had to be built with HTML/CSS/JavaScript and the D3 library.

For the first project, you were required to create a dashboard that synthesized multiple datasets, visualized at least two charts, and supported cross-filtering between the charts. Students could choose to visualize any dataset of their pleasure and the assignment parameters were fairly broad so you could get pretty creative with the implementation.

I know Tableau is incredibly common among data scientists and those working in analytical jobs. I work as a software engineer for my day-to-day job. My role does not require Tableau so the visualization dashboard project was my first introduction to the tool. I think this assignment was a good introduction and very approachable. I completed it over the course of two nights.

The second project was more involved. You were required to analyze some dataset, find a story in that data, then build a website using plain JavasScript with multiple pages telling that story, and finally write a report afterward describing everything. It was a lot. I still felt like it was a good project, but it took some serious effort to complete.

Exams

The course had one midterm and a final. The exams were non-cumulative and relatively easy for multiple choice. Each exam was about 20 questions, proctored, and you had one hour to complete it.

Each exam was administered through ProctorU. ProctorU has always been a nemesis of mine, and this semester only got worse. We were forced to use a Chromium-based browser called Guardian. Guardian is easily one of the worst pieces of software I've ever used. It frequently crashes, and I hate downloading that type of spyware to my machine. Unfortunately, there was no other way to take the exams.

Exams were quick and easy. I'm to the point in my educational career where I'm tired of studying and taking exams. I appreciate that this course emphasized the projects over the exams.

My Takeaways

I think this class could be really useful for anyone interested in pursuing analyst or data science-type roles. This content feels fundamental and very relevant for those roles.

As a software engineer, I didn't find many takeaways that would be useful in my current job. However, I still had a really good time in this class. The assignments were well-constructed, the lectures were novel, and the projects were fairly useful.

If you're interested in a class that focuses on the softer side of computer science, I would highly recommend this course.

Banner Credit

The banner was generated using the UIUC LinkedIn Banner Generator. It is an awesome tool if you need an Illinois-themed banner for anything.

More Reviews

Check out uiucmcs.org for more reviews of MCS courses. I don't know who maintains this site, but it's a good review collection from many semesters.

I have also written up a CS 427 review, CS 435 review, and CS 498 Cloud Computing review.

Originally published at https://blog.seancoughlin.me.