linkedin.svg

LinkedIn

instagram (1).svg

Instagram

facebook.svg

Facebook

twitter.svg

Twitter

github (1).svg

GitHub

## Hi there 👋

My name is Adam and I'm a software developer. I'm a big fan of TypeScript, JavaScript, React, and Node.js. I'm currently working at AppUnite as a full-stack developer, mostly with React and Elixir (Phoenix). I'm open to new technologies and solutions, and always willing to learn new things. My main focuses right now are broadening my knowledge beyond the JavaScript world, going deeper into Elixir and maybe trying some mobile platforms in the future? 🤔

### Hit me up  📞

You can interact with me mostly on the social media I listed on below my profile photo! If you have something more serious though... [write me an email](mailto:a@siekierski.me) 📨

And I'm also quite active on Discord servers like [Frontlive](https://discord.gg/XTRkJXwCU9), [Type of Web](https://typeofweb.com/discord), and Devscord, so I highly encourage you to join them if you want to chat a bit 😎

large_adam-2022.jpg

medium_adam-2022.jpg

small_adam-2022.jpg

thumbnail_adam-2022.jpg

adam-2022.jpg

TIL means Today I Learned. And that's what this series/category is all about - short and quick articles about everyday problems that I have dealt with, and along solving them, I came up to an interesting solution that you might also implement one day.

**Ever had a headache because of the number of branches you have on your repo locally?** If so - I have something for you.

Working in a git project with some team members, and lots of tasks - you don't have any other way, than to work on a separate branch for each task. This is pretty useful, and GitHub also deals with it quite nice by deleting the merged branches... but that doesn't happen on your local repository. Also, git branches are *light* - they just point to a specific commit in the repo's history. And commits are also light. So having lots of branches won't cause huge performance issues, and thus - we don't remember to always delete the branch after we finish working on it - because it's not a big deal to keep it!

Unless it is. Sometimes you have to switch between branches, go to a branch that you just pushed, because you started working on an another task, and then you have to go back because you've got to make some changes from the code review. And that's the point where a problem araises - you don't remember the name of the branch... and you have to crawl through all the branches you have locally (assuming you're lazy enough to not just switch to the browser and check the branch on PR...). So this argumentation may not convince you. But still, even though you don't have problems with switching between branches, wouldn't it be nicer if you local repository was clean, and you had only, let's say, 5 branches? In my opinion - it would.

### So if you're a person like me, you'll love this shell&nbsp;snippet!

```bash
git branch | grep -v "[branches]" | xargs git branch -D
```
_Now just replace the `[branches]` with the **names of your branches you want to have preserved** divided by _`\|`_ (for example _`master\|develop`_) and... voilà_


### Or you can go even further, and create a short bash script like&nbsp;this!

```bash
#!/bin/bash

BRANCHES=""

for branch in "$@"
do
    if [ "$BRANCHES" = "" ];
    then
        BRANCHES="$branch";
    else
        BRANCHES="$BRANCHES\\|$branch";
    fi
done

git branch | grep -v "$BRANCHES" | xargs git branch -D
```

I saved it in a file called `gbc` - Git Branch Cleanup - and I can use it like this (if I want to for example remove all the branches except master and develop): `gbc master develop`.



<p style={{ fontSize: "0.8rem", lineHeight: 1.2 }}>

_I do not take any responsibility for accidentally removed branches, broken repo histories and other f\*ckups. If some wrong things happen - I recommend you to check out the tips on https://ohshitgit.com/_

</p>

Ever had a headache because of the number of branches you have on your repo locally? If so, take advantage of the tips from this post :)

TIL: Cleaning your Git repository by removing the unused branches

When dealing with bigger amounts of data that you have to somehow transform (for example map over) in Elixir, you might encounter a problem of running out of memory or losing the performance that Phoenix and Elixir can provide.

What they can provide though, are **Streams**. Elixir Streams allow you to build a pipeline of operations, and are really beneficial when working with larger amounts of data - what they do, is they chunk the set of data you have, and do the transforms (like maps, filters, etc.) on demand, in those chunks, which allows to **save a lot of memory**, by not loading the whole set at once, rather “streaming” the data one after another. Simply speaking - Streams are basically “lazy” enumerables.

This concept would work perfectly when working with large sets of entities from the database, wouldn’t it? That’s what also Ecto’s developers thought, and thanks to them - we have the Ecto’s `Repo.stream/1`.

## Example

Let’s take a look at a real example of how a simplified code for preparing and rendering a sitemap, with the help of Phoenix, would look without, and then with the Ecto’s Stream:

```elixir
def fetch(conn, _params) do
  render(conn, "sitemap.xml",
    sitemap_items: get_sitemap_paths(),
    host: "https://appunite.com"
  )
end

def get_sitemap_paths do
  sitemap_profiles() ++ sitemap_posts()
end

defp sitemap_profiles do
  from(u in User, where: is_nil(u.deleted_at))
  |> Repo.all()
  |> Enum.map(fn profile ->
    %SitemapUrl{
      url: "/profiles/#{profile.slug}",
      lastmod: profile.updated_at
    }
  end)
end

defp sitemap_posts do
  from(p in Posts,
    where: p.private == false and is_nil(p.deleted_at)
  )
  |> Repo.all()
  |> Enum.map(fn post ->
    %SitemapUrl{
      url: "/posts/#{post.slug}",
      lastmod: post.updated_at
    }
  end)
end
```

and then with the `Repo.Stream/1` 

```elixir
def fetch(conn, _params) do
  {:ok, conn} =
    Repo.transaction(fn ->
      render(conn, "sitemap.xml",
        sitemap_items: get_sitemap_paths(),
        host: "https://appunite.com"
      )
    end)

  conn
end

def get_sitemap_paths do
  Stream.concat(sitemap_profiles(), sitemap_posts())
end

defp sitemap_profiles do
  from(u in User, where: is_nil(u.deleted_at))
  |> Repo.stream()
  |> Stream.map(fn profile ->
    %SitemapUrl{
      url: "/profiles/#{profile.slug}",
      lastmod: profile.updated_at
    }
  end)
end

defp sitemap_posts do
  from(p in Post,
    where: p.private == false and is_nil(p.deleted_at)
  )
  |> Repo.stream()
  |> Stream.map(fn post ->
    %SitemapUrl{
      url: "/posts/#{post.slug}",
      lastmod: post.updated_at
    }
  end)
end
```

### Differences

- We replaced `Repo.all/1` with (surprisingly) `Repo.stream/1` . It’ll still allow us to work with all the records from the query, but with one difference - it returns a Stream, instead of an enumerable list.
- We had to wrap the whole part where we work with the Stream inside a **database transaction**. It’s a required step, as we have to be sure that the **data doesn’t change during the lifespan of the Stream** (you have to remember, that only a chunk of the entities from the query is inside our app’s memory at once).
- In order to work with the Stream, we can’t use the typical `Enum` methods - instead we use the `Stream` module, but it’s not a big deal - it has all the methods you would need, like `map`, `filter`, etc. Also take a look at how we’ve composed two streams - instead of the `++` operator, the [Stream.concat/2](https://hexdocs.pm/elixir/1.12/Module.html#concat/2) function had to be used.

## Read more

- [https://elixir-lang.org/getting-started/enumerables-and-streams.html#streams](https://elixir-lang.org/getting-started/enumerables-and-streams.html#streams)
- [https://hexdocs.pm/ecto/Ecto.Repo.html#c:stream/2](https://hexdocs.pm/ecto/Ecto.Repo.html#c:stream/2)
- [https://hexdocs.pm/elixir/1.12/Stream.html](https://hexdocs.pm/elixir/1.12/Stream.html)

Special thanks to [Kacper Latuszewski](https://github.com/latachz) ;)

Working with large sets of data can be slow, hard and annoying. Fortunately, Elixir and Ecto provide Streams - a simple, performant and elegant solution for all your data transformation problems.

TIL: Cleaning your Git repository by removing the unused branches

So if you're a person like me, you'll love this shell snippet!

Or you can go even further, and create a short bash script like this!