My name's Graham Wetzler. I live in the Dallas-Fort Worth Metro area where I work (remotely) as a senior analytics engineer. My job involves data modeling as well as managing analytics infrastructure and architecture. Outside of work I enjoy tinkering with computers, continuing to automate my home, and woodworking.

Graham Wetzler

## What is Advent of Code?
For the uninitiated, [Advent of Code][advent-of-code] (AoC) is an advent calendar in the form of coding problems that runs from December 1-25. It has run every year since 2015.

[advent-of-code]: https://adventofcode.com/

The [AoC about page][advent-of-code-about] describes it best:
> Advent of Code is an Advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language you like. People use them as interview prep, company training, university coursework, practice problems, a speed contest, or to challenge each other.

[advent-of-code-about]: https://adventofcode.com/2022/about

Each problem has two parts. Complete the solution for both parts and you get a gold star. Completing just part one earns you a silver star. The problems generally get tougher as the days go on. This is best illustrated by the [stats page][advent-of-code-stats] which clearly shows the tail off of the number of people completing the problems.

[advent-of-code-stats]: https://adventofcode.com/2022/stats

I've attempted AoC each year since 2020. In 2022 I used Python. In 2021, I decided to try to use Snowflake SQL but by day four it became too tedious for me and I returned to using Python.

The daily solution threads on [/r/adventofcode][Reddit] are full of people using any programming language you can imagine. This includes extremely odd choices such as [APL][APL], [Rockstar][Rockstar], and even Microsoft Excel. However, I was surprised to not find many SQL solutions posted. When I did find them they were often written in T-SQL for Microsoft SQL Server, and occasionally I'd find a PostgreSQL solution.

[Reddit]: https://www.reddit.com/r/adventofcode/
[APL]: https://en.wikipedia.org/wiki/APL_(programming_language)
[Rockstar]: https://codewithrockstar.com/

## Why DuckDB?

In November 2022 with AoC approaching I decided I would commit myself to using SQL for AoC, even if I didn't get very far. I like SQL because it's a very satisfying way to solve complex problems. The next question was which database I would use. I'd been familiar with DuckDB for years but never had a chance to use it in any practical sense. With its recent surge in popularity, DuckDB felt like an obvious choice. I could easily run it on my laptop, I didn't need to set up an account with a cloud data warehouse provider, and didn't need to mess with Docker to get PostgreSQL running.

While DuckDB could work perfectly fine on its own, I decided to pair it with [dbt-duckdb][dbt-duckdb], a DuckDB adapter for [dbt][dbt]. I use dbt daily during my job as an analytics engineer so it felt like an obvious way to structure my project. By using dbt I was able to add tests to ensure my solution still worked after refactoring.

[dbt-duckdb]: https://github.com/jwills/dbt-duckdb
[dbt]: https://www.getdbt.com/

## Patterns

After doing several AoC problems you start to see patterns appear. You're provided your puzzle input for each day. The puzzle inputs are text files, often in the form of long lists of numbers or strings. DuckDB has excellent support for [reading CSV files][CSV]. Both `read_csv` and `read_csv_auto` worked incredibly well for parsing my puzzle input depending on how much flexibility I needed.

[CSV]: https://duckdb.org/docs/data/csv

The data types provided by DuckDB are very comprehensive. While data types like lists are essential in procedural languages such as Python, I'd barely ever used them in SQL before. For many problems, I found a common pattern of using [`string_split`][text-functions] to return rows of lists containing strings, then using the incredibly powerful [`unnest`][unnest] function to turn the rows of lists into one row per list item. This worked especially well for grid problems that are often seen in AoC to format the structure into rows of `x`, `y`, and `value`.

[text-functions]: https://duckdb.org/docs/sql/functions/char
[unnest]: https://duckdb.org/docs/sql/query_syntax/unnest

Recursive CTEs are essential for many of the more challenging AoC problems, especially ones that require building and walking [graphs][graph-theory], as well as ones that require iterating over rows with conditional branching logic.

[graph-theory]: https://en.wikipedia.org/wiki/Graph_theory

Window functions are also very useful. DuckDB is kind enough to maintain the order of rows after reading in a CSV, but you'll often want to add an identifier to keep track of these rows through transformations. `row_number() over ()` will give you just that.

`string_agg` is a useful aggregate, window, and list function. However (at the time of writing) when using it as a list function it has an odd limitation; specifying the string separator does not work as expected. Thanks to the wonderful [DuckDB Discord][duckdb-discord] I found a solution for this: `list_aggr(['a', 'b', 'c'], 'string_agg', '')` will join a list together. It looks odd but it does work.

[duckdb-discord]: https://discord.com/invite/tcvwpjfnZx

## Walkthrough

Next, I'll walk through a couple of my solutions. Feel free to skip past if you plan on attempting these yourself and you don't want to be spoiled.

## Day Three

[Day three][day-three] has you working with ”items“ (represented as letters) in a rucksack (a line of input). The puzzle input contains 300 lines of varying length random-looking text strings.

[day-three]: https://adventofcode.com/2022/day/3

First, we start with reading in the puzzle input. Here we also add the `elf` identifier to each row to keep track of each elf's rucksack.
```sql
with input(elf, items) as (
  select row_number() over () as elf
       , *
    from read_csv_auto('input/03.csv')
)
```

The first real step is to split each rucksack into equal halves. We can do this by counting how many items each rucksack contains and then using string slicing we can separate each half into a new column. Finally, we split the strings into lists.
```sql
, compartments as (
  select *
       , length(items) as len
       , string_split(items[1 : len / 2], '') as compartment_1
       , string_split(items[len / 2 + 1 : len], '') as compartment_2
    from input
)
```

Part one asks us to find the one item type that appears in both compartments of each rucksack. With both compartments now `list` types we can use a `list_filter` to construct a lambda that uses the `contains` function to filter for the one item. Finally, we can use `[1]` which is a list slice to return a single value from the resulting lists.
```sql
, common_by_compartment as (
  select elf
       , list_filter(compartment_1, x -> contains(compartment_2, x))[1] as item
    from compartments
)
```

The final step for part one (and part two) is to calculate the priority. If you're familiar with [ASCII character codes][ASCII] you'll probably notice the shortcut we can use. The `ord` function returns the ASCII character code for the character passed in. With the ASCII code, we just need to figure out the offset needed to match the instructions. Finally, we can sum the column to get the answer to part one.
```sql
select sum(case
           when ord(item) between 65 and 90 then ord(item) - 38 /* A-Z */
           else ord(item) - 96 /* a-z */
       end) as answer
  from common_by_compartment
```

[ASCII]: https://en.wikipedia.org/wiki/Wikipedia:ASCII

Part two ups the difficulty and asks us to find the common item between groups of three elves. The first step is to create the groups using a `row_number` window function with a window frame specifying `elf % 3`. `elf` is the identifier we created in the first step and `%` is the modulo operator which returns the remainder of dividing the two values.
```sql
, elf_groups as (
  select row_number() over (partition by elf % 3 order by elf) as elf_group
       , *
    from input
)
```

Next, we split each rucksack into a list and `unnest` to fan out the results to a single item per row.
```sql
, distinct_items_by_group as (
  select distinct
         elf_group
       , elf
       , unnest(string_split(items, '')) as item
    from elf_groups
)
```

Nearly finished, we can use a simple `group by` and `having` statement to find the common item for each group of elves.
```sql
, common_by_group as (
  select elf_group
       , item
    from distinct_items_by_group
   group by 1, 2
  having count(*) = 3
)
```

The final step for part two is to calculate the priority the same way as in part one.

## Day Six
[Day six's][day-six] problem asks you to help the elves decode signals from their communication system. The puzzle input is a single line of 4,096 lowercase letters. In part one, you're asked to find the first *start-of-packet* marker which is defined as four sequential characters that are all different. Part two asks us to find the first *start-of-message* marker which is the same as a *start-of-packet* marker except it's 14 characters.

[day-six]: https://adventofcode.com/2022/day/6

We start the same way as usual, by reading from our puzzle input. We also dive right in by splitting the characters into a list and unnesting to get each character onto their own row.
```sql
with input as (
  select unnest(str_split(char, '')) as buffer
    from read_csv_auto('input/06.csv') as chars(char)
)
```

The next step simply adds an identifier column that we'll later use to sort by.
```sql
, row_id as (
  select row_number() over () as id
       , buffer
    from input
)
```

Here is where the bulk of the work happens for both parts. First, we use `list` in a window function with a [frame][frame] that looks backward the required number of characters. Then `list_distinct` returns the unique items from the column of lists. Finally, `length` will give us the length of each list.
```sql
, markers as (
  select id
       , length(list_distinct(list(buffer) over (order by id
                                                  rows between 3 preceding
                                                   and current row))) as packet_marker
       , length(list_distinct(list(buffer) over (order by id
                                                  rows between 13 preceding
                                                   and current row))) as message_marker
    from row_id
   order by id
```

[frame]: https://duckdb.org/docs/sql/window_functions#framing

To get the final answer for both parts we just figure out the minimum `id` that matches our criteria.
```sql
select 1 as part
     , min(id) as answer
  from markers
 where packet_marker = 4
 union all
select 2 as part
     , min(id) as answer
  from markers
 where message_marker = 14
```

## Wrapping Up

I enjoyed attempting AoC with DuckDB. It required a completely different way of thinking compared to Python. While I didn't complete as many days as in prior years using Python, I learned a ton. I also felt like several of my solutions were much more readable and elegant compared to those done in procedural languages.

I managed to get gold stars for the first eight days. On [day nine][day-nine] I struggled to come up with a solution; I believe it's possible to solve this using a recursive CTE or even a lateral join (currently in DuckDB development builds) but I didn't get very far. I did find a solution for day 10, however, on days 11, 12, and 13, I worked for many hours but ultimately did not manage to find solutions. Day 12 involved building a graph which I did using a recursive CTE. While it could run successfully on the sample input, I could not get it to run quickly enough to solve using my provided input.

[day-nine]: https://adventofcode.com/2022/day/9

Go give it a try! You don't have to wait until December, you can attempt any day from any of the prior years. I recommend joining or creating a private leaderboard for some friendly competition among friends or those with similar interests. If you're able to come up with DuckDB solutions I'd love to hear about them!

You can find [my Github repo with my solutions here][Github] and the best place to reach me is on [Mastodon][Mastodon] or [LinkedIn][LinkedIn].

[Github]: https://github.com/grahamwetzler/advent-of-code-dbt-2022
[Mastodon]: https://data-folks.masto.host/@graham
[LinkedIn]: https://www.linkedin.com/in/grahamwetzler/

Solving Advent of Code with DuckDB and dbt

I'm a Data Engineer by day at X-Team, working for Riot Games.
 
By night, I'm a content creator working on my YouTube channel and three newsletters: Data Gigs [finding jobs in data],  AWS Graviton Weekly and of course the DuckDB ecosystem newsletter.

AWS Community Builder since 2022.

I run a Talent Collective as well.

Best way to contact me? Twitter link below.

Marcos Ortiz

## Hey, friend 👋

Hi, I'm [Marcos](https://marcosortiz.carrd.co/)! I'm a data engineer by day at Riot Games (via X-Team). By night, I create newsletters for a few topics I'm passionate about: helping folks [find data digs](http://interestingdatagigs.substack.com/) and [AWS graviton](https://awsgravitonweekly.com/). After getting involved in the DuckDB community, I saw a great opportunity to partner with the MotherDuck team to share all the amazing things happening in the DuckDB ecosystem.

In this issue, we wanted to share the incredible talks from the DuckCon 2023, and many articles that were out in the second half of January and the first days of February. As each month goes by, a lot more great content is being published in the DuckDB ecosystem, so we've had to make some difficult choices for the featured community member and top links.

We hope you enjoy!

-Marcos

Feedback: [duckdbnews@motherduck.com](mailto:duckdbnews@motherduck.com)

Tweet great links to us with #DuckDBMonthly

<style type="text/css">
.row {
  display: flex;
  flex-direction:column;   
  margin-bottom: 10px;
}

.rowreverse {
  flex-direction:column-reverse;
}

@media screen and (min-width: 600px) {
  .row {
    flex-direction: row;
  }
.columnTextLeft h3 {
  margin-left: 0px !important;
  margin-right: 20px !important;
}

.columnTextRight h3 {
  margin-left: 20px !important;
}

.columnTextLeft p {
  margin-left: 0px !important;
  margin-right: 20px !important;
}

.columnTextRight p {
  margin-left: 20px !important;
}  
}

.columnPic {
  flex: 30%;
}


.columnText {
  flex: 70%;
}

.columnText h3 {
  margin-top: 0px !important;
}


</style>

## Featured Community Member

<div class="row">
  <div class="columnPic"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/Imported%20sitepage%20images/37849236ea9ab2feb2d2ee71f30a9351f15765e83a9792bcd7f8677dfbc9c460.jpg?width=320&upscale=true&name=37849236ea9ab2feb2d2ee71f30a9351f15765e83a9792bcd7f8677dfbc9c460.jpg"></img></div>
  <div class="columnText columnTextRight"><h3>Pedro Holanda</h3>
<p>Pedro is a Post-Doc based in Amsterdam and a member of the Database Architecture group at CWI and currently as working as Chief of Operations at DuckDB Labs. 

You can find him on Twitter [@holanda_pe](https://twitter.com/holanda_pe)

[Learn more about Pedro](https://pdet.github.io/)</p></div> 
</div>

## New DuckDB Release: 0.7.0

<div class="row rowreverse">
  <div class="columnText columnTextLeft"><p>The DuckDB team <a href="https://duckdb.org/2023/02/13/announcing-duckdb-070.html">recently announced DuckDB 0.7.0</a>!  This new release introduces JSON ingestion through read_json, partitioned Parquet and CSV export, attaching multiple DuckDB databases in the same instance, SQLite storage backend,  UPSERTs, LATERAL and POSITIONAL joins, improved Python APIs, better compression and more.  The DuckDB community has clearly been heads down coding!

[Download and Install 0.7.0](https://duckdb.org/docs/installation/index)</p></div>
  <div class="columnPic"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/Imported%20sitepage%20images/labrador_duck.png?width=320&upscale=true&name=labrador_duck.png" /></div>
</div>
  
## Top 10 DuckDB Links this Month

<div class="row">
  <div class="columnPic"><a href="https://www.youtube.com/playlist?list=PLIYcNkSjh-0wxBKPBuL6W1njhI31LwIRZ"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/Imported%20sitepage%20images/maxresdefault.jpg?width=320&upscale=true&name=maxresdefault.jpg" /></a></div>
  <div class="columnText columnTextRight"><h3><a href="https://www.youtube.com/playlist?list=PLIYcNkSjh-0wxBKPBuL6W1njhI31LwIRZ">DuckCon Brussels 2023: Talks by DuckDB Creators, MotherDuck, LakeFS, Hopsworks, Fluvio</a></h3>

  DuckCon this year had an exciting mix of talks from the core DuckDB team and the community. Catch them all on the playlist above.

Want to learn how to build DuckDB Extensions?  In their talk, Pedro and Sam teased the audience about the power of DuckDB Extensions and what you can achieve with them easily by cloning their example project.
  
  </div>
</div>


<div class="row rowreverse">
  <div class="columnText columnTextLeft"><h3><a href="https://www.youtube.com/watch?v=-rCZQHXSunc&list=PLIYcNkSjh-0ztvwoAp3GeW8HNSUSk_q3K&index=15">DuckDB: Bringing Analytical SQL directly to your Python shell</a></h3><p>In this talk at FOSDEM 2023, Pedro talks about how DuckDB fits perfectly inside the Python ecosystem and makes a cool demo at the end of the talk using DuckDB, Pandas, and PySpark.</p></div>
   <div class="columnPic"><a href="https://www.youtube.com/watch?v=-rCZQHXSunc&list=PLIYcNkSjh-0ztvwoAp3GeW8HNSUSk_q3K&index=15"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image10.jpg?width=320&upscale=true&name=image10.jpg" /></a></div>
</div>

<div class="row">
   <div class="columnPic"><a href="https://www.youtube.com/watch?v=rYbSu9wvQmk"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image3.jpg?width=320&upscale=true&name=image3.jpg" /></a></div>
   <div class="columnText columnTextRight"><h3><a href="https://www.youtube.com/watch?v=rYbSu9wvQmk">PyIceberg 0.2.1: Iceberg ❤️ PyArrow & DuckDB</a></h3><p>In this video, Tabular’s team demonstrated the new features of <a href="https://py.iceberg.apache.org/">PyIceberg 0.2.1</a>. If you prefer the article, here is the <a href="https://tabular.medium.com/pyiceberg-0-2-1-pyarrow-and-duckdb-79effbd1077f">complete write-up</a> on Medium.</p></div>
</div>

<div class="row rowreverse">
  <div class="columnText columnTextLeft"><h3><a href="https://motherduck.com/blog/solving-advent-code-duckdb-dbt/">Solving Advent Of Code With DuckDB And dbt</a></h3><p>A very interesting article from <a href="https://www.linkedin.com/in/grahamwetzler/">Graham Wetzler</a> about he used DuckDB and Python to solve some of the Advent of Code challenges.</p></div>
   <div class="columnPic"><a href="https://motherduck.com/blog/solving-advent-code-duckdb-dbt/"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image7.jpg?width=320&upscale=true&name=image7.jpg" /></a></div>
</div>

<div class="row">
   <div class="columnPic"><a href="https://www.vantage.sh/blog/querying-aws-cost-data-duckdb"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image4.png?width=320&upscale=true&name=image4.png" /></a></div>
   <div class="columnText columnTextRight"><h3><a href="https://www.vantage.sh/blog/querying-aws-cost-data-duckdb">Querying 1 Billion Rows of AWS Cost Data 100X Faster with DuckDB</a></h3><p>According to the Vantage’s team: from simple reads to complex writes and data ingestion they found that DuckDB was between 4X and 200X faster than Postgres for this use case.</p></div>
</div>

<div class="row rowreverse">
  <div class="columnText columnTextLeft"><h3><a href="https://www.youtube.com/watch?v=lT6JwbeuzCA">Command Line Data Visualization with DuckDB and YouPlot</a></h3><p>In this video, Mark Needham teaches us how to create data visualizations on the command line using YouPlot, DuckDB, and a bit of Pandas.</p></div>
   <div class="columnPic"><a href="https://www.youtube.com/watch?v=lT6JwbeuzCA"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image5.jpg?width=320&upscale=true&name=image5.jpg" /></a></div>
</div>

<div class="row">
   <div class="columnPic"><a href="https://pedram.substack.com/p/streaming-data-pipelines-with-striim"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image1.jpg?width=320&upscale=true&name=image1.jpg" /></a></div>
   <div class="columnText columnTextRight"><h3><a href="https://pedram.substack.com/p/streaming-data-pipelines-with-striim">Streaming Data Pipelines with Striim + DuckDB</a></h3><p>In this interesting article, Pedram Navid explains how to set up a streaming Data pipeline with the help of Striim (an enterprise-grade CDC platform) and DuckDB.</p></div>
</div>

<div class="row rowreverse">
  <div class="columnText columnTextLeft"><h3><a href="https://motherduck.com/blog/python-faker-duckdb-exploration/">Python Faker for DuckDB Fake Data Generation</a></h3><p>In this article, Ryan develops a simple way how to generate fake data with Python and upload it to DuckDB.</p></div>
   <div class="columnPic"><a href="https://motherduck.com/blog/python-faker-duckdb-exploration/"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image2.jpg?width=320&upscale=true&name=image2.jpg" /></a> </div>
</div>

<div class="row">
   <div class="columnPic"><a href="https://datastackshow.com/podcast/pragmatism-about-data-stacks-with-pedram-navid-of-west-marin-data/"><img src="https://22616816.fs1.hubspotusercontent-na1.net/hub/22616816/hubfs/image11.png?width=320&upscale=true&name=image11.png" /></a></div>
   <div class="columnText columnTextRight"><h3><a href="https://datastackshow.com/podcast/pragmatism-about-data-stacks-with-pedram-navid-of-west-marin-data/">Pragmatism About Data Stacks with Pedram Navid of West Marin Data</a></h3><p>The Data Stack Show, Eric and Kostas chat with Pedram Navid, Owner of West Marin Data and frequent contributor to substack. During the episode, Pedram discusses the modern data stack and its complexities, modern tooling, early-stage startups, and more.</p></div>
</div>

<h3><a href="https://duckdb.org/docs/sql/statements/insert#on-conflict-clause">DuckDB now supports ON CONFLICT clause on upserts</a></h3>
<p>Now available in the latest 0.7.0 release. Thanks to Alex Monahan for the <a href="https://twitter.com/__AlexMonahan__/status/1620435900235939841">tip on Twitter</a>.</p>

## Upcoming Events

[Data Council Austin](https://www.datacouncil.ai/austin) at the end of March will feature three days of technical talks on 
analytics, data engineering, data science and AI. Nicholas Ursa, co-founder and software engineer at MotherDuck, will speak about how ["Data Warehouses are Gilded Cages. What Comes Next?"](https://www.datacouncil.ai/talks/data-warehouses-are-gilded-cages-what-comes-next?hsLang=en)

[QCon London](https://qconlondon.com/), also at the end of March, is a software development conference featuring some of the brightest minds across software. Hannes Mühleisen, co-creator of DuckDB, will present on ["In-Process Analytical Data Management with DuckDB."](https://qconlondon.com/presentation/mar2023/process-analytical-data-management-duckdb)

[Modern Data Stack Conference](https://www.moderndatastackconference.com/) (MDS Con) by Fivetran at the beginning of April in San Francisco will feature leaders in the industry such as DJ Patil, George Fraser, Tristan Handy,  Ali Ghodsi, renowned analyst Sanjeev Mohan and Data Council founder Pete Soderling. Ryan Boyd, co-founder at MotherDuck, will be on a [panel](https://www.moderndatastackconference.com/agenda) with Gabi Steele (CEO, Preql) and Chetan Sharma (CEO, Eppo).

## Subscribe to the Newsletter
You can [subscribe to the blog using RSS](https://motherduck.com/rss.xml), or elect to <a href="https://motherduck.com/#stay-in-touch">join our mailing list</a> for either the DuckDB Ecosystem Newsletter, MotherDuck News or both!

This Month in the DuckDB Ecosystem: February 2023

Mehdi joins us as a Data Engineering and Analytics Advocate after a career as a Data Engineer and a nighttime hobby of creating YouTube videos and other content for data professionals.

Mehdi Ouazza

## How it started
During the 2nd edition of the DuckCon in Brussels, I had the pleasure of interviewing DuckDB co-creator Hannes Mühleisen. Hannes is a researcher at the Dutch research institute for computer science and mathematics, CWI. He has been working in a group called Database Architectures for ten years, where they research how data systems should be built.

In his work, he discovered that some data practitioners, particularly in the R community, were not using databases at all. Instead, they used hand-rolled dataframe engines and dataframes in memory. However, these dataframes were slow and limited because of how the engines were structured.

That was the first bit that inspired DuckDB to be created.

<iframe width="560" height="315" src="https://www.youtube.com/embed/kpOvgY_ykTE" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen style="margin-bottom: 15px"></iframe>

## Databases are cumbersome for local development
Data practitioners were not excited about traditional databases because they’re difficult to install and configure. It’s not a smooth to run a database locally. Plus, the client protocol of databases like JDBC, built in the 90s, hasn’t faced significant upgrades. Hannes wanted to research how he could build a database for these people while removing the hassle of managing one.

SQLite was a big inspiration for DuckDB. SQLite has no server, and it’s in-process with a simple library. However SQLite was designed for transactional workloads (with row-based storage). This limited the performance of SQLite for these use cases and presented an opportunity.  In-process analytics database are a brand new class of databases, which was exciting for Hannes as a researcher.

This was just the beginning of the story and not even close to what we know today as “DuckDB”. But Hannes isn’t done with the DuckDB project. To quote him :
>“My definition of success as a researcher is not to write papers but to have an impact. In the area of data systems, it is required to make something that will see widespread use in order to achieve impact.”

Check out the full interview above or [directly on YouTube](https://youtu.be/kpOvgY_ykTE). 


Why does everybody hate databases?

How it started

Databases are cumbersome for local development

CONTENT

NEXT POSTS

Solving Advent of Code with DuckDB and dbt

This Month in the DuckDB Ecosystem: February 2023