Recently open-sourced the playwright-ai project – a tool to generate LLM-based Playwright functional tests. Try it out via the docs at: https://github.com/vladikoff/playwright-ai

Still early, but it is useful for web projects that have zero functional tests! It has some fun stuff like support for OpenAI and Anthropic models in the CLI and self-healing tests through re-prompting. Hopefully more features soon…

Supported models:

• Anthropic’s Claude – configure API key with an ANTHROPIC_API_KEY.
• OpenAI’s GPT3 and GPT4 – configure API key with an OPENAI_API_KEY.

Quick start

• Make sure you have the most basic Playwright installation with npm init playwright@latest. See https://playwright.dev/docs/intro#installing-playwright for details.
• Install the CLI:

npm -g playwright-ai

• Obtrain the API key for the LLM model of your choice: Anthropic or OpenAI.
• Execute the CLI from project directory:

playwright-ai --endpoint=https://example.com --model=claude --tests=1

• After the CLI is done, it will generate the tests into the Playwright test directory. As the tests generate, the CLI will have both passing and failing tests. The failing tests will have to be manually fixed by the user of the tool.

I suggested using either the GPT-4 or Claude 2 models to get better results. Try out the tool in your own projects and let me know if it generated useful tests!

For JavaScript developers of all levels, my new book “Building Your Own JavaScript Framework” offers valuable insights into the world of all sorts of JavaScript frameworks. Whether you’re new to the scene or a seasoned expert, understanding how frameworks function under the hood will refine your skills and perspective.

In this book, we’ll explore the dynamic history of JavaScript frameworks, fueled by an innovative community pushing the boundaries of web development on both the front-end, back-end, and in other spaces. We’ll look at how each new framework brings a unique philosophy and solution set to common challenges.

Our goal extends beyond simply creating a framework from scratch. This book aims to deepen your comprehension of reusable architectures and encourage thinking from a framework point of view. With this improved understanding, you’ll be equipped to craft, maintain, and advance your own frameworks.

The book starts by introducing the JavaScript framework landscape. We’ll guide you through building your own framework, highlighting best practices along the way. To fully benefit, you should have a solid grasp of JavaScript and some experience with existing frameworks. Whether you’re a JavaScript expert or just starting out, this book will provide new depths of insight.

Key Features:

Explore the gateway to the constantly evolving world of JavaScript frameworks.

Navigate the JavaScript development landscape and master crucial software architecture patterns.

Your ultimate guide to building your own framework for career-related projects and beyond!

Check out the publication page for more information.

I got the honour of speaking at the Refactor DX 2023 conference in my hometown – Toronto. This was a great opportunity for me to share my knowledge and insights on end-to-end testing for modern web applications.

My talk was titled “The State of End-to-End Testing for modern web applications.” In this session, I discussed how the landscape for end-to-end testing has evolved since 2004. Back then, testing complex web apps end-to-end was painfully difficult and time-consuming. But today, thanks to modern testing frameworks and cloud services, it’s much easier to thoroughly test front-end, back-end, APIs, and everything in between.

You can watch the recorded version of my talk below:

During my talk, I outlined some of the main challenges we used to face when doing end-to-end testing:

• Setting up and maintaining our own testing environments
• Dealing with flaky tests and false failures
• Writing and maintaining tons of complex test code
• Slow and unreliable feedback loops

I then showcased some of the tools and techniques we can leverage today to overcome these challenges. With the addition of showing how testing tools will be much more improved by adding AI and LLM assistance into the mix. The audience was very engaged during the talk and asked some thoughtful questions afterward. It was clear many of them had experienced the testing pains I referenced from early in my career. Overall, I found Refactor DX 2023 to be exceptional, here are some of my main takeaways:

• Testing is more important than ever as web apps become more complex. We can’t skimp on end-to-end testing.
• There are fantastic open source tools available today that make testing much easier and faster than before. Taking time to learn them is worth the investment.
• Good testing requires strategic thinking, not just tools. Set your team up for testing success by instilling the right culture and values around quality.

I’m so glad I had the chance to present at Refactor DX this year. Conferences like this are such a great way to both share knowledge and stay on top of the latest industry trends. Looking forward to what the Refactor community will be up to in the coming months! If you are looking to follow along, join the community on LinkedIn: https://www.linkedin.com/company/refactor-community.

Recently, I had the honour of speaking at the Test Automation & Digital QA Summit (TAS23) in Toronto, a renowned global event attracting the brightest minds in software testing, test automation, and digital quality assurance. This summit is an invaluable gathering for Quality Assurance (QA) enthusiasts, which is hosted annually across twelve countries worldwide.

My talk, titled “Testing and Automation of Web Applications”, delved into the fascinating world of web browser automation testing. Over the years, this realm has seen significant evolution, triggered by innovative browser engines and cutting-edge tools. A focal point of my presentation was on how reliable cross-browser testing has become indispensable in today’s QA workflows, playing a crucial role in many projects. The power of integrating such testing within continuous integration pipelines cannot be overstated—it leads to superior quality products, faster release cycles, and an enhanced developer experience.

One of the principal takeaways from the talk was understanding the practical experiences and challenges that come with automating web applications. This process involves managing the complexity of supporting a diverse range of web browsers and grappling with different authentication flows, among other things. I highlighted how tools like Playwright are transforming the landscape of web automation tooling and shared in-depth examples of their optimal configuration.

This talk was designed to be a comprehensive introduction to the topic, loaded with practical examples to help attendees understand how they can implement similar automation strategies in their projects. A key objective was to help the audience recognize that with the right tools and strategies, web application automation can help achieve substantial improvements in product quality and operational efficiency.

Remember, the world of testing and automation is ever-evolving!

Python Pandas, the data analysis library has very good documentation, including both the API reference and the user guide. I like how descriptive it is and the clean design of the docs site makes it very readable. However, I do find that it still takes a bit of time to get started with Pandas, even if you have years and years of Python programming experience.

This article has been updated in March 2026 to include the latest changes with the Pandas 3.0 release. There are some significant improvements worth knowing about, including better performance with Arrow backends and the new Copy-on-Write default behaviour that eliminates those annoying SettingWithCopyWarning messages.

Getting started, install the module. This could be an obvious step, but anyway:

# Install with performance improvements
pip install pandas[all]
# or the basic version
pip install pandas

# in a new or existing .py file, import the module and make sure it works
import pandas as pd

Pandas is able to load CSV and SQL files, you can use .read_csv() for that. In this article, we create a DataFrame “inline” to focus on the rest of the Pandas API. We can create an example frame like this:

data = pd.DataFrame({
    "name": ["Tim", "Roger", "Bob", "Sarah", "Mike"],
    "town": ["Toronto", "Ottawa", "London", "Montreal", "Vancouver"],
    "balance": [50000, 52000, None, 65000, 48000],
    "account_type": ["Savings", "Checking", "Savings", "Investment", "Checking"],
})

Printing this out with print(data) will produce a nice table for you:

    name       town   balance account_type
0    Tim    Toronto   50000.0      Savings
1  Roger     Ottawa   52000.0     Checking
2    Bob     London       NaN      Savings
3  Sarah   Montreal   65000.0   Investment
4   Mike  Vancouver   48000.0     Checking

Now that we have our sample data all setup, I want to go over some of the common and crucial Pandas operations that will help you become a Pandas expert. These should also help you understand how the library works and what it is capable of. I’ve also included some modern patterns that have become popular in 2026.

Finding items by index

# Setup an "index" on name. Now we can use ".loc" to find things
data.set_index('name', inplace=True)

# Look up item by name "Tim" using the index
print(data.loc["Tim", :])

# Look up items by ".iloc", the "index" location.
print(data.iloc[0, :])

# Modern approach: using query() for readable filtering
toronto_accounts = data.query('town == "Toronto"')
print(toronto_accounts)

Rewriting column names

# The following updates the columns in our data frame.
cols = list(data.columns)
cols[0] = 'Location'
cols[1] = 'Balance' 
cols[2] = 'AccountType'
data.columns = cols

# Modern alternative using rename() method
data = data.rename(columns={
    'town': 'Location',
    'balance': 'Balance',
    'account_type': 'AccountType'
})

Get the number of rows and columns

# returns a tuple pair, which are number of rows and cols in the data
data.shape

# Get more detailed info about your DataFrame
data.info()

Ranges

# Looking up first and last rows
data.head(1)
data.tail(1)

# Using "list" lookup, other list range options work here as well
data[1:]

# Get specific rows by position
data.iloc[1:3]  # rows 1 and 2

Data types

# query the data type
data.dtypes

# Location     object
# Balance     float64
# AccountType  object
# dtype: object

# Modern approach: optimize data types for better performance
data['Balance'] = pd.to_numeric(data['Balance'], errors='coerce')
data['AccountType'] = data['AccountType'].astype('category')  # saves memory
data['Location'] = data['Location'].astype('string')  # new string dtype in pandas 3.0

Query the data

# look up the data based on columns
data[['Location', 'Balance']]

# Get all the positive balances
print(data[data['Balance'] > 0])

# You can also use the query syntax for this (recommended for readability)
print(data.query('Balance > 0'))

# Query with string columns
toronto_accounts = data.query('Location == "Toronto"')
high_balance = data.query('Balance > 50000')

Conditional Lookup

# an AND statement
print(data[(data['Balance'] > 50000) & (data['Location'] == 'Toronto')])

# an OR statement  
print(data[(data['Balance'] > 55000) | (data['Location'] == 'Vancouver')])

# Modern query syntax (more readable)
print(data.query('Balance > 50000 and Location == "Toronto"'))
print(data.query('Balance > 55000 or Location == "Vancouver"'))

Sorting

# sorts the data
data.sort_values(by='Balance', ascending=False)

# Multiple column sorting
data.sort_values(['Location', 'Balance'], ascending=[True, False])

For more advanced sorting methods, check out this article: Pandas Sort: Your Guide to Sorting Data in Python.

Modern Method Chaining (New in 2026)

One of the most powerful patterns that has become popular is method chaining, which lets you write more readable data pipelines:

# Instead of multiple assignment statements, chain operations together
result = (data
    .query('Balance > 40000')  # Filter accounts with balance > 40k
    .assign(
        BalanceCategory=lambda x: pd.cut(x['Balance'], 
                                        bins=[0, 50000, 60000, float('inf')], 
                                        labels=['Standard', 'Premium', 'Elite'])
    )
    .groupby(['Location', 'BalanceCategory'])
    .agg({'Balance': ['count', 'mean']})
    .round(2)
)

Working with Missing Data

# Check for missing values
print(data.isna().sum())

# Fill missing values
data['Balance'].fillna(data['Balance'].median(), inplace=True)

# Or use method chaining approach
clean_data = (data
    .assign(Balance=lambda x: x['Balance'].fillna(x['Balance'].median()))
    .dropna()  # remove any remaining missing values
)

Grouping and Aggregation

# Group by location and get summary stats
location_summary = data.groupby('Location').agg({
    'Balance': ['count', 'mean', 'sum'],
    'AccountType': lambda x: x.mode().iloc[0] if not x.empty else 'Unknown'
}).round(2)

# Custom aggregation functions
def balance_range(series):
    return series.max() - series.min()

custom_stats = data.groupby('Location').agg(
    avg_balance=('Balance', 'mean'),
    total_accounts=('Balance', 'count'),
    balance_spread=('Balance', balance_range)
)

Performance Tips for 2026

# Use proper data types for better performance
optimized_data = pd.DataFrame({
    "name": pd.array(["Tim", "Roger", "Bob"], dtype="string"),  # Arrow-backed strings
    "town": pd.Categorical(["Toronto", "Ottawa", "London"]),  # Categories for repeated values
    "balance": pd.array([50000, 52000, 48000], dtype="Int64"),  # Nullable integers
})

# For large datasets, use eval() for complex calculations
# This is much faster than regular operations on big DataFrames
large_data = pd.DataFrame({
    'revenue': np.random.randint(1000, 10000, 100000),
    'costs': np.random.randint(500, 8000, 100000),
    'tax_rate': 0.13  # Ontario HST rate
})

# Fast calculation using eval
large_data = large_data.eval('profit = revenue - costs')
large_data = large_data.eval('after_tax_profit = profit * (1 - tax_rate)')

Save to CSV file

# Saves the data into a file
data.to_csv('canadian_accounts.csv', index=False)

# Modern alternatives for better performance
data.to_parquet('canadian_accounts.parquet')  # Much faster for large files

# Excel with multiple sheets
with pd.ExcelWriter('bank_report.xlsx') as writer:
    data.to_excel(writer, sheet_name='Account_Data', index=False)
    location_summary.to_excel(writer, sheet_name='Location_Summary')

Reading Data with Modern Options

# Read CSV with optimized settings
df = pd.read_csv('canadian_accounts.csv', 
                dtype_backend='pyarrow',  # Use Arrow backend for performance
                parse_dates=['date_column'] if 'date_column' in data.columns else None)

# Read Parquet (recommended for large datasets)
df = pd.read_parquet('canadian_accounts.parquet')

Error Handling and Debugging

# Debug your data pipelines with helper functions
def debug_dataframe(df, step_name=""):
    print(f"{step_name}: {df.shape} rows, {df.columns.tolist()}")
    return df

# Use in method chains
result = (data
    .pipe(debug_dataframe, "Start")
    .query('Balance > 45000')
    .pipe(debug_dataframe, "After filtering") 
    .groupby('Location')['Balance'].mean()
    .pipe(debug_dataframe, "Final result")
)

As recommended by the official Pandas website, the Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython book can also be very useful if you are looking to learn more about Python data analysis. I hope these syntax examples saved you some time learning the Pandas library :).

The major improvements in Pandas 3.0 make it significantly faster and more memory-efficient than previous versions, especially when working with string data and large datasets. The Copy-on-Write behavior also means you don’t have to worry about those confusing warning messages anymore.

Just last week, I presented a workshop on web technologies with TechExplore, it’s been a great mentoring experience to showcase the Web tech to undergraduate students from different fields. Co-presented with General Assembly Toronto, we’ve setup 2 workshops – one about the Web (CSS, HTML & JavaScript) and the second one about programming with Python. The goal is to inspire more minds to get into the technology fields in some capacity. A bit about TechXplore:

The second workshop that I will be hosting is the Intro to Python presentation with TechExplore on October 26. Registration is still open at https://www.techxplore-uoft.com/event. If you are a university student or someone outside of the technology field you may find these workshops useful to expand your skills and find new opportunities.

Meet SmashingConf Live (August 20–21), a truly smashing, friendly online conference on front-end & UX. With interactive live sessions, practical insights, accessible speakers, collaborative notes and fireplace chats with like-minded folks.

The importance of WebAssembly in front-end development is growing and who knows where this technology will go next! Just over 8 months ago Web Assembly / WASM became an official Web Standard. This standard is a new frontier for front-end development that enables new possibilities to build more advanced projects, speed up their applications and learn new concepts. Even though fairly new, WebAssembly is already here in tools, libraries and large web applications.

There are many ways to get started with WebAssembly. In my technical session I went through a way to add WASM to existing projects. I also focused on helping attendees make the choice and evaluate if and where WASM would be successful in their dev life, especially for front-end web developers.

I’d like to thank the SmashingConf for organizing such an interactive event, with music, live chatter, Q&As and more, especially with the challenges of moving it to a remote conference.

Some useful resources and links from my talk:

• WebAssembly becomes a W3C Recommendation: https://www.w3.org/2019/12/pressrelease-wasm-rec.html.en
• “New Kid on the Web: A Study on the Prevalence of WebAssembly in the Wild” https://www.sec.cs.tu-bs.de/pubs/2019a-dimva.pdf
• WebAssembly at eBay: A Real-World Use Case https://tech.ebayinc.com/engineering/webassembly-at-ebay-a-real-world-use-case/
• Create Tableau-like data visualizations in browser, powered by WebAssembly https://muzejs.org/
• Streaming Analytics via WebAssembly https://perspective.finos.org/
• WebAssembly https://webassembly.studio/
• Awesome WebAssembly Languages https://github.com/appcypher/awesome-wasm-langs
• WebAssembly threads https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format#WebAssembly_threads
• WebAssembly threads in Firefox
• Bytecode Alliance https://bytecodealliance.org/
• Why would you use WebAssembly to put scikit-learn in the browser?
• How We Used WebAssembly To Speed Up Our Web App By 20X (Case Study)
• WebAssembly cut Figma’s load time by 3x
• The AutoCAD Web App
• twitter.com/WasmWeekly

and finally the slides below:

Please reach out to me via my contact page or on Twitter if you have any questions about my talk!

I wanted to create a quick list of my favourite 3D prints for the summer of 2020. Hopefully this gives someone ideas for their new 3D print and highlights some of these cool models out there!

Gear Bearing

https://www.thingiverse.com/thing:53451

A quick printed Gear Bearing is a fascinating model. It makes a cool sound while spinning and is all printed in place. By this time this model is a classic!

3D Benchy

https://www.thingiverse.com/thing:763622

Must include the 3D Benchy in this first list. It’s a great looking print and used for benchmarking. You may notice that one of the benches looks horrible, it did not print well at first.

Trivenger Boomerang

https://www.prusaprinters.org/prints/15353-trivenger-boomerang

I printed a few of these, the photo above is the first version. It turned out a bit rough, but it still flies! This is one of my favourite models so far.

Bag Clip(s)

https://www.thingiverse.com/thing:330151

https://www.prusaprinters.org/prints/27216-bag-clip-print-in-place-cam

The bag clips never stop being useful. These are the 2 designs that I have printed multiple times already:

Stratos Glider

https://www.thingiverse.com/thing:31944

This is one of the original gliders, all the way from 2012. I’ve had some luck make these fly and they do get stuck in trees sometimes.

Forbidden Tower

https://www.thingiverse.com/thing:2574499

Not a functional print, but looks beautiful and cheerful when painted.

My own print designs

The last one in this list is just a simple replacement piece for a portable desk. However it was my design and it serves me well now. Designing your own pieces, even simple ones, is very rewarding:

If you have any suggestions or your favourite prints send them my way on Twitter!