Title

### The Spark of Curiosity: Building My First PC (2010)
My journey into the world of technology began in 2010, sparked by the curiosity of assembling my first PC. This hands-on experience laid the foundation for my tech career, opening my eyes to the inner workings of computers and the magic of turning individual components into a functional whole.

### Diving into Mobile App Development at MIT (2012)
Two years later, I found myself immersed in the dynamic field of mobile app development. The iOS developer camp at MIT wasn't just an educational experience; it was a transformative one. It taught me the power of mobile platforms and the impact of apps on everyday life.

### Web Development and Academic Pursuits at Penn State (2013)
In 2013, my path took a creative turn as I started developing my own websites. This venture into the digital landscape coincided with the beginning of my bachelor's degree in Information Sciences and Technology (IST) at Penn State University. It was here that I began to formalize my education and align my practical skills with academic knowledge.

### Mastering Business Analytics at BI (2018)
Continuing my academic and professional growth, I embarked on a master's degree in Business Analytics in 2018. This advanced program at BI honed my analytical skills and provided a comprehensive understanding of how data-driven strategies can transform businesses.

### Stepping into Data Engineering at Helthjem (2020)
By 2020, I was ready to take on the real-world challenges of a data engineer. My role at Helthjem was not just a job; it was a proving ground for my skills in cloud platforms like AWS and GCP, and tools such as BigQuery, Athena, SQL, Python, S3, Glue, and SQS. This experience was instrumental in shaping my approach to data infrastructure and solutions.

### Consulting and Certification: The Capgemini Era (2021)
My most recent professional leap in 2021 was joining Capgemini as a data engineer consultant. Here, I build sophisticated data platforms using Databricks and Azure, further expanding my technical repertoire. Achieving certification as a professional data engineer in Databricks was a milestone that not only validated my expertise but also marked a new chapter of innovation and leadership.

Reflecting on the past decade, my journey from assembling PCs to engineering complex data platforms illustrates a trajectory of relentless learning and adaptation. As technology continues to evolve, so does my passion for mastering it, and I am excited to see where this path will lead me next.

My Journey to Data Engineering: A Decade of Growth and Learning

In the ever-evolving landscape of data engineering and data science, managing and processing large volumes of data efficiently is paramount. Delta Lake, an open-source storage layer that brings reliability to Data Lakes, has emerged as a robust solution for handling big data challenges. In this blog post, we will explore how you can leverage Delta Lake on Databricks to enhance your data management and analytics capabilities.

### What is Delta Lake?
Delta Lake is a storage layer that runs on top of your existing data lake and is fully compatible with Apache Spark APIs. It provides ACID transactions, scalable metadata handling, and unifies streaming and batch data processing. Delta Lake runs on top of your existing data lake and fully leverages Spark's distributed processing power.

### Key Features of Delta Lake
- **ACID Transactions**: Ensures data integrity with ACID transactions on Spark.
- **Scalable Metadata Handling**: Handles millions of files, providing a quick response time to operations like read, write, and metadata.
- **Time Travel (Data Versioning)**: Tracks historical data enabling rollbacks, audits, and reproductions.
- **Schema Enforcement**: Automatically enforces schema to ensure data quality.
- **Unified Batch and Streaming Sink and Source**: A table in Delta Lake can be a batch table, a streaming source, and a streaming sink simultaneously.

### Getting Started with Delta Lake on Databricks
To demonstrate how to use Delta Lake, we'll walk through a Python code example where we'll set up a Delta table, perform some data operations, and query the data using Databricks.

Prerequisites
Before we start, make sure you have:

- A Databricks workspace.
- A cluster running on Databricks with Delta Lake support.

### Step 1: Setting up a Delta Table
Let's create a Delta table from a sample data frame:

```python
# Import necessary libraries
from pyspark.sql import SparkSession
from pyspark.sql.functions import *

# Start a Spark session
spark = SparkSession.builder.appName("DeltaLakeExample").getOrCreate()

# Sample data
data = [
  (1, "Chicago", 3.0),
  (2, "San Francisco", 5.0),
  (3, "New York", 6.1)
]

# Create a DataFrame
df = spark.createDataFrame(data, ["id", "city", "rating"])

# Write the DataFrame as a Delta Lake table
df.write.format("delta").save("/delta/events")
```

### Step 2: Reading from the Delta Table
Reading data from the Delta table is as simple as reading a regular Spark DataFrame:


```python
# Load the data back as a Delta Lake table
df = spark.read.format("delta").load("/delta/events")

# Show the data
df.show()
```
### Step 3: Modifying Data and Time Travel
Delta Lake allows you to modify the table with full transactional integrity.

```python
# Update data in the Delta table
df_updated = df.withColumn("rating", col("rating") + 1)
df_updated.write.format("delta").mode("overwrite").save("/delta/events")

# Read the updated data
df_updated = spark.read.format("delta").load("/delta/events")
df_updated.show()

# Time travel to previous version
df_version0 = spark.read.format("delta")\
                        .option("versionAsOf", 0).load("/delta/events")
df_version0.show()
```
### Step 4: Querying with SQL
You can also run SQL queries directly on Delta tables using Databricks:

```python
# Register the Delta table as a SQL table
spark.sql("CREATE TABLE events USING DELTA LOCATION '/delta/events'")

# Run SQL query
spark.sql("SELECT * FROM events WHERE city = 'Chicago'").show()
```

### Step 5: Streaming Data into Delta Lake
Delta Lake seamlessly integrates with Spark Structured Streaming.

```python
# Define the streaming DataFrame
streaming_df = spark.readStream.format("rate").load()

# Stream data into the Delta table
query = (
  streaming_df
  .writeStream
  .format("delta")
  .option("checkpointLocation", "/delta/events/_checkpoints")
  .outputMode("append")
  .start("/delta/events")
)

# Remember to stop the stream when you're done
query.stop()
```

### Conclusion
Delta Lake provides a rich set of features that can significantly enhance your data management and analytics workflows on Databricks. Whether you are dealing with batch or streaming data, Delta Lake ensures consistency, reliability, and performance.

By integrating Delta Lake into your Databricks environment, you can overcome common challenges associated with big data processing and achieve seamless, transactional data operations. With its robust tooling and native integration with Apache Spark, Delta Lake is a compelling choice for data engineers and scientists looking to streamline their data pipelines.

Start experimenting with Delta! Now that you have gathered intel on Delta Lake why not get a [Lakehouse Fundamental](https://www.databricks.com/learn/certification/lakehouse-platform-fundamentals) badge 😃

Harnessing the Power of Delta Lake on Databricks for Robust Data Management

Embarking on the journey to become a Databricks Certified Data Engineer Professional is a commendable goal. This certification is a testament to one's proficiency in data engineering on the Databricks platform. Here's a comprehensive guide to help you prepare for the exam and ensure your success.

### Understand the Exam Structure and Content
The [Databricks Data Engineer Professional](https://www.databricks.com/learn/certification/data-engineer-professional) exam is designed to assess your knowledge and skills in implementing and running data engineering workloads on the Databricks platform. It's essential to familiarize yourself with the exam's structure, which includes 60 multiple-choice questions, covering a range of topics from data transformation to performance optimization.

A breakdown of the exam:
- Databricks Tooling – 20%
- Data Processing – 30%
- Data Modeling – 20%
- Security and Governance – 10%
- Monitoring and Logging – 10%
- Testing and Deployment – 10%

You will have 120 minutes to complete the exam, with a minimum passing score of 70% (42/60).

### Deep Dive into the Databricks Environment
Proficiency in the Databricks environment is crucial. Spend time exploring the Databricks workspace, understanding how to manage clusters, and becoming comfortable with the Databricks File System (DBFS). Knowledge of Databricks notebooks, which allow for collaborative coding, is also vital.

### Master Data Processing and Transformation
Data engineering is largely about processing and transforming data. Be sure you're well-versed in using Databricks for ETL (extract, transform, load) processes, and you can leverage Apache Spark effectively for data manipulation. Familiarity with [Delta Lake](harnessing-the-power-of-delta-lake-on-databricks-for-robust-data-management) on Databricks and its role in building reliable data lakes is also important.

### Sharpen Your SQL and Python Skills
The exam will test your ability to use SQL and [Python](python-best-practices-writing-clean-and-maintainable-code) for data engineering tasks. Ensure your SQL skills are up to scratch for querying and manipulating data. Python is also essential, particularly for creating data pipelines and working with Spark DataFrames on Databricks.

### Understand Data Storage and Optimization
Knowing how to store and retrieve data efficiently is key. This includes understanding table formats, partitioning strategies, and data indexing. Being able to implement caching and other performance optimization techniques within Databricks will also be tested.

### Get Comfortable with Data Security and Compliance
Data security is a top priority in data engineering. Be sure you understand how to implement security and compliance within the Databricks platform, including access controls and data encryption methods.

### Practice with Real-World Scenarios
Apply your knowledge by working through real-world scenarios. The Databricks platform offers various case studies and examples that can provide practical experience. This hands-on practice is invaluable and will help solidify your understanding of the concepts.

Play around with the community version:
- [Databricks Community Ed.](https://docs.databricks.com/en/getting-started/community-edition.html)

### Leverage Databricks' Resources
Databricks provides a wealth of resources to help you prepare, including documentation, webinars, and training materials. Take advantage of these to deepen your knowledge and address any gaps in your understanding.

Good places to start:
- [Databricks Academy](https://www.databricks.com/learn/training/login)
- [Udemy](https://www.udemy.com/share/108pzA3@5dkX1ODaJVUfNlh1cMIpLEH1A_hkN_GtcFbXLxtw2s1CgyndnrL8Kwn3xAQv3MGY/)

### Join the Community
Engaging with the Databricks community can provide insights and tips from those who have already taken the exam. Participate in forums, attend meetups, and connect with peers to share knowledge and experiences.

### Schedule Regular Study Times
Consistency is key when preparing for any certification exam. Set aside regular study times, and create a study plan that covers all the exam objectives. This structured approach will help ensure that you’re well-prepared when exam day comes.

### Practice with Sample Exams
Finally, take advantage of sample exams and practice questions. These will not only test your knowledge but also get you accustomed to the format and time constraints of the actual exam.

My go to Databricks practice exam:
- [Practice Exams: Databricks Data Engineer Professional (Udemy)](https://www.udemy.com/share/108F9M3@pOEiAjLETyh8qPN0jwP_COrcXAn3GzOUHg9095BugGPgJQCxuGfdm-G2dAc1U_Mf/)

By following these tips and dedicating yourself to a comprehensive study plan, you'll be well on your way to achieving the Databricks Data Engineer Professional certification. Good luck!

Preparing for the Databricks Data Engineer Professional Exam: Key Insights and Tips

Python is known for its simplicity and readability, making it an excellent choice for beginners and experts alike. However, writing Python code that is not only functional but also clean and maintainable requires following certain best practices. This is often referred to as [The Zen of Python](https://peps.python.org/pep-0020/#the-zen-of-python), a set of guideline principles. You can read the 19 of them them by importing this in python.

```python {1}
import this

# Output

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```
Here are some key tips accompanied by code examples to help you write better Python code.

### Use Descriptive Naming for Variables and Functions
Names should reflect purpose and context. Avoid vague names like list1 or doThing and opt for descriptive ones like customer_names or calculate_tax.

```python
# Bad Practice
def calc(a, b):
    return a * 1.1 + b

# Good Practice
def calculate_total_price(exclusive_price, tax_rate):
    return exclusive_price * (1 + tax_rate)
```

### Follow the PEP 8 Style Guide
[PEP 8](https://peps.python.org/pep-0008/) is Python's official style guide. It includes rules for formatting your code which helps maintain consistency and readability.

```python
# Bad Practice
import sys, os

def foo_bar(*args,**kwargs): print("Hello World")

# Good Practice
import os
import sys

def foo_bar(*args, **kwargs):
    print("Hello World")
```

### Leverage List Comprehensions for Conciseness
List comprehensions provide a concise way to create lists. Use them to write cleaner and more efficient code.

```python
# Bad Practice
squared_numbers = []
for x in range(10):
    squared_numbers.append(x * x)

# Good Practice
squared_numbers = [x * x for x in range(10)]
```

### Utilize Docstrings for Documentation
Docstrings are a way to document your functions, methods, and classes.  

```python
# Bad Practice
def add(a, b):
    return a + b

# Good Practice
def add(a, b):
    """Add two numbers and return the result.
    
    Args:
        a (int/float): First number to add.
        b (int/float): Second number to add.
    
    Returns:
        int/float: The sum of a and b.
    """
    return a + b
```

### Write Functions with a Single Functionality
Each function should have a single responsibility. This makes your code more testable and reusable.

```python
# Bad Practice
def process_data(data):
    # Multiple functionalities within a single function
    pass

# Good Practice
def clean_data(data):
    pass

def analyze_data(data):
    pass
```

### Handle Exceptions with Specificity
Catching exceptions is crucial, but you should always aim to catch specific exceptions rather than all exceptions.

```python
# Bad Practice
try:
    risky_operation()
except Exception as e:
    pass

# Good Practice
try:
    risky_operation()
except ValueError as e:
    pass
```

### Use Underscores for Large Numbers
Underscores can be used for visual separation in large numbers, which makes them more readable.

```python
# Bad Practice
number_of_stars = 1000000

# Good Practice
number_of_stars = 1_000_000
```

### Avoid Global Variables
Global variables can make your code harder to understand and debug. Pass variables to functions as parameters instead.

```python
# Bad Practice
counter = 0

def increment():
    global counter
    counter += 1

# Good Practice
def increment(counter):
    return counter + 1
```

### Use Context Managers for Resource Management
Context managers ensure resources are properly managed, for example when working with file operations.

```python
# Bad Practice
file = open('example.txt', 'w')
file.write('Hello, World!')
file.close()

# Good Practice
with open('example.txt', 'w') as file:
    file.write('Hello, World!')
```

By incorporating these best practices into your daily coding routine, you'll improve not only the quality of your code but also your efficiency and effectiveness as a Python developer. Remember, writing code is often a collaborative effort, so clean and maintainable code is crucial for teamwork and long-term project success.

Python Best Practices: Writing Clean and Maintainable Code


In the ever-evolving digital landscape, bloggers and content creators are constantly seeking innovative ways to streamline their workflows. Automation stands out as a powerful tool, simplifying repetitive tasks and enhancing productivity. In this article, I'll share how I transformed my blogging process using an ingenious automation flow that integrates GitHub issues, ChatGPT, and a Postgres database (via Supabase), all orchestrated through Zapier.

### The Genesis: Idea to Implementation
The inception of this automation flow began with a simple idea: to leverage technology to make the process of creating and publishing blog posts more efficient. The goal was to automate the creation of a new blog post in my database whenever a GitHub issue was created and subsequently processed using ChatGPT.

The Zap [^1] in action:

![Zapier Automation](https://res.cloudinary.com/dljq02nhe/image/upload/v1699997576/Blog/zapier-automation_mewzsr.png)

**Step 1: Harnessing GitHub Issues as a Starting Point**

Every great blog post starts with an idea. For me, these ideas begin as GitHub issues. I found GitHub issues to be an excellent way to organize and track blog post ideas. They are easy to create, can be tagged and categorized, and allow for collaborative input.

**Step 2: ChatGPT – The Creative Assistant**

Once an issue is created, ChatGPT comes into play. This AI-driven language model, developed by OpenAI, is a game-changer. It assists in fleshing out the blog post, providing a draft based on the initial idea. This integration significantly reduces the time spent on the initial draft and offers a unique perspective, thanks to its AI capabilities.

**Step 3: Storing in Postgres via Supabase**

After ChatGPT creates the draft, the next step is to store it. For this, I chose a Postgres database, managed through Supabase - an open-source Firebase alternative. Supabase offers a user-friendly interface and robust features, making it an excellent choice for managing my blog's backend.


### The Role of Zapier: The Automation Maestro
The glue that binds all these components together is Zapier. This online automation tool connects your favorite apps and services, automating workflows without the need for manual intervention. 
Here's how Zapier makes the magic happen:

- **Trigger:** The process begins when a new GitHub issue is created.
- **Action:** Zapier then triggers ChatGPT to start working on the draft.
- **Result:** Once the draft is ready, Zapier pushes this data to the Postgres database in Supabase.

### The Impact: Efficiency and Creativity Unleashed
The results of this automation flow have been remarkable:

- **Time-Saving:** What used to take hours, now takes minutes. The time from idea to draft has been drastically reduced.
- **Consistency:** Each blog post follows a consistent format and structure, ensuring quality and coherence.
- **Flexibility:** Ideas can be added to GitHub from anywhere, and the automated process takes care of the rest.

### Future Enhancements and Considerations
While this automation flow works seamlessly, there's always room for improvement:

- **Refining AI Outputs:** Integrating further AI tools for grammar and style checks could enhance the quality of the drafts.
- **Feedback Loop:** Implementing a system to incorporate feedback into the draft before finalizing it.

### Conclusion: Embracing Automation in Blogging
This automation flow demonstrates the power of integrating various technologies to create a seamless and efficient blogging process. It's a testament to how automation, when thoughtfully implemented, can significantly enhance productivity and creativity.

As we continue to explore the capabilities of AI and automation tools, the potential to revolutionize content creation is immense. By sharing this journey, I hope to inspire fellow bloggers and creators to explore the possibilities of automation in their creative processes.

In fact this very post was initially drafted using this very idea! The title along with the context of the issue is passed to the OpenAI (GPT-V.3.5-Turbo API) prior to sending the reponse to my backend. See here:

![Github Issue](https://res.cloudinary.com/dljq02nhe/image/upload/v1699998292/Blog/Github-Issue_gncwsn.png)



[^1]: Requires premium capabilities

My Journey to Data Engineering: A Decade of Growth and Learning

Table of Contents:

The Spark of Curiosity: Building My First PC (2010)

Diving into Mobile App Development at MIT (2012)

Web Development and Academic Pursuits at Penn State (2013)

Mastering Business Analytics at BI (2018)

Stepping into Data Engineering at Helthjem (2020)

Consulting and Certification: The Capgemini Era (2021)

Did you enjoy this post?